add support to timeline

Author: CareF

packages/integration_test/example/test_driver/example_integration_io.dart

@@ -13,22 +13,25 @@ import 'package:integration_test/integration_test.dart';
 import 'package:integration_test_example/main.dart' as app;
 
 void main() {
-  IntegrationTestWidgetsFlutterBinding.ensureInitialized();
+  final IntegrationTestWidgetsFlutterBinding binding =
+      IntegrationTestWidgetsFlutterBinding.ensureInitialized() as IntegrationTestWidgetsFlutterBinding;
   testWidgets('verify text', (WidgetTester tester) async {
     // Build our app and trigger a frame.
     app.main();
 
-    // Trigger a frame.
-    await tester.pumpAndSettle();
+    await binding.traceAction(() async {
+      // Trigger a frame.
+      await tester.pumpAndSettle();
 
-    // Verify that platform version is retrieved.
-    expect(
-      find.byWidgetPredicate(
-        (Widget widget) =>
-            widget is Text &&
-            widget.data.startsWith('Platform: ${Platform.operatingSystem}'),
-      ),
-      findsOneWidget,
-    );
+      // Verify that platform version is retrieved.
+      expect(
+        find.byWidgetPredicate(
+          (Widget widget) =>
+              widget is Text &&
+              widget.data.startsWith('Platform: ${Platform.operatingSystem}'),
+        ),
+        findsOneWidget,
+      );
+    });
   });
 }

packages/integration_test/lib/integration_test.dart

@@ -3,12 +3,15 @@
 // found in the LICENSE file.
 
 import 'dart:async';
+import 'dart:developer' as developer;
 
 import 'package:flutter/rendering.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter/widgets.dart';
+import 'package:vm_service/vm_service.dart' as vm;
+import 'package:vm_service/vm_service_io.dart' as vm_io;
 
 import 'common.dart';
 import '_extension_io.dart' if (dart.library.html) '_extension_web.dart';
@@ -188,4 +191,78 @@ class IntegrationTestWidgetsFlutterBinding
     );
     results[description] ??= 'success';
   }
+
+  vm.VmService _vmService;
+
+  /// Initialize the [vm.VmService] settings for the timeline.
+  @visibleForTesting
+  Future<void> enableTimeline({
+    List<String> streams = const <String>['all'],
+    @visibleForTesting vm.VmService vmService,
+  }) async {
+    assert(streams != null);
+    assert(streams.isNotEmpty);
+    if (vmService != null) {
+      _vmService = vmService;
+    }
+    if (_vmService == null) {
+      final developer.ServiceProtocolInfo info = await developer.Service.getInfo();
+      assert(info.serverUri != null);
+      _vmService = await vm_io.vmServiceConnectUri(
+        'ws://localhost:${info.serverUri.port}${info.serverUri.path}ws',
+      );
+    }
+    await _vmService.setVMTimelineFlags(streams);
+  }
+
+  /// Runs [action] and outputs a [vm.Timeline] trace for it.
+  ///
+  /// Waits for the `Future` returned by [action] to complete prior to stopping
+  /// the trace.
+  ///
+  /// `streams` limits the recorded timeline event streams to only the ones
+  /// listed. By default, all streams are recorded.
+  /// See `timeline_streams` in
+  /// https://github.com/dart-lang/sdk/blob/master/runtime/vm/timeline.cc
+  ///
+  /// If [retainPriorEvents] is true, retains events recorded prior to calling
+  /// [action]. Otherwise, prior events are cleared before calling [action]. By
+  /// default, prior events are cleared.
+  Future<vm.Timeline> traceTimeline(
+    Future<dynamic> action(), {
+    List<String> streams = const <String>['all'],
+    bool retainPriorEvents = false,
+  }) async {
+    await enableTimeline(streams: streams);
+    if (retainPriorEvents) {
+      await action();
+      return await _vmService.getVMTimeline();
+    }
+
+    await _vmService.clearVMTimeline();
+    final vm.Timestamp startTime = await _vmService.getVMTimelineMicros();
+    await action();
+    final vm.Timestamp endTime = await _vmService.getVMTimelineMicros();
+    return await _vmService.getVMTimeline(
+      timeOriginMicros: startTime.timestamp,
+      timeExtentMicros: endTime.timestamp,
+    );
+  }
+
+  /// This is a convience wrap of [traceTimeline] and send the result back to
+  /// the host.
+  Future<void> traceAction(
+    Future<dynamic> action(), {
+    List<String> streams = const <String>['all'],
+    bool retainPriorEvents = false,
+    String reportKey = 'timeline',
+  }) async {
+    vm.Timeline timeline = await traceTimeline(
+      action,
+      streams: streams,
+      retainPriorEvents: retainPriorEvents,
+    );
+    reportData ??= <String, dynamic>{};
+    reportData[reportKey] = timeline.toJson();
+  }
 }

packages/integration_test/pubspec.yaml

@@ -15,9 +15,11 @@ dependencies:
   flutter_test:
     sdk: flutter
   path: ^1.6.4
+  vm_service: ^4.2.0
 
 dev_dependencies:
   pedantic: ^1.8.0
+  mockito: ^4.1.1
 
 flutter:
   plugin:

packages/integration_test/test/binding_test.dart

@@ -1,8 +1,18 @@
+import 'dart:convert';
+
 import 'package:flutter/material.dart';
 
 import 'package:integration_test/integration_test.dart';
 import 'package:integration_test/common.dart';
 import 'package:flutter_test/flutter_test.dart';
+import 'package:mockito/mockito.dart';
+import 'package:vm_service/vm_service.dart' as vm;
+
+vm.Timeline _ktimelines = vm.Timeline(
+  traceEvents: <vm.TimelineEvent>[],
+  timeOriginMicros: 100,
+  timeExtentMicros: 200,
+);
 
 void main() async {
   Future<Map<String, dynamic>> request;
@@ -14,10 +24,21 @@ void main() async {
     final IntegrationTestWidgetsFlutterBinding integrationBinding =
         binding as IntegrationTestWidgetsFlutterBinding;
 
+    MockVM mockVM;
+    List<int> clockTimes = [100, 200];
+
     setUp(() {
       request = integrationBinding.callback(<String, String>{
         'command': 'request_data',
       });
+      mockVM = MockVM();
+      when(mockVM.getVMTimeline(
+        timeOriginMicros: anyNamed('timeOriginMicros'),
+        timeExtentMicros: anyNamed('timeExtentMicros'),
+      )).thenAnswer((_) => Future.value(_ktimelines));
+      when(mockVM.getVMTimelineMicros()).thenAnswer(
+        (_) => Future.value(vm.Timestamp(timestamp: clockTimes.removeAt(0))),
+      );
     });
 
     testWidgets('Run Integration app', (WidgetTester tester) async {
@@ -53,6 +74,17 @@ void main() async {
       expect(widgetCenter.dx, windowCenterX);
       expect(widgetCenter.dy, windowCenterY);
     });
+
+    testWidgets('Test traceAction', (WidgetTester tester) async {
+      await integrationBinding.enableTimeline(vmService: mockVM);
+      await integrationBinding.traceAction(() async {});
+      expect(integrationBinding.reportData, isNotNull);
+      expect(integrationBinding.reportData.containsKey('timeline'), true);
+      expect(
+        json.encode(integrationBinding.reportData['timeline']),
+        json.encode(_ktimelines),
+      );
+    });
   });
 
   tearDownAll(() async {
@@ -66,3 +98,5 @@ void main() async {
     assert(result.data['answer'] == 42);
   });
 }
+
+class MockVM extends Mock implements vm.VmService {}