Add ext.dwds.sendEvent service extension to implement DEBUGGER_READY event

Author: Anna Gringauze

dwds/lib/src/dwds_vm_client.dart

@@ -40,7 +40,8 @@ class DwdsVmClient {
         await client.dispose();
       }();
 
-  static Future<DwdsVmClient> create(DebugService debugService) async {
+  static Future<DwdsVmClient> create(
+      DebugService debugService, DwdsStats dwdsStats) async {
     // Set up hot restart as an extension.
     var requestController = StreamController<Map<String, Object>>();
     var responseController = StreamController<Map<String, Object>>();
@@ -154,6 +155,20 @@ class DwdsVmClient {
     });
     await client.registerService('ext.dwds.screenshot', 'DWDS');
 
+    client.registerServiceCallback('ext.dwds.sendEvent', (event) async {
+      var type = event['type'] as String;
+      switch (type) {
+        case 'DevtoolsReady':
+          {
+            emitEvent(DwdsEvent.debuggerReady(DateTime.now()
+                .difference(dwdsStats.debuggerStart)
+                .inMilliseconds));
+          }
+      }
+      return {'result': Success().toJson()};
+    });
+    await client.registerService('ext.dwds.sendEvent', 'DWDS');
+
     client.registerServiceCallback('ext.dwds.emitEvent', (event) async {
       emitEvent(DwdsEvent(
           event['type'] as String, event['payload'] as Map<String, dynamic>));

dwds/lib/src/handlers/dev_handler.dart

@@ -209,7 +209,6 @@ class DevHandler {
       useSse: false,
       expressionCompiler: _expressionCompiler,
       spawnDds: _spawnDds,
-      dwdsStats: DwdsStats(DateTime.now()),
     );
   }
 
@@ -223,12 +222,13 @@ class DevHandler {
   }
 
   Future<AppDebugServices> loadAppServices(AppConnection appConnection) async {
+    var dwdsStats = DwdsStats(DateTime.now());
     var appId = appConnection.request.appId;
     if (_servicesByAppId[appId] == null) {
       var debugService = await _startLocalDebugService(
           await _chromeConnection(), appConnection);
       var appServices = await _createAppDebugServices(
-          appConnection.request.appId, debugService);
+          appConnection.request.appId, debugService, dwdsStats);
       unawaited(appServices.chromeProxyService.remoteDebugger.onClose.first
           .whenComplete(() async {
         await appServices.close();
@@ -435,8 +435,8 @@ class DevHandler {
   }
 
   Future<AppDebugServices> _createAppDebugServices(
-      String appId, DebugService debugService) async {
-    var webdevClient = await DwdsVmClient.create(debugService);
+      String appId, DebugService debugService, DwdsStats dwdsStats) async {
+    var webdevClient = await DwdsVmClient.create(debugService, dwdsStats);
     if (_spawnDds) {
       await debugService.startDartDevelopmentService();
     }
@@ -464,6 +464,7 @@ class DevHandler {
     // Waits for a `DevToolsRequest` to be sent from the extension background
     // when the extension is clicked.
     extensionDebugger.devToolsRequestStream.listen((devToolsRequest) async {
+      var dwdsStats = DwdsStats(DateTime.now());
       var connection = _appConnectionByAppId[devToolsRequest.appId];
       if (connection == null) {
         // TODO(grouma) - Ideally we surface this warning to the extension so
@@ -491,10 +492,12 @@ class DevHandler {
           useSse: _useSseForDebugProxy,
           expressionCompiler: _expressionCompiler,
           spawnDds: _spawnDds,
-          dwdsStats: DwdsStats(DateTime.now()),
         );
-        var appServices =
-            await _createAppDebugServices(devToolsRequest.appId, debugService);
+        var appServices = await _createAppDebugServices(
+          devToolsRequest.appId,
+          debugService,
+          dwdsStats,
+        );
         var encodedUri = await debugService.encodedUri;
         extensionDebugger.sendEvent('dwds.encodedUri', encodedUri);
         unawaited(appServices.chromeProxyService.remoteDebugger.onClose.first

dwds/lib/src/services/chrome_proxy_service.dart

@@ -95,8 +95,6 @@ class ChromeProxyService implements VmServiceInterface {
   final ExpressionCompiler _compiler;
   ExpressionEvaluator _expressionEvaluator;
 
-  final DwdsStats _dwdsStats;
-
   bool terminatingIsolates = false;
 
   ChromeProxyService._(
@@ -109,7 +107,6 @@ class ChromeProxyService implements VmServiceInterface {
     this._skipLists,
     this.executionContext,
     this._compiler,
-    this._dwdsStats,
   ) {
     var debugger = Debugger.create(
       remoteDebugger,
@@ -123,14 +120,14 @@ class ChromeProxyService implements VmServiceInterface {
   }
 
   static Future<ChromeProxyService> create(
-      RemoteDebugger remoteDebugger,
-      String tabUrl,
-      AssetReader assetReader,
-      LoadStrategy loadStrategy,
-      AppConnection appConnection,
-      ExecutionContext executionContext,
-      ExpressionCompiler expressionCompiler,
-      DwdsStats dwdsStats) async {
+    RemoteDebugger remoteDebugger,
+    String tabUrl,
+    AssetReader assetReader,
+    LoadStrategy loadStrategy,
+    AppConnection appConnection,
+    ExecutionContext executionContext,
+    ExpressionCompiler expressionCompiler,
+  ) async {
     final vm = VM(
       name: 'ChromeDebugProxy',
       operatingSystem: Platform.operatingSystem,
@@ -159,7 +156,6 @@ class ChromeProxyService implements VmServiceInterface {
       skipLists,
       executionContext,
       expressionCompiler,
-      dwdsStats,
     );
     unawaited(service.createIsolate(appConnection));
     return service;
@@ -548,7 +544,7 @@ ${globalLoadStrategy.loadModuleSnippet}("dart_sdk").developer.invokeExtension(
       int endTokenPos,
       bool forceCompile,
       bool reportLines}) async {
-    var result = await _captureElapsedTime(() async {
+    return await _captureElapsedTime(() async {
       await isInitialized;
       return await _inspector?.getSourceReport(isolateId, reports,
           scriptId: scriptId,
@@ -557,18 +553,6 @@ ${globalLoadStrategy.loadModuleSnippet}("dart_sdk").developer.invokeExtension(
           forceCompile: forceCompile,
           reportLines: reportLines);
     }, (result) => DwdsEvent.getSourceReport());
-
-    // This metric is an approximation of the "debugger is ready"
-    // time when using devtools. It currently has flaws:
-    // - it does not make sense for other debugger uses
-    // - is also can be invalidated later.
-    // Issue: https://github.com/dart-lang/webdev/issues/1406
-    if (_dwdsStats.isFirstDebuggerReady()) {
-      emitEvent(DwdsEvent.debuggerReady(
-          DateTime.now().difference(_dwdsStats.debuggerStart).inMilliseconds));
-    }
-
-    return result;
   }
 
   /// Returns the current stack.

dwds/lib/src/services/debug_service.dart

@@ -23,7 +23,6 @@ import 'package:web_socket_channel/web_socket_channel.dart';
 import '../../dwds.dart';
 import '../debugging/execution_context.dart';
 import '../debugging/remote_debugger.dart';
-import '../events.dart';
 import '../utilities/shared.dart';
 import 'chrome_proxy_service.dart';
 
@@ -214,8 +213,7 @@ class DebugService {
       void Function(Map<String, dynamic>) onResponse,
       bool spawnDds = true,
       bool useSse,
-      ExpressionCompiler expressionCompiler,
-      DwdsStats dwdsStats}) async {
+      ExpressionCompiler expressionCompiler}) async {
     useSse ??= false;
     var chromeProxyService = await ChromeProxyService.create(
         remoteDebugger,
@@ -224,8 +222,7 @@ class DebugService {
         loadStrategy,
         appConnection,
         executionContext,
-        expressionCompiler,
-        dwdsStats);
+        expressionCompiler);
     var authToken = _makeAuthToken();
     var serviceExtensionRegistry = ServiceExtensionRegistry();
     Handler handler;

dwds/test/events_test.dart

@@ -55,11 +55,57 @@ void main() {
     await events;
   });
 
+  test('emits DEBUGGER_READY event', () async {
+    // The events stream is a broadcast stream so start listening before the
+    // action.
+    var events = expectLater(
+        context.testServer.dwds.events,
+        emitsThrough(predicate(
+            (DwdsEvent event) => event.type == DwdsEventKind.debuggerReady)));
+    await context.webDriver.driver.keyboard.sendChord([Keyboard.alt, 'd']);
+    await events;
+  },
+      skip:
+          'https://github.com/dart-lang/webdev/issues/1406'); // Not implemented yet.
+
   test('events can be listened to multiple times', () async {
     context.testServer.dwds.events.listen((_) {});
     context.testServer.dwds.events.listen((_) {});
   });
 
+  test('can emit event through service extension', () async {
+    var events = expectLater(
+        context.testServer.dwds.events,
+        emitsThrough(predicate((DwdsEvent event) =>
+            event.type == 'foo-event' && event.payload['data'] == 1234)));
+
+    var response = await context.debugConnection.vmService
+        .callServiceExtension('ext.dwds.emitEvent', args: {
+      'type': 'foo-event',
+      'payload': {'data': 1234},
+    });
+    expect(response.type, 'Success');
+    await events;
+  });
+
+  test(
+      'can receive DevtoolsReady event and emit DEBUGGER_READY '
+      'event through service extension', () async {
+    var events = expectLater(
+        context.testServer.dwds.events,
+        emitsThrough(predicate((DwdsEvent event) =>
+            event.type == DwdsEventKind.debuggerReady &&
+            event.payload['elapsedMilliseconds'] != null)));
+
+    var response = await context.debugConnection.vmService
+        .callServiceExtension('ext.dwds.sendEvent', args: {
+      'type': 'DevtoolsReady',
+      'payload': {},
+    });
+    expect(response.type, 'Success');
+    await events;
+  });
+
   group('evaluate', () {
     Isolate isolate;
     LibraryRef bootstrap;
@@ -75,21 +121,6 @@ void main() {
       setCurrentLogWriter();
     });
 
-    test('can emit event through service extension', () async {
-      var events = expectLater(
-          context.testServer.dwds.events,
-          emitsThrough(predicate((DwdsEvent event) =>
-              event.type == 'foo-event' && event.payload['data'] == 1234)));
-
-      var response = await context.debugConnection.vmService
-          .callServiceExtension('ext.dwds.emitEvent', args: {
-        'type': 'foo-event',
-        'payload': {'data': 1234},
-      });
-      expect(response.type, 'Success');
-      await events;
-    });
-
     test('emits EVALUATE events on evaluation success', () async {
       var expression = "helloString('world')";
       var events = expectLater(
@@ -260,14 +291,11 @@ void main() {
     test('emits GET_SOURCE_REPORT events', () async {
       var events = expectLater(
           context.testServer.dwds.events,
-          emitsInOrder([
+          emitsThrough(
             predicate((DwdsEvent event) =>
                 event.type == DwdsEventKind.getSourceReport &&
                 event.payload['elapsedMilliseconds'] != null),
-            predicate((DwdsEvent event) =>
-                event.type == DwdsEventKind.debuggerReady &&
-                event.payload['elapsedMilliseconds'] != null),
-          ]));
+          ));
       await service.getSourceReport(
           isolateId, [SourceReportKind.kPossibleBreakpoints],
           scriptId: mainScript.id);