DevTools: rename debugger/ to devtools/, move DevTools files into content/renderer/devtools.

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


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@173903 0039d316-1c4b-4281-b951-d872f2087c98

25 files changed, 3768 insertions, 0 deletions

diff --git a/content/browser/devtools/DEPS b/content/browser/devtools/DEPS
new file mode 100644
index 0000000..3e98aee
--- /dev/null
+++ b/content/browser/devtools/DEPS
@@ -0,0 +1,4 @@
+include_rules = [
+  # Generated by the local devtools_resources.gyp:devtools_resources
+  "+grit/devtools_resources_map.h",
+]
diff --git a/content/browser/devtools/OWNERS b/content/browser/devtools/OWNERS
new file mode 100644
index 0000000..bb6028e
--- /dev/null
+++ b/content/browser/devtools/OWNERS
@@ -0,0 +1,2 @@
+pfeldman@chromium.org
+yurys@chromium.org
diff --git a/content/browser/devtools/devtools_agent_host.cc b/content/browser/devtools/devtools_agent_host.cc
new file mode 100644
index 0000000..fa5bc0e
--- /dev/null
+++ b/content/browser/devtools/devtools_agent_host.cc
@@ -0,0 +1,57 @@
+// 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 "content/browser/devtools/devtools_agent_host.h"
+
+#include "base/basictypes.h"
+#include "content/common/devtools_messages.h"
+
+namespace content {
+
+DevToolsAgentHost::DevToolsAgentHost() : close_listener_(NULL) {
+}
+
+void DevToolsAgentHost::Attach() {
+  SendMessageToAgent(new DevToolsAgentMsg_Attach(MSG_ROUTING_NONE));
+  NotifyClientAttaching();
+}
+
+void DevToolsAgentHost::Reattach(const std::string& saved_agent_state) {
+  SendMessageToAgent(new DevToolsAgentMsg_Reattach(
+      MSG_ROUTING_NONE,
+      saved_agent_state));
+  NotifyClientAttaching();
+}
+
+void DevToolsAgentHost::Detach() {
+  SendMessageToAgent(new DevToolsAgentMsg_Detach(MSG_ROUTING_NONE));
+  NotifyClientDetaching();
+}
+
+void DevToolsAgentHost::DipatchOnInspectorBackend(const std::string& message) {
+  SendMessageToAgent(new DevToolsAgentMsg_DispatchOnInspectorBackend(
+      MSG_ROUTING_NONE, message));
+}
+
+void DevToolsAgentHost::InspectElement(int x, int y) {
+  SendMessageToAgent(new DevToolsAgentMsg_InspectElement(MSG_ROUTING_NONE,
+                                                         x, y));
+}
+
+void DevToolsAgentHost::AddMessageToConsole(ConsoleMessageLevel level,
+                                            const std::string& message) {
+  SendMessageToAgent(new DevToolsAgentMsg_AddMessageToConsole(
+      MSG_ROUTING_NONE,
+      level,
+      message));
+}
+
+void DevToolsAgentHost::NotifyCloseListener() {
+  if (close_listener_) {
+    close_listener_->AgentHostClosing(this);
+    close_listener_ = NULL;
+  }
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_agent_host.h b/content/browser/devtools/devtools_agent_host.h
new file mode 100644
index 0000000..ae44862
--- /dev/null
+++ b/content/browser/devtools/devtools_agent_host.h
@@ -0,0 +1,59 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_AGENT_HOST_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_AGENT_HOST_H_
+
+#include <string>
+
+#include "content/common/content_export.h"
+#include "content/public/common/console_message_level.h"
+
+namespace IPC {
+class Message;
+}
+
+namespace content {
+
+// Describes interface for managing devtools agents from the browser process.
+class CONTENT_EXPORT DevToolsAgentHost {
+ public:
+  class CONTENT_EXPORT CloseListener {
+   public:
+    virtual void AgentHostClosing(DevToolsAgentHost*) = 0;
+   protected:
+    virtual ~CloseListener() {}
+  };
+
+  // Sends the message to the devtools agent hosted by this object.
+  void Attach();
+  void Reattach(const std::string& saved_agent_state);
+  void Detach();
+  void DipatchOnInspectorBackend(const std::string& message);
+  void InspectElement(int x, int y);
+  void AddMessageToConsole(ConsoleMessageLevel level,
+                           const std::string& message);
+
+  virtual int GetRenderProcessId() = 0;
+
+  void set_close_listener(CloseListener* listener) {
+    close_listener_ = listener;
+  }
+
+ protected:
+  DevToolsAgentHost();
+  virtual ~DevToolsAgentHost() {}
+
+  virtual void SendMessageToAgent(IPC::Message* msg) = 0;
+  virtual void NotifyClientAttaching() = 0;
+  virtual void NotifyClientDetaching() = 0;
+
+  void NotifyCloseListener();
+
+  CloseListener* close_listener_;
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_AGENT_HOST_H_
diff --git a/content/browser/devtools/devtools_browser_target.cc b/content/browser/devtools/devtools_browser_target.cc
new file mode 100644
index 0000000..44291b4
--- /dev/null
+++ b/content/browser/devtools/devtools_browser_target.cc
@@ -0,0 +1,118 @@
+// 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 "content/browser/devtools/devtools_browser_target.h"
+
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
+#include "base/logging.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/values.h"
+
+
+namespace content {
+
+DevToolsBrowserTarget::DevToolsBrowserTarget(int connection_id)
+    : connection_id_(connection_id) {
+}
+
+DevToolsBrowserTarget::~DevToolsBrowserTarget() {
+  for (HandlersMap::iterator i = handlers_.begin(); i != handlers_.end(); ++i)
+    delete i->second;
+}
+
+void DevToolsBrowserTarget::RegisterHandler(Handler* handler) {
+  std::string domain = handler->Domain();
+  DCHECK(handlers_.find(domain) == handlers_.end());
+  handlers_[domain] = handler;
+}
+
+std::string DevToolsBrowserTarget::HandleMessage(const std::string& data) {
+  int error_code;
+  std::string error_message;
+  scoped_ptr<base::Value> command(
+      base::JSONReader::ReadAndReturnError(
+          data, 0, &error_code, &error_message));
+
+  if (!command || !command->IsType(base::Value::TYPE_DICTIONARY))
+    return SerializeErrorResponse(
+        -1, CreateErrorObject(error_code, error_message));
+
+  int request_id;
+  std::string domain;
+  std::string method;
+  base::DictionaryValue* command_dict = NULL;
+  bool ok = true;
+  ok &= command->GetAsDictionary(&command_dict);
+  ok &= command_dict->GetInteger("id", &request_id);
+  ok &= command_dict->GetString("method", &method);
+  if (!ok)
+    return SerializeErrorResponse(
+        request_id, CreateErrorObject(-1, "Malformed request"));
+
+  base::DictionaryValue* params = NULL;
+  command_dict->GetDictionary("params", &params);
+
+  size_t pos = method.find(".");
+  if (pos == std::string::npos)
+    return SerializeErrorResponse(
+        request_id, CreateErrorObject(-1, "Method unsupported"));
+
+  domain = method.substr(0, pos);
+  if (domain.empty() || handlers_.find(domain) == handlers_.end())
+    return SerializeErrorResponse(
+        request_id, CreateErrorObject(-1, "Domain unsupported"));
+
+  base::Value* error_object = NULL;
+  base::Value* domain_result = handlers_[domain]->OnProtocolCommand(
+      method, params, &error_object);
+
+  if (error_object)
+    return SerializeErrorResponse(request_id, error_object);
+
+  if (!domain_result)
+    return SerializeErrorResponse(
+        request_id, CreateErrorObject(-1, "Invalid call"));
+
+  DictionaryValue* response = new DictionaryValue();
+  response->Set("result", domain_result);
+  return SerializeResponse(request_id, response);
+}
+
+std::string DevToolsBrowserTarget::SerializeErrorResponse(
+    int request_id, base::Value* error_object) {
+  scoped_ptr<base::DictionaryValue> error_response(new base::DictionaryValue());
+  error_response->SetInteger("id", request_id);
+  error_response->Set("error", error_object);
+  // Serialize response.
+  std::string json_response;
+  base::JSONWriter::WriteWithOptions(error_response.get(),
+                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                     &json_response);
+  return json_response;
+}
+
+base::Value* DevToolsBrowserTarget::CreateErrorObject(
+    int error_code, const std::string& message) {
+  base::DictionaryValue* error_object = new base::DictionaryValue();
+  error_object->SetInteger("code", error_code);
+  error_object->SetString("message", message);
+  return error_object;
+}
+
+std::string DevToolsBrowserTarget::SerializeResponse(
+    int request_id, base::Value* response) {
+  scoped_ptr<base::DictionaryValue> ret(new base::DictionaryValue());
+  ret->SetInteger("id", request_id);
+  ret->Set("response", response);
+
+  // Serialize response.
+  std::string json_response;
+  base::JSONWriter::WriteWithOptions(ret.get(),
+                                     base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                     &json_response);
+  return json_response;
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_browser_target.h b/content/browser/devtools/devtools_browser_target.h
new file mode 100644
index 0000000..a0a34e3
--- /dev/null
+++ b/content/browser/devtools/devtools_browser_target.h
@@ -0,0 +1,68 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_BROWSER_TARGET_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_BROWSER_TARGET_H_
+
+#include <map>
+#include <string>
+
+#include "base/basictypes.h"
+
+namespace base {
+
+class DictionaryValue;
+class Value;
+
+}  // namespace base
+
+namespace content {
+
+// This class handles the "Browser" target for remote debugging.
+class DevToolsBrowserTarget {
+ public:
+  class Handler {
+   public:
+    virtual ~Handler() {}
+
+    // Returns the domain name for this handler.
+    virtual std::string Domain() = 0;
+
+    // |return_value| and |error_message_out| ownership is transferred to the
+    // caller.
+    virtual base::Value* OnProtocolCommand(
+        const std::string& method,
+        const base::DictionaryValue* params,
+        base::Value** error_message_out) = 0;
+  };
+
+  explicit DevToolsBrowserTarget(int connection_id);
+  ~DevToolsBrowserTarget();
+
+  int connection_id() const { return connection_id_; }
+
+  // Takes ownership of |handler|.
+  void RegisterHandler(Handler* handler);
+
+  std::string HandleMessage(const std::string& data);
+
+ private:
+  const int connection_id_;
+
+  typedef std::map<std::string, Handler*> HandlersMap;
+  HandlersMap handlers_;
+
+  // Takes ownership of |error_object|.
+  std::string SerializeErrorResponse(int request_id, base::Value* error_object);
+
+  base::Value* CreateErrorObject(int error_code, const std::string& message);
+
+  std::string SerializeResponse(int request_id, base::Value* response);
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsBrowserTarget);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_BROWSER_TARGET_H_
diff --git a/content/browser/devtools/devtools_frontend_host.cc b/content/browser/devtools/devtools_frontend_host.cc
new file mode 100644
index 0000000..fe7e82d
--- /dev/null
+++ b/content/browser/devtools/devtools_frontend_host.cc
@@ -0,0 +1,125 @@
+// 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 "content/browser/devtools/devtools_frontend_host.h"
+
+#include "content/browser/devtools/devtools_manager_impl.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/devtools_messages.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "content/public/browser/devtools_frontend_host_delegate.h"
+
+namespace content {
+
+// static
+DevToolsClientHost* DevToolsClientHost::CreateDevToolsFrontendHost(
+    WebContents* client_web_contents,
+    DevToolsFrontendHostDelegate* delegate) {
+  return new DevToolsFrontendHost(
+      static_cast<WebContentsImpl*>(client_web_contents), delegate);
+}
+
+// static
+void DevToolsClientHost::SetupDevToolsFrontendClient(
+    RenderViewHost* frontend_rvh) {
+  frontend_rvh->Send(new DevToolsMsg_SetupDevToolsClient(
+      frontend_rvh->GetRoutingID()));
+}
+
+DevToolsFrontendHost::DevToolsFrontendHost(
+    WebContentsImpl* web_contents,
+    DevToolsFrontendHostDelegate* delegate)
+    : RenderViewHostObserver(web_contents->GetRenderViewHost()),
+      web_contents_(web_contents),
+      delegate_(delegate) {
+}
+
+DevToolsFrontendHost::~DevToolsFrontendHost() {
+  DevToolsManager::GetInstance()->ClientHostClosing(this);
+}
+
+void DevToolsFrontendHost::DispatchOnInspectorFrontend(
+    const std::string& message) {
+  RenderViewHostImpl* target_host =
+      static_cast<RenderViewHostImpl*>(web_contents_->GetRenderViewHost());
+  target_host->Send(new DevToolsClientMsg_DispatchOnInspectorFrontend(
+      target_host->GetRoutingID(),
+      message));
+}
+
+void DevToolsFrontendHost::InspectedContentsClosing() {
+  delegate_->InspectedContentsClosing();
+}
+
+void DevToolsFrontendHost::FrameNavigating(const std::string& url) {
+  delegate_->FrameNavigating(url);
+}
+
+void DevToolsFrontendHost::ContentsReplaced(WebContents* new_contents) {
+  delegate_->ContentsReplaced(new_contents);
+}
+
+void DevToolsFrontendHost::ReplacedWithAnotherClient() {
+}
+
+bool DevToolsFrontendHost::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(DevToolsFrontendHost, message)
+    IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DispatchOnInspectorBackend,
+                        OnDispatchOnInspectorBackend)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_ActivateWindow, OnActivateWindow)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_CloseWindow, OnCloseWindow)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_MoveWindow, OnMoveWindow)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_RequestSetDockSide,
+                        OnRequestSetDockSide)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_OpenInNewTab, OnOpenInNewTab)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_Save, OnSave)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_Append, OnAppend)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void DevToolsFrontendHost::OnDispatchOnInspectorBackend(
+    const std::string& message) {
+  DevToolsManagerImpl::GetInstance()->DispatchOnInspectorBackend(this, message);
+//  delegate_->DispatchOnInspectorBackend(message);
+}
+
+void DevToolsFrontendHost::OnActivateWindow() {
+  delegate_->ActivateWindow();
+}
+
+void DevToolsFrontendHost::OnCloseWindow() {
+  delegate_->CloseWindow();
+}
+
+void DevToolsFrontendHost::OnMoveWindow(int x, int y) {
+  delegate_->MoveWindow(x, y);
+}
+
+void DevToolsFrontendHost::OnOpenInNewTab(const std::string& url) {
+  delegate_->OpenInNewTab(url);
+}
+
+void DevToolsFrontendHost::OnSave(
+    const std::string& url,
+    const std::string& content,
+    bool save_as) {
+  delegate_->SaveToFile(url, content, save_as);
+}
+
+void DevToolsFrontendHost::OnAppend(
+    const std::string& url,
+    const std::string& content) {
+  delegate_->AppendToFile(url, content);
+}
+
+void DevToolsFrontendHost::OnRequestSetDockSide(const std::string& side) {
+  delegate_->SetDockSide(side);
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_frontend_host.h b/content/browser/devtools/devtools_frontend_host.h
new file mode 100644
index 0000000..6168692
--- /dev/null
+++ b/content/browser/devtools/devtools_frontend_host.h
@@ -0,0 +1,59 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_FRONTEND_HOST_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_FRONTEND_HOST_H_
+
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "content/public/browser/render_view_host_observer.h"
+
+namespace content {
+
+class DevToolsFrontendHostDelegate;
+class WebContentsImpl;
+
+// This class handles messages from DevToolsClient and calls corresponding
+// methods on DevToolsFrontendHostDelegate which is implemented by the
+// embedder. This allows us to avoid exposing DevTools client messages through
+// the content public API.
+class DevToolsFrontendHost : public DevToolsClientHost,
+                             public RenderViewHostObserver {
+ public:
+  DevToolsFrontendHost(WebContentsImpl* web_contents,
+                       DevToolsFrontendHostDelegate* delegate);
+
+ private:
+  virtual ~DevToolsFrontendHost();
+
+  // DevToolsClientHost implementation.
+  virtual void DispatchOnInspectorFrontend(const std::string& message) OVERRIDE;
+  virtual void InspectedContentsClosing() OVERRIDE;
+  virtual void FrameNavigating(const std::string& url) OVERRIDE;
+  virtual void ContentsReplaced(WebContents* new_contents) OVERRIDE;
+  virtual void ReplacedWithAnotherClient() OVERRIDE;
+
+  // RenderViewHostObserver overrides.
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  void OnDispatchOnInspectorBackend(const std::string& message);
+  void OnActivateWindow();
+  void OnCloseWindow();
+  void OnMoveWindow(int x, int y);
+  void OnRequestSetDockSide(const std::string& side);
+  void OnOpenInNewTab(const std::string& url);
+  void OnSave(const std::string& url, const std::string& content, bool save_as);
+  void OnAppend(const std::string& url, const std::string& content);
+
+  WebContentsImpl* web_contents_;
+  DevToolsFrontendHostDelegate* delegate_;
+  DISALLOW_COPY_AND_ASSIGN(DevToolsFrontendHost);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_FRONTEND_HOST_H_
diff --git a/content/browser/devtools/devtools_http_handler_impl.cc b/content/browser/devtools/devtools_http_handler_impl.cc
new file mode 100644
index 0000000..6d214ab
--- /dev/null
+++ b/content/browser/devtools/devtools_http_handler_impl.cc
@@ -0,0 +1,873 @@
+// 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 "content/browser/devtools/devtools_http_handler_impl.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/compiler_specific.h"
+#include "base/file_util.h"
+#include "base/json/json_writer.h"
+#include "base/lazy_instance.h"
+#include "base/logging.h"
+#include "base/message_loop_proxy.h"
+#include "base/string_number_conversions.h"
+#include "base/stringprintf.h"
+#include "base/threading/thread.h"
+#include "base/utf_string_conversions.h"
+#include "base/values.h"
+#include "content/browser/devtools/devtools_browser_target.h"
+#include "content/browser/devtools/devtools_tracing_handler.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/devtools_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "content/public/browser/devtools_http_handler_delegate.h"
+#include "content/public/browser/devtools_manager.h"
+#include "content/public/browser/favicon_status.h"
+#include "content/public/browser/navigation_entry.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/common/content_client.h"
+#include "content/public/common/url_constants.h"
+#include "googleurl/src/gurl.h"
+#include "grit/devtools_resources_map.h"
+#include "net/base/escape.h"
+#include "net/base/io_buffer.h"
+#include "net/base/ip_endpoint.h"
+#include "net/server/http_server_request_info.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebDevToolsAgent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+#include "ui/base/layout.h"
+#include "webkit/user_agent/user_agent.h"
+#include "webkit/user_agent/user_agent_util.h"
+
+namespace content {
+
+const int kBufferSize = 16 * 1024;
+
+namespace {
+
+static const char* kDevToolsHandlerThreadName = "Chrome_DevToolsHandlerThread";
+
+class DevToolsDefaultBindingHandler
+    : public DevToolsHttpHandler::RenderViewHostBinding {
+ public:
+  DevToolsDefaultBindingHandler() {
+  }
+
+  virtual std::string GetIdentifier(RenderViewHost* rvh) OVERRIDE {
+    int process_id = rvh->GetProcess()->GetID();
+    int routing_id = rvh->GetRoutingID();
+    return base::StringPrintf("%d_%d", process_id, routing_id);
+  }
+
+  virtual RenderViewHost* ForIdentifier(
+      const std::string& identifier) OVERRIDE {
+    size_t pos = identifier.find("_");
+    if (pos == std::string::npos)
+      return NULL;
+
+    int process_id;
+    if (!base::StringToInt(identifier.substr(0, pos), &process_id))
+      return NULL;
+
+    int routing_id;
+    if (!base::StringToInt(identifier.substr(pos+1), &routing_id))
+      return NULL;
+
+    return RenderViewHost::FromID(process_id, routing_id);
+  }
+};
+
+
+// An internal implementation of DevToolsClientHost that delegates
+// messages sent for DevToolsClient to a DebuggerShell instance.
+class DevToolsClientHostImpl : public DevToolsClientHost {
+ public:
+  DevToolsClientHostImpl(
+      MessageLoop* message_loop,
+      net::HttpServer* server,
+      int connection_id)
+      : message_loop_(message_loop),
+        server_(server),
+        connection_id_(connection_id),
+        is_closed_(false),
+        detach_reason_("target_closed") {
+  }
+
+  ~DevToolsClientHostImpl() {}
+
+  // DevToolsClientHost interface
+  virtual void InspectedContentsClosing() {
+    if (is_closed_)
+      return;
+    is_closed_ = true;
+
+    std::string response =
+        WebKit::WebDevToolsAgent::inspectorDetachedEvent(
+            WebKit::WebString::fromUTF8(detach_reason_)).utf8();
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&net::HttpServer::SendOverWebSocket,
+                   server_,
+                   connection_id_,
+                   response));
+
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&net::HttpServer::Close, server_, connection_id_));
+  }
+
+  virtual void DispatchOnInspectorFrontend(const std::string& data) {
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&net::HttpServer::SendOverWebSocket,
+                   server_,
+                   connection_id_,
+                   data));
+  }
+
+  virtual void ContentsReplaced(WebContents* new_contents) {
+  }
+
+  virtual void ReplacedWithAnotherClient() {
+    detach_reason_ = "replaced_with_devtools";
+  }
+
+ private:
+  virtual void FrameNavigating(const std::string& url) {}
+  MessageLoop* message_loop_;
+  net::HttpServer* server_;
+  int connection_id_;
+  bool is_closed_;
+  std::string detach_reason_;
+};
+
+}  // namespace
+
+// static
+int DevToolsHttpHandler::GetFrontendResourceId(const std::string& name) {
+  for (size_t i = 0; i < kDevtoolsResourcesSize; ++i) {
+    if (name == kDevtoolsResources[i].name)
+      return kDevtoolsResources[i].value;
+  }
+  return -1;
+}
+
+// static
+DevToolsHttpHandler* DevToolsHttpHandler::Start(
+    const net::StreamListenSocketFactory* socket_factory,
+    const std::string& frontend_url,
+    DevToolsHttpHandlerDelegate* delegate) {
+  DevToolsHttpHandlerImpl* http_handler =
+      new DevToolsHttpHandlerImpl(socket_factory,
+                                  frontend_url,
+                                  delegate);
+  http_handler->Start();
+  return http_handler;
+}
+
+DevToolsHttpHandlerImpl::~DevToolsHttpHandlerImpl() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  // Stop() must be called prior to destruction.
+  DCHECK(server_.get() == NULL);
+  DCHECK(thread_.get() == NULL);
+}
+
+void DevToolsHttpHandlerImpl::Start() {
+  if (thread_.get())
+    return;
+  thread_.reset(new base::Thread(kDevToolsHandlerThreadName));
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&DevToolsHttpHandlerImpl::StartHandlerThread, this));
+}
+
+// Runs on FILE thread.
+void DevToolsHttpHandlerImpl::StartHandlerThread() {
+  base::Thread::Options options;
+  options.message_loop_type = MessageLoop::TYPE_IO;
+  if (!thread_->StartWithOptions(options)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThread, this));
+    return;
+  }
+
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&DevToolsHttpHandlerImpl::Init, this));
+}
+
+void DevToolsHttpHandlerImpl::ResetHandlerThread() {
+  thread_.reset();
+}
+
+void DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease() {
+  ResetHandlerThread();
+  Release();
+}
+
+void DevToolsHttpHandlerImpl::Stop() {
+  if (!thread_.get())
+    return;
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&DevToolsHttpHandlerImpl::StopHandlerThread, this),
+      base::Bind(&DevToolsHttpHandlerImpl::ResetHandlerThreadAndRelease, this));
+}
+
+void DevToolsHttpHandlerImpl::SetRenderViewHostBinding(
+    RenderViewHostBinding* binding) {
+  if (binding)
+    binding_ = binding;
+  else
+    binding_ = default_binding_.get();
+}
+
+GURL DevToolsHttpHandlerImpl::GetFrontendURL(RenderViewHost* render_view_host) {
+  net::IPEndPoint ip_address;
+  if (server_->GetLocalAddress(&ip_address))
+    return GURL();
+  std::string host = ip_address.ToString();
+  std::string id = binding_->GetIdentifier(render_view_host);
+  return GURL(std::string("http://") +
+              ip_address.ToString() +
+              GetFrontendURLInternal(id, host));
+}
+
+static std::string PathWithoutParams(const std::string& path) {
+  size_t query_position = path.find("?");
+  if (query_position != std::string::npos)
+    return path.substr(0, query_position);
+  return path;
+}
+
+static std::string GetMimeType(const std::string& filename) {
+  if (EndsWith(filename, ".html", false)) {
+    return "text/html";
+  } else if (EndsWith(filename, ".css", false)) {
+    return "text/css";
+  } else if (EndsWith(filename, ".js", false)) {
+    return "application/javascript";
+  } else if (EndsWith(filename, ".png", false)) {
+    return "image/png";
+  } else if (EndsWith(filename, ".gif", false)) {
+    return "image/gif";
+  }
+  NOTREACHED();
+  return "text/plain";
+}
+
+void DevToolsHttpHandlerImpl::Observe(int type,
+                                      const NotificationSource& source,
+                                      const NotificationDetails& details) {
+  RenderProcessHost* process = Source<RenderProcessHost>(source).ptr();
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  for (ConnectionToClientHostMap::iterator it =
+       connection_to_client_host_ui_.begin();
+       it != connection_to_client_host_ui_.end(); ++it) {
+    DevToolsAgentHost* agent = manager->GetDevToolsAgentHostFor(it->second);
+    if (!agent)
+      continue;
+    RenderViewHost* rvh = DevToolsAgentHostRegistry::GetRenderViewHost(agent);
+    if (rvh && rvh->GetProcess() == process)
+      it->second->InspectedContentsClosing();
+  }
+}
+
+void DevToolsHttpHandlerImpl::OnHttpRequest(
+    int connection_id,
+    const net::HttpServerRequestInfo& info) {
+  if (info.path.find("/json") == 0) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&DevToolsHttpHandlerImpl::OnJsonRequestUI,
+                   this,
+                   connection_id,
+                   info));
+    return;
+  }
+
+  if (info.path.find("/thumb/") == 0) {
+    // Thumbnail request.
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&DevToolsHttpHandlerImpl::OnThumbnailRequestUI,
+                   this,
+                   connection_id,
+                   info));
+    return;
+  }
+
+  if (info.path == "" || info.path == "/") {
+    // Discovery page request.
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI,
+                   this,
+                   connection_id));
+    return;
+  }
+
+  if (info.path.find("/devtools/") != 0) {
+    server_->Send404(connection_id);
+    return;
+  }
+
+  std::string filename = PathWithoutParams(info.path.substr(10));
+  std::string mime_type = GetMimeType(filename);
+
+  FilePath frontend_dir = delegate_->GetDebugFrontendDir();
+  if (!frontend_dir.empty()) {
+    FilePath path = frontend_dir.AppendASCII(filename);
+    std::string data;
+    file_util::ReadFileToString(path, &data);
+    server_->Send200(connection_id, data, mime_type);
+    return;
+  }
+  if (delegate_->BundlesFrontendResources()) {
+    int resource_id = DevToolsHttpHandler::GetFrontendResourceId(filename);
+    if (resource_id != -1) {
+      base::StringPiece data = GetContentClient()->GetDataResource(
+              resource_id, ui::SCALE_FACTOR_NONE);
+      server_->Send200(connection_id, data.as_string(), mime_type);
+      return;
+    }
+  }
+  server_->Send404(connection_id);
+}
+
+void DevToolsHttpHandlerImpl::OnWebSocketRequest(
+    int connection_id,
+    const net::HttpServerRequestInfo& request) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &DevToolsHttpHandlerImpl::OnWebSocketRequestUI,
+          this,
+          connection_id,
+          request));
+}
+
+void DevToolsHttpHandlerImpl::OnWebSocketMessage(
+    int connection_id,
+    const std::string& data) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &DevToolsHttpHandlerImpl::OnWebSocketMessageUI,
+          this,
+          connection_id,
+          data));
+}
+
+void DevToolsHttpHandlerImpl::OnClose(int connection_id) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &DevToolsHttpHandlerImpl::OnCloseUI,
+          this,
+          connection_id));
+}
+
+struct DevToolsHttpHandlerImpl::PageInfo {
+  PageInfo()
+      : attached(false) {
+  }
+
+  std::string id;
+  std::string url;
+  bool attached;
+  std::string title;
+  std::string thumbnail_url;
+  std::string favicon_url;
+  base::TimeTicks last_selected_time;
+};
+
+// static
+bool DevToolsHttpHandlerImpl::SortPageListByTime(const PageInfo& info1,
+                                                 const PageInfo& info2) {
+  return info1.last_selected_time > info2.last_selected_time;
+}
+
+DevToolsHttpHandlerImpl::PageList DevToolsHttpHandlerImpl::GeneratePageList() {
+  PageList page_list;
+  for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
+       !it.IsAtEnd(); it.Advance()) {
+    RenderProcessHost* render_process_host = it.GetCurrentValue();
+    DCHECK(render_process_host);
+
+    // Ignore processes that don't have a connection, such as crashed contents.
+    if (!render_process_host->HasConnection())
+      continue;
+
+    RenderProcessHost::RenderWidgetHostsIterator rwit(
+        render_process_host->GetRenderWidgetHostsIterator());
+    for (; !rwit.IsAtEnd(); rwit.Advance()) {
+      const RenderWidgetHost* widget = rwit.GetCurrentValue();
+      DCHECK(widget);
+      if (!widget || !widget->IsRenderView())
+        continue;
+
+      RenderViewHost* host =
+          RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
+      page_list.push_back(CreatePageInfo(host));
+    }
+  }
+  std::sort(page_list.begin(), page_list.end(), SortPageListByTime);
+  return page_list;
+}
+
+std::string DevToolsHttpHandlerImpl::GetFrontendURLInternal(
+    const std::string rvh_id,
+    const std::string& host) {
+  return base::StringPrintf(
+      "%s%sws=%s/devtools/page/%s",
+      overridden_frontend_url_.c_str(),
+      overridden_frontend_url_.find("?") == std::string::npos ? "?" : "&",
+      host.c_str(),
+      rvh_id.c_str());
+}
+
+static bool ParseJsonPath(
+    const std::string& path,
+    std::string* command,
+    std::string* target_id) {
+
+  // Fall back to list in case of empty query.
+  if (path.empty()) {
+    *command = "list";
+    return true;
+  }
+
+  if (path.find("/") != 0) {
+    // Malformed command.
+    return false;
+  }
+  *command = path.substr(1);
+
+  size_t separator_pos = command->find("/");
+  if (separator_pos != std::string::npos) {
+    *target_id = command->substr(separator_pos + 1);
+    *command = command->substr(0, separator_pos);
+  }
+  return true;
+}
+
+void DevToolsHttpHandlerImpl::OnJsonRequestUI(
+    int connection_id,
+    const net::HttpServerRequestInfo& info) {
+  // Trim /json and ?jsonp=...
+  std::string path = info.path.substr(5);
+  std::string jsonp;
+  size_t jsonp_pos = path.find("?jsonp=");
+  if (jsonp_pos != std::string::npos) {
+    jsonp = path.substr(jsonp_pos + 7);
+    path = path.substr(0, jsonp_pos);
+  }
+
+  // Trim fragment and query
+  size_t query_pos = path.find("?");
+  if (query_pos != std::string::npos)
+    path = path.substr(0, query_pos);
+
+  size_t fragment_pos = path.find("#");
+  if (fragment_pos != std::string::npos)
+    path = path.substr(0, fragment_pos);
+
+  std::string command;
+  std::string target_id;
+  if (!ParseJsonPath(path, &command, &target_id)) {
+    SendJson(connection_id,
+             net::HTTP_NOT_FOUND,
+             NULL,
+             "Malformed query: " + info.path,
+             jsonp);
+    return;
+  }
+
+  if (command == "version") {
+    DictionaryValue version;
+    version.SetString("Protocol-Version",
+                      WebKit::WebDevToolsAgent::inspectorProtocolVersion());
+    version.SetString("WebKit-Version",
+                      webkit_glue::GetWebKitVersion());
+    version.SetString("User-Agent",
+                      webkit_glue::GetUserAgent(GURL(chrome::kAboutBlankURL)));
+    SendJson(connection_id, net::HTTP_OK, &version, "", jsonp);
+    return;
+  }
+
+  if (command == "list") {
+    PageList page_list = GeneratePageList();
+    ListValue json_pages_list;
+    std::string host = info.headers["Host"];
+    for (PageList::iterator i = page_list.begin(); i != page_list.end(); ++i)
+      json_pages_list.Append(SerializePageInfo(*i, host));
+    SendJson(connection_id, net::HTTP_OK, &json_pages_list, "", jsonp);
+    return;
+  }
+
+  if (command == "new") {
+    RenderViewHost* rvh = delegate_->CreateNewTarget();
+    if (!rvh) {
+      SendJson(connection_id,
+               net::HTTP_INTERNAL_SERVER_ERROR,
+               NULL,
+               "Could not create new page",
+               jsonp);
+      return;
+    }
+    PageInfo page_info = CreatePageInfo(rvh);
+    std::string host = info.headers["Host"];
+    scoped_ptr<DictionaryValue> dictionary(SerializePageInfo(page_info, host));
+    SendJson(connection_id, net::HTTP_OK, dictionary.get(), "", jsonp);
+    return;
+  }
+
+  if (command == "activate" || command == "close") {
+    RenderViewHost* rvh = binding_->ForIdentifier(target_id);
+    if (!rvh) {
+      SendJson(connection_id,
+               net::HTTP_NOT_FOUND,
+               NULL,
+               "No such target id: " + target_id,
+               jsonp);
+      return;
+    }
+
+    if (command == "activate") {
+      rvh->GetDelegate()->Activate();
+      SendJson(connection_id, net::HTTP_OK, NULL, "Target activated", jsonp);
+      return;
+    }
+
+    if (command == "close") {
+      rvh->ClosePage();
+      SendJson(connection_id, net::HTTP_OK, NULL, "Target is closing", jsonp);
+      return;
+    }
+  }
+  SendJson(connection_id,
+           net::HTTP_NOT_FOUND,
+           NULL,
+           "Unknown command: " + command,
+           jsonp);
+  return;
+}
+
+void DevToolsHttpHandlerImpl::OnThumbnailRequestUI(
+    int connection_id,
+    const net::HttpServerRequestInfo& info) {
+  std::string prefix = "/thumb/";
+  size_t pos = info.path.find(prefix);
+  if (pos != 0) {
+    Send404(connection_id);
+    return;
+  }
+
+  std::string page_url = info.path.substr(prefix.length());
+  std::string data = delegate_->GetPageThumbnailData(GURL(page_url));
+  if (!data.empty())
+    Send200(connection_id, data, "image/png");
+  else
+    Send404(connection_id);
+}
+
+void DevToolsHttpHandlerImpl::OnDiscoveryPageRequestUI(int connection_id) {
+  std::string response = delegate_->GetDiscoveryPageHTML();
+  Send200(connection_id, response, "text/html; charset=UTF-8");
+}
+
+void DevToolsHttpHandlerImpl::OnWebSocketRequestUI(
+    int connection_id,
+    const net::HttpServerRequestInfo& request) {
+  if (!thread_.get())
+    return;
+  std::string browser_prefix = "/devtools/browser";
+  size_t browser_pos = request.path.find(browser_prefix);
+  if (browser_pos == 0) {
+    if (browser_target_) {
+      Send500(connection_id, "Another client already attached");
+      return;
+    }
+    browser_target_.reset(new DevToolsBrowserTarget(connection_id));
+    browser_target_->RegisterHandler(new DevToolsTracingHandler());
+    AcceptWebSocket(connection_id, request);
+    return;
+  }
+
+  std::string page_prefix = "/devtools/page/";
+  size_t pos = request.path.find(page_prefix);
+  if (pos != 0) {
+    Send404(connection_id);
+    return;
+  }
+
+  std::string page_id = request.path.substr(page_prefix.length());
+  RenderViewHost* rvh = binding_->ForIdentifier(page_id);
+  if (!rvh) {
+    Send500(connection_id, "No such target id: " + page_id);
+    return;
+  }
+
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+      rvh);
+  if (manager->GetDevToolsClientHostFor(agent)) {
+    Send500(connection_id,
+            "Target with given id is being inspected: " + page_id);
+    return;
+  }
+
+  DevToolsClientHostImpl* client_host =
+      new DevToolsClientHostImpl(thread_->message_loop(),
+                                 server_,
+                                 connection_id);
+  connection_to_client_host_ui_[connection_id] = client_host;
+
+  manager->RegisterDevToolsClientHostFor(agent, client_host);
+
+  AcceptWebSocket(connection_id, request);
+}
+
+void DevToolsHttpHandlerImpl::OnWebSocketMessageUI(
+    int connection_id,
+    const std::string& data) {
+  if (browser_target_ && connection_id == browser_target_->connection_id()) {
+    std::string json_response = browser_target_->HandleMessage(data);
+
+    thread_->message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&net::HttpServer::SendOverWebSocket,
+                   server_.get(),
+                   connection_id,
+                   json_response));
+    return;
+  }
+
+  ConnectionToClientHostMap::iterator it =
+      connection_to_client_host_ui_.find(connection_id);
+  if (it == connection_to_client_host_ui_.end())
+    return;
+
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  manager->DispatchOnInspectorBackend(it->second, data);
+}
+
+void DevToolsHttpHandlerImpl::OnCloseUI(int connection_id) {
+  ConnectionToClientHostMap::iterator it =
+      connection_to_client_host_ui_.find(connection_id);
+  if (it != connection_to_client_host_ui_.end()) {
+    DevToolsClientHostImpl* client_host =
+        static_cast<DevToolsClientHostImpl*>(it->second);
+    DevToolsManager::GetInstance()->ClientHostClosing(client_host);
+    delete client_host;
+    connection_to_client_host_ui_.erase(connection_id);
+  }
+  if (browser_target_ && browser_target_->connection_id() == connection_id) {
+    browser_target_.reset();
+    return;
+  }
+}
+
+DevToolsHttpHandlerImpl::DevToolsHttpHandlerImpl(
+    const net::StreamListenSocketFactory* socket_factory,
+    const std::string& frontend_url,
+    DevToolsHttpHandlerDelegate* delegate)
+    : overridden_frontend_url_(frontend_url),
+      socket_factory_(socket_factory),
+      delegate_(delegate) {
+  if (overridden_frontend_url_.empty())
+      overridden_frontend_url_ = "/devtools/devtools.html";
+
+  default_binding_.reset(new DevToolsDefaultBindingHandler);
+  binding_ = default_binding_.get();
+
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_TERMINATED,
+                 NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
+                 NotificationService::AllBrowserContextsAndSources());
+
+  // Balanced in ResetHandlerThreadAndRelease().
+  AddRef();
+}
+
+// Runs on the handler thread
+void DevToolsHttpHandlerImpl::Init() {
+  server_ = new net::HttpServer(*socket_factory_.get(), this);
+}
+
+// Runs on the handler thread
+void DevToolsHttpHandlerImpl::Teardown() {
+  server_ = NULL;
+}
+
+// Runs on FILE thread to make sure that it is serialized against
+// {Start|Stop}HandlerThread and to allow calling pthread_join.
+void DevToolsHttpHandlerImpl::StopHandlerThread() {
+  if (!thread_->message_loop())
+    return;
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&DevToolsHttpHandlerImpl::Teardown, this));
+  // Thread::Stop joins the thread.
+  thread_->Stop();
+}
+
+void DevToolsHttpHandlerImpl::SendJson(int connection_id,
+                                       net::HttpStatusCode status_code,
+                                       Value* value,
+                                       const std::string& message,
+                                       const std::string& jsonp) {
+  if (!thread_.get())
+    return;
+
+  // Serialize value and message.
+  std::string json_value;
+  if (value) {
+    base::JSONWriter::WriteWithOptions(value,
+                                       base::JSONWriter::OPTIONS_PRETTY_PRINT,
+                                       &json_value);
+  }
+  std::string json_message;
+  scoped_ptr<Value> message_object(Value::CreateStringValue(message));
+  base::JSONWriter::Write(message_object.get(), &json_message);
+
+  std::string response;
+  std::string mime_type = "application/json; charset=UTF-8";
+
+  // Wrap jsonp if necessary.
+  if (!jsonp.empty()) {
+    mime_type = "text/javascript; charset=UTF-8";
+    response = StringPrintf("%s(%s, %d, %s);",
+                            jsonp.c_str(),
+                            json_value.empty() ? "undefined"
+                                               : json_value.c_str(),
+                            status_code,
+                            json_message.c_str());
+    // JSONP always returns 200.
+    status_code = net::HTTP_OK;
+  } else {
+    response = StringPrintf("%s%s", json_value.c_str(), message.c_str());
+  }
+
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServer::Send,
+                 server_.get(),
+                 connection_id,
+                 status_code,
+                 response,
+                 mime_type));
+}
+
+void DevToolsHttpHandlerImpl::Send200(int connection_id,
+                                      const std::string& data,
+                                      const std::string& mime_type) {
+  if (!thread_.get())
+    return;
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServer::Send200,
+                 server_.get(),
+                 connection_id,
+                 data,
+                 mime_type));
+}
+
+void DevToolsHttpHandlerImpl::Send404(int connection_id) {
+  if (!thread_.get())
+    return;
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServer::Send404, server_.get(), connection_id));
+}
+
+void DevToolsHttpHandlerImpl::Send500(int connection_id,
+                                      const std::string& message) {
+  if (!thread_.get())
+    return;
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServer::Send500, server_.get(), connection_id,
+                 message));
+}
+
+void DevToolsHttpHandlerImpl::AcceptWebSocket(
+    int connection_id,
+    const net::HttpServerRequestInfo& request) {
+  if (!thread_.get())
+    return;
+  thread_->message_loop()->PostTask(
+      FROM_HERE,
+      base::Bind(&net::HttpServer::AcceptWebSocket, server_.get(),
+                 connection_id, request));
+}
+
+DevToolsHttpHandlerImpl::PageInfo
+DevToolsHttpHandlerImpl::CreatePageInfo(RenderViewHost* rvh)
+{
+  RenderViewHostDelegate* host_delegate = rvh->GetDelegate();
+  DevToolsAgentHost* agent =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh);
+  DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
+      GetDevToolsClientHostFor(agent);
+  PageInfo page_info;
+  page_info.id = binding_->GetIdentifier(rvh);
+  page_info.attached = client_host != NULL;
+  page_info.url = host_delegate->GetURL().spec();
+
+  WebContents* web_contents = host_delegate->GetAsWebContents();
+  if (web_contents) {
+    page_info.title = UTF16ToUTF8(
+        net::EscapeForHTML(web_contents->GetTitle()));
+    page_info.last_selected_time = web_contents->GetLastSelectedTime();
+
+    NavigationController& controller = web_contents->GetController();
+    NavigationEntry* entry = controller.GetActiveEntry();
+    if (entry != NULL && entry->GetURL().is_valid()) {
+      page_info.thumbnail_url = "/thumb/" + entry->GetURL().spec();
+      page_info.favicon_url = entry->GetFavicon().url.spec();
+    }
+  }
+  return page_info;
+}
+
+DictionaryValue* DevToolsHttpHandlerImpl::SerializePageInfo(
+    const PageInfo& page_info,
+    const std::string& host) {
+  DictionaryValue* dictionary = new DictionaryValue;
+  dictionary->SetString("title", page_info.title);
+  dictionary->SetString("url", page_info.url);
+  dictionary->SetString("thumbnailUrl", page_info.thumbnail_url);
+  dictionary->SetString("faviconUrl", page_info.favicon_url);
+  if (!page_info.attached) {
+    dictionary->SetString("webSocketDebuggerUrl",
+                          base::StringPrintf("ws://%s/devtools/page/%s",
+                                             host.c_str(),
+                                             page_info.id.c_str()));
+    std::string devtools_frontend_url = GetFrontendURLInternal(
+        page_info.id.c_str(),
+        host);
+    dictionary->SetString("devtoolsFrontendUrl", devtools_frontend_url);
+  }
+  return dictionary;
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_http_handler_impl.h b/content/browser/devtools/devtools_http_handler_impl.h
new file mode 100644
index 0000000..9ee6f92
--- /dev/null
+++ b/content/browser/devtools/devtools_http_handler_impl.h
@@ -0,0 +1,143 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_HTTP_HANDLER_IMPL_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_HTTP_HANDLER_IMPL_H_
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/devtools_http_handler.h"
+#include "content/public/browser/devtools_http_handler_delegate.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "net/server/http_server.h"
+
+namespace base {
+class DictionaryValue;
+class Thread;
+class Value;
+}
+
+namespace net {
+class StreamListenSocketFactory;
+class URLRequestContextGetter;
+}
+
+namespace content {
+
+class DevToolsBrowserTarget;
+class DevToolsClientHost;
+class RenderViewHost;
+
+class DevToolsHttpHandlerImpl
+    : public DevToolsHttpHandler,
+      public NotificationObserver,
+      public base::RefCountedThreadSafe<DevToolsHttpHandlerImpl>,
+      public net::HttpServer::Delegate {
+ private:
+  struct PageInfo;
+  typedef std::vector<PageInfo> PageList;
+  friend class base::RefCountedThreadSafe<DevToolsHttpHandlerImpl>;
+  friend class DevToolsHttpHandler;
+
+  static bool SortPageListByTime(const PageInfo& info1, const PageInfo& info2);
+
+  // Takes ownership over |socket_factory|.
+  DevToolsHttpHandlerImpl(const net::StreamListenSocketFactory* socket_factory,
+                          const std::string& frontend_url,
+                          DevToolsHttpHandlerDelegate* delegate);
+  virtual ~DevToolsHttpHandlerImpl();
+  void Start();
+
+  // DevToolsHttpHandler implementation.
+  virtual void Stop() OVERRIDE;
+  virtual void SetRenderViewHostBinding(
+      RenderViewHostBinding* binding) OVERRIDE;
+  virtual GURL GetFrontendURL(RenderViewHost* render_view_host) OVERRIDE;
+
+  // NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+
+  // net::HttpServer::Delegate implementation.
+  virtual void OnHttpRequest(int connection_id,
+                             const net::HttpServerRequestInfo& info) OVERRIDE;
+  virtual void OnWebSocketRequest(
+      int connection_id,
+      const net::HttpServerRequestInfo& info) OVERRIDE;
+  virtual void OnWebSocketMessage(int connection_id,
+                                  const std::string& data) OVERRIDE;
+  virtual void OnClose(int connection_id) OVERRIDE;
+
+  void OnJsonRequestUI(int connection_id,
+                       const net::HttpServerRequestInfo& info);
+  void OnThumbnailRequestUI(int connection_id,
+                            const net::HttpServerRequestInfo& info);
+  void OnDiscoveryPageRequestUI(int connection_id);
+
+  void OnWebSocketRequestUI(int connection_id,
+                            const net::HttpServerRequestInfo& info);
+  void OnWebSocketMessageUI(int connection_id, const std::string& data);
+  void OnCloseUI(int connection_id);
+
+  void ResetHandlerThread();
+  void ResetHandlerThreadAndRelease();
+
+  void Init();
+  void Teardown();
+
+  void StartHandlerThread();
+  void StopHandlerThread();
+
+  void SendJson(int connection_id,
+                net::HttpStatusCode status_code,
+                base::Value* value,
+                const std::string& message,
+                const std::string& jsonp);
+  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 AcceptWebSocket(int connection_id,
+                       const net::HttpServerRequestInfo& request);
+
+  PageList GeneratePageList();
+
+  // Returns the front end url without the host at the beginning.
+  std::string GetFrontendURLInternal(const std::string rvh_id,
+                                     const std::string& host);
+
+  PageInfo CreatePageInfo(RenderViewHost* rvh);
+
+  base::DictionaryValue* SerializePageInfo(const PageInfo& page_info,
+                                           const std::string& host);
+
+  // The thread used by the devtools handler to run server socket.
+  scoped_ptr<base::Thread> thread_;
+
+  std::string overridden_frontend_url_;
+  scoped_ptr<const net::StreamListenSocketFactory> socket_factory_;
+  scoped_refptr<net::HttpServer> server_;
+  typedef std::map<int, DevToolsClientHost*> ConnectionToClientHostMap;
+  ConnectionToClientHostMap connection_to_client_host_ui_;
+  scoped_ptr<DevToolsHttpHandlerDelegate> delegate_;
+  RenderViewHostBinding* binding_;
+  scoped_ptr<RenderViewHostBinding> default_binding_;
+  NotificationRegistrar registrar_;
+  scoped_ptr<DevToolsBrowserTarget> browser_target_;
+  DISALLOW_COPY_AND_ASSIGN(DevToolsHttpHandlerImpl);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_HTTP_HANDLER_IMPL_H_
diff --git a/content/browser/devtools/devtools_http_handler_unittest.cc b/content/browser/devtools/devtools_http_handler_unittest.cc
new file mode 100644
index 0000000..b01c9d9
--- /dev/null
+++ b/content/browser/devtools/devtools_http_handler_unittest.cc
@@ -0,0 +1,103 @@
+// 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 "base/message_loop.h"
+#include "base/run_loop.h"
+#include "content/browser/browser_thread_impl.h"
+#include "content/public/browser/devtools_http_handler.h"
+#include "content/public/browser/devtools_http_handler_delegate.h"
+#include "net/base/stream_listen_socket.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+namespace {
+
+using net::StreamListenSocket;
+
+class DummyListenSocket : public StreamListenSocket,
+                          public StreamListenSocket::Delegate {
+ public:
+  DummyListenSocket()
+      : ALLOW_THIS_IN_INITIALIZER_LIST(StreamListenSocket(0, this)) {}
+
+  // StreamListenSocket::Delegate "implementation"
+  virtual void DidAccept(StreamListenSocket* server,
+                         StreamListenSocket* connection) OVERRIDE {}
+  virtual void DidRead(StreamListenSocket* connection,
+                       const char* data,
+                       int len) OVERRIDE {}
+  virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
+ protected:
+  virtual ~DummyListenSocket() {}
+  virtual void Accept() OVERRIDE {}
+};
+
+class DummyListenSocketFactory : public net::StreamListenSocketFactory {
+ public:
+  DummyListenSocketFactory(
+      base::Closure quit_closure_1, base::Closure quit_closure_2)
+      : quit_closure_1_(quit_closure_1), quit_closure_2_(quit_closure_2) {}
+  virtual ~DummyListenSocketFactory() {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, quit_closure_2_);
+  }
+
+  virtual scoped_refptr<StreamListenSocket> CreateAndListen(
+      StreamListenSocket::Delegate* delegate) const OVERRIDE {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, quit_closure_1_);
+    return new DummyListenSocket();
+  }
+ private:
+  base::Closure quit_closure_1_;
+  base::Closure quit_closure_2_;
+};
+
+class DummyDelegate : public DevToolsHttpHandlerDelegate {
+ public:
+  virtual std::string GetDiscoveryPageHTML() OVERRIDE { return ""; }
+  virtual bool BundlesFrontendResources() OVERRIDE { return true; }
+  virtual FilePath GetDebugFrontendDir() OVERRIDE { return FilePath(); }
+  virtual std::string GetPageThumbnailData(const GURL& url) { return ""; }
+  virtual RenderViewHost* CreateNewTarget() { return NULL; }
+};
+
+}
+
+class DevToolsHttpHandlerTest : public testing::Test {
+ public:
+  DevToolsHttpHandlerTest()
+      : ui_thread_(BrowserThread::UI, &message_loop_) {
+  }
+ protected:
+  virtual void SetUp() {
+    file_thread_.reset(new BrowserThreadImpl(BrowserThread::FILE));
+    file_thread_->Start();
+  }
+  virtual void TearDown() {
+    file_thread_->Stop();
+  }
+ private:
+  MessageLoopForIO message_loop_;
+  BrowserThreadImpl ui_thread_;
+  scoped_ptr<BrowserThreadImpl> file_thread_;
+};
+
+TEST_F(DevToolsHttpHandlerTest, TestStartStop) {
+  base::RunLoop run_loop, run_loop_2;
+  content::DevToolsHttpHandler* devtools_http_handler_ =
+      content::DevToolsHttpHandler::Start(
+          new DummyListenSocketFactory(
+              run_loop.QuitClosure(), run_loop_2.QuitClosure()),
+          "",
+          new DummyDelegate());
+  // Our dummy socket factory will post a quit message once the server will
+  // become ready.
+  run_loop.Run();
+  devtools_http_handler_->Stop();
+  // Make sure the handler actually stops.
+  run_loop_2.Run();
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_manager_impl.cc b/content/browser/devtools/devtools_manager_impl.cc
new file mode 100644
index 0000000..b548ba2
--- /dev/null
+++ b/content/browser/devtools/devtools_manager_impl.cc
@@ -0,0 +1,302 @@
+// 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 "content/browser/devtools/devtools_manager_impl.h"
+
+#include <vector>
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "content/browser/child_process_security_policy_impl.h"
+#include "content/browser/devtools/devtools_netlog_observer.h"
+#include "content/browser/devtools/render_view_devtools_agent_host.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "googleurl/src/gurl.h"
+
+namespace content {
+
+// static
+DevToolsManager* DevToolsManager::GetInstance() {
+  return DevToolsManagerImpl::GetInstance();
+}
+
+// static
+DevToolsManagerImpl* DevToolsManagerImpl::GetInstance() {
+  return Singleton<DevToolsManagerImpl>::get();
+}
+
+DevToolsManagerImpl::DevToolsManagerImpl()
+    : last_orphan_cookie_(0) {
+}
+
+DevToolsManagerImpl::~DevToolsManagerImpl() {
+  DCHECK(agent_to_client_host_.empty());
+  DCHECK(client_to_agent_host_.empty());
+  // By the time we destroy devtools manager, all orphan client hosts should
+  // have been deleted; no need to notify them upon contents closing.
+  DCHECK(orphan_client_hosts_.empty());
+}
+
+DevToolsClientHost* DevToolsManagerImpl::GetDevToolsClientHostFor(
+    DevToolsAgentHost* agent_host) {
+  AgentToClientHostMap::iterator it = agent_to_client_host_.find(agent_host);
+  if (it != agent_to_client_host_.end())
+    return it->second;
+  return NULL;
+}
+
+DevToolsAgentHost* DevToolsManagerImpl::GetDevToolsAgentHostFor(
+    DevToolsClientHost* client_host) {
+  ClientToAgentHostMap::iterator it = client_to_agent_host_.find(client_host);
+  if (it != client_to_agent_host_.end())
+    return it->second;
+  return NULL;
+}
+
+void DevToolsManagerImpl::RegisterDevToolsClientHostFor(
+    DevToolsAgentHost* agent_host,
+    DevToolsClientHost* client_host) {
+  BindClientHost(agent_host, client_host);
+  agent_host->Attach();
+}
+
+bool DevToolsManagerImpl::DispatchOnInspectorBackend(
+    DevToolsClientHost* from,
+    const std::string& message) {
+  DevToolsAgentHost* agent_host = GetDevToolsAgentHostFor(from);
+  if (!agent_host)
+    return false;
+
+  agent_host->DipatchOnInspectorBackend(message);
+  return true;
+}
+
+void DevToolsManagerImpl::DispatchOnInspectorFrontend(
+    DevToolsAgentHost* agent_host,
+    const std::string& message) {
+  DevToolsClientHost* client_host = GetDevToolsClientHostFor(agent_host);
+  if (!client_host) {
+    // Client window was closed while there were messages
+    // being sent to it.
+    return;
+  }
+  client_host->DispatchOnInspectorFrontend(message);
+}
+
+void DevToolsManagerImpl::SaveAgentRuntimeState(DevToolsAgentHost* agent_host,
+                                                const std::string& state) {
+  agent_runtime_states_[agent_host] = state;
+}
+
+void DevToolsManagerImpl::InspectElement(DevToolsAgentHost* agent_host,
+                                         int x, int y) {
+  agent_host->InspectElement(x, y);
+}
+
+void DevToolsManagerImpl::AddMessageToConsole(DevToolsAgentHost* agent_host,
+                                              ConsoleMessageLevel level,
+                                              const std::string& message) {
+  agent_host->AddMessageToConsole(level, message);
+}
+
+void DevToolsManagerImpl::ClientHostClosing(DevToolsClientHost* client_host) {
+  DevToolsAgentHost* agent_host = GetDevToolsAgentHostFor(client_host);
+  if (!agent_host) {
+    // It might be in the list of orphan client hosts, remove it from there.
+    for (OrphanClientHosts::iterator it = orphan_client_hosts_.begin();
+         it != orphan_client_hosts_.end(); ++it) {
+      if (it->second.first == client_host) {
+        orphan_client_hosts_.erase(it->first);
+        return;
+      }
+    }
+    return;
+  }
+
+  UnbindClientHost(agent_host, client_host);
+}
+
+void DevToolsManagerImpl::AgentHostClosing(DevToolsAgentHost* agent_host) {
+  UnregisterDevToolsClientHostFor(agent_host);
+}
+
+void DevToolsManagerImpl::UnregisterDevToolsClientHostFor(
+    DevToolsAgentHost* agent_host) {
+  DevToolsClientHost* client_host = GetDevToolsClientHostFor(agent_host);
+  if (!client_host)
+    return;
+  UnbindClientHost(agent_host, client_host);
+  client_host->InspectedContentsClosing();
+}
+
+void DevToolsManagerImpl::OnNavigatingToPendingEntry(
+    RenderViewHost* rvh,
+    RenderViewHost* dest_rvh,
+    const GURL& gurl) {
+  if (rvh == dest_rvh && static_cast<RenderViewHostImpl*>(
+          rvh)->render_view_termination_status() ==
+              base::TERMINATION_STATUS_STILL_RUNNING)
+    return;
+  int cookie = DetachClientHost(rvh);
+  if (cookie != -1) {
+    // Navigating to URL in the inspected window.
+    AttachClientHost(cookie, dest_rvh);
+
+    DevToolsAgentHost* dest_agent_host =
+        DevToolsAgentHostRegistry::GetDevToolsAgentHost(dest_rvh);
+    DevToolsClientHost* client_host = GetDevToolsClientHostFor(
+        dest_agent_host);
+    client_host->FrameNavigating(gurl.spec());
+  }
+}
+
+void DevToolsManagerImpl::OnCancelPendingNavigation(
+    RenderViewHost* pending,
+    RenderViewHost* current) {
+  int cookie = DetachClientHost(pending);
+  if (cookie != -1) {
+    // Navigating to URL in the inspected window.
+    AttachClientHost(cookie, current);
+  }
+}
+
+void DevToolsManagerImpl::ContentsReplaced(WebContents* old_contents,
+                                           WebContents* new_contents) {
+  RenderViewHost* old_rvh = old_contents->GetRenderViewHost();
+  if (!DevToolsAgentHostRegistry::HasDevToolsAgentHost(old_rvh))
+    return;
+
+  DevToolsAgentHost* old_agent_host =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(old_rvh);
+  DevToolsClientHost* client_host = GetDevToolsClientHostFor(old_agent_host);
+  if (!client_host)
+    return;  // Didn't know about old_contents.
+  int cookie = DetachClientHost(old_rvh);
+  if (cookie == -1)
+    return;  // Didn't know about old_contents.
+
+  client_host->ContentsReplaced(new_contents);
+  AttachClientHost(cookie, new_contents->GetRenderViewHost());
+}
+
+int DevToolsManagerImpl::DetachClientHost(RenderViewHost* from_rvh) {
+  DevToolsAgentHost* agent_host =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(from_rvh);
+  return DetachClientHost(agent_host);
+}
+
+int DevToolsManagerImpl::DetachClientHost(DevToolsAgentHost* agent_host) {
+  DevToolsClientHost* client_host = GetDevToolsClientHostFor(agent_host);
+  if (!client_host)
+    return -1;
+
+  int cookie = last_orphan_cookie_++;
+  orphan_client_hosts_[cookie] =
+      std::pair<DevToolsClientHost*, std::string>(
+          client_host, agent_runtime_states_[agent_host]);
+
+  UnbindClientHost(agent_host, client_host);
+  return cookie;
+}
+
+void DevToolsManagerImpl::AttachClientHost(int client_host_cookie,
+                                           RenderViewHost* to_rvh) {
+  DevToolsAgentHost* agent_host =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(to_rvh);
+  AttachClientHost(client_host_cookie, agent_host);
+}
+
+void DevToolsManagerImpl::AttachClientHost(int client_host_cookie,
+                                           DevToolsAgentHost* agent_host) {
+  OrphanClientHosts::iterator it = orphan_client_hosts_.find(
+      client_host_cookie);
+  if (it == orphan_client_hosts_.end())
+    return;
+
+  DevToolsClientHost* client_host = (*it).second.first;
+  const std::string& state = (*it).second.second;
+  BindClientHost(agent_host, client_host);
+  agent_host->Reattach(state);
+  agent_runtime_states_[agent_host] = state;
+
+  orphan_client_hosts_.erase(it);
+}
+
+void DevToolsManagerImpl::BindClientHost(
+    DevToolsAgentHost* agent_host,
+    DevToolsClientHost* client_host) {
+  DCHECK(agent_to_client_host_.find(agent_host) ==
+      agent_to_client_host_.end());
+  DCHECK(client_to_agent_host_.find(client_host) ==
+      client_to_agent_host_.end());
+
+  if (client_to_agent_host_.empty()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&DevToolsNetLogObserver::Attach));
+  }
+  agent_to_client_host_[agent_host] = client_host;
+  client_to_agent_host_[client_host] = agent_host;
+  agent_host->set_close_listener(this);
+
+  int process_id = agent_host->GetRenderProcessId();
+  if (process_id != -1)
+    ChildProcessSecurityPolicyImpl::GetInstance()->GrantReadRawCookies(
+        process_id);
+}
+
+void DevToolsManagerImpl::UnbindClientHost(DevToolsAgentHost* agent_host,
+                                           DevToolsClientHost* client_host) {
+  DCHECK(agent_host);
+  DCHECK(agent_to_client_host_.find(agent_host)->second ==
+      client_host);
+  DCHECK(client_to_agent_host_.find(client_host)->second ==
+      agent_host);
+  agent_host->set_close_listener(NULL);
+
+  agent_to_client_host_.erase(agent_host);
+  client_to_agent_host_.erase(client_host);
+  agent_runtime_states_.erase(agent_host);
+
+  if (client_to_agent_host_.empty()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&DevToolsNetLogObserver::Detach));
+  }
+  agent_host->Detach();
+
+  int process_id = agent_host->GetRenderProcessId();
+  if (process_id == -1)
+    return;
+  for (AgentToClientHostMap::iterator it = agent_to_client_host_.begin();
+       it != agent_to_client_host_.end();
+       ++it) {
+    if (it->first->GetRenderProcessId() == process_id)
+      return;
+  }
+  // We've disconnected from the last renderer -> revoke cookie permissions.
+  ChildProcessSecurityPolicyImpl::GetInstance()->RevokeReadRawCookies(
+      process_id);
+}
+
+void DevToolsManagerImpl::CloseAllClientHosts() {
+  std::vector<DevToolsAgentHost*> agents;
+  for (AgentToClientHostMap::iterator it =
+           agent_to_client_host_.begin();
+       it != agent_to_client_host_.end(); ++it) {
+    agents.push_back(it->first);
+  }
+  for (std::vector<DevToolsAgentHost*>::iterator it = agents.begin();
+       it != agents.end(); ++it) {
+    UnregisterDevToolsClientHostFor(*it);
+  }
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_manager_impl.h b/content/browser/devtools/devtools_manager_impl.h
new file mode 100644
index 0000000..ed213b7
--- /dev/null
+++ b/content/browser/devtools/devtools_manager_impl.h
@@ -0,0 +1,131 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_MANAGER_IMPL_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_MANAGER_IMPL_H_
+
+#include <map>
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "base/memory/singleton.h"
+#include "content/browser/devtools/devtools_agent_host.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "content/public/browser/devtools_manager.h"
+
+class GURL;
+
+namespace IPC {
+class Message;
+}
+
+namespace content {
+
+class DevToolsAgentHost;
+class RenderViewHost;
+
+// This class is a singleton that manages DevToolsClientHost instances and
+// routes messages between developer tools clients and agents.
+//
+// Methods below that accept inspected RenderViewHost as a parameter are
+// just convenience methods that call corresponding methods accepting
+// DevToolAgentHost.
+class CONTENT_EXPORT DevToolsManagerImpl
+    : public DevToolsAgentHost::CloseListener,
+      public DevToolsManager {
+ public:
+  // Returns single instance of this class. The instance is destroyed on the
+  // browser main loop exit so this method MUST NOT be called after that point.
+  static DevToolsManagerImpl* GetInstance();
+
+  DevToolsManagerImpl();
+  virtual ~DevToolsManagerImpl();
+
+  void DispatchOnInspectorFrontend(DevToolsAgentHost* agent_host,
+                                   const std::string& message);
+
+  void SaveAgentRuntimeState(DevToolsAgentHost* agent_host,
+                             const std::string& state);
+
+  // Sends 'Attach' message to the agent using |dest_rvh| in case
+  // there is a DevToolsClientHost registered for the |inspected_rvh|.
+  void OnNavigatingToPendingEntry(RenderViewHost* inspected_rvh,
+                                  RenderViewHost* dest_rvh,
+                                  const GURL& gurl);
+  void OnCancelPendingNavigation(RenderViewHost* pending,
+                                 RenderViewHost* current);
+
+  // DevToolsManager implementation
+  virtual bool DispatchOnInspectorBackend(DevToolsClientHost* from,
+                                          const std::string& message) OVERRIDE;
+  virtual void ContentsReplaced(WebContents* old_contents,
+                                WebContents* new_contents) OVERRIDE;
+  virtual void CloseAllClientHosts() OVERRIDE;
+  virtual void AttachClientHost(int client_host_cookie,
+                                DevToolsAgentHost* to_agent) OVERRIDE;
+  virtual DevToolsClientHost* GetDevToolsClientHostFor(
+      DevToolsAgentHost* agent_host) OVERRIDE;
+  virtual DevToolsAgentHost* GetDevToolsAgentHostFor(
+      DevToolsClientHost* client_host) OVERRIDE;
+  virtual void RegisterDevToolsClientHostFor(
+      DevToolsAgentHost* agent_host,
+      DevToolsClientHost* client_host) OVERRIDE;
+  virtual void UnregisterDevToolsClientHostFor(
+      DevToolsAgentHost* agent_host) OVERRIDE;
+  virtual int DetachClientHost(DevToolsAgentHost* from_agent) OVERRIDE;
+  virtual void ClientHostClosing(DevToolsClientHost* host) OVERRIDE;
+  virtual void InspectElement(DevToolsAgentHost* agent_host,
+                              int x, int y) OVERRIDE;
+  virtual void AddMessageToConsole(DevToolsAgentHost* agent_host,
+                                   ConsoleMessageLevel level,
+                                   const std::string& message) OVERRIDE;
+
+ private:
+  friend struct DefaultSingletonTraits<DevToolsManagerImpl>;
+
+  // DevToolsAgentHost::CloseListener implementation.
+  virtual void AgentHostClosing(DevToolsAgentHost* host) OVERRIDE;
+
+  void BindClientHost(DevToolsAgentHost* agent_host,
+                      DevToolsClientHost* client_host);
+  void UnbindClientHost(DevToolsAgentHost* agent_host,
+                        DevToolsClientHost* client_host);
+
+  // Detaches client host and returns cookie that can be used in
+  // AttachClientHost.
+  int DetachClientHost(RenderViewHost* from_rvh);
+
+  // Attaches orphan client host to new render view host.
+  void AttachClientHost(int client_host_cookie,
+                        RenderViewHost* to_rvh);
+
+  // These two maps are for tracking dependencies between inspected contents and
+  // their DevToolsClientHosts. They are useful for routing devtools messages
+  // and allow us to have at most one devtools client host per contents.
+  //
+  // DevToolsManagerImpl starts listening to DevToolsClientHosts when they are
+  // put into these maps and removes them when they are closing.
+  typedef std::map<DevToolsAgentHost*, DevToolsClientHost*>
+      AgentToClientHostMap;
+  AgentToClientHostMap agent_to_client_host_;
+
+  typedef std::map<DevToolsClientHost*, DevToolsAgentHost*>
+      ClientToAgentHostMap;
+  ClientToAgentHostMap client_to_agent_host_;
+
+  typedef std::map<DevToolsAgentHost*, std::string> AgentRuntimeStates;
+  AgentRuntimeStates agent_runtime_states_;
+
+  typedef std::map<int, std::pair<DevToolsClientHost*, std::string> >
+      OrphanClientHosts;
+  OrphanClientHosts orphan_client_hosts_;
+  int last_orphan_cookie_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsManagerImpl);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_MANAGER_IMPL_H_
diff --git a/content/browser/devtools/devtools_manager_unittest.cc b/content/browser/devtools/devtools_manager_unittest.cc
new file mode 100644
index 0000000..d2a47a5
--- /dev/null
+++ b/content/browser/devtools/devtools_manager_unittest.cc
@@ -0,0 +1,243 @@
+// 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 "base/basictypes.h"
+#include "base/time.h"
+#include "content/browser/devtools/devtools_manager_impl.h"
+#include "content/browser/devtools/render_view_devtools_agent_host.h"
+#include "content/browser/renderer_host/test_render_view_host.h"
+#include "content/browser/web_contents/test_web_contents.h"
+#include "content/common/view_messages.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
+#include "content/public/browser/devtools_client_host.h"
+#include "content/public/browser/web_contents_delegate.h"
+#include "content/test/test_content_browser_client.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::TimeDelta;
+
+namespace content {
+namespace {
+
+class TestDevToolsClientHost : public DevToolsClientHost {
+ public:
+  TestDevToolsClientHost()
+      : last_sent_message(NULL),
+        closed_(false) {
+  }
+
+  virtual ~TestDevToolsClientHost() {
+    EXPECT_TRUE(closed_);
+  }
+
+  virtual void Close(DevToolsManager* manager) {
+    EXPECT_FALSE(closed_);
+    close_counter++;
+    manager->ClientHostClosing(this);
+    closed_ = true;
+  }
+  virtual void InspectedContentsClosing() {
+    FAIL();
+  }
+
+  virtual void DispatchOnInspectorFrontend(const std::string& message) {
+    last_sent_message = &message;
+  }
+
+  virtual void ContentsReplaced(WebContents* new_contents) {
+  }
+
+  virtual void ReplacedWithAnotherClient() {
+  }
+
+  static void ResetCounters() {
+    close_counter = 0;
+  }
+
+  static int close_counter;
+
+  const std::string* last_sent_message;
+
+ private:
+  bool closed_;
+
+  virtual void FrameNavigating(const std::string& url) {}
+
+  DISALLOW_COPY_AND_ASSIGN(TestDevToolsClientHost);
+};
+
+int TestDevToolsClientHost::close_counter = 0;
+
+
+class TestWebContentsDelegate : public WebContentsDelegate {
+ public:
+  TestWebContentsDelegate() : renderer_unresponsive_received_(false) {}
+
+  // Notification that the contents is hung.
+  virtual void RendererUnresponsive(WebContents* source) {
+    renderer_unresponsive_received_ = true;
+  }
+
+  bool renderer_unresponsive_received() const {
+    return renderer_unresponsive_received_;
+  }
+
+ private:
+  bool renderer_unresponsive_received_;
+};
+
+class DevToolsManagerTestBrowserClient : public TestContentBrowserClient {
+ public:
+  DevToolsManagerTestBrowserClient() {
+  }
+
+  virtual bool ShouldSwapProcessesForNavigation(
+      const GURL& current_url,
+      const GURL& new_url) OVERRIDE {
+    return true;
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(DevToolsManagerTestBrowserClient);
+};
+
+}  // namespace
+
+class DevToolsManagerTest : public RenderViewHostImplTestHarness {
+ public:
+  DevToolsManagerTest() {
+  }
+
+ protected:
+  virtual void SetUp() OVERRIDE {
+    original_browser_client_ = GetContentClient()->browser();
+    GetContentClient()->set_browser_for_testing(&browser_client_);
+
+    RenderViewHostImplTestHarness::SetUp();
+    TestDevToolsClientHost::ResetCounters();
+  }
+
+  virtual void TearDown() OVERRIDE {
+    RenderViewHostImplTestHarness::TearDown();
+    GetContentClient()->set_browser_for_testing(original_browser_client_);
+  }
+
+ private:
+  ContentBrowserClient* original_browser_client_;
+  DevToolsManagerTestBrowserClient browser_client_;
+};
+
+TEST_F(DevToolsManagerTest, OpenAndManuallyCloseDevToolsClientHost) {
+  DevToolsManagerImpl manager;
+
+  DevToolsAgentHost* agent =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh());
+  DevToolsClientHost* host = manager.GetDevToolsClientHostFor(agent);
+  EXPECT_TRUE(NULL == host);
+
+  TestDevToolsClientHost client_host;
+  manager.RegisterDevToolsClientHostFor(agent, &client_host);
+  // Test that just registered devtools host is returned.
+  host = manager.GetDevToolsClientHostFor(agent);
+  EXPECT_TRUE(&client_host == host);
+  EXPECT_EQ(0, TestDevToolsClientHost::close_counter);
+
+  // Test that the same devtools host is returned.
+  host = manager.GetDevToolsClientHostFor(agent);
+  EXPECT_TRUE(&client_host == host);
+  EXPECT_EQ(0, TestDevToolsClientHost::close_counter);
+
+  client_host.Close(&manager);
+  EXPECT_EQ(1, TestDevToolsClientHost::close_counter);
+  host = manager.GetDevToolsClientHostFor(agent);
+  EXPECT_TRUE(NULL == host);
+}
+
+TEST_F(DevToolsManagerTest, ForwardMessageToClient) {
+  DevToolsManagerImpl manager;
+
+  TestDevToolsClientHost client_host;
+  DevToolsAgentHost* agent_host =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh());
+  manager.RegisterDevToolsClientHostFor(agent_host, &client_host);
+  EXPECT_EQ(0, TestDevToolsClientHost::close_counter);
+
+  std::string m = "test message";
+  agent_host = DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh());
+  manager.DispatchOnInspectorFrontend(agent_host, m);
+  EXPECT_TRUE(&m == client_host.last_sent_message);
+
+  client_host.Close(&manager);
+  EXPECT_EQ(1, TestDevToolsClientHost::close_counter);
+}
+
+TEST_F(DevToolsManagerTest, NoUnresponsiveDialogInInspectedContents) {
+  TestRenderViewHost* inspected_rvh = test_rvh();
+  inspected_rvh->set_render_view_created(true);
+  EXPECT_FALSE(contents()->GetDelegate());
+  TestWebContentsDelegate delegate;
+  contents()->SetDelegate(&delegate);
+
+  TestDevToolsClientHost client_host;
+  DevToolsAgentHost* agent_host =
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(inspected_rvh);
+  DevToolsManager::GetInstance()->
+      RegisterDevToolsClientHostFor(agent_host, &client_host);
+
+  // Start with a short timeout.
+  inspected_rvh->StartHangMonitorTimeout(TimeDelta::FromMilliseconds(10));
+  // Wait long enough for first timeout and see if it fired.
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, MessageLoop::QuitClosure(), TimeDelta::FromMilliseconds(10));
+  MessageLoop::current()->Run();
+  EXPECT_FALSE(delegate.renderer_unresponsive_received());
+
+  // Now close devtools and check that the notification is delivered.
+  client_host.Close(DevToolsManager::GetInstance());
+  // Start with a short timeout.
+  inspected_rvh->StartHangMonitorTimeout(TimeDelta::FromMilliseconds(10));
+  // Wait long enough for first timeout and see if it fired.
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE, MessageLoop::QuitClosure(), TimeDelta::FromMilliseconds(10));
+  MessageLoop::current()->Run();
+  EXPECT_TRUE(delegate.renderer_unresponsive_received());
+
+  contents()->SetDelegate(NULL);
+}
+
+TEST_F(DevToolsManagerTest, ReattachOnCancelPendingNavigation) {
+  contents()->transition_cross_site = true;
+  // Navigate to URL.  First URL should use first RenderViewHost.
+  const GURL url("http://www.google.com");
+  controller().LoadURL(
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(rvh(), 1, url, PAGE_TRANSITION_TYPED);
+  EXPECT_FALSE(contents()->cross_navigation_pending());
+
+  TestDevToolsClientHost client_host;
+  DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
+  devtools_manager->RegisterDevToolsClientHostFor(
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh()),
+      &client_host);
+
+  // Navigate to new site which should get a new RenderViewHost.
+  const GURL url2("http://www.yahoo.com");
+  controller().LoadURL(
+      url2, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  EXPECT_TRUE(contents()->cross_navigation_pending());
+  EXPECT_EQ(&client_host, devtools_manager->GetDevToolsClientHostFor(
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(pending_rvh())));
+
+  // Interrupt pending navigation and navigate back to the original site.
+  controller().LoadURL(
+      url, Referrer(), PAGE_TRANSITION_TYPED, std::string());
+  contents()->TestDidNavigate(rvh(), 1, url, PAGE_TRANSITION_TYPED);
+  EXPECT_FALSE(contents()->cross_navigation_pending());
+  EXPECT_EQ(&client_host, devtools_manager->GetDevToolsClientHostFor(
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh())));
+  client_host.Close(DevToolsManager::GetInstance());
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_netlog_observer.cc b/content/browser/devtools/devtools_netlog_observer.cc
new file mode 100644
index 0000000..f65bc42
--- /dev/null
+++ b/content/browser/devtools/devtools_netlog_observer.cc
@@ -0,0 +1,329 @@
+// 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 "content/browser/devtools/devtools_netlog_observer.h"
+
+#include "base/string_tokenizer.h"
+#include "base/string_util.h"
+#include "base/values.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/common/resource_response.h"
+#include "net/base/load_flags.h"
+#include "net/http/http_response_headers.h"
+#include "net/http/http_util.h"
+#include "net/spdy/spdy_header_block.h"
+#include "net/url_request/url_request.h"
+#include "net/url_request/url_request_netlog_params.h"
+#include "webkit/glue/resource_loader_bridge.h"
+
+namespace content {
+const size_t kMaxNumEntries = 1000;
+
+DevToolsNetLogObserver* DevToolsNetLogObserver::instance_ = NULL;
+
+DevToolsNetLogObserver::DevToolsNetLogObserver() {
+}
+
+DevToolsNetLogObserver::~DevToolsNetLogObserver() {
+}
+
+DevToolsNetLogObserver::ResourceInfo*
+DevToolsNetLogObserver::GetResourceInfo(uint32 id) {
+  RequestToInfoMap::iterator it = request_to_info_.find(id);
+  if (it != request_to_info_.end())
+    return it->second;
+  return NULL;
+}
+
+void DevToolsNetLogObserver::OnAddEntry(const net::NetLog::Entry& entry) {
+  // The events that the Observer is interested in only occur on the IO thread.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
+    return;
+
+  if (entry.source().type == net::NetLog::SOURCE_URL_REQUEST)
+    OnAddURLRequestEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_HTTP_STREAM_JOB)
+    OnAddHTTPStreamJobEntry(entry);
+  else if (entry.source().type == net::NetLog::SOURCE_SOCKET)
+    OnAddSocketEntry(entry);
+}
+
+void DevToolsNetLogObserver::OnAddURLRequestEntry(
+    const net::NetLog::Entry& entry) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  bool is_begin = entry.phase() == net::NetLog::PHASE_BEGIN;
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
+
+  if (entry.type() == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
+    if (is_begin) {
+      int load_flags;
+      scoped_ptr<Value> event_param(entry.ParametersToValue());
+      if (!net::StartEventLoadFlagsFromEventParams(event_param.get(),
+                                                   &load_flags)) {
+        return;
+      }
+
+      if (!(load_flags & net::LOAD_REPORT_RAW_HEADERS))
+        return;
+
+      if (request_to_info_.size() > kMaxNumEntries) {
+        LOG(WARNING) << "The raw headers observer url request count has grown "
+                        "larger than expected, resetting";
+        request_to_info_.clear();
+      }
+
+      request_to_info_[entry.source().id] = new ResourceInfo();
+
+      if (request_to_encoded_data_length_.size() > kMaxNumEntries) {
+        LOG(WARNING) << "The encoded data length observer url request count "
+                        "has grown larger than expected, resetting";
+        request_to_encoded_data_length_.clear();
+      }
+
+      request_to_encoded_data_length_[entry.source().id] = 0;
+    }
+    return;
+  } else if (entry.type() == net::NetLog::TYPE_REQUEST_ALIVE) {
+    // Cleanup records based on the TYPE_REQUEST_ALIVE entry.
+    if (is_end) {
+      request_to_info_.erase(entry.source().id);
+      request_to_encoded_data_length_.erase(entry.source().id);
+    }
+    return;
+  }
+
+  ResourceInfo* info = GetResourceInfo(entry.source().id);
+  if (!info)
+    return;
+
+  switch (entry.type()) {
+    case net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_HEADERS: {
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      std::string request_line;
+      net::HttpRequestHeaders request_headers;
+
+      if (!net::HttpRequestHeaders::FromNetLogParam(event_params.get(),
+                                                    &request_headers,
+                                                    &request_line)) {
+        NOTREACHED();
+      }
+
+      // We need to clear headers in case the same url_request is reused for
+      // several http requests (e.g. see http://crbug.com/80157).
+      info->request_headers.clear();
+
+      for (net::HttpRequestHeaders::Iterator it(request_headers);
+           it.GetNext();) {
+        info->request_headers.push_back(std::make_pair(it.name(), it.value()));
+      }
+      info->request_headers_text = request_line + request_headers.ToString();
+      break;
+    }
+    case net::NetLog::TYPE_HTTP_TRANSACTION_SPDY_SEND_REQUEST_HEADERS: {
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      net::SpdyHeaderBlock request_headers;
+
+      if (!net::SpdyHeaderBlockFromNetLogParam(event_params.get(),
+                                               &request_headers)) {
+        NOTREACHED();
+      }
+
+      // We need to clear headers in case the same url_request is reused for
+      // several http requests (e.g. see http://crbug.com/80157).
+      info->request_headers.clear();
+
+      for (net::SpdyHeaderBlock::const_iterator it = request_headers.begin();
+           it != request_headers.end(); ++it) {
+        info->request_headers.push_back(std::make_pair(it->first, it->second));
+      }
+      info->request_headers_text = "";
+      break;
+    }
+    case net::NetLog::TYPE_HTTP_TRANSACTION_READ_RESPONSE_HEADERS: {
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+
+      scoped_refptr<net::HttpResponseHeaders> response_headers;
+
+      if (!net::HttpResponseHeaders::FromNetLogParam(event_params.get(),
+                                                     &response_headers)) {
+        NOTREACHED();
+      }
+
+      info->http_status_code = response_headers->response_code();
+      info->http_status_text = response_headers->GetStatusText();
+      std::string name, value;
+
+      // We need to clear headers in case the same url_request is reused for
+      // several http requests (e.g. see http://crbug.com/80157).
+      info->response_headers.clear();
+
+      for (void* it = NULL;
+           response_headers->EnumerateHeaderLines(&it, &name, &value); ) {
+        info->response_headers.push_back(std::make_pair(name, value));
+      }
+      info->response_headers_text =
+          net::HttpUtil::ConvertHeadersBackToHTTPResponse(
+              response_headers->raw_headers());
+      break;
+    }
+    case net::NetLog::TYPE_HTTP_STREAM_REQUEST_BOUND_TO_JOB: {
+      scoped_ptr<Value> event_params(entry.ParametersToValue());
+      net::NetLog::Source http_stream_job_source;
+      if (!net::NetLog::Source::FromEventParameters(event_params.get(),
+                                                    &http_stream_job_source)) {
+        NOTREACHED();
+        break;
+      }
+
+      uint32 http_stream_job_id = http_stream_job_source.id;
+      HTTPStreamJobToSocketMap::iterator it =
+          http_stream_job_to_socket_.find(http_stream_job_id);
+      if (it == http_stream_job_to_socket_.end())
+        return;
+      uint32 socket_id = it->second;
+
+      if (socket_to_request_.size() > kMaxNumEntries) {
+        LOG(WARNING) << "The url request observer socket count has grown "
+                        "larger than expected, resetting";
+        socket_to_request_.clear();
+      }
+
+      socket_to_request_[socket_id] = entry.source().id;
+      http_stream_job_to_socket_.erase(http_stream_job_id);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+void DevToolsNetLogObserver::OnAddHTTPStreamJobEntry(
+    const net::NetLog::Entry& entry) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (entry.type() == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET) {
+    scoped_ptr<Value> event_params(entry.ParametersToValue());
+    net::NetLog::Source socket_source;
+    if (!net::NetLog::Source::FromEventParameters(event_params.get(),
+                                                  &socket_source)) {
+      NOTREACHED();
+      return;
+    }
+
+    // Prevents us from passively growing the memory unbounded in
+    // case something went wrong. Should not happen.
+    if (http_stream_job_to_socket_.size() > kMaxNumEntries) {
+      LOG(WARNING) << "The load timing observer http stream job count "
+                      "has grown larger than expected, resetting";
+      http_stream_job_to_socket_.clear();
+    }
+    http_stream_job_to_socket_[entry.source().id] = socket_source.id;
+  }
+}
+
+void DevToolsNetLogObserver::OnAddSocketEntry(
+    const net::NetLog::Entry& entry) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  bool is_end = entry.phase() == net::NetLog::PHASE_END;
+
+  SocketToRequestMap::iterator it =
+      socket_to_request_.find(entry.source().id);
+  if (it == socket_to_request_.end())
+    return;
+  uint32 request_id = it->second;
+
+  if (entry.type() == net::NetLog::TYPE_SOCKET_IN_USE) {
+    if (is_end)
+      socket_to_request_.erase(entry.source().id);
+    return;
+  }
+
+  RequestToEncodedDataLengthMap::iterator encoded_data_length_it =
+      request_to_encoded_data_length_.find(request_id);
+  if (encoded_data_length_it == request_to_encoded_data_length_.end())
+    return;
+
+  if (net::NetLog::TYPE_SOCKET_BYTES_RECEIVED == entry.type()) {
+    int byte_count = 0;
+    scoped_ptr<Value> value(entry.ParametersToValue());
+    if (!value->IsType(Value::TYPE_DICTIONARY))
+      return;
+
+    DictionaryValue* dValue = static_cast<DictionaryValue*>(value.get());
+    if (!dValue->GetInteger("byte_count", &byte_count))
+      return;
+
+    encoded_data_length_it->second += byte_count;
+  }
+}
+
+void DevToolsNetLogObserver::Attach() {
+  DCHECK(!instance_);
+  net::NetLog* net_log = GetContentClient()->browser()->GetNetLog();
+  if (net_log) {
+    instance_ = new DevToolsNetLogObserver();
+    net_log->AddThreadSafeObserver(instance_, net::NetLog::LOG_ALL_BUT_BYTES);
+  }
+}
+
+void DevToolsNetLogObserver::Detach() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (instance_) {
+    // Safest not to do this in the destructor to maintain thread safety across
+    // refactorings.
+    instance_->net_log()->RemoveThreadSafeObserver(instance_);
+    delete instance_;
+    instance_ = NULL;
+  }
+}
+
+DevToolsNetLogObserver* DevToolsNetLogObserver::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  return instance_;
+}
+
+// static
+void DevToolsNetLogObserver::PopulateResponseInfo(
+    net::URLRequest* request,
+    ResourceResponse* response) {
+  if (!(request->load_flags() & net::LOAD_REPORT_RAW_HEADERS))
+    return;
+
+  uint32 source_id = request->net_log().source().id;
+  DevToolsNetLogObserver* dev_tools_net_log_observer =
+      DevToolsNetLogObserver::GetInstance();
+  if (dev_tools_net_log_observer == NULL)
+    return;
+  response->head.devtools_info =
+      dev_tools_net_log_observer->GetResourceInfo(source_id);
+}
+
+// static
+int DevToolsNetLogObserver::GetAndResetEncodedDataLength(
+    net::URLRequest* request) {
+  if (!(request->load_flags() & net::LOAD_REPORT_RAW_HEADERS))
+    return -1;
+
+  uint32 source_id = request->net_log().source().id;
+  DevToolsNetLogObserver* dev_tools_net_log_observer =
+      DevToolsNetLogObserver::GetInstance();
+  if (dev_tools_net_log_observer == NULL)
+    return -1;
+
+  RequestToEncodedDataLengthMap::iterator it =
+      dev_tools_net_log_observer->request_to_encoded_data_length_.find(
+          source_id);
+  if (it == dev_tools_net_log_observer->request_to_encoded_data_length_.end())
+    return -1;
+  int encoded_data_length = it->second;
+  it->second = 0;
+  return encoded_data_length;
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_netlog_observer.h b/content/browser/devtools/devtools_netlog_observer.h
new file mode 100644
index 0000000..4e74edd
--- /dev/null
+++ b/content/browser/devtools/devtools_netlog_observer.h
@@ -0,0 +1,70 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_NETLOG_OBSERVER_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_NETLOG_OBSERVER_H_
+
+#include "base/hash_tables.h"
+#include "base/memory/ref_counted.h"
+#include "net/base/net_log.h"
+#include "webkit/glue/resource_loader_bridge.h"
+
+namespace net {
+class URLRequest;
+}  // namespace net
+
+namespace content {
+struct ResourceResponse;
+
+// DevToolsNetLogObserver watches the NetLog event stream and collects the
+// stuff that may be of interest to DevTools. Currently, this only includes
+// actual HTTP/SPDY headers sent and received over the network.
+//
+// As DevToolsNetLogObserver shares live data with objects that live on the
+// IO Thread, it must also reside on the IO Thread.  Only OnAddEntry can be
+// called from other threads.
+class DevToolsNetLogObserver : public net::NetLog::ThreadSafeObserver {
+  typedef webkit_glue::ResourceDevToolsInfo ResourceInfo;
+
+ public:
+  // net::NetLog::ThreadSafeObserver implementation:
+  virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE;
+
+  void OnAddURLRequestEntry(const net::NetLog::Entry& entry);
+  void OnAddHTTPStreamJobEntry(const net::NetLog::Entry& entry);
+  void OnAddSocketEntry(const net::NetLog::Entry& entry);
+
+  static void Attach();
+  static void Detach();
+
+  // Must be called on the IO thread. May return NULL if no observers
+  // are active.
+  static DevToolsNetLogObserver* GetInstance();
+  static void PopulateResponseInfo(net::URLRequest*,
+                                   ResourceResponse*);
+  static int GetAndResetEncodedDataLength(net::URLRequest* request);
+
+ private:
+  static DevToolsNetLogObserver* instance_;
+
+  DevToolsNetLogObserver();
+  virtual ~DevToolsNetLogObserver();
+
+  ResourceInfo* GetResourceInfo(uint32 id);
+
+  typedef base::hash_map<uint32, scoped_refptr<ResourceInfo> > RequestToInfoMap;
+  typedef base::hash_map<uint32, int> RequestToEncodedDataLengthMap;
+  typedef base::hash_map<uint32, uint32> HTTPStreamJobToSocketMap;
+  typedef base::hash_map<uint32, uint32> SocketToRequestMap;
+  RequestToInfoMap request_to_info_;
+  RequestToEncodedDataLengthMap request_to_encoded_data_length_;
+  HTTPStreamJobToSocketMap http_stream_job_to_socket_;
+  SocketToRequestMap socket_to_request_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsNetLogObserver);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_NETLOG_OBSERVER_H_
diff --git a/content/browser/devtools/devtools_resources.gyp b/content/browser/devtools/devtools_resources.gyp
new file mode 100644
index 0000000..9ee2076
--- /dev/null
+++ b/content/browser/devtools/devtools_resources.gyp
@@ -0,0 +1,58 @@
+# 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.
+
+{
+  'variables': {
+    'conditions': [
+      ['inside_chromium_build==0', {
+        'webkit_src_dir': '../../../../../..',
+      },{
+        'webkit_src_dir': '../../../third_party/WebKit',
+      }],
+    ],
+  },
+  'targets': [
+    {
+      'target_name': 'devtools_resources',
+      'type': 'none',
+      'dependencies': [
+        '<(webkit_src_dir)/Source/WebKit/chromium/WebKit.gyp:generate_devtools_grd',
+      ],
+      'variables': {
+        'grit_out_dir': '<(SHARED_INTERMEDIATE_DIR)/webkit',
+      },
+      'actions': [
+        {
+          'action_name': 'devtools_resources',
+          # This can't use build/grit_action.gypi because the grd file
+          # is generated at build time, so the trick of using grit_info to get
+          # the real inputs/outputs at GYP time isn't possible.
+          'variables': {
+            'grit_cmd': ['python', '../../../tools/grit/grit.py'],
+            'grit_grd_file': '<(SHARED_INTERMEDIATE_DIR)/devtools/devtools_resources.grd',
+          },
+          'inputs': [
+            '<(grit_grd_file)',
+            '<!@pymod_do_main(grit_info --inputs)',
+          ],
+          'outputs': [
+            '<(grit_out_dir)/grit/devtools_resources.h',
+            '<(grit_out_dir)/devtools_resources.pak',
+            '<(grit_out_dir)/grit/devtools_resources_map.cc',
+            '<(grit_out_dir)/grit/devtools_resources_map.h',
+          ],
+          'action': ['<@(grit_cmd)',
+                     '-i', '<(grit_grd_file)', 'build',
+                     '-f', 'GRIT_DIR/../gritsettings/resource_ids',
+                     '-o', '<(grit_out_dir)',
+                     '-D', 'SHARED_INTERMEDIATE_DIR=<(SHARED_INTERMEDIATE_DIR)',
+                     '<@(grit_defines)' ],
+          'message': 'Generating resources from <(grit_grd_file)',
+          'msvs_cygwin_shell': 1,
+        }
+      ],
+      'includes': [ '../../../build/grit_target.gypi' ],
+    },
+  ],
+}
diff --git a/content/browser/devtools/devtools_tracing_handler.cc b/content/browser/devtools/devtools_tracing_handler.cc
new file mode 100644
index 0000000..5514452
--- /dev/null
+++ b/content/browser/devtools/devtools_tracing_handler.cc
@@ -0,0 +1,103 @@
+// 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 "content/browser/devtools/devtools_tracing_handler.h"
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/location.h"
+#include "base/values.h"
+#include "content/browser/devtools/devtools_http_handler_impl.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/trace_controller.h"
+#include "content/public/browser/trace_subscriber.h"
+
+namespace content {
+
+DevToolsTracingHandler::DevToolsTracingHandler()
+    : has_completed_(false),
+      buffer_data_size_(0) {
+}
+
+DevToolsTracingHandler::~DevToolsTracingHandler() {
+}
+
+std::string DevToolsTracingHandler::Domain() {
+  return "Tracing";
+}
+
+void DevToolsTracingHandler::OnEndTracingComplete() {
+  has_completed_ = true;
+}
+
+void DevToolsTracingHandler::OnTraceDataCollected(
+    const scoped_refptr<base::RefCountedString>& trace_fragment) {
+  buffer_.push_back(trace_fragment->data());
+  buffer_data_size_ += trace_fragment->data().size();
+}
+
+base::Value* DevToolsTracingHandler::OnProtocolCommand(
+    const std::string& method,
+    const base::DictionaryValue* params,
+    base::Value** error_out) {
+  if (method == "Tracing.start")
+    return Start(params);
+  else if (method == "Tracing.end")
+    return End(params);
+  else if (method == "Tracing.hasCompleted")
+    return HasCompleted(params);
+  else if (method == "Tracing.getTraceAndReset")
+    return GetTraceAndReset(params);
+
+  base::DictionaryValue* error_object = new base::DictionaryValue();
+  error_object->SetInteger("code", -1);
+  error_object->SetString("message", "Invalid method");
+
+  *error_out = error_object;
+
+  return NULL;
+}
+
+base::Value* DevToolsTracingHandler::Start(
+    const base::DictionaryValue* params) {
+  std::string categories;
+  if (params && params->HasKey("categories"))
+    params->GetString("categories", &categories);
+  TraceController::GetInstance()->BeginTracing(this, categories);
+
+  return base::Value::CreateBooleanValue(true);
+}
+
+base::Value* DevToolsTracingHandler::End(
+    const base::DictionaryValue* /* params */) {
+  TraceController::GetInstance()->EndTracingAsync(this);
+
+  return base::Value::CreateBooleanValue(true);
+}
+
+
+base::Value* DevToolsTracingHandler::HasCompleted(
+    const base::DictionaryValue* /* params */) {
+
+  return base::Value::CreateBooleanValue(has_completed_);
+}
+
+base::Value* DevToolsTracingHandler::GetTraceAndReset(
+    const base::DictionaryValue* /* params */) {
+  std::string ret;
+  ret.reserve(buffer_data_size_);
+  for (std::vector<std::string>::const_iterator i = buffer_.begin();
+       i != buffer_.end(); ++i) {
+    if (!ret.empty())
+      ret.append(",");
+    ret.append(*i);
+  }
+  buffer_.clear();
+  has_completed_ = false;
+  buffer_data_size_ = 0;
+
+  return base::Value::CreateStringValue(ret);
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/devtools_tracing_handler.h b/content/browser/devtools/devtools_tracing_handler.h
new file mode 100644
index 0000000..c01896a
--- /dev/null
+++ b/content/browser/devtools/devtools_tracing_handler.h
@@ -0,0 +1,50 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_TRACING_HANDLER_H_
+#define CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_TRACING_HANDLER_H_
+
+#include "content/browser/devtools/devtools_browser_target.h"
+#include "content/public/browser/trace_subscriber.h"
+
+namespace content {
+
+// This class bridges DevTools remote debugging server with the trace
+// infrastructure.
+class DevToolsTracingHandler
+    : public TraceSubscriber,
+      public DevToolsBrowserTarget::Handler {
+ public:
+  DevToolsTracingHandler();
+  virtual ~DevToolsTracingHandler();
+
+  // TraceSubscriber:
+  virtual void OnEndTracingComplete() OVERRIDE;;
+  virtual void OnTraceDataCollected(
+      const scoped_refptr<base::RefCountedString>& trace_fragment) OVERRIDE;
+
+  // DevToolBrowserTarget::Handler:
+  virtual std::string Domain() OVERRIDE;
+  virtual base::Value* OnProtocolCommand(
+      const std::string& method,
+      const base::DictionaryValue* params,
+      base::Value** error_out) OVERRIDE;
+
+ private:
+  base::Value* Start(const base::DictionaryValue* params);
+  base::Value* End(const base::DictionaryValue* params);
+  base::Value* HasCompleted(const base::DictionaryValue* params);
+  base::Value* GetTraceAndReset(const base::DictionaryValue* params);
+
+  bool has_completed_;
+
+  std::vector<std::string> buffer_;
+  int buffer_data_size_;
+
+  DISALLOW_COPY_AND_ASSIGN(DevToolsTracingHandler);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_DEVTOOLS_TRACING_HANDLER_H_
diff --git a/content/browser/devtools/render_view_devtools_agent_host.cc b/content/browser/devtools/render_view_devtools_agent_host.cc
new file mode 100644
index 0000000..4de7545
--- /dev/null
+++ b/content/browser/devtools/render_view_devtools_agent_host.cc
@@ -0,0 +1,154 @@
+// 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 "content/browser/devtools/render_view_devtools_agent_host.h"
+
+#include "base/basictypes.h"
+#include "base/lazy_instance.h"
+#include "content/browser/devtools/devtools_manager_impl.h"
+#include "content/browser/devtools/render_view_devtools_agent_host.h"
+#include "content/browser/renderer_host/render_process_host_impl.h"
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/browser/site_instance_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/devtools_messages.h"
+#include "content/public/browser/content_browser_client.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+
+namespace content {
+
+typedef std::map<RenderViewHost*, RenderViewDevToolsAgentHost*> Instances;
+
+namespace {
+base::LazyInstance<Instances>::Leaky g_instances = LAZY_INSTANCE_INITIALIZER;
+}  // namespace
+
+// static
+DevToolsAgentHost* DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+    RenderViewHost* rvh) {
+  Instances::iterator it = g_instances.Get().find(rvh);
+  if (it != g_instances.Get().end())
+    return it->second;
+  return new RenderViewDevToolsAgentHost(rvh);
+}
+
+// static
+RenderViewHost* DevToolsAgentHostRegistry::GetRenderViewHost(
+     DevToolsAgentHost* agent_host) {
+  for (Instances::iterator it = g_instances.Get().begin();
+       it != g_instances.Get().end(); ++it) {
+    if (agent_host == it->second)
+      return it->first;
+  }
+  return NULL;
+}
+
+// static
+bool DevToolsAgentHostRegistry::HasDevToolsAgentHost(RenderViewHost* rvh) {
+  if (g_instances == NULL)
+    return false;
+  Instances::iterator it = g_instances.Get().find(rvh);
+  return it != g_instances.Get().end();
+}
+
+bool DevToolsAgentHostRegistry::IsDebuggerAttached(WebContents* web_contents) {
+  if (g_instances == NULL)
+    return false;
+  DevToolsManager* devtools_manager = DevToolsManager::GetInstance();
+  if (!devtools_manager)
+    return false;
+  RenderViewHostDelegate* delegate =
+      static_cast<WebContentsImpl*>(web_contents);
+  for (Instances::iterator it = g_instances.Get().begin();
+       it != g_instances.Get().end(); ++it) {
+    if (it->first->GetDelegate() != delegate)
+      continue;
+    if (devtools_manager->GetDevToolsClientHostFor(it->second))
+      return true;
+  }
+  return false;
+}
+
+RenderViewDevToolsAgentHost::RenderViewDevToolsAgentHost(
+    RenderViewHost* rvh)
+    : RenderViewHostObserver(rvh),
+      render_view_host_(rvh) {
+  g_instances.Get()[rvh] = this;
+}
+
+void RenderViewDevToolsAgentHost::SendMessageToAgent(IPC::Message* msg) {
+  msg->set_routing_id(render_view_host_->GetRoutingID());
+  render_view_host_->Send(msg);
+}
+
+void RenderViewDevToolsAgentHost::NotifyClientAttaching() {
+  NotificationService::current()->Notify(
+      NOTIFICATION_DEVTOOLS_AGENT_ATTACHED,
+      Source<BrowserContext>(
+          render_view_host_->GetSiteInstance()->GetProcess()->
+              GetBrowserContext()),
+      Details<RenderViewHost>(render_view_host_));
+}
+
+void RenderViewDevToolsAgentHost::NotifyClientDetaching() {
+  NotificationService::current()->Notify(
+      NOTIFICATION_DEVTOOLS_AGENT_DETACHED,
+      Source<BrowserContext>(
+          render_view_host_->GetSiteInstance()->GetProcess()->
+              GetBrowserContext()),
+      Details<RenderViewHost>(render_view_host_));
+}
+
+int RenderViewDevToolsAgentHost::GetRenderProcessId() {
+  return render_view_host_->GetProcess()->GetID();
+}
+
+RenderViewDevToolsAgentHost::~RenderViewDevToolsAgentHost() {
+  g_instances.Get().erase(render_view_host_);
+}
+
+void RenderViewDevToolsAgentHost::RenderViewHostDestroyed(
+    RenderViewHost* rvh) {
+  NotifyCloseListener();
+  delete this;
+}
+
+bool RenderViewDevToolsAgentHost::OnMessageReceived(
+    const IPC::Message& message) {
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(RenderViewDevToolsAgentHost, message)
+    IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
+                        OnDispatchOnInspectorFrontend)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_SaveAgentRuntimeState,
+                        OnSaveAgentRuntimeState)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_ClearBrowserCache, OnClearBrowserCache)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_ClearBrowserCookies,
+                        OnClearBrowserCookies)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void RenderViewDevToolsAgentHost::OnSaveAgentRuntimeState(
+    const std::string& state) {
+  DevToolsManagerImpl::GetInstance()->SaveAgentRuntimeState(this, state);
+}
+
+void RenderViewDevToolsAgentHost::OnDispatchOnInspectorFrontend(
+    const std::string& message) {
+  DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(
+      this, message);
+}
+
+void RenderViewDevToolsAgentHost::OnClearBrowserCache() {
+  GetContentClient()->browser()->ClearCache(render_view_host_);
+}
+
+void RenderViewDevToolsAgentHost::OnClearBrowserCookies() {
+  GetContentClient()->browser()->ClearCookies(render_view_host_);
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/render_view_devtools_agent_host.h b/content/browser/devtools/render_view_devtools_agent_host.h
new file mode 100644
index 0000000..afd3173
--- /dev/null
+++ b/content/browser/devtools/render_view_devtools_agent_host.h
@@ -0,0 +1,51 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_RENDER_VIEW_DEVTOOLS_AGENT_HOST_H_
+#define CONTENT_BROWSER_DEVTOOLS_RENDER_VIEW_DEVTOOLS_AGENT_HOST_H_
+
+#include <map>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "content/browser/devtools/devtools_agent_host.h"
+#include "content/common/content_export.h"
+#include "content/public/browser/render_view_host_observer.h"
+
+namespace content {
+
+class RenderViewHost;
+
+class CONTENT_EXPORT RenderViewDevToolsAgentHost
+    : public DevToolsAgentHost,
+      private RenderViewHostObserver {
+ public:
+  RenderViewDevToolsAgentHost(RenderViewHost*);
+
+ private:
+  virtual ~RenderViewDevToolsAgentHost();
+
+  // DevToolsAgentHost implementation.
+  virtual void SendMessageToAgent(IPC::Message* msg) OVERRIDE;
+  virtual void NotifyClientAttaching() OVERRIDE;
+  virtual void NotifyClientDetaching() OVERRIDE;
+  virtual int GetRenderProcessId() OVERRIDE;
+
+  // RenderViewHostObserver overrides.
+  virtual void RenderViewHostDestroyed(RenderViewHost* rvh) OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  void OnDispatchOnInspectorFrontend(const std::string& message);
+  void OnSaveAgentRuntimeState(const std::string& state);
+  void OnClearBrowserCache();
+  void OnClearBrowserCookies();
+
+  RenderViewHost* render_view_host_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderViewDevToolsAgentHost);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_RENDER_VIEW_DEVTOOLS_AGENT_HOST_H_
diff --git a/content/browser/devtools/worker_devtools_manager.cc b/content/browser/devtools/worker_devtools_manager.cc
new file mode 100644
index 0000000..f341c82
--- /dev/null
+++ b/content/browser/devtools/worker_devtools_manager.cc
@@ -0,0 +1,472 @@
+// Copyright (c) 2011 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/worker_devtools_manager.h"
+
+#include <list>
+#include <map>
+
+#include "base/bind.h"
+#include "content/browser/devtools/devtools_agent_host.h"
+#include "content/browser/devtools/devtools_manager_impl.h"
+#include "content/browser/devtools/worker_devtools_message_filter.h"
+#include "content/browser/worker_host/worker_service_impl.h"
+#include "content/common/devtools_messages.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/child_process_data.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
+#include "content/public/common/process_type.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebDevToolsAgent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebCString.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
+
+namespace content {
+
+// Called on the UI thread.
+// static
+DevToolsAgentHost* DevToolsAgentHostRegistry::GetDevToolsAgentHostForWorker(
+    int worker_process_id,
+    int worker_route_id) {
+  return WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+      worker_process_id,
+      worker_route_id);
+}
+
+class WorkerDevToolsManager::AgentHosts {
+public:
+  static void Add(WorkerId id, WorkerDevToolsAgentHost* host) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (!instance_)
+      instance_ = new AgentHosts();
+    instance_->map_[id] = host;
+  }
+  static void Remove(WorkerId id) {
+    DCHECK(instance_);
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    Instances& map = instance_->map_;
+    map.erase(id);
+    if (map.empty()) {
+      delete instance_;
+      instance_ = NULL;
+    }
+  }
+
+  static WorkerDevToolsAgentHost* GetAgentHost(WorkerId id) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (!instance_)
+      return NULL;
+    Instances& map = instance_->map_;
+    Instances::iterator it = map.find(id);
+    if (it == map.end())
+      return NULL;
+    return it->second;
+  }
+
+private:
+  AgentHosts() {
+  }
+  ~AgentHosts() {}
+
+  static AgentHosts* instance_;
+  typedef std::map<WorkerId, WorkerDevToolsAgentHost*> Instances;
+  Instances map_;
+};
+
+WorkerDevToolsManager::AgentHosts*
+    WorkerDevToolsManager::AgentHosts::instance_ = NULL;
+
+
+struct WorkerDevToolsManager::TerminatedInspectedWorker {
+  TerminatedInspectedWorker(WorkerId id, const GURL& url, const string16& name)
+      : old_worker_id(id),
+        worker_url(url),
+        worker_name(name) {}
+  WorkerId old_worker_id;
+  GURL worker_url;
+  string16 worker_name;
+};
+
+
+class WorkerDevToolsManager::WorkerDevToolsAgentHost
+    : public DevToolsAgentHost {
+ public:
+  explicit WorkerDevToolsAgentHost(WorkerId worker_id)
+      : worker_id_(worker_id) {
+    AgentHosts::Add(worker_id, this);
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(
+            &RegisterAgent,
+            worker_id.first,
+            worker_id.second));
+  }
+
+  void WorkerDestroyed() {
+    NotifyCloseListener();
+    delete this;
+  }
+
+ private:
+  virtual ~WorkerDevToolsAgentHost() {
+    AgentHosts::Remove(worker_id_);
+  }
+
+  static void RegisterAgent(
+      int worker_process_id,
+      int worker_route_id) {
+    WorkerDevToolsManager::GetInstance()->RegisterDevToolsAgentHostForWorker(
+        worker_process_id, worker_route_id);
+  }
+
+  static void ForwardToWorkerDevToolsAgent(
+      int worker_process_id,
+      int worker_route_id,
+      IPC::Message* message) {
+    WorkerDevToolsManager::GetInstance()->ForwardToWorkerDevToolsAgent(
+        worker_process_id, worker_route_id, *message);
+  }
+
+  // DevToolsAgentHost implementation.
+  virtual void SendMessageToAgent(IPC::Message* message) OVERRIDE {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(
+            &WorkerDevToolsAgentHost::ForwardToWorkerDevToolsAgent,
+            worker_id_.first,
+            worker_id_.second,
+            base::Owned(message)));
+  }
+  virtual void NotifyClientAttaching() OVERRIDE {}
+  virtual void NotifyClientDetaching() OVERRIDE {}
+  virtual int GetRenderProcessId() OVERRIDE { return -1; }
+
+  WorkerId worker_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsAgentHost);
+};
+
+
+class WorkerDevToolsManager::DetachedClientHosts {
+ public:
+  static void WorkerReloaded(WorkerId old_id, WorkerId new_id) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (instance_ && instance_->ReattachClient(old_id, new_id))
+      return;
+    RemovePendingWorkerData(old_id);
+  }
+
+  static void WorkerDestroyed(WorkerId id) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    WorkerDevToolsAgentHost* agent = AgentHosts::GetAgentHost(id);
+    if (!agent) {
+      RemovePendingWorkerData(id);
+      return;
+    }
+    DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(
+        agent,
+        WebKit::WebDevToolsAgent::workerDisconnectedFromWorkerEvent().utf8());
+    int cookie = DevToolsManagerImpl::GetInstance()->DetachClientHost(agent);
+    agent->WorkerDestroyed();
+    if (cookie == -1) {
+      RemovePendingWorkerData(id);
+      return;
+    }
+    if (!instance_)
+      new DetachedClientHosts();
+    instance_->worker_id_to_cookie_[id] = cookie;
+  }
+
+ private:
+  DetachedClientHosts() {
+    instance_ = this;
+  }
+  ~DetachedClientHosts() {
+    instance_ = NULL;
+  }
+
+  bool ReattachClient(WorkerId old_id, WorkerId new_id) {
+    WorkerIdToCookieMap::iterator it = worker_id_to_cookie_.find(old_id);
+    if (it == worker_id_to_cookie_.end())
+      return false;
+    DevToolsAgentHost* agent =
+        WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+            new_id.first,
+            new_id.second);
+    DevToolsManagerImpl::GetInstance()->AttachClientHost(
+        it->second,
+        agent);
+    worker_id_to_cookie_.erase(it);
+    if (worker_id_to_cookie_.empty())
+      delete this;
+    return true;
+  }
+
+  static void RemovePendingWorkerData(WorkerId id) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&RemoveInspectedWorkerDataOnIOThread, id));
+  }
+
+  static void RemoveInspectedWorkerDataOnIOThread(WorkerId id) {
+    WorkerDevToolsManager::GetInstance()->RemoveInspectedWorkerData(id);
+  }
+
+  static DetachedClientHosts* instance_;
+  typedef std::map<WorkerId, int> WorkerIdToCookieMap;
+  WorkerIdToCookieMap worker_id_to_cookie_;
+};
+
+WorkerDevToolsManager::DetachedClientHosts*
+    WorkerDevToolsManager::DetachedClientHosts::instance_ = NULL;
+
+struct WorkerDevToolsManager::InspectedWorker {
+  InspectedWorker(WorkerProcessHost* host, int route_id, const GURL& url,
+                  const string16& name)
+      : host(host),
+        route_id(route_id),
+        worker_url(url),
+        worker_name(name) {}
+  WorkerProcessHost* const host;
+  int const route_id;
+  GURL worker_url;
+  string16 worker_name;
+};
+
+// static
+WorkerDevToolsManager* WorkerDevToolsManager::GetInstance() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  return Singleton<WorkerDevToolsManager>::get();
+}
+
+// static
+DevToolsAgentHost* WorkerDevToolsManager::GetDevToolsAgentHostForWorker(
+    int worker_process_id,
+    int worker_route_id) {
+  WorkerId id(worker_process_id, worker_route_id);
+  WorkerDevToolsAgentHost* result = AgentHosts::GetAgentHost(id);
+  if (!result)
+    result = new WorkerDevToolsAgentHost(id);
+  return result;
+}
+
+WorkerDevToolsManager::WorkerDevToolsManager() {
+}
+
+WorkerDevToolsManager::~WorkerDevToolsManager() {
+}
+
+void WorkerDevToolsManager::WorkerCreated(
+    WorkerProcessHost* worker,
+    const WorkerProcessHost::WorkerInstance& instance) {
+  for (TerminatedInspectedWorkers::iterator it = terminated_workers_.begin();
+       it != terminated_workers_.end(); ++it) {
+    if (instance.Matches(it->worker_url, it->worker_name,
+                         instance.partition(),
+                         instance.resource_context())) {
+      worker->Send(new DevToolsAgentMsg_PauseWorkerContextOnStart(
+          instance.worker_route_id()));
+      WorkerId new_worker_id(worker->GetData().id, instance.worker_route_id());
+      paused_workers_[new_worker_id] = it->old_worker_id;
+      terminated_workers_.erase(it);
+      return;
+    }
+  }
+}
+
+void WorkerDevToolsManager::WorkerDestroyed(
+    WorkerProcessHost* worker,
+    int worker_route_id) {
+  InspectedWorkersList::iterator it = FindInspectedWorker(
+      worker->GetData().id,
+      worker_route_id);
+  if (it == inspected_workers_.end())
+    return;
+
+  WorkerId worker_id(worker->GetData().id, worker_route_id);
+  terminated_workers_.push_back(TerminatedInspectedWorker(
+      worker_id,
+      it->worker_url,
+      it->worker_name));
+  inspected_workers_.erase(it);
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&DetachedClientHosts::WorkerDestroyed, worker_id));
+}
+
+void WorkerDevToolsManager::WorkerContextStarted(WorkerProcessHost* process,
+                                                 int worker_route_id) {
+  WorkerId new_worker_id(process->GetData().id, worker_route_id);
+  PausedWorkers::iterator it = paused_workers_.find(new_worker_id);
+  if (it == paused_workers_.end())
+    return;
+
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          &DetachedClientHosts::WorkerReloaded,
+          it->second,
+          new_worker_id));
+  paused_workers_.erase(it);
+}
+
+void WorkerDevToolsManager::RemoveInspectedWorkerData(
+    const WorkerId& id) {
+  for (TerminatedInspectedWorkers::iterator it = terminated_workers_.begin();
+       it != terminated_workers_.end(); ++it) {
+    if (it->old_worker_id == id) {
+      terminated_workers_.erase(it);
+      return;
+    }
+  }
+
+  for (PausedWorkers::iterator it = paused_workers_.begin();
+       it != paused_workers_.end(); ++it) {
+    if (it->second == id) {
+      SendResumeToWorker(it->first);
+      paused_workers_.erase(it);
+      return;
+    }
+  }
+}
+
+WorkerDevToolsManager::InspectedWorkersList::iterator
+WorkerDevToolsManager::FindInspectedWorker(
+    int host_id, int route_id) {
+  InspectedWorkersList::iterator it = inspected_workers_.begin();
+  while (it != inspected_workers_.end()) {
+    if (it->host->GetData().id == host_id && it->route_id == route_id)
+      break;
+    ++it;
+  }
+  return it;
+}
+
+static WorkerProcessHost* FindWorkerProcess(int worker_process_id) {
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    if (iter.GetData().id == worker_process_id)
+      return *iter;
+  }
+  return NULL;
+}
+
+void WorkerDevToolsManager::RegisterDevToolsAgentHostForWorker(
+    int worker_process_id,
+    int worker_route_id) {
+  if (WorkerProcessHost* process = FindWorkerProcess(worker_process_id)) {
+    const WorkerProcessHost::Instances& instances = process->instances();
+    for (WorkerProcessHost::Instances::const_iterator i = instances.begin();
+         i != instances.end(); ++i) {
+      if (i->worker_route_id() == worker_route_id) {
+        DCHECK(FindInspectedWorker(worker_process_id, worker_route_id) ==
+               inspected_workers_.end());
+        inspected_workers_.push_back(
+            InspectedWorker(process, worker_route_id, i->url(), i->name()));
+        return;
+      }
+    }
+  }
+  NotifyWorkerDestroyedOnIOThread(worker_process_id, worker_route_id);
+}
+
+void WorkerDevToolsManager::ForwardToDevToolsClient(
+    int worker_process_id,
+    int worker_route_id,
+    const std::string& message) {
+  if (FindInspectedWorker(worker_process_id, worker_route_id) ==
+          inspected_workers_.end()) {
+      NOTREACHED();
+      return;
+  }
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          &ForwardToDevToolsClientOnUIThread,
+          worker_process_id,
+          worker_route_id,
+          message));
+}
+
+void WorkerDevToolsManager::SaveAgentRuntimeState(int worker_process_id,
+                                                  int worker_route_id,
+                                                  const std::string& state) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          &SaveAgentRuntimeStateOnUIThread,
+          worker_process_id,
+          worker_route_id,
+          state));
+}
+
+void WorkerDevToolsManager::ForwardToWorkerDevToolsAgent(
+    int worker_process_id,
+    int worker_route_id,
+    const IPC::Message& message) {
+  InspectedWorkersList::iterator it = FindInspectedWorker(
+      worker_process_id,
+      worker_route_id);
+  if (it == inspected_workers_.end())
+    return;
+  IPC::Message* msg = new IPC::Message(message);
+  msg->set_routing_id(worker_route_id);
+  it->host->Send(msg);
+}
+
+// static
+void WorkerDevToolsManager::ForwardToDevToolsClientOnUIThread(
+    int worker_process_id,
+    int worker_route_id,
+    const std::string& message) {
+  WorkerDevToolsAgentHost* agent_host = AgentHosts::GetAgentHost(WorkerId(
+      worker_process_id,
+      worker_route_id));
+  if (!agent_host)
+    return;
+  DevToolsManagerImpl::GetInstance()->DispatchOnInspectorFrontend(agent_host,
+                                                                  message);
+}
+
+// static
+void WorkerDevToolsManager::SaveAgentRuntimeStateOnUIThread(
+    int worker_process_id,
+    int worker_route_id,
+    const std::string& state) {
+  WorkerDevToolsAgentHost* agent_host = AgentHosts::GetAgentHost(WorkerId(
+      worker_process_id,
+      worker_route_id));
+  if (!agent_host)
+    return;
+  DevToolsManagerImpl::GetInstance()->SaveAgentRuntimeState(agent_host, state);
+}
+
+// static
+void WorkerDevToolsManager::NotifyWorkerDestroyedOnIOThread(
+    int worker_process_id,
+    int worker_route_id) {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          &WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread,
+          worker_process_id,
+          worker_route_id));
+}
+
+// static
+void WorkerDevToolsManager::NotifyWorkerDestroyedOnUIThread(
+    int worker_process_id,
+    int worker_route_id) {
+  WorkerDevToolsAgentHost* host =
+      AgentHosts::GetAgentHost(WorkerId(worker_process_id, worker_route_id));
+  if (host)
+    host->WorkerDestroyed();
+}
+
+// static
+void WorkerDevToolsManager::SendResumeToWorker(const WorkerId& id) {
+  if (WorkerProcessHost* process = FindWorkerProcess(id.first))
+    process->Send(new DevToolsAgentMsg_ResumeWorkerContext(id.second));
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/worker_devtools_manager.h b/content/browser/devtools/worker_devtools_manager.h
new file mode 100644
index 0000000..13ef33b
--- /dev/null
+++ b/content/browser/devtools/worker_devtools_manager.h
@@ -0,0 +1,109 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_
+#define CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_
+
+#include <list>
+#include <map>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/memory/singleton.h"
+#include "content/browser/worker_host/worker_process_host.h"
+#include "content/common/content_export.h"
+
+namespace content {
+
+class DevToolsAgentHost;
+
+// All methods are supposed to be called on the IO thread.
+class WorkerDevToolsManager {
+ public:
+  // Returns the WorkerDevToolsManager singleton.
+  static WorkerDevToolsManager* GetInstance();
+
+  // Called on the UI thread.
+  static DevToolsAgentHost* GetDevToolsAgentHostForWorker(
+      int worker_process_id,
+      int worker_route_id);
+
+  void ForwardToDevToolsClient(int worker_process_id,
+                               int worker_route_id,
+                               const std::string& message);
+  void SaveAgentRuntimeState(int worker_process_id,
+                             int worker_route_id,
+                             const std::string& state);
+
+  // Called on the IO thread.
+  void WorkerCreated(
+      WorkerProcessHost* process,
+      const WorkerProcessHost::WorkerInstance& instance);
+  void WorkerDestroyed(WorkerProcessHost* process, int worker_route_id);
+  void WorkerContextStarted(WorkerProcessHost* process, int worker_route_id);
+
+ private:
+  friend struct DefaultSingletonTraits<WorkerDevToolsManager>;
+  typedef std::pair<int, int> WorkerId;
+  class AgentHosts;
+  class DetachedClientHosts;
+  class WorkerDevToolsAgentHost;
+  struct InspectedWorker;
+  typedef std::list<InspectedWorker> InspectedWorkersList;
+
+  WorkerDevToolsManager();
+  virtual ~WorkerDevToolsManager();
+
+  void RemoveInspectedWorkerData(const WorkerId& id);
+  InspectedWorkersList::iterator FindInspectedWorker(int host_id, int route_id);
+
+  void RegisterDevToolsAgentHostForWorker(int worker_process_id,
+                                          int worker_route_id);
+  void ForwardToWorkerDevToolsAgent(int worker_process_host_id,
+                                    int worker_route_id,
+                                    const IPC::Message& message);
+  static void ForwardToDevToolsClientOnUIThread(
+      int worker_process_id,
+      int worker_route_id,
+      const std::string& message);
+  static void SaveAgentRuntimeStateOnUIThread(
+      int worker_process_id,
+      int worker_route_id,
+      const std::string& state);
+  static void NotifyWorkerDestroyedOnIOThread(int worker_process_id,
+                                              int worker_route_id);
+  static void NotifyWorkerDestroyedOnUIThread(int worker_process_id,
+                                              int worker_route_id);
+  static void SendResumeToWorker(const WorkerId& id);
+
+  InspectedWorkersList inspected_workers_;
+
+  struct TerminatedInspectedWorker;
+  typedef std::list<TerminatedInspectedWorker> TerminatedInspectedWorkers;
+  // List of terminated workers for which there may be a devtools client on
+  // the UI thread. Worker entry is added into this list when inspected worker
+  // is terminated and will be removed in one of two cases:
+  // - shared worker with the same URL and name is started(in wich case we will
+  // try to reattach existing DevTools client to the new worker).
+  // - DevTools client which was inspecting terminated worker is closed on the
+  // UI thread and and WorkerDevToolsManager is notified about that on the IO
+  // thread.
+  TerminatedInspectedWorkers terminated_workers_;
+
+  typedef std::map<WorkerId, WorkerId> PausedWorkers;
+  // Map from old to new worker id for the inspected workers that have been
+  // terminated and started again in paused state. Worker data will be removed
+  // from this list in one of two cases:
+  // - DevTools client is closed on the UI thread, WorkerDevToolsManager was
+  // notified about that on the IO thread and sent "resume" message to the
+  // worker.
+  // - Existing DevTools client was reattached to the new worker.
+  PausedWorkers paused_workers_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsManager);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MANAGER_H_
diff --git a/content/browser/devtools/worker_devtools_message_filter.cc b/content/browser/devtools/worker_devtools_message_filter.cc
new file mode 100644
index 0000000..3f5553f1
--- /dev/null
+++ b/content/browser/devtools/worker_devtools_message_filter.cc
@@ -0,0 +1,50 @@
+// Copyright (c) 2011 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/worker_devtools_message_filter.h"
+
+#include "content/browser/devtools/worker_devtools_manager.h"
+#include "content/common/devtools_messages.h"
+#include "content/common/worker_messages.h"
+
+namespace content {
+
+WorkerDevToolsMessageFilter::WorkerDevToolsMessageFilter(
+    int worker_process_host_id)
+    : worker_process_host_id_(worker_process_host_id),
+      current_routing_id_(0) {
+}
+
+WorkerDevToolsMessageFilter::~WorkerDevToolsMessageFilter() {
+}
+
+bool WorkerDevToolsMessageFilter::OnMessageReceived(
+    const IPC::Message& message,
+    bool* message_was_ok) {
+  bool handled = true;
+  current_routing_id_ = message.routing_id();
+  IPC_BEGIN_MESSAGE_MAP_EX(WorkerDevToolsMessageFilter, message,
+                           *message_was_ok)
+    IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
+                        OnDispatchOnInspectorFrontend)
+    IPC_MESSAGE_HANDLER(DevToolsHostMsg_SaveAgentRuntimeState,
+                        OnSaveAgentRumtimeState)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP_EX()
+  return handled;
+}
+
+void WorkerDevToolsMessageFilter::OnDispatchOnInspectorFrontend(
+    const std::string& message) {
+  WorkerDevToolsManager::GetInstance()->ForwardToDevToolsClient(
+      worker_process_host_id_, current_routing_id_, message);
+}
+
+void WorkerDevToolsMessageFilter::OnSaveAgentRumtimeState(
+    const std::string& state) {
+  WorkerDevToolsManager::GetInstance()->SaveAgentRuntimeState(
+      worker_process_host_id_, current_routing_id_, state);
+}
+
+}  // namespace content
diff --git a/content/browser/devtools/worker_devtools_message_filter.h b/content/browser/devtools/worker_devtools_message_filter.h
new file mode 100644
index 0000000..73ba6f84
--- /dev/null
+++ b/content/browser/devtools/worker_devtools_message_filter.h
@@ -0,0 +1,35 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MESSAGE_FILTER_H_
+#define CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MESSAGE_FILTER_H_
+
+#include "base/callback_forward.h"
+#include "content/public/browser/browser_message_filter.h"
+
+namespace content {
+
+class WorkerDevToolsMessageFilter : public BrowserMessageFilter {
+ public:
+  explicit WorkerDevToolsMessageFilter(int worker_process_host_id);
+
+ private:
+  virtual ~WorkerDevToolsMessageFilter();
+
+  // BrowserMessageFilter implementation.
+  virtual bool OnMessageReceived(const IPC::Message& message,
+                                 bool* message_was_ok) OVERRIDE;
+  // Message handlers.
+  void OnDispatchOnInspectorFrontend(const std::string& message);
+  void OnSaveAgentRumtimeState(const std::string& state);
+
+  int worker_process_host_id_;
+  int current_routing_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(WorkerDevToolsMessageFilter);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_DEVTOOLS_WORKER_DEVTOOLS_MESSAGE_FILTER_H_