DevTools: enable target domain handler on the browser target, make browser target non-discoverable.

content/browser/devtools/devtools_http_handler.cc

Index: content/browser/devtools/devtools_http_handler.cc
diff --git a/content/browser/devtools/devtools_http_handler.cc b/content/browser/devtools/devtools_http_handler.cc
index 98841ec8cec7ab59e58aec0d2f723fe106b7bea6..9469e9c1c7f5a5f65a2719975638449155bf8d6a 100644
--- a/content/browser/devtools/devtools_http_handler.cc
+++ b/content/browser/devtools/devtools_http_handler.cc
@@ -48,10 +48,13 @@ namespace {
 
 const base::FilePath::CharType kDevToolsActivePortFileName[] =
     FILE_PATH_LITERAL("DevToolsActivePort");
+const base::FilePath::CharType kDevToolsBrowserTargetFileName[] =
+    FILE_PATH_LITERAL("DevToolsBrowserTarget");
 
 const char kDevToolsHandlerThreadName[] = "Chrome_DevToolsHandlerThread";
 
 const char kPageUrlPrefix[] = "/devtools/page/";
+const char kBrowserUrlPrefix[] = "/devtools/browser";
 
 const char kTargetIdField[] = "id";
 const char kTargetParentIdField[] = "parentId";
@@ -77,6 +80,7 @@ class ServerWrapper : net::HttpServer::Delegate {
   ServerWrapper(base::WeakPtr<DevToolsHttpHandler> handler,
                 std::unique_ptr<net::ServerSocket> socket,
                 const base::FilePath& frontend_dir,
+                const std::string& browser_guid,
                 bool bundles_resources);
 
   int GetLocalAddress(net::IPEndPoint* address);
@@ -93,7 +97,8 @@ class ServerWrapper : net::HttpServer::Delegate {
   void Send500(int connection_id, const std::string& message);
   void Close(int connection_id);
 
-  void WriteActivePortToUserProfile(const base::FilePath& output_directory);
+  void WriteActivePortAndGuidToUserProfile(
+      const base::FilePath& output_directory);
 
   ~ServerWrapper() override {}
 
@@ -111,16 +116,19 @@ class ServerWrapper : net::HttpServer::Delegate {
   base::WeakPtr<DevToolsHttpHandler> handler_;
   std::unique_ptr<net::HttpServer> server_;
   base::FilePath frontend_dir_;
+  std::string browser_guid_;
   bool bundles_resources_;
 };
 
 ServerWrapper::ServerWrapper(base::WeakPtr<DevToolsHttpHandler> handler,
                              std::unique_ptr<net::ServerSocket> socket,
                              const base::FilePath& frontend_dir,
+                             const std::string& browser_guid,
                              bool bundles_resources)
     : handler_(handler),
       server_(new net::HttpServer(std::move(socket), this)),
       frontend_dir_(frontend_dir),
+      browser_guid_(browser_guid),
       bundles_resources_(bundles_resources) {}
 
 int ServerWrapper::GetLocalAddress(net::IPEndPoint* address) {
@@ -195,23 +203,24 @@ void ServerStartedOnUI(base::WeakPtr<DevToolsHttpHandler> handler,
   }
 }
 
-void StartServerOnHandlerThread(
-    base::WeakPtr<DevToolsHttpHandler> handler,
-    base::Thread* thread,
-    DevToolsSocketFactory* socket_factory,
-    const base::FilePath& output_directory,
-    const base::FilePath& frontend_dir,
-    bool bundles_resources) {
+void StartServerOnHandlerThread(base::WeakPtr<DevToolsHttpHandler> handler,
+                                base::Thread* thread,
+                                DevToolsSocketFactory* socket_factory,
+                                const base::FilePath& output_directory,
+                                const base::FilePath& frontend_dir,
+                                const std::string& browser_guid,
+                                bool bundles_resources) {
   DCHECK(thread->task_runner()->BelongsToCurrentThread());
   ServerWrapper* server_wrapper = nullptr;
   std::unique_ptr<net::ServerSocket> server_socket =
       socket_factory->CreateForHttpServer();
   std::unique_ptr<net::IPEndPoint> ip_address(new net::IPEndPoint);
   if (server_socket) {
-    server_wrapper = new ServerWrapper(handler, std::move(server_socket),
-                                       frontend_dir, bundles_resources);
+    server_wrapper =
+        new ServerWrapper(handler, std::move(server_socket), frontend_dir,
+                          browser_guid, bundles_resources);
     if (!output_directory.empty())
-      server_wrapper->WriteActivePortToUserProfile(output_directory);
+      server_wrapper->WriteActivePortAndGuidToUserProfile(output_directory);
 
     if (server_wrapper->GetLocalAddress(ip_address.get()) != net::OK)
       ip_address.reset();
@@ -228,12 +237,12 @@ void StartServerOnHandlerThread(
                  base::Passed(&ip_address)));
 }
 
-void StartServerOnFile(
-    base::WeakPtr<DevToolsHttpHandler> handler,
-    DevToolsSocketFactory* socket_factory,
-    const base::FilePath& output_directory,
-    const base::FilePath& frontend_dir,
-    bool bundles_resources) {
+void StartServerOnFile(base::WeakPtr<DevToolsHttpHandler> handler,
+                       DevToolsSocketFactory* socket_factory,
+                       const base::FilePath& output_directory,
+                       const base::FilePath& frontend_dir,
+                       const std::string& browser_guid,
+                       bool bundles_resources) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   std::unique_ptr<base::Thread> thread(
       new base::Thread(kDevToolsHandlerThreadName));
@@ -242,10 +251,10 @@ void StartServerOnFile(
   if (thread->StartWithOptions(options)) {
     base::MessageLoop* message_loop = thread->message_loop();
     message_loop->task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&StartServerOnHandlerThread, handler,
-                   base::Unretained(thread.release()), socket_factory,
-                   output_directory, frontend_dir, bundles_resources));
+        FROM_HERE, base::Bind(&StartServerOnHandlerThread, handler,
+                              base::Unretained(thread.release()),
+                              socket_factory, output_directory, frontend_dir,
+                              browser_guid, bundles_resources));
   }
 }
 
@@ -644,7 +653,10 @@ void DevToolsHttpHandler::OnWebSocketRequest(
   if (!thread_)
     return;
 
-  std::string browser_prefix = "/devtools/browser";
+  std::string browser_prefix = kBrowserUrlPrefix;
+  std::string browser_guid = delegate_->GetBrowserTargetGUID();
+  if (!browser_guid.empty())
+    browser_prefix = browser_prefix + "/" + browser_guid;

[dgozman, 2016/11/18 23:25:56]

This breaks tethering which tries to communicate over /devtools/browser. See
port_forwarding_controller.cc.

   if (base::StartsWith(request.path, browser_prefix,
                        base::CompareCase::SENSITIVE)) {
     scoped_refptr<DevToolsAgentHost> browser_agent =
@@ -719,12 +731,9 @@ DevToolsHttpHandler::DevToolsHttpHandler(
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      base::Bind(&StartServerOnFile,
-                 weak_factory_.GetWeakPtr(),
-                 socket_factory.release(),
-                 output_directory,
-                 debug_frontend_dir,
-                 bundles_resources));
+      base::Bind(&StartServerOnFile, weak_factory_.GetWeakPtr(),
+                 socket_factory.release(), output_directory, debug_frontend_dir,
+                 delegate->GetBrowserTargetGUID(), bundles_resources));
 }
 
 void DevToolsHttpHandler::ServerStarted(
@@ -738,7 +747,7 @@ void DevToolsHttpHandler::ServerStarted(
   server_ip_address_.swap(ip_address);
 }
 
-void ServerWrapper::WriteActivePortToUserProfile(
+void ServerWrapper::WriteActivePortAndGuidToUserProfile(
     const base::FilePath& output_directory) {
   DCHECK(!output_directory.empty());
   net::IPEndPoint endpoint;
@@ -748,14 +757,25 @@ void ServerWrapper::WriteActivePortToUserProfile(
     return;
   }
 
-  // Write this port to a well-known file in the profile directory
-  // so Telemetry can pick it up.
+  // Write this port to a well-known file in the profile directory.
   base::FilePath path = output_directory.Append(kDevToolsActivePortFileName);
   std::string port_string = base::UintToString(endpoint.port());
-  if (base::WriteFile(path, port_string.c_str(),
-                      static_cast<int>(port_string.length())) < 0) {
+  if (base::WriteFile(path, port_string.c_str(), port_string.length()) < 0) {
     LOG(ERROR) << "Error writing DevTools active port to file";
   }
+
+  if (!browser_guid_.empty()) {
+    std::string browser_address =
+        base::StringPrintf("ws://%s%s/%s", endpoint.ToString().c_str(),
+                           kBrowserUrlPrefix, browser_guid_.c_str());
+
+    // Write browser target guid to a well-known file in the profile directory.
+    path = output_directory.Append(kDevToolsBrowserTargetFileName);
+    if (base::WriteFile(path, browser_address.c_str(),
+                        browser_address.length()) < 0) {
+      LOG(ERROR) << "Error writing DevTools browser target path to file";
+    }
+  }
 }
 
 void DevToolsHttpHandler::SendJson(int connection_id,