[ DWDS ] Reestablish WS connections with app and Chrome debugger

When the computer enters sleep mode, Chrome does not attempt to
reestablish websocket connections when the computer wakes up. This would
break debugging of web applications when DWDS is configured to
communicate with the Chrome debugger or the debugged application is
using web sockets to communicate with DWDS.

This change adds some retry logic to reestablish these web socket
connections from the injected client and to the Chrome debugger.

Related to flutter/flutter#179886

Author: bkonyi

dwds/CHANGELOG.md

@@ -1,10 +1,11 @@
-## 26.2.3-wip
+## 26.2.3
 
 - Bump `build_web_compilers` to ^4.4.1.
 - Remove unused `clientFuture` arg from `DwdsVmClient` methods.
 - Fix pausing starting of `main` after the hot restart.
 - Updating bootstrapper for DDC library bundler module format + Frontend Server.
 - Fix setting up breakpoints when handling in-app restarts with attached debugger.
+- Fix issue where the web socket connections with the target application and Chrome debugger close when the computer sleeps.
 
 ## 26.2.2
 

dwds/lib/src/debugging/debugger.dart

@@ -228,6 +228,7 @@ class Debugger {
       skipLists,
       root,
     );
+    remoteDebugger.onReconnect = debugger._initialize;
     await debugger._initialize();
     return debugger;
   }

dwds/lib/src/debugging/remote_debugger.dart

@@ -10,6 +10,10 @@ class TargetCrashedEvent extends WipEvent {
 
 /// A generic debugger used in remote debugging.
 abstract class RemoteDebugger {
+  /// An optional callback that's invoked in the case where the debugger
+  /// connection needs to be reinitialized.
+  Future<void> Function()? onReconnect;
+
   Stream<ConsoleAPIEvent> get onConsoleAPICalled;
 
   Stream<ExceptionThrownEvent> get onExceptionThrown;

dwds/lib/src/debugging/webkit_debugger.dart

@@ -2,27 +2,126 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'dart:async';
+
 import 'package:dwds/src/debugging/remote_debugger.dart';
 import 'package:webkit_inspection_protocol/webkit_inspection_protocol.dart';
 
+typedef _EventStreamState = ({
+  StreamController controller,
+  WipEventTransformer transformer,
+});
+
 /// A remote debugger with a Webkit Inspection Protocol connection.
 class WebkitDebugger implements RemoteDebugger {
-  final WipDebugger _wipDebugger;
+  WipDebugger _wipDebugger;
 
   /// Null until [close] is called.
   ///
   /// All subsequent calls to [close] will return this future.
   Future<void>? _closed;
 
-  WebkitDebugger(this._wipDebugger);
+  // We need to forward the events from the [WipDebugger] instance rather than
+  // directly expose its streams as it may need to be recreated due to an
+  // unexpected loss in connection to the debugger.
+  final _onClosedController = StreamController<WipConnection>.broadcast();
+  final _onConsoleAPICalledController =
+      StreamController<ConsoleAPIEvent>.broadcast();
+  final _onExceptionThrownController =
+      StreamController<ExceptionThrownEvent>.broadcast();
+  final _onGlobalObjectClearedController =
+      StreamController<GlobalObjectClearedEvent>.broadcast();
+  final _onPausedController = StreamController<DebuggerPausedEvent>.broadcast();
+  final _onResumedController =
+      StreamController<DebuggerResumedEvent>.broadcast();
+  final _onScriptParsedController =
+      StreamController<ScriptParsedEvent>.broadcast();
+  final _onTargetCrashedController =
+      StreamController<TargetCrashedEvent>.broadcast();
+
+  /// Tracks and manages all subscriptions to streams created with
+  /// `eventStream`.
+  final _eventStreams = <String, _EventStreamState>{};
+
+  late final _controllers = <StreamController>[
+    _onClosedController,
+    _onConsoleAPICalledController,
+    _onExceptionThrownController,
+    _onGlobalObjectClearedController,
+    _onPausedController,
+    _onResumedController,
+    _onScriptParsedController,
+    _onTargetCrashedController,
+  ];
+
+  @override
+  Future<void> Function()? onReconnect;
+
+  WebkitDebugger(this._wipDebugger) {
+    _initialize();
+  }
+
+  void _initialize() {
+    late StreamSubscription sub;
+    sub = _wipDebugger.connection.onClose.listen((connection) async {
+      await sub.cancel();
+      if (_closed != null) {
+        // The connection closing is expected.
+        _onClosedController.add(connection);
+        await Future.wait([
+          for (final controller in _controllers) controller.close(),
+          for (final MapEntry(value: (:controller, transformer: _))
+              in _eventStreams.entries)
+            controller.close(),
+        ]);
+        return;
+      }
+      var retry = false;
+      var retryCount = 0;
+      const maxAttempts = 5;
+      do {
+        retry = false;
+        try {
+          _wipDebugger = WipDebugger(
+            await WipConnection.connect(connection.url),
+          );
+          await onReconnect?.call();
+        } on Exception {
+          await Future.delayed(Duration(milliseconds: 25 << retryCount));
+          retry = true;
+          retryCount++;
+        }
+      } while (retry && retryCount <= maxAttempts);
+      _initialize();
+    });
+
+    _wipDebugger.connection.runtime
+      ..onConsoleAPICalled.listen(_onConsoleAPICalledController.add)
+      ..onExceptionThrown.listen(_onExceptionThrownController.add);
+    _wipDebugger
+      ..onGlobalObjectCleared.listen(_onGlobalObjectClearedController.add)
+      ..onPaused.listen(_onPausedController.add)
+      ..onResumed.listen(_onResumedController.add)
+      ..onScriptParsed.listen(_onScriptParsedController.add)
+      ..eventStream(
+        'Inspector.targetCrashed',
+        (WipEvent event) => TargetCrashedEvent(event.json),
+      ).listen(_onTargetCrashedController.add);
+
+    for (final MapEntry(:key, value: (:controller, :transformer))
+        in _eventStreams.entries) {
+      final stream = _wipDebugger.eventStream(key, transformer);
+      stream.listen(controller.add, onError: controller.addError);
+    }
+  }
 
   @override
   Stream<ConsoleAPIEvent> get onConsoleAPICalled =>
-      _wipDebugger.connection.runtime.onConsoleAPICalled;
+      _onConsoleAPICalledController.stream;
 
   @override
   Stream<ExceptionThrownEvent> get onExceptionThrown =>
-      _wipDebugger.connection.runtime.onExceptionThrown;
+      _onExceptionThrownController.stream;
 
   @override
   Future<WipResponse> sendCommand(
@@ -103,31 +202,40 @@ class WebkitDebugger implements RemoteDebugger {
   }
 
   @override
-  Stream<T> eventStream<T>(String method, WipEventTransformer<T> transformer) =>
-      _wipDebugger.eventStream(method, transformer);
+  Stream<T> eventStream<T>(String method, WipEventTransformer<T> transformer) {
+    return _eventStreams
+        .putIfAbsent(method, () {
+          final controller = StreamController<T>();
+          final stream = _wipDebugger.eventStream(method, transformer);
+          stream.listen(controller.add, onError: controller.addError);
+          return (controller: controller, transformer: transformer);
+        })
+        .controller
+        .stream
+        .cast<T>();
+  }
 
   @override
   Stream<GlobalObjectClearedEvent> get onGlobalObjectCleared =>
-      _wipDebugger.onGlobalObjectCleared;
+      _onGlobalObjectClearedController.stream;
 
   @override
-  Stream<DebuggerPausedEvent> get onPaused => _wipDebugger.onPaused;
+  Stream<DebuggerPausedEvent> get onPaused => _onPausedController.stream;
 
   @override
-  Stream<DebuggerResumedEvent> get onResumed => _wipDebugger.onResumed;
+  Stream<DebuggerResumedEvent> get onResumed => _onResumedController.stream;
 
   @override
-  Stream<ScriptParsedEvent> get onScriptParsed => _wipDebugger.onScriptParsed;
+  Stream<ScriptParsedEvent> get onScriptParsed =>
+      _onScriptParsedController.stream;
 
   @override
-  Stream<TargetCrashedEvent> get onTargetCrashed => _wipDebugger.eventStream(
-    'Inspector.targetCrashed',
-    (WipEvent event) => TargetCrashedEvent(event.json),
-  );
+  Stream<TargetCrashedEvent> get onTargetCrashed =>
+      _onTargetCrashedController.stream;
 
   @override
   Map<String, WipScript> get scripts => _wipDebugger.scripts;
 
   @override
-  Stream<WipConnection> get onClose => _wipDebugger.connection.onClose;
+  Stream<WipConnection> get onClose => _onClosedController.stream;
 }

dwds/lib/src/handlers/dev_handler.dart

@@ -171,12 +171,13 @@ class DevHandler {
   ) async {
     ChromeTab? appTab;
     ExecutionContext? executionContext;
-    WipConnection? tabConnection;
+    WipConnection? connection;
+    late final debugger = WebkitDebugger(WipDebugger(connection!));
     final appInstanceId = appConnection.request.instanceId;
     for (final tab in await chromeConnection.getTabs()) {
       if (tab.isChromeExtension || tab.isBackgroundPage) continue;
 
-      final connection = tabConnection = await tab.connect();
+      connection = await tab.connect();
       if (_enableLogging) {
         connection.onSend.listen((message) {
           _log('  wip', '==> $message');
@@ -208,30 +209,28 @@ class DevHandler {
           appTab = tab;
           executionContext = RemoteDebuggerExecutionContext(
             contextId,
-            WebkitDebugger(WipDebugger(connection)),
+            debugger,
           );
           break;
         }
       }
       if (appTab != null) break;
       safeUnawaited(connection.close());
     }
-    if (appTab == null || tabConnection == null || executionContext == null) {
+    if (appTab == null || connection == null || executionContext == null) {
       throw AppConnectionException(
         'Could not connect to application with appInstanceId: '
         '$appInstanceId',
       );
     }
 
-    final webkitDebugger = WebkitDebugger(WipDebugger(tabConnection));
-
     return ChromeDebugService.start(
       // We assume the user will connect to the debug service on the same
       // machine. This allows consumers of DWDS to provide a `hostname` for
       // debugging through the Dart Debug Extension without impacting the local
       // debug workflow.
       hostname: 'localhost',
-      remoteDebugger: webkitDebugger,
+      remoteDebugger: debugger,
       executionContext: executionContext,
       assetReader: _assetReader,
       appConnection: appConnection,