DevTools: merge devtools_http_handler into content - it is used in all the embedders anyways.

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>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "build/build_config.h"
-#include "components/devtools_http_handler/devtools_http_handler.h"
-#include "components/devtools_http_handler/devtools_http_handler_delegate.h"
+#include "content/browser/devtools/devtools_http_handler.h"
+#include "content/browser/devtools/devtools_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_external_agent_proxy_delegate.h"
 #include "content/public/browser/devtools_manager_delegate.h"
 #include "content/public/browser/devtools_socket_factory.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/user_agent.h"
 #include "net/base/escape.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
 #include "net/socket/server_socket.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
 #endif
 
-using content::BrowserThread;
-using content::DevToolsAgentHost;
-using content::DevToolsAgentHostClient;
-
-namespace devtools_http_handler {
+namespace content {
 
 namespace {
 
 const base::FilePath::CharType kDevToolsActivePortFileName[] =
     FILE_PATH_LITERAL("DevToolsActivePort");
 
 const char kDevToolsHandlerThreadName[] = "Chrome_DevToolsHandlerThread";
 
 const char kPageUrlPrefix[] = "/devtools/page/";
 
@@ skipping 103 matching lines @@
 }
 
 void ServerWrapper::Close(int connection_id) {
   server_->Close(connection_id);
 }
 
 // Thread and ServerWrapper lifetime management ------------------------------
 
 void TerminateOnUI(base::Thread* thread,
                    ServerWrapper* server_wrapper,
-                   content::DevToolsSocketFactory* socket_factory) {
+                   DevToolsSocketFactory* socket_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (server_wrapper) {
     DCHECK(thread);
     thread->task_runner()->DeleteSoon(FROM_HERE, server_wrapper);
   }
   if (socket_factory) {
     DCHECK(thread);
     thread->task_runner()->DeleteSoon(FROM_HERE, socket_factory);
   }
   if (thread) {
     BrowserThread::DeleteSoon(BrowserThread::FILE, FROM_HERE, thread);
   }
 }
 
 void ServerStartedOnUI(base::WeakPtr<DevToolsHttpHandler> handler,
                        base::Thread* thread,
                        ServerWrapper* server_wrapper,
-                       content::DevToolsSocketFactory* socket_factory,
+                       DevToolsSocketFactory* socket_factory,
                        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,
-    content::DevToolsSocketFactory* socket_factory,
+    DevToolsSocketFactory* socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     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),
@@ skipping 11 matching lines @@
       base::Bind(&ServerStartedOnUI,
                  handler,
                  thread,
                  server_wrapper,
                  socket_factory,
                  base::Passed(&ip_address)));
 }
 
 void StartServerOnFile(
     base::WeakPtr<DevToolsHttpHandler> handler,
-    content::DevToolsSocketFactory* socket_factory,
+    DevToolsSocketFactory* socket_factory,
     const base::FilePath& output_directory,
     const base::FilePath& frontend_dir,
     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();
@@ skipping 270 matching lines @@
              net::HTTP_NOT_FOUND,
              NULL,
              "Malformed query: " + info.path);
     return;
   }
 
   if (command == "version") {
     base::DictionaryValue version;
     version.SetString("Protocol-Version",
         DevToolsAgentHost::GetProtocolVersion().c_str());
-    version.SetString("WebKit-Version", content::GetWebKitVersion());
+    version.SetString("WebKit-Version", GetWebKitVersion());
     version.SetString("Browser", product_name_);
     version.SetString("User-Agent", user_agent_);
 #if defined(OS_ANDROID)
     version.SetString("Android-Package",
         base::android::BuildInfo::GetInstance()->package_name());
 #endif
     SendJson(connection_id, net::HTTP_OK, &version, std::string());
     return;
   }
 
   if (command == "list") {
     std::string host = info.headers["host"];
     DevToolsAgentHost::List agent_hosts =
-        content::DevToolsAgentHost::DiscoverAllHosts();
+        DevToolsAgentHost::DiscoverAllHosts();
     std::sort(agent_hosts.begin(), agent_hosts.end(), TimeComparator);
     agent_host_map_.clear();
     base::ListValue list_value;
     for (auto& agent_host : agent_hosts) {
       agent_host_map_[agent_host->GetId()] = agent_host;
       list_value.Append(SerializeDescriptor(agent_host, host));
     }
     SendJson(connection_id, net::HTTP_OK, &list_value, std::string());
     return;
   }
 
   if (command == "new") {
     GURL url(net::UnescapeURLComponent(
         query, net::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS |
                    net::UnescapeRule::PATH_SEPARATORS));
     if (!url.is_valid())
       url = GURL(url::kAboutBlankURL);
     scoped_refptr<DevToolsAgentHost> agent_host = nullptr;
-    content::DevToolsManagerDelegate* delegate =
-        DevToolsAgentHost::GetDevToolsManagerDelegate();
-    if (delegate)
-      agent_host = delegate->CreateNewTarget(url);
+    agent_host = delegate_->CreateNewTarget(url);
     if (!agent_host) {
       SendJson(connection_id,
                net::HTTP_INTERNAL_SERVER_ERROR,
                NULL,
                "Could not create new page");
       return;
     }
     std::string host = info.headers["host"];
     std::unique_ptr<base::DictionaryValue> dictionary(
         SerializeDescriptor(agent_host, host));
@@ skipping 67 matching lines @@
     const net::HttpServerRequestInfo& request) {
   if (!thread_)
     return;
 
   std::string browser_prefix = "/devtools/browser";
   if (base::StartsWith(request.path, browser_prefix,
                        base::CompareCase::SENSITIVE)) {
     scoped_refptr<DevToolsAgentHost> browser_agent =
         DevToolsAgentHost::CreateForBrowser(
             thread_->task_runner(),
-            base::Bind(&content::DevToolsSocketFactory::CreateForTethering,
+            base::Bind(&DevToolsSocketFactory::CreateForTethering,
                        base::Unretained(socket_factory_)));
     connection_to_client_[connection_id] = new DevToolsAgentHostClientImpl(
         thread_->message_loop(), server_wrapper_, connection_id, browser_agent);
     AcceptWebSocket(connection_id, request);
     return;
   }
 
   if (!base::StartsWith(request.path, kPageUrlPrefix,
                         base::CompareCase::SENSITIVE)) {
     Send404(connection_id);
@@ skipping 32 matching lines @@
 void DevToolsHttpHandler::OnClose(int connection_id) {
   ConnectionToClientMap::iterator it =
       connection_to_client_.find(connection_id);
   if (it != connection_to_client_.end()) {
     delete it->second;
     connection_to_client_.erase(connection_id);
   }
 }
 
 DevToolsHttpHandler::DevToolsHttpHandler(
-    std::unique_ptr<content::DevToolsSocketFactory> socket_factory,
+    DevToolsManagerDelegate* delegate,
+    std::unique_ptr<DevToolsSocketFactory> socket_factory,
     const std::string& frontend_url,
-    DevToolsHttpHandlerDelegate* delegate,
     const base::FilePath& output_directory,
     const base::FilePath& debug_frontend_dir,
     const std::string& product_name,
     const std::string& user_agent)
     : thread_(nullptr),
       frontend_url_(frontend_url),
       product_name_(product_name),
       user_agent_(user_agent),
       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));
 }
 
 void DevToolsHttpHandler::ServerStarted(
     base::Thread* thread,
     ServerWrapper* server_wrapper,
-    content::DevToolsSocketFactory* socket_factory,
+    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(
     const base::FilePath& output_directory) {
   DCHECK(!output_directory.empty());
@@ skipping 109 matching lines @@
     std::string devtools_frontend_url = GetFrontendURLInternal(
         id.c_str(),
         host);
     dictionary->SetString(
         kTargetDevtoolsFrontendUrlField, devtools_frontend_url);
   }
 
   return dictionary;
 }
 
-}  // namespace devtools_http_handler
+}  // namespace content