consolidate handleChromeMessages and handleWebSocketMessages created default createIsolate and destroyIsolate in ProxyService

Author: jyameo

dwds/lib/src/handlers/dev_handler.dart

@@ -141,6 +141,7 @@ class DevHandler {
   /// Sends the provided [request] to all connected injected clients.
   /// Returns the number of clients the request was successfully sent to.
   int _sendRequestToClients(Object request) {
+    _logger.finest('Sending request to injected clients: $request');
     var successfulSends = 0;
     for (final injectedConnection in _injectedConnections) {
       try {
@@ -358,12 +359,9 @@ class DevHandler {
           }
           if (message is DevToolsRequest) {
             await _handleDebugRequest(connection, injectedConnection);
-          } else if (useWebSocketConnection) {
-            // Handle WebSocket-specific messages
-            await _handleWebSocketMessage(connection, message);
           } else {
-            // Handle Chrome-specific messages
-            await _handleChromeMessage(connection, message);
+            // Handle messages for both WebSocket and Chrome proxy services
+            await _handleMessage(connection, message);
           }
         }
       } catch (e, s) {
@@ -413,66 +411,40 @@ class DevHandler {
     );
   }
 
-  /// Handles WebSocket-specific messages.
-  Future<void> _handleWebSocketMessage(
-    AppConnection connection,
-    Object? message,
-  ) async {
+  /// Handles messages for both WebSocket and Chrome proxy services.
+  Future<void> _handleMessage(AppConnection connection, Object? message) async {
     if (message == null) return;
 
     final appId = connection.request.appId;
     final proxyService = _servicesByAppId[appId]?.proxyService;
-    final wsService =
-        proxyService is WebSocketProxyService ? proxyService : null;
 
-    if (wsService == null) {
+    if (proxyService == null) {
       _logger.warning(
-        'No WebSocketProxyService found for appId: $appId to process $message',
+        'No proxy service found for appId: $appId to process $message',
       );
       return;
     }
+
+    // Handle messages that are specific to certain proxy service types
     if (message is HotReloadResponse) {
-      wsService.completeHotReload(message);
+      proxyService.completeHotReload(message);
     } else if (message is ServiceExtensionResponse) {
-      wsService.completeServiceExtension(message);
-    } else if (message is RegisterEvent) {
-      wsService.parseRegisterEvent(message);
-    } else if (message is BatchedDebugEvents) {
-      wsService.parseBatchedDebugEvents(message);
-    } else if (message is DebugEvent) {
-      wsService.parseDebugEvent(message);
-    } else {
-      throw UnsupportedError(
-        'Message type ${message.runtimeType} is not supported in WebSocket mode',
-      );
-    }
-  }
-
-  /// Handles Chrome-specific messages.
-  Future<void> _handleChromeMessage(
-    AppConnection connection,
-    Object? message,
-  ) async {
-    if (message == null) return;
-
-    final appId = connection.request.appId;
-    final proxyService = _servicesByAppId[appId]?.proxyService;
-    final chromeService =
-        proxyService is ChromeProxyService ? proxyService : null;
-
-    if (message is IsolateExit) {
+      proxyService.completeServiceExtension(message);
+    } else if (message is IsolateExit) {
       _handleIsolateExit(connection);
     } else if (message is IsolateStart) {
       await _handleIsolateStart(connection);
     } else if (message is BatchedDebugEvents) {
-      chromeService?.parseBatchedDebugEvents(message);
+      proxyService.parseBatchedDebugEvents(message);
     } else if (message is DebugEvent) {
-      chromeService?.parseDebugEvent(message);
+      proxyService.parseDebugEvent(message);
     } else if (message is RegisterEvent) {
-      chromeService?.parseRegisterEvent(message);
+      proxyService.parseRegisterEvent(message);
     } else {
+      final serviceType =
+          proxyService is WebSocketProxyService ? 'WebSocket' : 'Chrome';
       throw UnsupportedError(
-        'Message type ${message.runtimeType} is not supported in Chrome mode',
+        'Message type ${message.runtimeType} is not supported in $serviceType mode',
       );
     }
   }
@@ -649,12 +621,12 @@ class DevHandler {
     // AppConnection is in the KeepAlive state (this means it disconnected but
     // is still waiting for a possible reconnect - this happens during a page
     // reload).
-    final canReuseConnection =
+    final canReconnect =
         services != null &&
         (services.connectedInstanceId == null ||
             existingConnection?.isInKeepAlivePeriod == true);
 
-    if (canReuseConnection) {
+    if (canReconnect) {
       // Disconnect any old connection (eg. those in the keep-alive waiting
       // state when reloading the page).
       existingConnection?.shutDown();
@@ -719,13 +691,13 @@ class DevHandler {
     final hasNoActiveConnection = services?.connectedInstanceId == null;
     final noExistingConnection = existingConnection == null;
 
-    final canReuseConnection =
+    final canReconnect =
         services != null &&
         (isSameInstance ||
             (isKeepAliveReconnect && hasNoActiveConnection) ||
             (noExistingConnection && hasNoActiveConnection));
 
-    if (canReuseConnection) {
+    if (canReconnect) {
       // Reconnect to existing service.
       await _reconnectToService(
         services,
@@ -739,15 +711,13 @@ class DevHandler {
       readyToRunMainCompleter.complete();
 
       // For WebSocket mode, we need to proactively create and emit a debug connection
-      // since Flutter tools won't call debugConnection() for WebServerDevice
       try {
         // Initialize the WebSocket service and create debug connection
         final debugConnection = await createDebugConnectionForWebSocket(
           connection,
         );
 
         // Emit the debug connection through the extension stream
-        // This should trigger Flutter tools to pick it up as if it was an extension connection
         extensionDebugConnections.add(debugConnection);
       } catch (e, s) {
         _logger.warning('Failed to create WebSocket debug connection: $e\n$s');

dwds/lib/src/services/chrome_proxy_service.dart

@@ -262,6 +262,7 @@ class ChromeProxyService extends ProxyService {
   ///
   /// If [newConnection] is true, this method does not recompute metadata
   /// information as the metadata couldn't have changed.
+  @override
   Future<void> createIsolate(
     AppConnection appConnection, {
     bool newConnection = false,
@@ -381,6 +382,7 @@ class ChromeProxyService extends ProxyService {
   /// Should be called when there is a hot restart or full page refresh.
   ///
   /// Clears out the [_inspector] and all related cached information.
+  @override
   void destroyIsolate() {
     _logger.fine('Destroying isolate');
     if (!_isIsolateRunning) return;

dwds/lib/src/services/proxy_service.dart

@@ -5,7 +5,10 @@
 import 'dart:async';
 
 import 'package:dwds/data/debug_event.dart';
+import 'package:dwds/data/hot_reload_response.dart';
 import 'package:dwds/data/register_event.dart';
+import 'package:dwds/data/service_extension_response.dart';
+import 'package:dwds/src/connections/app_connection.dart';
 import 'package:dwds/src/events.dart';
 import 'package:dwds/src/utilities/shared.dart';
 import 'package:pub_semver/pub_semver.dart' as semver;
@@ -182,6 +185,22 @@ abstract class ProxyService implements VmServiceInterface {
   /// protocol [Event].
   void parseRegisterEvent(RegisterEvent registerEvent);
 
+  /// Completes hot reload with response from client.
+  ///
+  /// Default implementation throws UnimplementedError.
+  /// Override in subclasses that support hot reload completion.
+  void completeHotReload(HotReloadResponse response) {
+    throw UnimplementedError('completeHotReload not supported');
+  }
+
+  /// Completes service extension with response from client.
+  ///
+  /// Default implementation throws UnimplementedError.
+  /// Override in subclasses that support service extension completion.
+  void completeServiceExtension(ServiceExtensionResponse response) {
+    throw UnimplementedError('completeServiceExtension not supported');
+  }
+
   /// Standard RPC error for unsupported methods.
   static vm_service.RPCError _rpcNotSupported(String method) {
     return vm_service.RPCError(
@@ -347,6 +366,21 @@ abstract class ProxyService implements VmServiceInterface {
     return _rpcNotSupportedFuture('clearCpuSamples');
   }
 
+  /// Creates a new isolate for debugging.
+  ///
+  /// Implementations should handle isolate lifecycle management according to
+  /// their specific debugging mode (Chrome vs WebSocket).
+  Future<void> createIsolate(
+    AppConnection appConnection, {
+    bool newConnection = false,
+  });
+
+  /// Destroys the isolate and cleans up debugging state.
+  ///
+  /// Implementations should handle cleanup according to their specific
+  /// debugging mode and connection management strategy.
+  void destroyIsolate();
+
   /// Prevent DWDS from blocking Dart SDK rolls if changes in package:vm_service
   /// are unimplemented in DWDS.
   @override

dwds/lib/src/services/web_socket_proxy_service.dart

@@ -122,15 +122,20 @@ class WebSocketProxyService extends ProxyService {
   bool _mainHasStarted = false;
 
   /// Creates a new isolate for WebSocket debugging.
-  Future<void> createIsolate([AppConnection? appConnectionOverride]) async {
-    // Update app connection if override provided
-    appConnection = appConnectionOverride ?? appConnection;
+  @override
+  Future<void> createIsolate(
+    AppConnection appConnection, {
+    bool newConnection = false,
+  }) async {
+    // Update app connection
+    this.appConnection = appConnection;
 
     // Track this connection
     final connectionId = appConnection.request.instanceId;
 
     // Check if this connection is already being tracked
     final isNewConnection =
+        newConnection ||
         !_appConnectionDoneSubscriptions.containsKey(connectionId);
 
     if (isNewConnection) {
@@ -265,6 +270,7 @@ class WebSocketProxyService extends ProxyService {
   }
 
   /// Destroys the isolate and cleans up state.
+  @override
   void destroyIsolate() {
     _logger.fine('Destroying isolate');
 
@@ -452,6 +458,7 @@ class WebSocketProxyService extends ProxyService {
   }
 
   /// Completes hot reload with response from client.
+  @override
   void completeHotReload(HotReloadResponse response) {
     final tracker = _pendingHotReloads[response.id];
 
@@ -630,6 +637,7 @@ class WebSocketProxyService extends ProxyService {
   }
 
   /// Completes service extension with response.
+  @override
   void completeServiceExtension(ServiceExtensionResponse response) {
     final id = response.id;