Add wrapper class for devtools endpoint URLs.

This change moves the logic for constructing DevTools endpoint URLs into
a common location (DevToolsHttpEndpoint). Call sites that were
previously building URL strings directly can now call the appropriate
method on DevToolsHttpEndpoint instead. For example, List() returns
an endpoint's /json/list URL.

A DevToolsHttpEndpoint can be constructed from a NetAddress for the
common case where the endpoint is running on localhost on a certain
port. It can also be constructed from a URL with a path prefix. The
prefix will be included in all URLs for that endpoint.

This is mainly to support some downstream features in MSEdgeDriver that
rely on devtools endpoints with path prefixes and which may be served
over HTTPS. There is no functional change to ChromeDriver. Just some
refactoring.

Bug: 1016888
Change-Id: I50dc97f23637f58f972e7f5a5807e74a7af5f69a
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1874200Reviewed-by: John Chen <johnchen@chromium.org>
Commit-Queue: Brandon Walderman <brwalder@microsoft.com>
Cr-Commit-Position: refs/heads/master@{#708813}

chrome/test/chromedriver/BUILD.gn

@@ -108,6 +108,8 @@ source_set("automation_client_lib") {
     "chrome/devtools_client.h",
     "chrome/devtools_client_impl.cc",
     "chrome/devtools_client_impl.h",
+    "chrome/devtools_endpoint.cc",
+    "chrome/devtools_endpoint.h",
     "chrome/devtools_event_listener.cc",
     "chrome/devtools_event_listener.h",
     "chrome/devtools_http_client.cc",
@@ -377,6 +379,7 @@ test("chromedriver_unittests") {
     "chrome/console_logger_unittest.cc",
     "chrome/device_manager_unittest.cc",
     "chrome/devtools_client_impl_unittest.cc",
+    "chrome/devtools_endpoint_unittest.cc",
     "chrome/devtools_http_client_unittest.cc",
     "chrome/dom_tracker_unittest.cc",
     "chrome/download_directory_override_manager_unittest.cc",

chrome/test/chromedriver/capabilities.cc

@@ -404,8 +404,9 @@ Status ParseExcludeSwitches(const base::Value& option,
   return Status(kOk);
 }
 
-Status ParseUseRemoteBrowser(const base::Value& option,
-                               Capabilities* capabilities) {
+Status ParseNetAddress(NetAddress* to_set,
+                       const base::Value& option,
+                       Capabilities* capabilities) {
   std::string server_addr;
   if (!option.GetAsString(&server_addr))
     return Status(kInvalidArgument, "must be 'host:port'");
@@ -420,7 +421,7 @@ Status ParseUseRemoteBrowser(const base::Value& option,
   if (port <= 0)
     return Status(kInvalidArgument, "port must be > 0");
 
-  capabilities->debugger_address = NetAddress(values[0], port);
+  *to_set = NetAddress(values[0], port);
   return Status(kOk);
 }
 
@@ -563,7 +564,8 @@ Status ParseChromeOptions(
     parser_map["excludeSwitches"] = base::Bind(&ParseExcludeSwitches);
     parser_map["loadAsync"] = base::Bind(&IgnoreDeprecatedOption, "loadAsync");
   } else if (is_remote) {
-    parser_map["debuggerAddress"] = base::Bind(&ParseUseRemoteBrowser);
+    parser_map["debuggerAddress"] =
+        base::Bind(&ParseNetAddress, &capabilities->debugger_address);
   } else {
     parser_map["args"] = base::Bind(&ParseSwitches);
     parser_map["binary"] = base::Bind(&ParseFilePath, &capabilities->binary);

chrome/test/chromedriver/chrome/browser_info.h

@@ -5,8 +5,8 @@
 #ifndef CHROME_TEST_CHROMEDRIVER_CHROME_BROWSER_INFO_H_
 #define CHROME_TEST_CHROMEDRIVER_CHROME_BROWSER_INFO_H_
 
+#include "chrome/test/chromedriver/chrome/devtools_endpoint.h"
 #include "chrome/test/chromedriver/chrome/status.h"
-#include "chrome/test/chromedriver/net/net_util.h"
 
 // Content Shell and WebView have an empty product version and a fake user
 // agent. There's no way to detect the actual version, so unless specified we
@@ -24,7 +24,7 @@ struct BrowserInfo {
   std::string browser_name;
   std::string browser_version;
   std::string web_socket_url;
-  NetAddress debugger_address;
+  DevToolsEndpoint debugger_endpoint;
   int major_version;
   int build_no;
   int blink_revision;

chrome/test/chromedriver/chrome/devtools_endpoint.cc

+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/test/chromedriver/chrome/devtools_endpoint.h"
+
+#include "base/strings/stringprintf.h"
+#include "chrome/test/chromedriver/chrome/devtools_http_client.h"
+#include "chrome/test/chromedriver/net/net_util.h"
+
+DevToolsEndpoint::DevToolsEndpoint(int port)
+    : DevToolsEndpoint(NetAddress(port)) {}
+
+DevToolsEndpoint::DevToolsEndpoint(const NetAddress& address)
+    : server_url_(std::string("http://") + address.ToString()) {}
+
+DevToolsEndpoint::DevToolsEndpoint(const std::string& url) : server_url_(url) {}
+
+bool DevToolsEndpoint::IsValid() const {
+  return server_url_.is_valid();
+}
+
+NetAddress DevToolsEndpoint::Address() const {
+  return NetAddress(server_url_.host(), server_url_.EffectiveIntPort());
+}
+
+std::string DevToolsEndpoint::GetBrowserDebuggerUrl() const {
+  const std::string scheme = server_url_.SchemeIs("https") ? "wss" : "ws";
+
+  url::Replacements<char> replacements;
+  replacements.SetScheme(scheme.c_str(), url::Component(0, scheme.length()));
+
+  return server_url_.Resolve("devtools/browser/")
+      .ReplaceComponents(replacements)
+      .spec();
+}
+
+std::string DevToolsEndpoint::GetDebuggerUrl(const std::string& id) const {
+  const std::string scheme = server_url_.SchemeIs("https") ? "wss" : "ws";
+
+  url::Replacements<char> replacements;
+  replacements.SetScheme(scheme.c_str(), url::Component(0, scheme.length()));
+
+  return server_url_.Resolve("devtools/page/" + id)
+      .ReplaceComponents(replacements)
+      .spec();
+}
+
+std::string DevToolsEndpoint::GetVersionUrl() const {
+  return server_url_.Resolve("json/version").spec();
+}
+
+std::string DevToolsEndpoint::GetListUrl() const {
+  return server_url_.Resolve("json/list").spec();
+}
+
+std::string DevToolsEndpoint::GetCloseUrl(const std::string& id) const {
+  return server_url_.Resolve("json/close/" + id).spec();
+}
+
+std::string DevToolsEndpoint::GetActivateUrl(const std::string& id) const {
+  return server_url_.Resolve("json/activate/" + id).spec();
+}

chrome/test/chromedriver/chrome/devtools_endpoint.h

+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_TEST_CHROMEDRIVER_CHROME_DEVTOOLS_ENDPOINT_H_
+#define CHROME_TEST_CHROMEDRIVER_CHROME_DEVTOOLS_ENDPOINT_H_
+
+#include "url/gurl.h"
+
+class NetAddress;
+
+// Describes a DevTools debugger endpoint such as a
+// hostname:port pair, or a full URL with auth credentials.
+class DevToolsEndpoint {
+ public:
+  DevToolsEndpoint() = default;  // Creates an invalid endpoint
+  explicit DevToolsEndpoint(int port);
+  explicit DevToolsEndpoint(const NetAddress& address);
+  explicit DevToolsEndpoint(const std::string& url);
+  ~DevToolsEndpoint() = default;
+
+  bool IsValid() const;
+  NetAddress Address() const;
+  std::string GetBrowserDebuggerUrl() const;
+  std::string GetDebuggerUrl(const std::string& id) const;
+  std::string GetVersionUrl() const;
+  std::string GetListUrl() const;
+  std::string GetCloseUrl(const std::string& id) const;
+  std::string GetActivateUrl(const std::string& id) const;
+
+ private:
+  GURL server_url_;
+};
+
+#endif  // CHROME_TEST_CHROMEDRIVER_CHROME_DEVTOOLS_ENDPOINT_H_

chrome/test/chromedriver/chrome/devtools_endpoint_unittest.cc

+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/test/chromedriver/chrome/devtools_endpoint.h"
+#include "chrome/test/chromedriver/net/net_util.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(DevToolsEndpoint, Invalid) {
+  const DevToolsEndpoint endpoint;
+  ASSERT_FALSE(endpoint.IsValid());
+}
+
+TEST(DevToolsEndpoint, FromPort) {
+  const DevToolsEndpoint endpoint(9999);
+  ASSERT_TRUE(endpoint.IsValid());
+  ASSERT_EQ(endpoint.Address().ToString(), NetAddress(9999).ToString());
+  ASSERT_EQ(endpoint.GetBrowserDebuggerUrl(),
+            "ws://localhost:9999/devtools/browser/");
+  ASSERT_EQ(endpoint.GetDebuggerUrl("abc"),
+            "ws://localhost:9999/devtools/page/abc");
+  ASSERT_EQ(endpoint.GetVersionUrl(), "http://localhost:9999/json/version");
+  ASSERT_EQ(endpoint.GetListUrl(), "http://localhost:9999/json/list");
+  ASSERT_EQ(endpoint.GetCloseUrl("xyz"),
+            "http://localhost:9999/json/close/xyz");
+  ASSERT_EQ(endpoint.GetActivateUrl("xyz"),
+            "http://localhost:9999/json/activate/xyz");
+}
+
+TEST(DevToolsEndpoint, FromNetAddress) {
+  const DevToolsEndpoint endpoint(NetAddress(9222));
+  ASSERT_TRUE(endpoint.IsValid());
+  ASSERT_EQ(endpoint.Address().ToString(), NetAddress(9222).ToString());
+  ASSERT_EQ(endpoint.GetBrowserDebuggerUrl(),
+            "ws://localhost:9222/devtools/browser/");
+  ASSERT_EQ(endpoint.GetDebuggerUrl("abc"),
+            "ws://localhost:9222/devtools/page/abc");
+  ASSERT_EQ(endpoint.GetVersionUrl(), "http://localhost:9222/json/version");
+  ASSERT_EQ(endpoint.GetListUrl(), "http://localhost:9222/json/list");
+  ASSERT_EQ(endpoint.GetCloseUrl("xyz"),
+            "http://localhost:9222/json/close/xyz");
+  ASSERT_EQ(endpoint.GetActivateUrl("xyz"),
+            "http://localhost:9222/json/activate/xyz");
+}
+
+TEST(DevToolsEndpoint, FromHttpUrl) {
+  const DevToolsEndpoint endpoint("http://remote:9223/custom/path/");
+  ASSERT_TRUE(endpoint.IsValid());
+  ASSERT_EQ(endpoint.Address().ToString(),
+            NetAddress("remote", 9223).ToString());
+  ASSERT_EQ(endpoint.GetBrowserDebuggerUrl(),
+            "ws://remote:9223/custom/path/devtools/browser/");
+  ASSERT_EQ(endpoint.GetDebuggerUrl("abc"),
+            "ws://remote:9223/custom/path/devtools/page/abc");
+  ASSERT_EQ(endpoint.GetVersionUrl(),
+            "http://remote:9223/custom/path/json/version");
+  ASSERT_EQ(endpoint.GetListUrl(), "http://remote:9223/custom/path/json/list");
+  ASSERT_EQ(endpoint.GetCloseUrl("xyz"),
+            "http://remote:9223/custom/path/json/close/xyz");
+  ASSERT_EQ(endpoint.GetActivateUrl("xyz"),
+            "http://remote:9223/custom/path/json/activate/xyz");
+}
+
+TEST(DevToolsEndpoint, FromHttpsUrl) {
+  const DevToolsEndpoint endpoint("https://secure:9224/custom/path/");
+  ASSERT_TRUE(endpoint.IsValid());
+  ASSERT_EQ(endpoint.Address().ToString(),
+            NetAddress("secure", 9224).ToString());
+  ASSERT_EQ(endpoint.GetBrowserDebuggerUrl(),
+            "wss://secure:9224/custom/path/devtools/browser/");
+  ASSERT_EQ(endpoint.GetDebuggerUrl("abc"),
+            "wss://secure:9224/custom/path/devtools/page/abc");
+  ASSERT_EQ(endpoint.GetVersionUrl(),
+            "https://secure:9224/custom/path/json/version");
+  ASSERT_EQ(endpoint.GetListUrl(), "https://secure:9224/custom/path/json/list");
+  ASSERT_EQ(endpoint.GetCloseUrl("xyz"),
+            "https://secure:9224/custom/path/json/close/xyz");
+  ASSERT_EQ(endpoint.GetActivateUrl("xyz"),
+            "https://secure:9224/custom/path/json/activate/xyz");
+}

chrome/test/chromedriver/chrome/devtools_http_client.cc

@@ -65,7 +65,7 @@ const WebViewInfo* WebViewsInfo::GetForId(const std::string& id) const {
 }
 
 DevToolsHttpClient::DevToolsHttpClient(
-    const NetAddress& address,
+    const DevToolsEndpoint& endpoint,
     network::mojom::URLLoaderFactory* factory,
     const SyncWebSocketFactory& socket_factory,
     std::unique_ptr<DeviceMetrics> device_metrics,
@@ -73,22 +73,25 @@ DevToolsHttpClient::DevToolsHttpClient(
     std::string page_load_strategy)
     : url_loader_factory_(factory),
       socket_factory_(socket_factory),
-      server_url_("http://" + address.ToString()),
-      web_socket_url_prefix_(base::StringPrintf("ws://%s/devtools/page/",
-                                                address.ToString().c_str())),
+      endpoint_(endpoint),
       device_metrics_(std::move(device_metrics)),
       window_types_(std::move(window_types)),
       page_load_strategy_(page_load_strategy) {
   window_types_->insert(WebViewInfo::kPage);
   window_types_->insert(WebViewInfo::kApp);
-  browser_info_.debugger_address = address;
 }
 
 DevToolsHttpClient::~DevToolsHttpClient() {}
 
 Status DevToolsHttpClient::Init(const base::TimeDelta& timeout) {
+  if (!endpoint_.IsValid()) {
+    return Status(kChromeNotReachable);
+  }
+
+  browser_info_.debugger_endpoint = endpoint_;
+
   base::TimeTicks deadline = base::TimeTicks::Now() + timeout;
-  std::string version_url = server_url_ + "/json/version";
+  std::string version_url = endpoint_.GetVersionUrl();
   std::string data;
 
   while (!FetchUrlAndLog(version_url, &data) || data.empty()) {
@@ -102,7 +105,7 @@ Status DevToolsHttpClient::Init(const base::TimeDelta& timeout) {
 
 Status DevToolsHttpClient::GetWebViewsInfo(WebViewsInfo* views_info) {
   std::string data;
-  if (!FetchUrlAndLog(server_url_ + "/json", &data))
+  if (!FetchUrlAndLog(endpoint_.GetListUrl(), &data))
     return Status(kChromeNotReachable);
 
   return internal::ParseWebViewsInfo(data, views_info);
@@ -111,14 +114,14 @@ Status DevToolsHttpClient::GetWebViewsInfo(WebViewsInfo* views_info) {
 std::unique_ptr<DevToolsClient> DevToolsHttpClient::CreateClient(
     const std::string& id) {
   return std::unique_ptr<DevToolsClient>(
-      new DevToolsClientImpl(socket_factory_, web_socket_url_prefix_ + id, id,
+      new DevToolsClientImpl(socket_factory_, endpoint_.GetDebuggerUrl(id), id,
                              base::Bind(&DevToolsHttpClient::CloseFrontends,
                                         base::Unretained(this), id)));
 }
 
 Status DevToolsHttpClient::CloseWebView(const std::string& id) {
   std::string data;
-  if (!FetchUrlAndLog(server_url_ + "/json/close/" + id, &data)) {
+  if (!FetchUrlAndLog(endpoint_.GetCloseUrl(id), &data)) {
     return Status(kOk);  // Closing the last web view leads chrome to quit.
   }
 
@@ -141,7 +144,7 @@ Status DevToolsHttpClient::CloseWebView(const std::string& id) {
 
 Status DevToolsHttpClient::ActivateWebView(const std::string& id) {
   std::string data;
-  if (!FetchUrlAndLog(server_url_ + "/json/activate/" + id, &data))
+  if (!FetchUrlAndLog(endpoint_.GetActivateUrl(id), &data))
     return Status(kUnknownError, "cannot activate web view");
   return Status(kOk);
 }
@@ -196,7 +199,7 @@ Status DevToolsHttpClient::CloseFrontends(const std::string& for_client_id) {
   for (std::list<std::string>::const_iterator it = docked_frontend_ids.begin();
        it != docked_frontend_ids.end(); ++it) {
     std::unique_ptr<DevToolsClient> client(new DevToolsClientImpl(
-        socket_factory_, web_socket_url_prefix_ + *it, *it));
+        socket_factory_, endpoint_.GetDebuggerUrl(*it), *it));
     std::unique_ptr<WebViewImpl> web_view(
         new WebViewImpl(*it, false, &browser_info_, std::move(client), NULL,
                         page_load_strategy_));

chrome/test/chromedriver/chrome/devtools_http_client.h

@@ -15,6 +15,7 @@
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/test/chromedriver/chrome/browser_info.h"
+#include "chrome/test/chromedriver/chrome/devtools_endpoint.h"
 #include "chrome/test/chromedriver/net/sync_websocket_factory.h"
 
 namespace base {
@@ -29,7 +30,6 @@ class URLLoaderFactory;
 
 struct DeviceMetrics;
 class DevToolsClient;
-class NetAddress;
 class Status;
 
 struct WebViewInfo {
@@ -79,7 +79,7 @@ class WebViewsInfo {
 
 class DevToolsHttpClient {
  public:
-  DevToolsHttpClient(const NetAddress& address,
+  DevToolsHttpClient(const DevToolsEndpoint& endpoint,
                      network::mojom::URLLoaderFactory* factory,
                      const SyncWebSocketFactory& socket_factory,
                      std::unique_ptr<DeviceMetrics> device_metrics,
@@ -107,8 +107,7 @@ class DevToolsHttpClient {
 
   network::mojom::URLLoaderFactory* url_loader_factory_;
   SyncWebSocketFactory socket_factory_;
-  std::string server_url_;
-  std::string web_socket_url_prefix_;
+  DevToolsEndpoint endpoint_;
   BrowserInfo browser_info_;
   std::unique_ptr<DeviceMetrics> device_metrics_;
   std::unique_ptr<std::set<WebViewInfo::Type>> window_types_;

chrome/test/chromedriver/chrome_launcher.cc

@@ -206,7 +206,7 @@ Status PrepareDesktopCommandLine(const Capabilities& capabilities,
 }
 
 Status WaitForDevToolsAndCheckVersion(
-    const NetAddress& address,
+    const DevToolsEndpoint& endpoint,
     network::mojom::URLLoaderFactory* factory,
     const SyncWebSocketFactory& socket_factory,
     const Capabilities* capabilities,
@@ -232,12 +232,12 @@ Status WaitForDevToolsAndCheckVersion(
         cmd_line->GetSwitchValueNative("devtools-replay");
     base::FilePath log_file_path(log_path);
     client.reset(
-        new ReplayHttpClient(address, factory, socket_factory,
+        new ReplayHttpClient(endpoint, factory, socket_factory,
                              std::move(device_metrics), std::move(window_types),
                              capabilities->page_load_strategy, log_file_path));
   } else {
     client.reset(new DevToolsHttpClient(
-        address, factory, socket_factory, std::move(device_metrics),
+        endpoint, factory, socket_factory, std::move(device_metrics),
         std::move(window_types), capabilities->page_load_strategy));
   }
 
@@ -307,7 +307,7 @@ Status WaitForDevToolsAndCheckVersion(
 }
 
 Status CreateBrowserwideDevToolsClientAndConnect(
-    const NetAddress& address,
+    const DevToolsEndpoint& endpoint,
     const PerfLoggingPrefs& perf_logging_prefs,
     const SyncWebSocketFactory& socket_factory,
     const std::vector<std::unique_ptr<DevToolsEventListener>>&
@@ -316,8 +316,7 @@ Status CreateBrowserwideDevToolsClientAndConnect(
     std::unique_ptr<DevToolsClient>* browser_client) {
   std::string url(web_socket_url);
   if (url.length() == 0) {
-    url = base::StringPrintf("ws://%s/devtools/browser/",
-                             address.ToString().c_str());
+    url = endpoint.GetBrowserDebuggerUrl();
   }
   std::unique_ptr<DevToolsClient> client(new DevToolsClientImpl(
       socket_factory, url, DevToolsClientImpl::kBrowserwideDevToolsClientId));
@@ -353,8 +352,8 @@ Status LaunchRemoteChromeSession(
   std::unique_ptr<DevToolsHttpClient> devtools_http_client;
   bool retry = true;
   status = WaitForDevToolsAndCheckVersion(
-      capabilities.debugger_address, factory, socket_factory, &capabilities, 60,
-      &devtools_http_client, &retry);
+      DevToolsEndpoint(capabilities.debugger_address), factory, socket_factory,
+      &capabilities, 60, &devtools_http_client, &retry);
   if (status.IsError()) {
     return Status(
         kUnknownError,
@@ -366,8 +365,8 @@ Status LaunchRemoteChromeSession(
 
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
-      capabilities.debugger_address, capabilities.perf_logging_prefs,
-      socket_factory, devtools_event_listeners,
+      DevToolsEndpoint(capabilities.debugger_address),
+      capabilities.perf_logging_prefs, socket_factory, devtools_event_listeners,
       devtools_http_client->browser_info()->web_socket_url,
       &devtools_websocket_client);
   if (status.IsError()) {
@@ -496,8 +495,8 @@ Status LaunchDesktopChrome(network::mojom::URLLoaderFactory* factory,
     }
     if (status.IsOk()) {
       status = WaitForDevToolsAndCheckVersion(
-          NetAddress(devtools_port), factory, socket_factory, &capabilities, 1,
-          &devtools_http_client, &retry);
+          DevToolsEndpoint(devtools_port), factory, socket_factory,
+          &capabilities, 1, &devtools_http_client, &retry);
       if (!retry) {
         break;
       }
@@ -563,7 +562,7 @@ Status LaunchDesktopChrome(network::mojom::URLLoaderFactory* factory,
 
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
-      NetAddress(devtools_port), capabilities.perf_logging_prefs,
+      DevToolsEndpoint(devtools_port), capabilities.perf_logging_prefs,
       socket_factory, devtools_event_listeners,
       devtools_http_client->browser_info()->web_socket_url,
       &devtools_websocket_client);
@@ -636,9 +635,9 @@ Status LaunchAndroidChrome(network::mojom::URLLoaderFactory* factory,
 
   std::unique_ptr<DevToolsHttpClient> devtools_http_client;
   bool retry = true;
-  status = WaitForDevToolsAndCheckVersion(NetAddress(devtools_port), factory,
-                                          socket_factory, &capabilities, 60,
-                                          &devtools_http_client, &retry);
+  status = WaitForDevToolsAndCheckVersion(
+      DevToolsEndpoint(devtools_port), factory, socket_factory, &capabilities,
+      60, &devtools_http_client, &retry);
   if (status.IsError()) {
     device->TearDown();
     return status;
@@ -646,7 +645,7 @@ Status LaunchAndroidChrome(network::mojom::URLLoaderFactory* factory,
 
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
-      NetAddress(devtools_port), capabilities.perf_logging_prefs,
+      DevToolsEndpoint(devtools_port), capabilities.perf_logging_prefs,
       socket_factory, devtools_event_listeners,
       devtools_http_client->browser_info()->web_socket_url,
       &devtools_websocket_client);
@@ -691,12 +690,12 @@ Status LaunchReplayChrome(network::mojom::URLLoaderFactory* factory,
 
   std::unique_ptr<DevToolsHttpClient> devtools_http_client;
   bool retry = true;
-  status = WaitForDevToolsAndCheckVersion(NetAddress(0), factory,
+  status = WaitForDevToolsAndCheckVersion(DevToolsEndpoint(0), factory,
                                           socket_factory, &capabilities, 1,
                                           &devtools_http_client, &retry);
   std::unique_ptr<DevToolsClient> devtools_websocket_client;
   status = CreateBrowserwideDevToolsClientAndConnect(
-      NetAddress(0), capabilities.perf_logging_prefs, socket_factory,
+      DevToolsEndpoint(0), capabilities.perf_logging_prefs, socket_factory,
       devtools_event_listeners,
       devtools_http_client->browser_info()->web_socket_url,
       &devtools_websocket_client);

chrome/test/chromedriver/log_replay/replay_http_client.cc

@@ -20,14 +20,14 @@ std::string UrlPath(const std::string& url) {
 }  // namespace
 
 ReplayHttpClient::ReplayHttpClient(
-    const NetAddress& address,
+    const DevToolsEndpoint& endpoint,
     network::mojom::URLLoaderFactory* factory,
     const SyncWebSocketFactory& socket_factory,
     std::unique_ptr<DeviceMetrics> device_metrics,
     std::unique_ptr<std::set<WebViewInfo::Type>> window_types,
     std::string page_load_strategy,
     const base::FilePath& log_path)
-    : DevToolsHttpClient(address,
+    : DevToolsHttpClient(endpoint,
                          factory,
                          socket_factory,
                          std::move(device_metrics),

chrome/test/chromedriver/log_replay/replay_http_client.h

@@ -27,7 +27,7 @@ class URLLoaderFactory;
 class ReplayHttpClient : public DevToolsHttpClient {
  public:
   // Initializes a DevToolsLogReader with the given log file.
-  ReplayHttpClient(const NetAddress& address,
+  ReplayHttpClient(const DevToolsEndpoint& endpoint,
                    network::mojom::URLLoaderFactory* factory,
                    const SyncWebSocketFactory& socket_factory,
                    std::unique_ptr<DeviceMetrics> device_metrics,

chrome/test/chromedriver/session_commands.cc

@@ -179,9 +179,9 @@ std::unique_ptr<base::DictionaryValue> CreateCapabilities(
   caps->SetString(chromedriverVersionKey, kChromeDriverVersion);
   const std::string debuggerAddressKey =
       base::StringPrintf("%s.debuggerAddress", kChromeDriverOptionsKeyPrefixed);
-  caps->SetString(
-      debuggerAddressKey,
-      session->chrome->GetBrowserInfo()->debugger_address.ToString());
+  caps->SetString(debuggerAddressKey, session->chrome->GetBrowserInfo()
+                                          ->debugger_endpoint.Address()
+                                          .ToString());
   ChromeDesktopImpl* desktop = NULL;
   Status status = session->chrome->GetAsDesktop(&desktop);
   if (status.IsOk()) {