[DevTools] Expose DevToolsAgentHost for browser, move DevToolsHttpHandler to it.

In preparation to making DevToolsHttpHandler a component, this patch removes
unneeded dependencies from it to content/browser/devtools.
Drive-by: cleanup DevToolsAgentHost::IsWorker method.

BUG=476496

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

Cr-Commit-Position: refs/heads/master@{#324885}

12 files changed, 193 insertions, 122 deletions

diff --git a/content/browser/devtools/browser_devtools_agent_host.cc b/content/browser/devtools/browser_devtools_agent_host.cc
new file mode 100644
index 0000000..03fb0e2
--- /dev/null
+++ b/content/browser/devtools/browser_devtools_agent_host.cc
@@ -0,0 +1,65 @@
+// Copyright 2014 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 "content/browser/devtools/browser_devtools_agent_host.h"
+
+#include "base/bind.h"
+#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
+#include "content/browser/devtools/protocol/system_info_handler.h"
+#include "content/browser/devtools/protocol/tethering_handler.h"
+#include "content/browser/devtools/protocol/tracing_handler.h"
+
+namespace content {
+
+scoped_refptr<DevToolsAgentHost> DevToolsAgentHost::CreateForBrowser(
+    scoped_refptr<base::MessageLoopProxy> tethering_message_loop,
+    const CreateServerSocketCallback& socket_callback) {
+  return new BrowserDevToolsAgentHost(tethering_message_loop, socket_callback);
+}
+
+BrowserDevToolsAgentHost::BrowserDevToolsAgentHost(
+    scoped_refptr<base::MessageLoopProxy> tethering_message_loop,
+    const CreateServerSocketCallback& socket_callback)
+    : system_info_handler_(new devtools::system_info::SystemInfoHandler()),
+      tethering_handler_(new devtools::tethering::TetheringHandler(
+          socket_callback, tethering_message_loop)),
+      tracing_handler_(new devtools::tracing::TracingHandler(
+          devtools::tracing::TracingHandler::Browser)) {
+  set_handle_all_protocol_commands();
+  DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
+  dispatcher->SetSystemInfoHandler(system_info_handler_.get());
+  dispatcher->SetTetheringHandler(tethering_handler_.get());
+  dispatcher->SetTracingHandler(tracing_handler_.get());
+}
+
+BrowserDevToolsAgentHost::~BrowserDevToolsAgentHost() {
+}
+
+void BrowserDevToolsAgentHost::Attach() {
+}
+
+void BrowserDevToolsAgentHost::Detach() {
+}
+
+DevToolsAgentHost::Type BrowserDevToolsAgentHost::GetType() {
+  return TYPE_BROWSER;
+}
+
+std::string BrowserDevToolsAgentHost::GetTitle() {
+  return "";
+}
+
+GURL BrowserDevToolsAgentHost::GetURL() {
+  return GURL();
+}
+
+bool BrowserDevToolsAgentHost::Activate() {
+  return false;
+}
+
+bool BrowserDevToolsAgentHost::Close() {
+  return false;
+}
+
+}  // content
diff --git a/content/browser/devtools/browser_devtools_agent_host.h b/content/browser/devtools/browser_devtools_agent_host.h
new file mode 100644
index 0000000..b4fbb7d
--- /dev/null
+++ b/content/browser/devtools/browser_devtools_agent_host.h
@@ -0,0 +1,44 @@
+// Copyright 2015 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 CONTENT_BROWSER_DEVTOOLS_BROWSER_DEVTOOLS_AGENT_HOST_H_
+#define CONTENT_BROWSER_DEVTOOLS_BROWSER_DEVTOOLS_AGENT_HOST_H_
+
+#include "content/browser/devtools/devtools_agent_host_impl.h"
+
+namespace content {
+
+namespace devtools {
+namespace system_info { class SystemInfoHandler; }
+namespace tethering { class TetheringHandler; }
+namespace tracing { class TracingHandler; }
+}  // namespace devtools
+
+class BrowserDevToolsAgentHost : public DevToolsAgentHostImpl {
+ private:
+  friend class DevToolsAgentHost;
+  BrowserDevToolsAgentHost(
+      scoped_refptr<base::MessageLoopProxy> tethering_message_loop,
+      const CreateServerSocketCallback& socket_callback);
+  ~BrowserDevToolsAgentHost() override;
+
+  // DevToolsAgentHostImpl implementation.
+  void Attach() override;
+  void Detach() override;
+
+  // DevToolsAgentHost implementation.
+  Type GetType() override;
+  std::string GetTitle() override;
+  GURL GetURL() override;
+  bool Activate() override;
+  bool Close() override;
+
+  scoped_ptr<devtools::system_info::SystemInfoHandler> system_info_handler_;
+  scoped_ptr<devtools::tethering::TetheringHandler> tethering_handler_;
+  scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_BROWSER_DEVTOOLS_AGENT_HOST_H_
diff --git a/content/browser/devtools/devtools_agent_host_impl.cc b/content/browser/devtools/devtools_agent_host_impl.cc
index efd76cb..3eb6ace 100644
--- a/content/browser/devtools/devtools_agent_host_impl.cc
+++ b/content/browser/devtools/devtools_agent_host_impl.cc
@@ -35,6 +35,16 @@ base::LazyInstance<AgentStateCallbacks>::Leaky g_callbacks =
 }  // namespace
 
 // static
+std::string DevToolsAgentHost::GetProtocolVersion() {
+  return std::string(devtools::kProtocolVersion);
+}
+
+// static
+bool DevToolsAgentHost::IsSupportedProtocolVersion(const std::string& version) {
+  return devtools::IsSupportedProtocolVersion(version);
+}
+
+// static
 DevToolsAgentHost::List DevToolsAgentHost::GetOrCreateAll() {
   List result;
   SharedWorkerDevToolsAgentHost::List shared_list;
@@ -71,7 +81,8 @@ DevToolsAgentHostImpl::DevToolsAgentHostImpl()
           base::Bind(&DevToolsAgentHostImpl::SendMessageToClient,
                      base::Unretained(this)))),
       id_(base::GenerateGUID()),
-      client_(NULL) {
+      client_(NULL),
+      handle_all_commands_(false) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   g_instances.Get()[id_] = this;
 }
@@ -144,10 +155,6 @@ void DevToolsAgentHostImpl::DisconnectWebContents() {
 void DevToolsAgentHostImpl::ConnectWebContents(WebContents* wc) {
 }
 
-bool DevToolsAgentHostImpl::IsWorker() const {
-  return false;
-}
-
 void DevToolsAgentHostImpl::HostClosed() {
   if (!client_)
     return;
@@ -244,7 +251,10 @@ bool DevToolsAgentHostImpl::DispatchProtocolMessage(
     }
   }
 
-  return protocol_handler_->HandleOptionalCommand(command.Pass());
+  if (!handle_all_commands_)
+    return protocol_handler_->HandleOptionalCommand(command.Pass());
+  protocol_handler_->HandleCommand(command.Pass());
+  return true;
 }
 
 }  // namespace content
diff --git a/content/browser/devtools/devtools_agent_host_impl.h b/content/browser/devtools/devtools_agent_host_impl.h
index 07112c3..698bfe9 100644
--- a/content/browser/devtools/devtools_agent_host_impl.h
+++ b/content/browser/devtools/devtools_agent_host_impl.h
@@ -45,7 +45,6 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
   WebContents* GetWebContents() override;
   void DisconnectWebContents() override;
   void ConnectWebContents(WebContents* wc) override;
-  bool IsWorker() const override;
 
  protected:
   DevToolsAgentHostImpl();
@@ -53,6 +52,7 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
 
   scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
 
+  void set_handle_all_protocol_commands() { handle_all_commands_ = true; }
   void HostClosed();
   void SendMessageToClient(const std::string& message);
   static void NotifyCallbacks(DevToolsAgentHostImpl* agent_host, bool attached);
@@ -62,6 +62,7 @@ class CONTENT_EXPORT DevToolsAgentHostImpl : public DevToolsAgentHost {
 
   const std::string id_;
   DevToolsAgentHostClient* client_;
+  bool handle_all_commands_;
 };
 
 }  // namespace content
diff --git a/content/browser/devtools/devtools_http_handler_impl.cc b/content/browser/devtools/devtools_http_handler_impl.cc
index fb25825d..4cae448 100644
--- a/content/browser/devtools/devtools_http_handler_impl.cc
+++ b/content/browser/devtools/devtools_http_handler_impl.cc
@@ -13,14 +13,11 @@
 #include "base/message_loop/message_loop_proxy.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 "content/browser/devtools/devtools_manager.h"
-#include "content/browser/devtools/protocol/devtools_protocol_handler.h"
-#include "content/browser/devtools/protocol/system_info_handler.h"
-#include "content/browser/devtools/protocol/tethering_handler.h"
-#include "content/browser/devtools/protocol/tracing_handler.h"
-#include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_http_handler.h"
@@ -71,7 +68,6 @@ const char kTargetDevtoolsFrontendUrlField[] = "devtoolsFrontendUrl";
 // added back pressure on the TraceComplete message protocol - crbug.com/456845.
 const int32 kSendBufferSizeForDevTools = 256 * 1024 * 1024;  // 256Mb
 
-class BrowserTarget;
 class DevToolsAgentHostClientImpl;
 class ServerWrapper;
 
@@ -148,8 +144,6 @@ class DevToolsHttpHandlerImpl : public DevToolsHttpHandler {
   ServerSocketFactory* socket_factory_;
   typedef std::map<std::string, DevToolsTarget*> TargetMap;
   TargetMap target_map_;
-  typedef std::map<int, BrowserTarget*> BrowserTargets;
-  BrowserTargets browser_targets_;
   base::WeakPtrFactory<DevToolsHttpHandlerImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsHttpHandlerImpl);
@@ -346,7 +340,7 @@ class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
   DevToolsAgentHostClientImpl(base::MessageLoop* message_loop,
                               ServerWrapper* server_wrapper,
                               int connection_id,
-                              DevToolsAgentHost* agent_host)
+                              scoped_refptr<DevToolsAgentHost> agent_host)
       : message_loop_(message_loop),
         server_wrapper_(server_wrapper),
         connection_id_(connection_id),
@@ -363,13 +357,12 @@ class DevToolsAgentHostClientImpl : public DevToolsAgentHostClient {
                        bool replaced_with_another_client) override {
     DCHECK(agent_host == agent_host_.get());
 
-    base::Callback<void(const std::string&)> raw_message_callback(
-        base::Bind(&DevToolsAgentHostClientImpl::DispatchProtocolMessage,
-                   base::Unretained(this), base::Unretained(agent_host)));
-    devtools::inspector::Client inspector(raw_message_callback);
-    inspector.Detached(devtools::inspector::DetachedParams::Create()
-       ->set_reason(replaced_with_another_client ?
-            "replaced_with_devtools" : "target_closed"));
+    std::string message = base::StringPrintf(
+        "{ \"method\": \"Inspector.detached\", "
+        "\"params\": { \"reason\": \"%s\"} }",
+        replaced_with_another_client ?
+            "replaced_with_devtools" : "target_closed");
+    DispatchProtocolMessage(agent_host, message);
 
     agent_host_ = nullptr;
     message_loop_->PostTask(
@@ -407,59 +400,6 @@ static bool TimeComparator(const DevToolsTarget* target1,
   return target1->GetLastActivityTime() > target2->GetLastActivityTime();
 }
 
-// BrowserTarget -------------------------------------------------------------
-
-class BrowserTarget {
- public:
-  BrowserTarget(base::MessageLoop* message_loop,
-                ServerWrapper* server_wrapper,
-                DevToolsHttpHandler::ServerSocketFactory* socket_factory,
-                int connection_id)
-      : message_loop_(message_loop),
-        server_wrapper_(server_wrapper),
-        connection_id_(connection_id),
-        system_info_handler_(new devtools::system_info::SystemInfoHandler()),
-        tethering_handler_(new devtools::tethering::TetheringHandler(
-            socket_factory, message_loop->message_loop_proxy())),
-        tracing_handler_(new devtools::tracing::TracingHandler(
-            devtools::tracing::TracingHandler::Browser)),
-        protocol_handler_(new DevToolsProtocolHandler(
-            base::Bind(&BrowserTarget::Respond, base::Unretained(this)))) {
-    DevToolsProtocolDispatcher* dispatcher = protocol_handler_->dispatcher();
-    dispatcher->SetSystemInfoHandler(system_info_handler_.get());
-    dispatcher->SetTetheringHandler(tethering_handler_.get());
-    dispatcher->SetTracingHandler(tracing_handler_.get());
-  }
-
-  void HandleMessage(const std::string& message) {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    std::string error_response;
-    scoped_ptr<base::DictionaryValue> command =
-        protocol_handler_->ParseCommand(message);
-    if (command)
-      protocol_handler_->HandleCommand(command.Pass());
-  }
-
-  void Respond(const std::string& message) {
-    DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    message_loop_->PostTask(
-        FROM_HERE,
-        base::Bind(&ServerWrapper::SendOverWebSocket,
-                   base::Unretained(server_wrapper_),
-                   connection_id_,
-                   message));
-  }
-
- private:
-  base::MessageLoop* const message_loop_;
-  ServerWrapper* const server_wrapper_;
-  const int connection_id_;
-  scoped_ptr<devtools::system_info::SystemInfoHandler> system_info_handler_;
-  scoped_ptr<devtools::tethering::TetheringHandler> tethering_handler_;
-  scoped_ptr<devtools::tracing::TracingHandler> tracing_handler_;
-  scoped_ptr<DevToolsProtocolHandler> protocol_handler_;
-};
-
 }  // namespace
 
 // DevToolsHttpHandler -------------------------------------------------------
@@ -467,7 +407,7 @@ class BrowserTarget {
 // static
 bool DevToolsHttpHandler::IsSupportedProtocolVersion(
     const std::string& version) {
-  return devtools::IsSupportedProtocolVersion(version);
+  return DevToolsAgentHost::IsSupportedProtocolVersion(version);
 }
 
 // static
@@ -511,7 +451,6 @@ DevToolsHttpHandler::ServerSocketFactory::CreateForTethering(
 DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
   TerminateOnUI(thread_, server_wrapper_, socket_factory_);
   STLDeleteValues(&target_map_);
-  STLDeleteValues(&browser_targets_);
   STLDeleteValues(&connection_to_client_);
 }
 
@@ -718,7 +657,8 @@ void DevToolsHttpHandlerImpl::OnJsonRequest(
 
   if (command == "version") {
     base::DictionaryValue version;
-    version.SetString("Protocol-Version", devtools::kProtocolVersion);
+    version.SetString("Protocol-Version",
+        DevToolsAgentHost::GetProtocolVersion().c_str());
     version.SetString("WebKit-Version", GetWebKitVersion());
     version.SetString("Browser", GetContentClient()->GetProduct());
     version.SetString("User-Agent", GetContentClient()->GetUserAgent());
@@ -880,10 +820,13 @@ void DevToolsHttpHandlerImpl::OnWebSocketRequest(
   std::string browser_prefix = "/devtools/browser";
   size_t browser_pos = request.path.find(browser_prefix);
   if (browser_pos == 0) {
-    browser_targets_[connection_id] = new BrowserTarget(thread_->message_loop(),
-                                                        server_wrapper_,
-                                                        socket_factory_,
-                                                        connection_id);
+    scoped_refptr<DevToolsAgentHost> browser_agent =
+        DevToolsAgentHost::CreateForBrowser(
+            thread_->message_loop_proxy(),
+            base::Bind(&ServerSocketFactory::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;
   }
@@ -910,7 +853,7 @@ void DevToolsHttpHandlerImpl::OnWebSocketRequest(
   }
 
   DevToolsAgentHostClientImpl* client_host = new DevToolsAgentHostClientImpl(
-      thread_->message_loop(), server_wrapper_, connection_id, agent.get());
+      thread_->message_loop(), server_wrapper_, connection_id, agent);
   connection_to_client_[connection_id] = client_host;
 
   AcceptWebSocket(connection_id, request);
@@ -919,12 +862,6 @@ void DevToolsHttpHandlerImpl::OnWebSocketRequest(
 void DevToolsHttpHandlerImpl::OnWebSocketMessage(
     int connection_id,
     const std::string& data) {
-  BrowserTargets::iterator browser_it = browser_targets_.find(connection_id);
-  if (browser_it != browser_targets_.end()) {
-    browser_it->second->HandleMessage(data);
-    return;
-  }
-
   ConnectionToClientMap::iterator it =
       connection_to_client_.find(connection_id);
   if (it != connection_to_client_.end())
@@ -932,13 +869,6 @@ void DevToolsHttpHandlerImpl::OnWebSocketMessage(
 }
 
 void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
-  BrowserTargets::iterator browser_it = browser_targets_.find(connection_id);
-  if (browser_it != browser_targets_.end()) {
-    delete browser_it->second;
-    browser_targets_.erase(connection_id);
-    return;
-  }
-
   ConnectionToClientMap::iterator it =
       connection_to_client_.find(connection_id);
   if (it != connection_to_client_.end()) {
diff --git a/content/browser/devtools/protocol/tethering_handler.cc b/content/browser/devtools/protocol/tethering_handler.cc
index efdf0d1..291a132 100644
--- a/content/browser/devtools/protocol/tethering_handler.cc
+++ b/content/browser/devtools/protocol/tethering_handler.cc
@@ -27,6 +27,8 @@ const int kMinTetheringPort = 1024;
 const int kMaxTetheringPort = 32767;
 
 using Response = DevToolsProtocolClient::Response;
+using CreateServerSocketCallback =
+    base::Callback<scoped_ptr<net::ServerSocket>(std::string*)>;
 
 class SocketPump {
  public:
@@ -36,9 +38,9 @@ class SocketPump {
         pending_destruction_(false) {
   }
 
-  std::string Init(DevToolsHttpHandler::ServerSocketFactory* socket_factory) {
+  std::string Init(const CreateServerSocketCallback& socket_callback) {
     std::string channel_name;
-    server_socket_ = socket_factory->CreateForTethering(&channel_name);
+    server_socket_ = socket_callback.Run(&channel_name);
     if (!server_socket_.get() || channel_name.empty())
       SelfDestruct();
 
@@ -157,9 +159,9 @@ class BoundSocket {
   typedef base::Callback<void(uint16, const std::string&)> AcceptedCallback;
 
   BoundSocket(AcceptedCallback accepted_callback,
-              DevToolsHttpHandler::ServerSocketFactory* socket_factory)
+              const CreateServerSocketCallback& socket_callback)
       : accepted_callback_(accepted_callback),
-        socket_factory_(socket_factory),
+        socket_callback_(socket_callback),
         socket_(new net::TCPServerSocket(NULL, net::NetLog::Source())),
         port_(0) {
   }
@@ -213,13 +215,13 @@ class BoundSocket {
       return;
 
     SocketPump* pump = new SocketPump(accept_socket_.release());
-    std::string name = pump->Init(socket_factory_);
+    std::string name = pump->Init(socket_callback_);
     if (!name.empty())
       accepted_callback_.Run(port_, name);
   }
 
   AcceptedCallback accepted_callback_;
-  DevToolsHttpHandler::ServerSocketFactory* socket_factory_;
+  CreateServerSocketCallback socket_callback_;
   scoped_ptr<net::ServerSocket> socket_;
   scoped_ptr<net::StreamSocket> accept_socket_;
   uint16 port_;
@@ -233,7 +235,7 @@ class TetheringHandler::TetheringImpl {
  public:
   TetheringImpl(
       base::WeakPtr<TetheringHandler> handler,
-      DevToolsHttpHandler::ServerSocketFactory* socket_factory);
+      const CreateServerSocketCallback& socket_callback);
   ~TetheringImpl();
 
   void Bind(DevToolsCommandId command_id, uint16 port);
@@ -245,7 +247,7 @@ class TetheringHandler::TetheringImpl {
                          const std::string& message);
 
   base::WeakPtr<TetheringHandler> handler_;
-  DevToolsHttpHandler::ServerSocketFactory* socket_factory_;
+  CreateServerSocketCallback socket_callback_;
 
   typedef std::map<uint16, BoundSocket*> BoundSockets;
   BoundSockets bound_sockets_;
@@ -253,9 +255,9 @@ class TetheringHandler::TetheringImpl {
 
 TetheringHandler::TetheringImpl::TetheringImpl(
     base::WeakPtr<TetheringHandler> handler,
-    DevToolsHttpHandler::ServerSocketFactory* socket_factory)
+    const CreateServerSocketCallback& socket_callback)
     : handler_(handler),
-      socket_factory_(socket_factory) {
+      socket_callback_(socket_callback) {
 }
 
 TetheringHandler::TetheringImpl::~TetheringImpl() {
@@ -272,7 +274,7 @@ void TetheringHandler::TetheringImpl::Bind(
   BoundSocket::AcceptedCallback callback = base::Bind(
       &TetheringHandler::TetheringImpl::Accepted, base::Unretained(this));
   scoped_ptr<BoundSocket> bound_socket(
-      new BoundSocket(callback, socket_factory_));
+      new BoundSocket(callback, socket_callback_));
   if (!bound_socket->Listen(port)) {
     SendInternalError(command_id, "Could not bind port");
     return;
@@ -327,9 +329,9 @@ void TetheringHandler::TetheringImpl::SendInternalError(
 TetheringHandler::TetheringImpl* TetheringHandler::impl_ = nullptr;
 
 TetheringHandler::TetheringHandler(
-    DevToolsHttpHandler::ServerSocketFactory* socket_factory,
+    const CreateServerSocketCallback& socket_callback,
     scoped_refptr<base::MessageLoopProxy> message_loop_proxy)
-    : socket_factory_(socket_factory),
+    : socket_callback_(socket_callback),
       message_loop_proxy_(message_loop_proxy),
       is_active_(false),
       weak_factory_(this) {
@@ -357,7 +359,7 @@ bool TetheringHandler::Activate() {
   if (impl_)
     return false;
   is_active_ = true;
-  impl_ = new TetheringImpl(weak_factory_.GetWeakPtr(), socket_factory_);
+  impl_ = new TetheringImpl(weak_factory_.GetWeakPtr(), socket_callback_);
   return true;
 }
 
diff --git a/content/browser/devtools/protocol/tethering_handler.h b/content/browser/devtools/protocol/tethering_handler.h
index ac6afc8..6be8a0a 100644
--- a/content/browser/devtools/protocol/tethering_handler.h
+++ b/content/browser/devtools/protocol/tethering_handler.h
@@ -18,8 +18,10 @@ namespace tethering {
 class TetheringHandler {
  public:
   using Response = DevToolsProtocolClient::Response;
+  using CreateServerSocketCallback =
+      base::Callback<scoped_ptr<net::ServerSocket>(std::string*)>;
 
-  TetheringHandler(DevToolsHttpHandler::ServerSocketFactory* delegate,
+  TetheringHandler(const CreateServerSocketCallback& socket_callback,
                    scoped_refptr<base::MessageLoopProxy> message_loop_proxy);
   ~TetheringHandler();
 
@@ -40,7 +42,7 @@ class TetheringHandler {
                          const std::string& message);
 
   scoped_ptr<Client> client_;
-  DevToolsHttpHandler::ServerSocketFactory* socket_factory_;
+  CreateServerSocketCallback socket_callback_;
   scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
   bool is_active_;
   base::WeakPtrFactory<TetheringHandler> weak_factory_;
diff --git a/content/browser/devtools/worker_devtools_agent_host.cc b/content/browser/devtools/worker_devtools_agent_host.cc
index 204435a..fcf8dd7 100644
--- a/content/browser/devtools/worker_devtools_agent_host.cc
+++ b/content/browser/devtools/worker_devtools_agent_host.cc
@@ -11,10 +11,6 @@
 
 namespace content {
 
-bool WorkerDevToolsAgentHost::IsWorker() const {
-  return true;
-}
-
 BrowserContext* WorkerDevToolsAgentHost::GetBrowserContext() {
   RenderProcessHost* rph = RenderProcessHost::FromID(worker_id_.first);
   return rph ? rph->GetBrowserContext() : nullptr;
diff --git a/content/browser/devtools/worker_devtools_agent_host.h b/content/browser/devtools/worker_devtools_agent_host.h
index ae5e39f..7bd5128 100644
--- a/content/browser/devtools/worker_devtools_agent_host.h
+++ b/content/browser/devtools/worker_devtools_agent_host.h
@@ -19,7 +19,6 @@ class WorkerDevToolsAgentHost : public IPCDevToolsAgentHost,
   typedef std::pair<int, int> WorkerId;
 
   // DevToolsAgentHost override.
-  bool IsWorker() const override;
   BrowserContext* GetBrowserContext() override;
 
   // IPCDevToolsAgentHost implementation.
diff --git a/content/content_browser.gypi b/content/content_browser.gypi
index c172678..117d20a 100644
--- a/content/content_browser.gypi
+++ b/content/content_browser.gypi
@@ -521,6 +521,8 @@
       'browser/device_sensors/sensor_manager_android.h',
       'browser/device_sensors/sensor_manager_chromeos.cc',
       'browser/device_sensors/sensor_manager_chromeos.h',
+      'browser/devtools/browser_devtools_agent_host.cc',
+      'browser/devtools/browser_devtools_agent_host.h',
       'browser/devtools/devtools_agent_host_impl.cc',
       'browser/devtools/devtools_agent_host_impl.h',
       'browser/devtools/devtools_frame_trace_recorder.cc',
diff --git a/content/public/browser/devtools_agent_host.h b/content/public/browser/devtools_agent_host.h
index 49feaf1..12616c1 100644
--- a/content/public/browser/devtools_agent_host.h
+++ b/content/public/browser/devtools_agent_host.h
@@ -11,10 +11,16 @@
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/devtools_agent_host_client.h"
 #include "url/gurl.h"
 
+namespace net {
+class ServerSocket;
+}
+
 namespace content {
 
 class BrowserContext;
@@ -40,8 +46,17 @@ class CONTENT_EXPORT DevToolsAgentHost
 
     // Agent host associated with DevToolsExternalAgentProxyDelegate.
     TYPE_EXTERNAL,
+
+    // Agent host associated with browser.
+    TYPE_BROWSER,
   };
 
+  // Latest DevTools protocol version supported.
+  static std::string GetProtocolVersion();
+
+  // Returns whether particular version of DevTools protocol is supported.
+  static bool IsSupportedProtocolVersion(const std::string& version);
+
   // Returns DevToolsAgentHost with a given |id| or nullptr of it doesn't exist.
   static scoped_refptr<DevToolsAgentHost> GetForId(const std::string& id);
 
@@ -65,6 +80,15 @@ class CONTENT_EXPORT DevToolsAgentHost
   static scoped_refptr<DevToolsAgentHost> Create(
       DevToolsExternalAgentProxyDelegate* delegate);
 
+  using CreateServerSocketCallback =
+      base::Callback<scoped_ptr<net::ServerSocket>(std::string*)>;
+
+  // Creates DevToolsAgentHost for the browser, which works with browser-wide
+  // debugging protocol.
+  static scoped_refptr<DevToolsAgentHost> CreateForBrowser(
+      scoped_refptr<base::MessageLoopProxy> tethering_message_loop,
+      const CreateServerSocketCallback& socket_callback);
+
   static bool IsDebuggerAttached(WebContents* web_contents);
 
   typedef std::vector<scoped_refptr<DevToolsAgentHost> > List;
@@ -103,9 +127,6 @@ class CONTENT_EXPORT DevToolsAgentHost
   // Attaches render view host to this host.
   virtual void ConnectWebContents(WebContents* web_contents) = 0;
 
-  // Returns true if DevToolsAgentHost is for worker.
-  virtual bool IsWorker() const = 0;
-
   // Returns agent host type.
   virtual Type GetType() = 0;
 
diff --git a/content/public/browser/devtools_http_handler.h b/content/public/browser/devtools_http_handler.h
index 1c79ef0..a61901b 100644
--- a/content/public/browser/devtools_http_handler.h
+++ b/content/public/browser/devtools_http_handler.h
@@ -15,7 +15,6 @@ class GURL;
 
 namespace net {
 class ServerSocket;
-class URLRequestContextGetter;
 }
 
 namespace content {