Expose content shell's remote debugging URL.

Closes #297

[email protected]

Review URL: https://codereview.chromium.org//1257953008 .

Author: nex3

lib/src/runner.dart

@@ -234,13 +234,25 @@ class Runner {
         }
       }
 
+      if (suite.platform == TestPlatform.contentShell) {
+        var url = suite.environment.remoteDebuggerUrl;
+        if (url == null) {
+          print("${yellow}Remote debugger URL not found.$noColor");
+        } else {
+          print("Remote debugger URL: $bold$url$noColor");
+        }
+      }
+
       var buffer = new StringBuffer(
           "${bold}The test runner is paused.${noColor} ");
       if (!suite.platform.isHeadless) {
         buffer.write("Open the dev console in ${suite.platform} ");
         if (suite.platform.isDartVM) buffer.write("or ");
       } else {
         buffer.write("Open ");
+        if (suite.platform == TestPlatform.contentShell) {
+          buffer.write("the remote debugger or ");
+        }
       }
       if (suite.platform.isDartVM) buffer.write("the Observatory ");
 

lib/src/runner/browser/browser.dart

@@ -32,6 +32,14 @@ abstract class Browser {
   Future<Uri> get observatoryUrl =>
       throw new UnsupportedError("$name doesn't support Observatory.");
 
+  /// The remote debugger URL for this browser.
+  ///
+  /// This will throw an [UnsupportedError] for browsers that don't support
+  /// remote debugging, and return `null` if the remote debugging URL can't be
+  /// found.
+  Future<Uri> get remoteDebuggerUrl =>
+      throw new UnsupportedError("$name doesn't support remote debugging.");
+
   /// The underlying process.
   ///
   /// This will fire once the process has started successfully.

lib/src/runner/browser/browser_manager.dart

@@ -151,7 +151,13 @@ class BrowserManager {
   Future<_BrowserEnvironment> _loadBrowserEnvironment() async {
     var observatoryUrl;
     if (_platform.isDartVM) observatoryUrl = await _browser.observatoryUrl;
-    return new _BrowserEnvironment(this, observatoryUrl);
+
+    var remoteDebuggerUrl;
+    if (_platform == TestPlatform.contentShell) {
+      remoteDebuggerUrl = await _browser.remoteDebuggerUrl;
+    }
+
+    return new _BrowserEnvironment(this, observatoryUrl, remoteDebuggerUrl);
   }
 
   /// Tells the browser the load a test suite from the URL [url].
@@ -285,7 +291,10 @@ class _BrowserEnvironment implements Environment {
 
   final Uri observatoryUrl;
 
-  _BrowserEnvironment(this._manager, this.observatoryUrl);
+  final Uri remoteDebuggerUrl;
+
+  _BrowserEnvironment(this._manager, this.observatoryUrl,
+      this.remoteDebuggerUrl);
 
   CancelableFuture displayPause() => _manager._displayPause();
 }

lib/src/runner/browser/content_shell.dart

@@ -5,8 +5,10 @@
 library test.runner.browser.content_shell;
 
 import 'dart:async';
+import 'dart:convert';
 import 'dart:io';
 
+import '../../util/io.dart';
 import '../../utils.dart';
 import '../application_exception.dart';
 import 'browser.dart';
@@ -25,43 +27,97 @@ class ContentShell extends Browser {
 
   final Future<Uri> observatoryUrl;
 
+  final Future<Uri> remoteDebuggerUrl;
+
   factory ContentShell(url, {String executable, bool debug: false}) {
-    var completer = new Completer.sync();
-    return new ContentShell._(() async {
+    var observatoryCompleter = new Completer.sync();
+    var remoteDebuggerCompleter = new Completer.sync();
+    return new ContentShell._(() {
       if (executable == null) executable = _defaultExecutable();
 
-      var process = await Process.start(
-          executable, ["--dump-render-tree", url.toString()],
-          environment: {"DART_FLAGS": "--checked"});
-
-      if (debug) {
-        completer.complete(lineSplitter.bind(process.stdout).map((line) {
-          var match = _observatoryRegExp.firstMatch(line);
-          if (match == null) return null;
-          return Uri.parse(match[1]);
-        }).where((uri) => uri != null).first);
-      } else {
-        completer.complete(null);
+      tryPort([port]) async {
+        var args = ["--dump-render-tree", url.toString()];
+        if (port != null) args.add("--remote-debugging-port=$port");
+
+        var process = await Process.start(executable, args,
+            environment: {"DART_FLAGS": "--checked"});
+
+        if (debug) {
+          observatoryCompleter.complete(lineSplitter.bind(process.stdout)
+              .map((line) {
+            var match = _observatoryRegExp.firstMatch(line);
+            if (match == null) return null;
+            return Uri.parse(match[1]);
+          }).where((uri) => uri != null).first);
+        } else {
+          observatoryCompleter.complete(null);
+        }
+
+        var stderr = new StreamIterator(lineSplitter.bind(process.stderr));
+
+        // Before we can consider content_shell started successfully, we have to
+        // make sure it's not expired and that the remote debugging port worked.
+        // Any errors from this will always come before the "Running without
+        // renderer sanxbox" message.
+        while (await stderr.moveNext() &&
+            !stderr.current.endsWith("Running without renderer sandbox")) {
+          if (stderr.current == "[dartToStderr]: Dartium build has expired") {
+            stderr.cancel();
+            process.kill();
+            // TODO(nweiz): link to dartlang.org once it has download links for
+            // content shell
+            // (https://github.com/dart-lang/www.dartlang.org/issues/1164).
+            throw new ApplicationException(
+                "You're using an expired content_shell. Upgrade to the latest "
+                    "version:\n"
+                "http://gsdview.appspot.com/dart-archive/channels/stable/"
+                    "release/latest/dartium/");
+          } else if (stderr.current.contains("bind() returned an error")) {
+            // If we failed to bind to the port, return null to tell
+            // getUnusedPort to try another one.
+            stderr.cancel();
+            process.kill();
+            return null;
+          }
+        }
+
+        if (port != null) {
+          remoteDebuggerCompleter.complete(
+              _getRemoteDebuggerUrl(Uri.parse("http://localhost:$port")));
+        } else {
+          remoteDebuggerCompleter.complete(null);
+        }
+
+        stderr.cancel();
+        return process;
       }
 
-      lineSplitter.bind(process.stderr).listen((line) {
-        if (line != "[dartToStderr]: Dartium build has expired") return;
-
-        // TODO(nweiz): link to dartlang.org once it has download links for
-        // content shell
-        // (https://github.com/dart-lang/www.dartlang.org/issues/1164).
-        throw new ApplicationException(
-            "You're using an expired content_shell. Upgrade to the latest "
-                "version:\n"
-            "http://gsdview.appspot.com/dart-archive/channels/stable/release/"
-                "latest/dartium/");
-      });
-
-      return process;
-    }, completer.future);
+      if (!debug) return tryPort();
+      return getUnusedPort(tryPort);
+    }, observatoryCompleter.future, remoteDebuggerCompleter.future);
+  }
+
+  /// Returns the full URL of the remote debugger for the host page.
+  ///
+  /// This takes the base remote debugger URL (which points to a browser-wide
+  /// page) and uses its JSON API to find the resolved URL for debugging the
+  /// host page.
+  static Future<Uri> _getRemoteDebuggerUrl(Uri base) async {
+    try {
+      var client = new HttpClient();
+      var request = await client.getUrl(base.resolve("/json/list"));
+      var response = await request.close();
+      var json = await JSON.fuse(UTF8).decoder.bind(response).single;
+      return base.resolve(json.first["devtoolsFrontendUrl"]);
+    } catch (_) {
+      // If we fail to talk to the remote debugger protocol, give up and return
+      // the raw URL rather than crashing.
+      return base;
+    }
   }
 
-  ContentShell._(Future<Process> startBrowser(), this.observatoryUrl)
+  ContentShell._(Future<Process> startBrowser(), this.observatoryUrl,
+          this.remoteDebuggerUrl)
       : super(startBrowser);
 
   /// Return the default executable for the current operating system.

lib/src/runner/environment.dart

@@ -13,6 +13,10 @@ abstract class Environment {
   /// environment doesn't run the Dart VM or the URL couldn't be detected.
   Uri get observatoryUrl;
 
+  /// The URL of the remote debugger for this environment, or `null` if it isn't
+  /// enabled.
+  Uri get remoteDebuggerUrl;
+
   /// Displays information indicating that the test runner is paused.
   ///
   /// The returned future will complete when the user takes action within the

lib/src/runner/vm/environment.dart

@@ -14,6 +14,9 @@ class VMEnvironment implements Environment {
   Uri get observatoryUrl => throw new UnsupportedError(
       "VMEnvironment.observatoryUrl is not currently supported.");
 
+  Uri get remoteDebuggerUrl => throw new UnsupportedError(
+      "VMEnvironment.observatoryUrl is not supported.");
+
   CancelableFuture displayPause() =>
       throw new UnsupportedError(
           "The VM doesn't yet support Environment.displayPause.");

lib/src/util/io.dart

@@ -195,3 +195,24 @@ String libraryPath(Symbol libraryName, {String packageRoot}) {
   if (packageRoot == null) packageRoot = p.absolute('packages');
   return p.join(packageRoot, p.fromUri(lib.uri.path));
 }
+
+/// Repeatedly finds a probably-unused port on localhost and passes it to
+/// [tryPort] until it binds successfully.
+///
+/// [tryPort] should return a non-`null` value or a Future completing to a
+/// non-`null` value once it binds successfully. This value will be returned
+/// by [getUnusedPort] in turn.
+///
+/// This is necessary for ensuring that our port binding isn't flaky for
+/// applications that don't print out the bound port.
+Future getUnusedPort(tryPort(int port)) {
+  var value;
+  return Future.doWhile(() async {
+    var socket = await RawServerSocket.bind(InternetAddress.LOOPBACK_IP_V4, 0);
+    var port = socket.port;
+    await socket.close();
+
+    value = await tryPort(port);
+    return value == null;
+  }).then((_) => value);
+}