Fixed hot reload/restart crashes after closing browser tab on web-server device (flutter#177026)

This PR fixes crashes during hot reload/restart operations on web-server
devices that occur when browser tabs are closed. Previously, the VM
service would throw "Bad state: No element" errors when attempting
operations with no connected clients. The fix introduces graceful
handling on both sides: DWDS now catches NoClientsAvailableException in
its hot reload/restart operations and returns structured JSON responses
with a noClientsAvailable boolean flag instead of throwing exceptions.
Flutter Tools reads this flag via a helper method
_checkNoClientsAvailable() and handles the scenario gracefully by
displaying "Recompile complete. No client connected." while preserving
the DWDS connection to automatically support browser reconnections
without requiring a full restart of the Flutter tools.


Fixes: flutter#174791

Changes in DWDS (Parent PR):
dart-lang/webdev#2699

Follow up bug: dart-lang/sdk#61757

Author: jyameo

packages/flutter_tools/lib/src/isolated/resident_web_runner.dart

@@ -88,6 +88,8 @@ const kExitMessage =
     'instance in Chrome.\nThis can happen if the websocket connection used by the '
     'web tooling is unable to correctly establish a connection, for example due to a firewall.';
 
+const kNoClientConnectedMessage = 'Recompile complete. No client connected.';
+
 class ResidentWebRunner extends ResidentRunner {
   ResidentWebRunner(
     FlutterDevice device, {
@@ -404,6 +406,13 @@ class ResidentWebRunner extends ResidentRunner {
     );
   }
 
+  /// Handles the no clients available scenario gracefully.
+  OperationResult _handleNoClientsAvailable(Status status) {
+    status.stop();
+    _logger.printStatus(kNoClientConnectedMessage);
+    return OperationResult.ok;
+  }
+
   @override
   Future<OperationResult> restart({
     bool fullRestart = false,
@@ -487,9 +496,7 @@ class ResidentWebRunner extends ResidentRunner {
     }
 
     if (_connectionResult == null) {
-      status.stop();
-      _logger.printStatus('Recompile complete. No client connected..');
-      return OperationResult.ok;
+      return _handleNoClientsAvailable(status);
     }
 
     // Both will be null when not assigned.
@@ -504,13 +511,51 @@ class ResidentWebRunner extends ResidentRunner {
           // it. Otherwise, default to calling "hotRestart" without a namespace.
           final String hotRestartMethod =
               _registeredMethodsForService['hotRestart'] ?? 'hotRestart';
-          await _vmService.service.callMethod(hotRestartMethod);
+
+          try {
+            await _vmService.service.callMethod(hotRestartMethod);
+          } on vmservice.RPCError catch (e) {
+            // DWDS throws an RPC error with kIsolateCannotReload code when there are no
+            // browser clients currently connected during a hot restart operation.
+
+            // TODO(61757): Remove this temporary workaround once vm_service is fixed.
+            // There's a bug in vm_service where it re-encodes RPCErrors as kServerError
+            // instead of preserving the original error code. Until that's fixed, we need
+            // to check for both kIsolateCannotReload and kServerError for this method.
+            if (e.callingMethod == hotRestartMethod &&
+                (e.code == vmservice.RPCErrorKind.kIsolateCannotReload.code ||
+                    e.code == vmservice.RPCErrorKind.kServerError.code)) {
+              return _handleNoClientsAvailable(status);
+            }
+            // Re-throw other RPC errors
+            rethrow;
+          }
         } else {
           final DateTime reloadStart = _systemClock.now();
           final vmservice.VM vm = await _vmService.service.getVM();
-          final vmservice.ReloadReport report = await _vmService.service.reloadSources(
-            vm.isolates!.first.id!,
-          );
+          final String hotReloadMethod =
+              _registeredMethodsForService['reloadSources'] ?? 'reloadSources';
+
+          // Check if there are any isolates available
+          if (vm.isolates == null || vm.isolates!.isEmpty) {
+            _logger.printTrace('No isolates available for hot reload');
+            return _handleNoClientsAvailable(status);
+          }
+
+          vmservice.ReloadReport report;
+          try {
+            report = await _vmService.service.reloadSources(vm.isolates!.first.id!);
+          } on vmservice.RPCError catch (e) {
+            // DWDS throws an RPC error with kIsolateCannotReload code when there are no
+            // browser clients currently connected during a hot reload operation.
+            if (e.callingMethod == hotReloadMethod &&
+                e.code == vmservice.RPCErrorKind.kIsolateCannotReload.code) {
+              return _handleNoClientsAvailable(status);
+            }
+            // Re-throw other RPC errors
+            rethrow;
+          }
+
           reloadDuration = _systemClock.now().difference(reloadStart);
           final contents = ReloadReportContents.fromReloadReport(report);
           final bool success = contents.success ?? false;

packages/flutter_tools/pubspec.yaml

@@ -14,7 +14,7 @@ dependencies:
   archive: 3.6.1
   args: 2.7.0
   dds: 5.0.3
-  dwds: 26.0.0
+  dwds: 26.1.0
   code_builder: 4.11.0
   collection: 1.19.1
   completion: 1.0.2
@@ -127,4 +127,4 @@ dev_dependencies:
 dartdoc:
   # Exclude this package from the hosted API docs.
   nodoc: true
-# PUBSPEC CHECKSUM: 848sij
+# PUBSPEC CHECKSUM: d3nerf

packages/flutter_tools/test/general.shard/resident_web_runner_test.dart

@@ -963,7 +963,7 @@ name: my_app
       expect(debugConnectionInfo, isNotNull);
 
       final OperationResult result = await residentWebRunner.restart();
-      expect(logger.statusText, contains('Recompile complete. No client connected.'));
+      expect(logger.statusText, contains(kNoClientConnectedMessage));
       expect(result.code, 0);
     },
     overrides: <Type, Generator>{
@@ -1166,7 +1166,7 @@ name: my_app
 
       expect(result.code, 0);
       expect(result.isOk, isTrue);
-      expect(logger.statusText, contains('Recompile complete. No client connected.'));
+      expect(logger.statusText, contains(kNoClientConnectedMessage));
     },
     overrides: <Type, Generator>{
       Analytics: () => fakeAnalytics,

packages/flutter_tools/test/integration.shard/hot_reload_websocket_test.dart

@@ -8,7 +8,7 @@ library;
 import 'dart:async';
 
 import 'package:file/file.dart';
-
+import 'package:flutter_tools/src/isolated/resident_web_runner.dart' show kNoClientConnectedMessage;
 import '../src/common.dart';
 import 'test_data/hot_reload_project.dart';
 import 'test_data/websocket_dwds_test_common.dart';
@@ -54,7 +54,7 @@ void testAll({List<String> additionalCommandArgs = const <String>[]}) {
 
         try {
           // Test hot reload functionality
-          debugPrint('Step 6: Testing hot reload with WebSocket connection...');
+          debugPrint('Testing hot reload with WebSocket connection...');
           await flutter.hotReload().timeout(
             hotReloadTimeout,
             onTimeout: () {
@@ -80,5 +80,71 @@ void testAll({List<String> additionalCommandArgs = const <String>[]}) {
       },
       skip: !platform.isMacOS, // Skip on non-macOS platforms where Chrome paths may differ
     );
+
+    testWithoutContext(
+      'hot reload gracefully handles closed browser (no clients available)',
+      () async {
+        debugPrint('Starting test for no clients available scenario...');
+
+        // Set up WebSocket connection
+        final WebSocketDwdsTestSetup setup = await WebSocketDwdsTestUtils.setupWebSocketConnection(
+          flutter,
+          additionalCommandArgs: additionalCommandArgs,
+        );
+
+        try {
+          // First, verify hot reload works with browser connected
+          debugPrint('Verifying initial hot reload with browser connected...');
+          await flutter.hotReload().timeout(
+            hotReloadTimeout,
+            onTimeout: () {
+              throw Exception('Initial hot reload timed out');
+            },
+          );
+
+          await Future<void>.delayed(const Duration(seconds: 1));
+          final initialOutput = setup.stdout.toString();
+          expect(initialOutput, contains('Reloaded'), reason: 'Initial hot reload should succeed');
+          debugPrint('✓ Initial hot reload succeeded');
+
+          // Close the browser to simulate no clients available
+          debugPrint('Closing browser to simulate no clients available...');
+          setup.chromeProcess.kill();
+          await setup.chromeProcess.exitCode;
+          debugPrint('✓ Browser closed');
+
+          // Give DWDS time to detect the disconnection
+          await Future<void>.delayed(const Duration(seconds: 2));
+
+          // Attempt hot reload with no browser connected
+          debugPrint('Attempting hot reload with no browser connected...');
+          await flutter.hotReload().timeout(
+            hotReloadTimeout,
+            onTimeout: () {
+              throw Exception('Hot reload with no clients timed out');
+            },
+          );
+
+          // Give some time for logs to capture
+          await Future<void>.delayed(const Duration(seconds: 2));
+
+          final output = setup.stdout.toString();
+
+          // Verify the graceful handling message
+          expect(
+            output,
+            contains(kNoClientConnectedMessage),
+            reason: 'Should show no client connected message',
+          );
+
+          debugPrint('✓ Hot reload handled no clients gracefully');
+          debugPrint('✓ Test completed: Verified graceful handling when browser is closed');
+        } finally {
+          // Note: Chrome process is already killed in the test, so just cancel subscription
+          await setup.subscription.cancel();
+        }
+      },
+      skip: !platform.isMacOS, // Skip on non-macOS platforms where Chrome paths may differ
+    );
   });
 }

packages/flutter_tools/test/integration.shard/test_data/websocket_dwds_test_common.dart

@@ -51,7 +51,7 @@ class WebSocketDwdsTestUtils {
     required List<String> additionalCommandArgs,
     WebSocketDwdsTestConfig config = const WebSocketDwdsTestConfig(),
   }) async {
-    debugPrint('Step 1: Starting WebSocket DWDS connection setup...');
+    debugPrint('Starting WebSocket DWDS connection setup...');
 
     // Set up listening for app output before starting
     final stdout = StringBuffer();
@@ -72,15 +72,15 @@ class WebSocketDwdsTestUtils {
 
     io.Process? chromeProcess;
     try {
-      // Step 1: Start Flutter app with web-server device (will wait for debug connection)
-      debugPrint('Step 2: Starting Flutter app with web-server device...');
+      // Start Flutter app with web-server device (will wait for debug connection)
+      debugPrint('Starting Flutter app with web-server device...');
       final Future<void> appStartFuture = runFlutterWithWebServerDevice(
         flutter,
         additionalCommandArgs: [...additionalCommandArgs, '--no-web-resources-cdn'],
       );
 
-      // Step 2: Wait for DWDS debug URL to be available
-      debugPrint('Step 3: Waiting for DWDS debug service URL...');
+      // Wait for DWDS debug URL to be available
+      debugPrint('Waiting for DWDS debug service URL...');
       final String debugUrl = await sawDebugUrl.future.timeout(
         config.debugUrlTimeout,
         onTimeout: () {
@@ -89,13 +89,13 @@ class WebSocketDwdsTestUtils {
       );
       debugPrint('✓ DWDS debug service available at: $debugUrl');
 
-      // Step 3: Launch headless Chrome to connect to DWDS
-      debugPrint('Step 4: Launching headless Chrome to connect to DWDS...');
+      // Launch headless Chrome to connect to DWDS
+      debugPrint('Launching headless Chrome to connect to DWDS...');
       chromeProcess = await launchHeadlessChrome(debugUrl);
       debugPrint('✓ Headless Chrome launched and connecting to DWDS');
 
-      // Step 4: Wait for app to start (Chrome connection established)
-      debugPrint('Step 5: Waiting for Flutter app to start after Chrome connection...');
+      // Wait for app to start (Chrome connection established)
+      debugPrint('Waiting for Flutter app to start after Chrome connection...');
       await appStartFuture.timeout(
         config.appStartTimeout,
         onTimeout: () {