Configure DevTools to pause isolates on hot restart, and then only resume once breakpoints have been set

packages/devtools_app/lib/src/screens/debugger/breakpoint_manager.dart

@@ -85,6 +85,10 @@ class BreakpointManager with DisposerMixin {
         isolateRef: isolateRef,
       );
     }
+
+    // Resume the isolate now that the breakpoints have been set:
+    await serviceConnection.serviceManager.isolateManager
+        .resumeIsolate(isolateRef);
   }
 
   void clearCache({required bool isServiceShutdown}) {

packages/devtools_app/release_notes/NEXT_RELEASE_NOTES.md

@@ -34,7 +34,7 @@ TODO: Remove this section if there are not any general updates.
 
 ## Debugger updates
 
-TODO: Remove this section if there are not any general updates.
+* During a hot-restart, `pause_isolates_on_start` and only `resume` the app once breakpoints are set. - [#7234](https://github.com/flutter/devtools/pull/7234)
 
 ## Network profiler updates
 

packages/devtools_app_shared/lib/src/service/isolate_manager.dart

@@ -99,6 +99,22 @@ final class IsolateManager with DisposerMixin {
     _isolates.add(isolateRef);
     isolateIndex(isolateRef);
     await _loadIsolateState(isolateRef);
+    // If the flag pause-breakpoints-on-start was successfully set, then each
+    // new isolate will start paused. Therefore resume it (unless it is the
+    // current isolate, in which case the breakpoint manager will resume it
+    // after setting breakpoints):
+    if (selectedIsolate.value?.id != isolateRef.id) {
+      final isWebApp =
+          serviceConnection.serviceManager.connectedApp?.isDartWebAppNow ??
+              false;
+      // TODO(bug link) Once we can reliably determine whether a web app is
+      // paused, then switch to resumeIsolateIfPaused.
+      if (isWebApp) {
+        await resumeIsolate(isolateRef);
+      } else {
+        await resumeIsolateIfPaused(isolateRef);
+      }
+    }
   }
 
   Future<void> _loadIsolateState(IsolateRef isolateRef) async {
@@ -237,6 +253,28 @@ final class IsolateManager with DisposerMixin {
     _isolateRunnableCompleters.clear();
   }
 
+  /// Resumes the isolate for the given [isolateRef] if it is paused.
+  ///
+  /// CAUTION: This is not reliable for web apps. An "isolate" can be paused,
+  /// but isPaused is returns false. See [bug link] for details.
+  Future<void> resumeIsolateIfPaused(IsolateRef isolateRef) async {
+    final isPaused = _isolateStates[isolateRef]?.isPaused.value ?? false;
+    if (isPaused) {
+      return resumeIsolate(isolateRef);
+    }
+  }
+
+  Future<void> resumeIsolate(IsolateRef isolateRef) async {
+    if (isolateRef.id == null || _service == null) return;
+    final isolateId = isolateRef.id!;
+    final service = _service!;
+    try {
+      await service.resume(isolateId);
+    } catch (error) {
+      _log.warning(error);
+    }
+  }
+
   void _clearIsolateStates() {
     for (var isolateState in _isolateStates.values) {
       isolateState.dispose();

packages/devtools_app_shared/lib/src/service/service_manager.dart

@@ -5,6 +5,7 @@
 import 'dart:async';
 import 'dart:core';
 
+import 'package:dds_service_extensions/dds_service_extensions.dart';
 import 'package:flutter/foundation.dart';
 import 'package:logging/logging.dart';
 import 'package:meta/meta.dart';
@@ -130,6 +131,13 @@ class ServiceManager<T extends VmService> {
     _deviceBusy.value = isBusy;
   }
 
+  /// Whether the flag pause_isolates_on_start was set by either the user or
+  /// another debugging client.
+  bool get pauseIsolatesOnStartExternallySet =>
+      _pauseIsolatesOnStartExternallySet;
+
+  bool _pauseIsolatesOnStartExternallySet = false;
+
   /// Set the device as busy during the duration of the given async task.
   Future<V> runDeviceBusyTask<V>(Future<V> task) async {
     try {
@@ -229,6 +237,8 @@ class ServiceManager<T extends VmService> {
     serviceExtensionManager.vmServiceOpened(service, connectedApp!);
     resolvedUriManager.vmServiceOpened(service);
 
+    await _configureIsolateSettings();
+
     await callLifecycleCallbacks(
       ServiceManagerLifecycle.beforeOpenVmService,
       service,
@@ -269,6 +279,45 @@ class ServiceManager<T extends VmService> {
     _connectedState.value = connectionState;
   }
 
+  Future<void> _configureIsolateSettings() async {
+    await _setPauseIsolatesOnStart();
+  }
+
+  Future<void> _setPauseIsolatesOnStart() async {
+    _pauseIsolatesOnStartExternallySet = await _isPauseIsolatesOnStartSet();
+
+    if (service == null) return;
+    final vmService = service!;
+
+    try {
+      await vmService.setFlag('pause_isolates_on_start', 'true');
+      await vmService.requirePermissionToResume(
+        onPauseStart: true,
+      );
+    } catch (error) {
+      _log.warning('$error');
+    }
+  }
+
+  Future<bool> _isPauseIsolatesOnStartSet() async {
+    if (service == null) return false;
+    final vmService = service!;
+
+    try {
+      final flagList = await vmService.getFlagList();
+      if (flagList.flags == null) return false;
+      final flags = flagList.flags!;
+      return flags.any(
+        (flag) =>
+            flag.name == 'pause_isolates_on_start' &&
+            flag.valueAsString == 'true',
+      );
+    } catch (error) {
+      _log.warning('$error');
+      return false;
+    }
+  }
+
   /// Initializes the service manager for [service], including setting up other
   /// managers, initializing stream listeners, and setting up connection state.
   Future<void> _openVmServiceConnection(

packages/devtools_app_shared/pubspec.yaml

@@ -9,6 +9,7 @@ environment:
 
 dependencies:
   collection: ^1.15.0
+  dds_service_extensions: ^1.7.0
   devtools_shared: ^6.0.1
   dtd: ^1.0.0
   flutter: