Adding support for macrobenchmarking with "flutter run" (flutter#167692)

Notable changes:
* Allows macrobenchmarks to run via `flutter run`.
* Splits macrobenchmarking between "orchestration logic" and "app
serving" (served on separate ports on the same machine to keep the
scheme consistent with the `flutter build` path).
* Adds an intercepted entrypoint for web benchmarks. We can't pass flags
to the app since it's not supported, so I've hard-coded the
orchestration server's port.
* Adding logic to connect to an existing Chrome debugger instance (vs
spawning one) for benchmarks.

Author: Markzipan

dev/benchmarks/macrobenchmarks/lib/web_benchmarks.dart

@@ -7,6 +7,7 @@ import 'dart:convert' show json;
 import 'dart:js_interop';
 import 'dart:math' as math;
 
+import 'package:args/args.dart';
 import 'package:web/web.dart' as web;
 
 import 'src/web/bench_build_image.dart';
@@ -81,9 +82,28 @@ final Map<String, RecorderFactory> benchmarks = <String, RecorderFactory>{
   BenchImageDecoding.benchmarkName: () => BenchImageDecoding(),
 };
 
-final LocalBenchmarkServerClient _client = LocalBenchmarkServerClient();
+late final LocalBenchmarkServerClient _client;
+
+Future<void> main(List<String> args) async {
+  final ArgParser parser =
+      ArgParser()..addOption(
+        'port',
+        abbr: 'p',
+        help:
+            'The port of the local benchmark server used that implements the '
+            'API required for orchestrating macrobenchmarks.',
+      );
+  final ArgResults argResults = parser.parse(args);
+  Uri serverOrigin;
+  if (argResults.wasParsed('port')) {
+    final int port = int.parse(argResults['port'] as String);
+    serverOrigin = Uri.http('localhost:$port');
+  } else {
+    serverOrigin = Uri.base;
+  }
+
+  _client = LocalBenchmarkServerClient(serverOrigin);
 
-Future<void> main() async {
   // Check if the benchmark server wants us to run a specific benchmark.
   final String nextBenchmark = await _client.requestNextBenchmark();
 
@@ -96,6 +116,14 @@ Future<void> main() async {
   web.window.location.reload();
 }
 
+/// Shared entrypoint used for DDC, which runs the macrobenchmarks server on a
+/// separate port.
+// TODO(markzipan): Use `main` in `'web_benchmarks.dart` when Flutter Web supports the `--dart-entrypoint-args` flag.
+// ignore: unreachable_from_main
+Future<void> sharedMain(List<String> args) {
+  return main(args);
+}
+
 Future<void> _runBenchmark(String benchmarkName) async {
   final RecorderFactory? recorderFactory = benchmarks[benchmarkName];
 
@@ -310,23 +338,36 @@ class TimeseriesVisualization {
 /// implement a manual fallback. This allows debugging benchmarks using plain
 /// `flutter run`.
 class LocalBenchmarkServerClient {
+  LocalBenchmarkServerClient(this.serverOrigin);
+
   /// This value is returned by [requestNextBenchmark].
   static const String kManualFallback = '__manual_fallback__';
 
+  /// The origin (e.g., http://localhost:1234) of the benchmark server that
+  /// hosts the macrobenchmarking API.
+  final Uri serverOrigin;
+
   /// Whether we fell back to manual mode.
   ///
   /// This happens when you run benchmarks using plain `flutter run` rather than
   /// devicelab test harness. The test harness spins up a special server that
   /// provides API for automatically picking the next benchmark to run.
   bool isInManualMode = false;
 
+  Map<String, String> get headers => <String, String>{
+    'Access-Control-Allow-Headers': 'Origin, Content-Type, Accept',
+    'Access-Control-Allow-Methods': 'Post',
+    'Access-Control-Allow-Origin': serverOrigin.path,
+  };
+
   /// Asks the local server for the name of the next benchmark to run.
   ///
   /// Returns [kManualFallback] if local server is not available (uses 404 as a
   /// signal).
   Future<String> requestNextBenchmark() async {
     final web.XMLHttpRequest request = await _requestXhr(
-      '/next-benchmark',
+      serverOrigin.resolve('next-benchmark'),
+      requestHeaders: headers,
       method: 'POST',
       mimeType: 'application/json',
       sendData: json.encode(benchmarks.keys.toList()),
@@ -358,7 +399,8 @@ class LocalBenchmarkServerClient {
   Future<void> startPerformanceTracing(String benchmarkName) async {
     _checkNotManualMode();
     await _requestXhr(
-      '/start-performance-tracing?label=$benchmarkName',
+      serverOrigin.resolve('start-performance-tracing?label=$benchmarkName'),
+      requestHeaders: headers,
       method: 'POST',
       mimeType: 'application/json',
     );
@@ -367,15 +409,21 @@ class LocalBenchmarkServerClient {
   /// Stops the performance tracing session started by [startPerformanceTracing].
   Future<void> stopPerformanceTracing() async {
     _checkNotManualMode();
-    await _requestXhr('/stop-performance-tracing', method: 'POST', mimeType: 'application/json');
+    await _requestXhr(
+      serverOrigin.resolve('stop-performance-tracing'),
+      requestHeaders: headers,
+      method: 'POST',
+      mimeType: 'application/json',
+    );
   }
 
   /// Sends the profile data collected by the benchmark to the local benchmark
   /// server.
   Future<void> sendProfileData(Profile profile) async {
     _checkNotManualMode();
     final web.XMLHttpRequest request = await _requestXhr(
-      '/profile-data',
+      serverOrigin.resolve('profile-data'),
+      requestHeaders: headers,
       method: 'POST',
       mimeType: 'application/json',
       sendData: json.encode(profile.toJson()),
@@ -394,7 +442,8 @@ class LocalBenchmarkServerClient {
   Future<void> reportError(dynamic error, StackTrace stackTrace) async {
     _checkNotManualMode();
     await _requestXhr(
-      '/on-error',
+      serverOrigin.resolve('on-error'),
+      requestHeaders: headers,
       method: 'POST',
       mimeType: 'application/json',
       sendData: json.encode(<String, dynamic>{'error': '$error', 'stackTrace': '$stackTrace'}),
@@ -405,7 +454,8 @@ class LocalBenchmarkServerClient {
   Future<void> printToConsole(String report) async {
     _checkNotManualMode();
     await _requestXhr(
-      '/print-to-console',
+      serverOrigin.resolve('print-to-console'),
+      requestHeaders: headers,
       method: 'POST',
       mimeType: 'text/plain',
       sendData: report,
@@ -415,7 +465,7 @@ class LocalBenchmarkServerClient {
   /// This is the same as calling [html.HttpRequest.request] but it doesn't
   /// crash on 404, which we use to detect `flutter run`.
   Future<web.XMLHttpRequest> _requestXhr(
-    String url, {
+    Uri url, {
     String? method,
     bool? withCredentials,
     String? responseType,
@@ -427,7 +477,7 @@ class LocalBenchmarkServerClient {
     final web.XMLHttpRequest xhr = web.XMLHttpRequest();
 
     method ??= 'GET';
-    xhr.open(method, url, true);
+    xhr.open(method, '$url', true);
 
     if (withCredentials != null) {
       xhr.withCredentials = withCredentials;

dev/benchmarks/macrobenchmarks/lib/web_benchmarks_ddc.dart

@@ -0,0 +1,18 @@
+// Copyright 2014 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'web_benchmarks.dart';
+
+/// An entrypoint used by DDC for running macrobenchmarks.
+///
+/// DDC runs macrobenchmarks via 'flutter run', which hosts files from its own
+/// local server. As a result, the macrobenchmarking orchestration server needs
+/// to be hosted on a separate port. We split the entrypoint here because we
+/// can't pass command line args to Dart apps on Flutter Web.
+///
+// TODO(markzipan): Use `main` in `'web_benchmarks.dart` when Flutter Web supports the `--dart-entrypoint-args` flag.
+Future<void> main() async {
+  // This is hard-coded and must be the same as `benchmarkServerPort` in `flutter/dev/devicelab/lib/tasks/web_benchmarks.dart`.
+  await sharedMain(<String>['--port', '9999']);
+}

dev/benchmarks/macrobenchmarks/pubspec.yaml

@@ -18,6 +18,7 @@ dependencies:
   #   flutter update-packages --force-upgrade
   flutter_gallery_assets: 1.0.2
 
+  args: 2.7.0
   web: 1.1.1
 
   async: 2.13.0 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"
@@ -52,7 +53,6 @@ dev_dependencies:
 
   _fe_analyzer_shared: 82.0.0 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"
   analyzer: 7.4.4 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"
-  args: 2.7.0 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"
   cli_config: 0.2.0 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"
   convert: 3.1.2 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"
   coverage: 1.12.0 # THIS LINE IS AUTOGENERATED - TO UPDATE USE "flutter update-packages --force-upgrade"

dev/devicelab/lib/framework/browser.dart

@@ -74,7 +74,7 @@ class Chrome {
     });
   }
 
-  /// Launches Chrome with the give [options].
+  /// Launches Chrome with the given [options].
   ///
   /// The [onError] callback is called with an error message when the Chrome
   /// process encounters an error. In particular, [onError] is called when the
@@ -125,7 +125,28 @@ class Chrome {
 
     WipConnection? debugConnection;
     if (withDebugging) {
-      debugConnection = await _connectToChromeDebugPort(chromeProcess, options.debugPort!);
+      debugConnection = await _connectToChromeDebugPort(options.debugPort!);
+    }
+
+    return Chrome._(chromeProcess, onError, debugConnection);
+  }
+
+  /// Connects to an existing Chrome process with the given [options].
+  ///
+  /// The [onError] callback is called with an error message when the Chrome
+  /// process encounters an error. In particular, [onError] is called when the
+  /// Chrome process exits prematurely, i.e. before [stop] is called.
+  static Future<Chrome> connect(
+    io.Process chromeProcess,
+    ChromeOptions options, {
+    String? workingDirectory,
+    required ChromeErrorCallback onError,
+  }) async {
+    final bool withDebugging = options.debugPort != null;
+
+    WipConnection? debugConnection;
+    if (withDebugging) {
+      debugConnection = await _connectToChromeDebugPort(options.debugPort!);
     }
 
     return Chrome._(chromeProcess, onError, debugConnection);
@@ -260,7 +281,7 @@ String _findSystemChromeExecutable() {
 }
 
 /// Waits for Chrome to print DevTools URI and connects to it.
-Future<WipConnection> _connectToChromeDebugPort(io.Process chromeProcess, int port) async {
+Future<WipConnection> _connectToChromeDebugPort(int port) async {
   final Uri devtoolsUri = await _getRemoteDebuggerUrl(Uri.parse('http://localhost:$port'));
   print('Connecting to DevTools: $devtoolsUri');
   final ChromeConnection chromeConnection = ChromeConnection('localhost', port);