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

content/browser/devtools/devtools_http_handler.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <utility>
 
@@ skipping 30 matching lines @@
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
 namespace content {
 
 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";
 const char kTargetTypeField[] = "type";
 const char kTargetTitleField[] = "title";
 const char kTargetDescriptionField[] = "description";
 const char kTargetUrlField[] = "url";
 const char kTargetFaviconUrlField[] = "faviconUrl";
 const char kTargetWebSocketDebuggerUrlField[] = "webSocketDebuggerUrl";
 const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
 
 // Maximum write buffer size of devtools http/websocket connections.
 // TODO(rmcilroy/pfieldman): Reduce this back to 100Mb when we have
 // added back pressure on the TraceComplete message protocol - crbug.com/456845.
 const int32_t kSendBufferSizeForDevTools = 256 * 1024 * 1024;  // 256Mb
 
 }  // namespace
 
 // ServerWrapper -------------------------------------------------------------
 // All methods in this class are only called on handler thread.
 class ServerWrapper : net::HttpServer::Delegate {
  public:
   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);
 
   void AcceptWebSocket(int connection_id,
                        const net::HttpServerRequestInfo& request);
   void SendOverWebSocket(int connection_id, const std::string& message);
   void SendResponse(int connection_id,
                     const net::HttpServerResponseInfo& response);
   void Send200(int connection_id,
                const std::string& data,
                const std::string& mime_type);
   void Send404(int connection_id);
   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 {}
 
  private:
   // net::HttpServer::Delegate implementation.
   void OnConnect(int connection_id) override {}
   void OnHttpRequest(int connection_id,
                      const net::HttpServerRequestInfo& info) override;
   void OnWebSocketRequest(int connection_id,
                           const net::HttpServerRequestInfo& info) override;
   void OnWebSocketMessage(int connection_id,
                           const std::string& data) override;
   void OnClose(int connection_id) override;
 
   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) {
   return server_->GetLocalAddress(address);
 }
 
 void ServerWrapper::AcceptWebSocket(int connection_id,
                                     const net::HttpServerRequestInfo& request) {
   server_->SetSendBufferSize(connection_id, kSendBufferSizeForDevTools);
   server_->AcceptWebSocket(connection_id, request);
@@ skipping 54 matching lines @@
                        std::unique_ptr<net::IPEndPoint> ip_address) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (handler && thread && server_wrapper) {
     handler->ServerStarted(thread, server_wrapper, socket_factory,
                            std::move(ip_address));
   } else {
     TerminateOnUI(thread, server_wrapper, socket_factory);
   }
 }
 
-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();
   } else {
     ip_address.reset();
     LOG(ERROR) << "Cannot start http server for devtools. Stop devtools.";
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(&ServerStartedOnUI,
                  handler,
                  thread,
                  server_wrapper,
                  socket_factory,
                  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));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   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));
   }
 }
 
 // DevToolsAgentHostClientImpl -----------------------------------------------
 // An internal implementation of DevToolsAgentHostClient that delegates
 // messages sent to a DebuggerShell instance.
 class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
  public:
   DevToolsAgentHostClientImpl(base::MessageLoop* message_loop,
                               ServerWrapper* server_wrapper,
@@ skipping 378 matching lines @@
           delegate_->GetFrontendResource(path),
           GetMimeType(path));
 }
 
 void DevToolsHttpHandler::OnWebSocketRequest(
     int connection_id,
     const net::HttpServerRequestInfo& request) {
   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 =
         DevToolsAgentHost::CreateForBrowser(
             thread_->task_runner(),
             base::Bind(&DevToolsSocketFactory::CreateForTethering,
                        base::Unretained(socket_factory_)));
     connection_to_client_[connection_id].reset(new DevToolsAgentHostClientImpl(
         thread_->message_loop(), server_wrapper_, connection_id,
         browser_agent));
@@ skipping 54 matching lines @@
       server_wrapper_(nullptr),
       delegate_(delegate),
       socket_factory_(nullptr),
       weak_factory_(this) {
   bool bundles_resources = frontend_url_.empty();
   if (frontend_url_.empty())
     frontend_url_ = "/devtools/inspector.html";
 
   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(
     base::Thread* thread,
     ServerWrapper* server_wrapper,
     DevToolsSocketFactory* socket_factory,
     std::unique_ptr<net::IPEndPoint> ip_address) {
   thread_ = thread;
   server_wrapper_ = server_wrapper;
   socket_factory_ = socket_factory;
   server_ip_address_.swap(ip_address);
 }
 
-void ServerWrapper::WriteActivePortToUserProfile(
+void ServerWrapper::WriteActivePortAndGuidToUserProfile(
     const base::FilePath& output_directory) {
   DCHECK(!output_directory.empty());
   net::IPEndPoint endpoint;
   int err;
   if ((err = server_->GetLocalAddress(&endpoint)) != net::OK) {
     LOG(ERROR) << "Error " << err << " getting local address";
     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,
                                    net::HttpStatusCode status_code,
                                    base::Value* value,
                                    const std::string& message) {
   if (!thread_)
     return;
 
   // Serialize value and message.
@@ skipping 85 matching lines @@
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
 }  // namespace content