Merge Chromium at 7.0.540.0 : Initial merge by git

Not including third_party/icu as it contains huge data files that break Gerrit, and aren't actually used.

Change-Id: I428a386e70f3b58cacd28677b8cfda282e891e15

27 files changed, 545 insertions, 460 deletions

diff --git a/chrome/browser/debugger/debugger_host.h b/chrome/browser/debugger/debugger_host.h
index 71857e5..63fbaaa 100644
--- a/chrome/browser/debugger/debugger_host.h
+++ b/chrome/browser/debugger/debugger_host.h
@@ -6,6 +6,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_HOST_H_
 #define CHROME_BROWSER_DEBUGGER_DEBUGGER_HOST_H_
+#pragma once
 
 #include <string>
 
diff --git a/chrome/browser/debugger/debugger_remote_service.cc b/chrome/browser/debugger/debugger_remote_service.cc
index 91fca90..4c3341b 100644
--- a/chrome/browser/debugger/debugger_remote_service.cc
+++ b/chrome/browser/debugger/debugger_remote_service.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -9,7 +9,8 @@
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
-#include "base/string_util.h"
+#include "base/string_number_conversions.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_manager.h"
@@ -20,23 +21,14 @@
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/devtools_messages.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/common/render_messages_params.h"
 
 namespace {
 
-// A constant for the "data" JSON message field.
-// The type is wstring because the constant is used to get a
-// DictionaryValue field (which requires a wide string).
-static const std::wstring kDataWide = L"data";
-
-// A constant for the "result" JSON message field.
-// The type is wstring because the constant is used to get a
-// DictionaryValue field (which requires a wide string).
-static const std::wstring kResultWide = L"result";
-
-// A constant for the "command" JSON message field.
-// The type is wstring because the constant is used to get a
-// DictionaryValue field (which requires a wide string).
-static const std::wstring kCommandWide = L"command";
+// Constants for the "data", "result", and "command" JSON message fields.
+const char kDataKey[] = "data";
+const char kResultKey[] = "result";
+const char kCommandKey[] = "command";
 
 }  // namespace
 
@@ -78,32 +70,32 @@ void DebuggerRemoteService::HandleMessage(
     return;
   }
   content = static_cast<DictionaryValue*>(request.get());
-  if (!content->HasKey(kCommandWide)) {
+  if (!content->HasKey(kCommandKey)) {
     NOTREACHED();  // Broken protocol :(
     return;
   }
   std::string command;
   DictionaryValue response;
 
-  content->GetString(kCommandWide, &command);
-  response.SetString(kCommandWide, command);
+  content->GetString(kCommandKey, &command);
+  response.SetString(kCommandKey, command);
   bool send_response = true;
   if (destination.size() == 0) {
     // Unknown command (bad format?)
     NOTREACHED();
-    response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+    response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     SendResponse(response, message.tool(), message.destination());
     return;
   }
   int32 tab_uid = -1;
-  StringToInt(destination, &tab_uid);
+  base::StringToInt(destination, &tab_uid);
 
   if (command == DebuggerRemoteServiceCommand::kAttach) {
     // TODO(apavlov): handle 0 for a new tab
-    response.SetString(kCommandWide, DebuggerRemoteServiceCommand::kAttach);
+    response.SetString(kCommandKey, DebuggerRemoteServiceCommand::kAttach);
     AttachToTab(destination, &response);
   } else if (command == DebuggerRemoteServiceCommand::kDetach) {
-    response.SetString(kCommandWide, DebuggerRemoteServiceCommand::kDetach);
+    response.SetString(kCommandKey, DebuggerRemoteServiceCommand::kDetach);
     DetachFromTab(destination, &response);
   } else if (command == DebuggerRemoteServiceCommand::kDebuggerCommand) {
     send_response = DispatchDebuggerCommand(tab_uid, content, &response);
@@ -112,7 +104,7 @@ void DebuggerRemoteService::HandleMessage(
   } else {
     // Unknown command
     NOTREACHED();
-    response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+    response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
   }
 
   if (send_response) {
@@ -166,12 +158,12 @@ void DebuggerRemoteService::DebuggerOutput(int32 tab_uid,
   std::string content = StringPrintf(
       "{\"command\":\"%s\",\"result\":%s,\"data\":%s}",
       DebuggerRemoteServiceCommand::kDebuggerCommand.c_str(),
-      IntToString(RESULT_OK).c_str(),
+      base::IntToString(RESULT_OK).c_str(),
       message.c_str());
   scoped_ptr<DevToolsRemoteMessage> response_message(
       DevToolsRemoteMessageBuilder::instance().Create(
           kToolName,
-          IntToString(tab_uid),
+          base::IntToString(tab_uid),
           content));
   delegate_->Send(*(response_message.get()));
 }
@@ -183,10 +175,10 @@ void DebuggerRemoteService::DebuggerOutput(int32 tab_uid,
 void DebuggerRemoteService::FrameNavigate(int32 tab_uid,
                                           const std::string& url) {
   DictionaryValue value;
-  value.SetString(kCommandWide, DebuggerRemoteServiceCommand::kFrameNavigate);
-  value.SetInteger(kResultWide, RESULT_OK);
-  value.SetString(kDataWide, url);
-  SendResponse(value, kToolName, IntToString(tab_uid));
+  value.SetString(kCommandKey, DebuggerRemoteServiceCommand::kFrameNavigate);
+  value.SetInteger(kResultKey, RESULT_OK);
+  value.SetString(kDataKey, url);
+  SendResponse(value, kToolName, base::IntToString(tab_uid));
 }
 
 // Gets invoked from a DevToolsClientHost callback whenever
@@ -194,9 +186,9 @@ void DebuggerRemoteService::FrameNavigate(int32 tab_uid,
 // Sends the corresponding message to the remote debugger.
 void DebuggerRemoteService::TabClosed(int32 tab_id) {
   DictionaryValue value;
-  value.SetString(kCommandWide, DebuggerRemoteServiceCommand::kTabClosed);
-  value.SetInteger(kResultWide, RESULT_OK);
-  SendResponse(value, kToolName, IntToString(tab_id));
+  value.SetString(kCommandKey, DebuggerRemoteServiceCommand::kTabClosed);
+  value.SetInteger(kResultKey, RESULT_OK);
+  SendResponse(value, kToolName, base::IntToString(tab_id));
 }
 
 // Attaches a remote debugger to the target tab specified by |destination|
@@ -205,23 +197,23 @@ void DebuggerRemoteService::TabClosed(int32 tab_id) {
 void DebuggerRemoteService::AttachToTab(const std::string& destination,
                                         DictionaryValue* response) {
   int32 tab_uid = -1;
-  StringToInt(destination, &tab_uid);
+  base::StringToInt(destination, &tab_uid);
   if (tab_uid < 0) {
     // Bad tab_uid received from remote debugger (perhaps NaN)
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return;
   }
   if (tab_uid == 0) {  // single tab_uid
     // We've been asked to open a new tab with URL
     // TODO(apavlov): implement
     NOTIMPLEMENTED();
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return;
   }
   TabContents* tab_contents = ToTabContents(tab_uid);
   if (tab_contents == NULL) {
     // No active tab contents with tab_uid
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return;
   }
   RenderViewHost* target_host = tab_contents->render_view_host();
@@ -233,13 +225,13 @@ void DebuggerRemoteService::AttachToTab(const std::string& destination,
     DevToolsManager* manager = DevToolsManager::GetInstance();
     if (manager != NULL) {
       manager->RegisterDevToolsClientHostFor(target_host, client_host);
-      response->SetInteger(kResultWide, RESULT_OK);
+      response->SetInteger(kResultKey, RESULT_OK);
     } else {
-      response->SetInteger(kResultWide, RESULT_DEBUGGER_ERROR);
+      response->SetInteger(kResultKey, RESULT_DEBUGGER_ERROR);
     }
   } else {
     // DevToolsClientHost for this tab is already registered
-    response->SetInteger(kResultWide, RESULT_ILLEGAL_TAB_STATE);
+    response->SetInteger(kResultKey, RESULT_ILLEGAL_TAB_STATE);
   }
 }
 
@@ -249,11 +241,11 @@ void DebuggerRemoteService::AttachToTab(const std::string& destination,
 void DebuggerRemoteService::DetachFromTab(const std::string& destination,
                                           DictionaryValue* response) {
   int32 tab_uid = -1;
-  StringToInt(destination, &tab_uid);
+  base::StringToInt(destination, &tab_uid);
   if (tab_uid == -1) {
     // Bad tab_uid received from remote debugger (NaN)
     if (response != NULL) {
-      response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+      response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     }
     return;
   }
@@ -268,7 +260,7 @@ void DebuggerRemoteService::DetachFromTab(const std::string& destination,
     result_code = RESULT_UNKNOWN_TAB;
   }
   if (response != NULL) {
-    response->SetInteger(kResultWide, result_code);
+    response->SetInteger(kResultKey, result_code);
   }
 }
 
@@ -281,30 +273,30 @@ bool DebuggerRemoteService::DispatchDebuggerCommand(int tab_uid,
                                                     DictionaryValue* response) {
   if (tab_uid == -1) {
     // Invalid tab_uid from remote debugger (perhaps NaN)
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return true;
   }
   DevToolsManager* manager = DevToolsManager::GetInstance();
   if (manager == NULL) {
-    response->SetInteger(kResultWide, RESULT_DEBUGGER_ERROR);
+    response->SetInteger(kResultKey, RESULT_DEBUGGER_ERROR);
     return true;
   }
   TabContents* tab_contents = ToTabContents(tab_uid);
   if (tab_contents == NULL) {
     // Unknown tab_uid from remote debugger
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return true;
   }
   DevToolsClientHost* client_host =
       manager->GetDevToolsClientHostFor(tab_contents->render_view_host());
   if (client_host == NULL) {
     // tab_uid is not being debugged (Attach has not been invoked)
-    response->SetInteger(kResultWide, RESULT_ILLEGAL_TAB_STATE);
+    response->SetInteger(kResultKey, RESULT_ILLEGAL_TAB_STATE);
     return true;
   }
   std::string v8_command;
   DictionaryValue* v8_command_value;
-  content->GetDictionary(kDataWide, &v8_command_value);
+  content->GetDictionary(kDataKey, &v8_command_value);
   base::JSONWriter::Write(v8_command_value, false, &v8_command);
   manager->ForwardToDevToolsAgent(
       client_host, DevToolsAgentMsg_DebuggerCommand(v8_command));
@@ -322,26 +314,26 @@ bool DebuggerRemoteService::DispatchEvaluateJavascript(
     DictionaryValue* response) {
   if (tab_uid == -1) {
     // Invalid tab_uid from remote debugger (perhaps NaN)
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return true;
   }
   TabContents* tab_contents = ToTabContents(tab_uid);
   if (tab_contents == NULL) {
     // Unknown tab_uid from remote debugger
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return true;
   }
   RenderViewHost* render_view_host = tab_contents->render_view_host();
   if (render_view_host == NULL) {
     // No RenderViewHost
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_TAB);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_TAB);
     return true;
   }
-  std::wstring javascript;
-  content->GetString(kDataWide, &javascript);
+  std::string javascript;
+  content->GetString(kDataKey, &javascript);
   render_view_host->Send(
       new ViewMsg_ScriptEvalRequest(render_view_host->routing_id(),
                                     L"",
-                                    javascript));
+                                    UTF8ToWide(javascript)));
   return false;
 }
diff --git a/chrome/browser/debugger/debugger_remote_service.h b/chrome/browser/debugger/debugger_remote_service.h
index 7f6e4e8..83b1f40 100644
--- a/chrome/browser/debugger/debugger_remote_service.h
+++ b/chrome/browser/debugger/debugger_remote_service.h
@@ -7,6 +7,7 @@
 // "V8Debugger" tool.
 #ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_REMOTE_SERVICE_H_
 #define CHROME_BROWSER_DEBUGGER_DEBUGGER_REMOTE_SERVICE_H_
+#pragma once
 
 #include <string>
 
diff --git a/chrome/browser/debugger/debugger_wrapper.h b/chrome/browser/debugger/debugger_wrapper.h
index 0a82366..a9cf7bf 100644
--- a/chrome/browser/debugger/debugger_wrapper.h
+++ b/chrome/browser/debugger/debugger_wrapper.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.
 
@@ -8,8 +8,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_WRAPPER_H_
 #define CHROME_BROWSER_DEBUGGER_DEBUGGER_WRAPPER_H_
-
-#include <string>
+#pragma once
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
diff --git a/chrome/browser/debugger/devtools_client_host.h b/chrome/browser/debugger/devtools_client_host.h
index 71534fb..e62237d 100644
--- a/chrome/browser/debugger/devtools_client_host.h
+++ b/chrome/browser/debugger/devtools_client_host.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_CLIENT_HOST_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_CLIENT_HOST_H_
+#pragma once
 
 #include "base/basictypes.h"
 
diff --git a/chrome/browser/debugger/devtools_http_protocol_handler.cc b/chrome/browser/debugger/devtools_http_protocol_handler.cc
index 2f24e07..4ab1a79 100644
--- a/chrome/browser/debugger/devtools_http_protocol_handler.cc
+++ b/chrome/browser/debugger/devtools_http_protocol_handler.cc
@@ -7,8 +7,9 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/message_loop_proxy.h"
-#include "base/string_util.h"
+#include "base/string_number_conversions.h"
 #include "base/thread.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/chrome_thread.h"
@@ -16,6 +17,7 @@
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
+#include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/common/devtools_messages.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "googleurl/src/gurl.h"
@@ -37,28 +39,29 @@ class DevToolsClientHostImpl : public DevToolsClientHost {
   ~DevToolsClientHostImpl() {}
 
   // DevToolsClientHost interface
-  virtual void InspectedTabClosing() {}
+  virtual void InspectedTabClosing() {
+    ChromeThread::PostTask(
+        ChromeThread::IO,
+        FROM_HERE,
+        NewRunnableMethod(socket_,
+                          &HttpListenSocket::Close));
+  }
+
   virtual void SendMessageToClient(const IPC::Message& msg) {
     IPC_BEGIN_MESSAGE_MAP(DevToolsClientHostImpl, msg)
-      IPC_MESSAGE_HANDLER(DevToolsClientMsg_RpcMessage, OnRpcMessage);
+      IPC_MESSAGE_HANDLER(DevToolsClientMsg_DispatchOnInspectorFrontend,
+                          OnDispatchOnInspectorFrontend);
       IPC_MESSAGE_UNHANDLED_ERROR()
     IPC_END_MESSAGE_MAP()
   }
 
+  void NotifyCloseListener() {
+    DevToolsClientHost::NotifyCloseListener();
+  }
  private:
   // Message handling routines
-  void OnRpcMessage(const DevToolsMessageData& data) {
-    std::string message;
-    message += "devtools$$dispatch(\"" + data.class_name + "\", \"" +
-        data.method_name + "\"";
-    for (std::vector<std::string>::const_iterator it = data.arguments.begin();
-         it != data.arguments.end(); ++it) {
-      std::string param = *it;
-      if (!param.empty())
-        message += ", " + param;
-    }
-    message += ")";
-    socket_->SendOverWebSocket(message);
+  void OnDispatchOnInspectorFrontend(const std::string& data) {
+    socket_->SendOverWebSocket(data);
   }
   HttpListenSocket* socket_;
 };
@@ -82,9 +85,29 @@ void DevToolsHttpProtocolHandler::Stop() {
       NewRunnableMethod(this, &DevToolsHttpProtocolHandler::Teardown));
 }
 
-void DevToolsHttpProtocolHandler::OnHttpRequest(HttpListenSocket* socket,
-                                                HttpServerRequestInfo* info) {
-  URLRequest* request = new URLRequest(GURL("chrome:/" + info->path), this);
+void DevToolsHttpProtocolHandler::OnHttpRequest(
+    HttpListenSocket* socket,
+    const HttpServerRequestInfo& info) {
+  if (info.path == "" || info.path == "/") {
+    // Pages discovery request.
+    ChromeThread::PostTask(
+        ChromeThread::UI,
+        FROM_HERE,
+        NewRunnableMethod(this,
+                          &DevToolsHttpProtocolHandler::OnHttpRequestUI,
+                          socket,
+                          info));
+    return;
+  }
+
+  size_t pos = info.path.find("/devtools/");
+  if (pos != 0) {
+    socket->Send404();
+    return;
+  }
+
+  // Proxy static files from chrome://devtools/*.
+  URLRequest* request = new URLRequest(GURL("chrome:/" + info.path), this);
   Bind(request, socket);
   request->set_context(
       Profile::GetDefaultRequestContext()->GetURLRequestContext());
@@ -93,8 +116,15 @@ void DevToolsHttpProtocolHandler::OnHttpRequest(HttpListenSocket* socket,
 
 void DevToolsHttpProtocolHandler::OnWebSocketRequest(
     HttpListenSocket* socket,
-    HttpServerRequestInfo* request) {
-  socket->AcceptWebSocket(request);
+    const HttpServerRequestInfo& request) {
+  ChromeThread::PostTask(
+      ChromeThread::UI,
+      FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &DevToolsHttpProtocolHandler::OnWebSocketRequestUI,
+          socket,
+          request));
 }
 
 void DevToolsHttpProtocolHandler::OnWebSocketMessage(HttpListenSocket* socket,
@@ -109,58 +139,139 @@ void DevToolsHttpProtocolHandler::OnWebSocketMessage(HttpListenSocket* socket,
           data));
 }
 
-void DevToolsHttpProtocolHandler::OnWebSocketMessageUI(
-    HttpListenSocket* socket,
-    const std::string& d) {
-  std::string data = d;
-  if (!client_host_.get() && data == "attach") {
-    client_host_.reset(new DevToolsClientHostImpl(socket));
-    BrowserList::const_iterator it = BrowserList::begin();
-    TabContents* tab_contents = (*it)->tabstrip_model()->GetTabContentsAt(0);
-    DevToolsManager* manager = DevToolsManager::GetInstance();
-    manager->RegisterDevToolsClientHostFor(tab_contents->render_view_host(),
-                                           client_host_.get());
-  } else {
-    // TODO(pfeldman): Replace with proper parsing / dispatching.
-    DevToolsMessageData message_data;
-    message_data.class_name = "ToolsAgent";
-    message_data.method_name = "dispatchOnInspectorController";
+void DevToolsHttpProtocolHandler::OnClose(HttpListenSocket* socket) {
+  SocketToRequestsMap::iterator it = socket_to_requests_io_.find(socket);
+  if (it != socket_to_requests_io_.end()) {
+    // Dispose delegating socket.
+    for (std::set<URLRequest*>::iterator it2 = it->second.begin();
+         it2 != it->second.end(); ++it2) {
+      URLRequest* request = *it2;
+      request->Cancel();
+      request_to_socket_io_.erase(request);
+      request_to_buffer_io_.erase(request);
+      delete request;
+    }
+    socket_to_requests_io_.erase(socket);
+  }
+
+  ChromeThread::PostTask(
+      ChromeThread::UI,
+      FROM_HERE,
+      NewRunnableMethod(
+          this,
+          &DevToolsHttpProtocolHandler::OnCloseUI,
+          socket));
+}
 
-    size_t pos = data.find(" ");
-    message_data.arguments.push_back(data.substr(0, pos));
-    data = data.substr(pos + 1);
+void DevToolsHttpProtocolHandler::OnHttpRequestUI(
+    HttpListenSocket* socket,
+    const HttpServerRequestInfo& info) {
+  std::string response = "<html><body>";
+  for (BrowserList::const_iterator it = BrowserList::begin(),
+       end = BrowserList::end(); it != end; ++it) {
+    TabStripModel* model = (*it)->tabstrip_model();
+    for (int i = 0, size = model->count(); i < size; ++i) {
+      TabContents* tab_contents = model->GetTabContentsAt(i);
+      NavigationController& controller = tab_contents->controller();
+      NavigationEntry* entry = controller.GetActiveEntry();
+      if (entry == NULL)
+        continue;
+
+      if (!entry->url().is_valid())
+        continue;
+
+      DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
+          GetDevToolsClientHostFor(tab_contents->render_view_host());
+      if (!client_host) {
+        response += StringPrintf(
+            "<a href='/devtools/devtools.html?page=%d'>%s (%s)</a><br>",
+            controller.session_id().id(),
+            UTF16ToUTF8(entry->title()).c_str(),
+            entry->url().spec().c_str());
+      } else {
+        response += StringPrintf(
+            "%s (%s)<br>",
+            UTF16ToUTF8(entry->title()).c_str(),
+            entry->url().spec().c_str());
+      }
+    }
+  }
+  response += "</body></html>";
+  Send200(socket, response, "text/html; charset=UTF-8");
+}
 
-    pos = data.find(" ");
-    message_data.arguments.push_back(data.substr(0, pos));
-    data = data.substr(pos + 1);
+void DevToolsHttpProtocolHandler::OnWebSocketRequestUI(
+    HttpListenSocket* socket,
+    const HttpServerRequestInfo& request) {
+  std::string prefix = "/devtools/page/";
+  size_t pos = request.path.find(prefix);
+  if (pos != 0) {
+    Send404(socket);
+    return;
+  }
+  std::string page_id = request.path.substr(prefix.length());
+  int id = 0;
+  if (!base::StringToInt(page_id, &id)) {
+    Send500(socket, "Invalid page id: " + page_id);
+    return;
+  }
 
-    message_data.arguments.push_back(data);
+  TabContents* tab_contents = GetTabContents(id);
+  if (tab_contents == NULL) {
+    Send500(socket, "No such page id: " + page_id);
+    return;
+  }
 
-    DevToolsManager* manager = DevToolsManager::GetInstance();
-    manager->ForwardToDevToolsAgent(client_host_.get(),
-        DevToolsAgentMsg_RpcMessage(DevToolsMessageData(message_data)));
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+  if (manager->GetDevToolsClientHostFor(tab_contents->render_view_host())) {
+    Send500(socket, "Page with given id is being inspected: " + page_id);
+    return;
   }
+
+  DevToolsClientHostImpl* client_host = new DevToolsClientHostImpl(socket);
+  socket_to_client_host_ui_[socket] = client_host;
+
+  manager->RegisterDevToolsClientHostFor(
+      tab_contents->render_view_host(),
+      client_host);
+  AcceptWebSocket(socket, request);
 }
 
-void DevToolsHttpProtocolHandler::OnClose(HttpListenSocket* socket) {
-  SocketToRequestsMap::iterator it = socket_to_requests_.find(socket);
-  if (it == socket_to_requests_.end())
+void DevToolsHttpProtocolHandler::OnWebSocketMessageUI(
+    HttpListenSocket* socket,
+    const std::string& data) {
+  SocketToClientHostMap::iterator it = socket_to_client_host_ui_.find(socket);
+  if (it == socket_to_client_host_ui_.end())
     return;
 
-  for (std::set<URLRequest*>::iterator it2 = it->second.begin();
-       it2 != it->second.end(); ++it2) {
-    URLRequest* request = *it2;
-    request->Cancel();
-    request_to_socket_.erase(request);
-    request_to_buffer_.erase(request);
-    delete request;
+  DevToolsManager* manager = DevToolsManager::GetInstance();
+
+  if (data == "loaded") {
+    manager->ForwardToDevToolsAgent(
+        it->second,
+        DevToolsAgentMsg_FrontendLoaded());
+    return;
   }
-  socket_to_requests_.erase(socket);
+
+  manager->ForwardToDevToolsAgent(
+      it->second,
+      DevToolsAgentMsg_DispatchOnInspectorBackend(data));
+}
+
+void DevToolsHttpProtocolHandler::OnCloseUI(HttpListenSocket* socket) {
+  SocketToClientHostMap::iterator it = socket_to_client_host_ui_.find(socket);
+  if (it == socket_to_client_host_ui_.end())
+    return;
+  DevToolsClientHostImpl* client_host =
+      static_cast<DevToolsClientHostImpl*>(it->second);
+  client_host->NotifyCloseListener();
+  delete client_host;
+  socket_to_client_host_ui_.erase(socket);
 }
 
 void DevToolsHttpProtocolHandler::OnResponseStarted(URLRequest* request) {
-  RequestToSocketMap::iterator it = request_to_socket_.find(request);
-  if (it == request_to_socket_.end())
+  RequestToSocketMap::iterator it = request_to_socket_io_.find(request);
+  if (it == request_to_socket_io_.end())
     return;
 
   HttpListenSocket* socket = it->second;
@@ -178,9 +289,7 @@ void DevToolsHttpProtocolHandler::OnResponseStarted(URLRequest* request) {
                               content_type.c_str(),
                               expected_size));
   } else {
-    socket->Send("HTTP/1.1 404 Not Found\r\n"
-                 "Content-Length: 0\r\n"
-                 "\r\n");
+    socket->Send404();
   }
 
   int bytes_read = 0;
@@ -188,7 +297,7 @@ void DevToolsHttpProtocolHandler::OnResponseStarted(URLRequest* request) {
   // network connection as soon as possible, signal that the request has
   // completed immediately, without trying to read any data back (all we care
   // about is the response code and headers, which we already have).
-  net::IOBuffer* buffer = request_to_buffer_[request].get();
+  net::IOBuffer* buffer = request_to_buffer_io_[request].get();
   if (request->status().is_success())
     request->Read(buffer, kBufferSize, &bytes_read);
   OnReadCompleted(request, bytes_read);
@@ -196,13 +305,13 @@ void DevToolsHttpProtocolHandler::OnResponseStarted(URLRequest* request) {
 
 void DevToolsHttpProtocolHandler::OnReadCompleted(URLRequest* request,
                                                   int bytes_read) {
-  RequestToSocketMap::iterator it = request_to_socket_.find(request);
-  if (it == request_to_socket_.end())
+  RequestToSocketMap::iterator it = request_to_socket_io_.find(request);
+  if (it == request_to_socket_io_.end())
     return;
 
   HttpListenSocket* socket = it->second;
 
-  net::IOBuffer* buffer = request_to_buffer_[request].get();
+  net::IOBuffer* buffer = request_to_buffer_io_[request].get();
   do {
     if (!request->status().is_success() || bytes_read <= 0)
       break;
@@ -230,27 +339,78 @@ void DevToolsHttpProtocolHandler::Teardown() {
 
 void DevToolsHttpProtocolHandler::Bind(URLRequest* request,
                                        HttpListenSocket* socket) {
-  request_to_socket_[request] = socket;
-  SocketToRequestsMap::iterator it = socket_to_requests_.find(socket);
-  if (it == socket_to_requests_.end()) {
+  request_to_socket_io_[request] = socket;
+  SocketToRequestsMap::iterator it = socket_to_requests_io_.find(socket);
+  if (it == socket_to_requests_io_.end()) {
     std::pair<HttpListenSocket*, std::set<URLRequest*> > value(
         socket,
         std::set<URLRequest*>());
-    it = socket_to_requests_.insert(value).first;
+    it = socket_to_requests_io_.insert(value).first;
   }
   it->second.insert(request);
-  request_to_buffer_[request] = new net::IOBuffer(kBufferSize);
+  request_to_buffer_io_[request] = new net::IOBuffer(kBufferSize);
 }
 
 void DevToolsHttpProtocolHandler::RequestCompleted(URLRequest* request) {
-  RequestToSocketMap::iterator it = request_to_socket_.find(request);
-  if (it == request_to_socket_.end())
+  RequestToSocketMap::iterator it = request_to_socket_io_.find(request);
+  if (it == request_to_socket_io_.end())
     return;
 
   HttpListenSocket* socket = it->second;
-  request_to_socket_.erase(request);
-  SocketToRequestsMap::iterator it2 = socket_to_requests_.find(socket);
+  request_to_socket_io_.erase(request);
+  SocketToRequestsMap::iterator it2 = socket_to_requests_io_.find(socket);
   it2->second.erase(request);
-  request_to_buffer_.erase(request);
+  request_to_buffer_io_.erase(request);
   delete request;
 }
+
+void DevToolsHttpProtocolHandler::Send200(HttpListenSocket* socket,
+                                          const std::string& data,
+                                          const std::string& mime_type) {
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(socket,
+                        &HttpListenSocket::Send200,
+                        data,
+                        mime_type));
+}
+
+void DevToolsHttpProtocolHandler::Send404(HttpListenSocket* socket) {
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(socket,
+                        &HttpListenSocket::Send404));
+}
+
+void DevToolsHttpProtocolHandler::Send500(HttpListenSocket* socket,
+                                          const std::string& message) {
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(socket,
+                        &HttpListenSocket::Send500,
+                        message));
+}
+
+void DevToolsHttpProtocolHandler::AcceptWebSocket(
+    HttpListenSocket* socket,
+    const HttpServerRequestInfo& request) {
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(socket,
+                        &HttpListenSocket::AcceptWebSocket,
+                        request));
+}
+
+TabContents* DevToolsHttpProtocolHandler::GetTabContents(int session_id) {
+  for (BrowserList::const_iterator it = BrowserList::begin(),
+       end = BrowserList::end(); it != end; ++it) {
+    TabStripModel* model = (*it)->tabstrip_model();
+    for (int i = 0, size = model->count(); i < size; ++i) {
+      NavigationController& controller =
+          model->GetTabContentsAt(i)->controller();
+      if (controller.session_id().id() == session_id)
+        return controller.tab_contents();
+    }
+  }
+  return NULL;
+}
diff --git a/chrome/browser/debugger/devtools_http_protocol_handler.h b/chrome/browser/debugger/devtools_http_protocol_handler.h
index 14163d5..332fbaa 100644
--- a/chrome/browser/debugger/devtools_http_protocol_handler.h
+++ b/chrome/browser/debugger/devtools_http_protocol_handler.h
@@ -4,17 +4,18 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_HTTP_PROTOCOL_HANDLER_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_HTTP_PROTOCOL_HANDLER_H_
+#pragma once
 
 #include <set>
 #include <string>
 
 #include "base/ref_counted.h"
-#include "base/scoped_ptr.h"
 #include "net/server/http_listen_socket.h"
 #include "net/url_request/url_request.h"
 
 class DevToolsClientHost;
 class DevToolsHttpServer;
+class TabContents;
 
 class DevToolsHttpProtocolHandler
     : public HttpListenSocket::Delegate,
@@ -29,41 +30,61 @@ class DevToolsHttpProtocolHandler
   // This method should be called before the object destruction.
   void Stop();
 
+ private:
+  friend class base::RefCountedThreadSafe<DevToolsHttpProtocolHandler>;
+  virtual ~DevToolsHttpProtocolHandler();
+
   // HttpListenSocket::Delegate implementation.
   virtual void OnHttpRequest(HttpListenSocket* socket,
-                             HttpServerRequestInfo* info);
+                             const HttpServerRequestInfo& info);
   virtual void OnWebSocketRequest(HttpListenSocket* socket,
-                                  HttpServerRequestInfo* info);
+                                  const HttpServerRequestInfo& info);
   virtual void OnWebSocketMessage(HttpListenSocket* socket,
                                   const std::string& data);
   virtual void OnClose(HttpListenSocket* socket);
 
+  virtual void OnHttpRequestUI(HttpListenSocket* socket,
+                               const HttpServerRequestInfo& info);
+  virtual void OnWebSocketRequestUI(HttpListenSocket* socket,
+                                    const HttpServerRequestInfo& info);
+  virtual void OnWebSocketMessageUI(HttpListenSocket* socket,
+                                    const std::string& data);
+  virtual void OnCloseUI(HttpListenSocket* socket);
+
   // URLRequest::Delegate implementation.
   virtual void OnResponseStarted(URLRequest* request);
   virtual void OnReadCompleted(URLRequest* request, int bytes_read);
 
- private:
-  friend class base::RefCountedThreadSafe<DevToolsHttpProtocolHandler>;
-  virtual ~DevToolsHttpProtocolHandler();
-
   void Init();
   void Teardown();
   void Bind(URLRequest* request, HttpListenSocket* socket);
   void RequestCompleted(URLRequest* request);
-  void OnWebSocketMessageUI(HttpListenSocket* socket, const std::string& data);
+
+  void Send200(HttpListenSocket* socket,
+               const std::string& data,
+               const std::string& mime_type = "text/html");
+  void Send404(HttpListenSocket* socket);
+  void Send500(HttpListenSocket* socket,
+               const std::string& message);
+  void AcceptWebSocket(HttpListenSocket* socket,
+                       const HttpServerRequestInfo& request);
+
+  TabContents* GetTabContents(int session_id);
 
   int port_;
   scoped_refptr<HttpListenSocket> server_;
   typedef std::map<URLRequest*, HttpListenSocket*>
       RequestToSocketMap;
-  RequestToSocketMap request_to_socket_;
+  RequestToSocketMap request_to_socket_io_;
   typedef std::map<HttpListenSocket*, std::set<URLRequest*> >
       SocketToRequestsMap;
-  SocketToRequestsMap socket_to_requests_;
+  SocketToRequestsMap socket_to_requests_io_;
   typedef std::map<URLRequest*, scoped_refptr<net::IOBuffer> >
       BuffersMap;
-  BuffersMap request_to_buffer_;
-  scoped_ptr<DevToolsClientHost> client_host_;
+  BuffersMap request_to_buffer_io_;
+  typedef std::map<HttpListenSocket*, DevToolsClientHost*>
+      SocketToClientHostMap;
+  SocketToClientHostMap socket_to_client_host_ui_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsHttpProtocolHandler);
 };
 
diff --git a/chrome/browser/debugger/devtools_manager.cc b/chrome/browser/debugger/devtools_manager.cc
index 6b958cc..5116d85 100644
--- a/chrome/browser/debugger/devtools_manager.cc
+++ b/chrome/browser/debugger/devtools_manager.cc
@@ -13,12 +13,11 @@
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
-#include "chrome/browser/pref_service.h"
+#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/renderer_host/site_instance.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
-#include "chrome/common/devtools_messages.h"
 #include "chrome/common/pref_names.h"
 #include "googleurl/src/gurl.h"
 
@@ -64,8 +63,8 @@ void DevToolsManager::RegisterDevToolsClientHostFor(
     DevToolsClientHost* client_host) {
   DCHECK(!GetDevToolsClientHostFor(inspected_rvh));
 
-  RuntimeFeatures initial_features;
-  BindClientHost(inspected_rvh, client_host, initial_features);
+  DevToolsRuntimeProperties initial_properties;
+  BindClientHost(inspected_rvh, client_host, initial_properties);
   client_host->set_close_listener(this);
   SendAttachToAgent(inspected_rvh);
 }
@@ -143,29 +142,28 @@ void DevToolsManager::ToggleDevToolsWindow(
   ToggleDevToolsWindow(inspected_rvh, false, action);
 }
 
-void DevToolsManager::RuntimeFeatureStateChanged(RenderViewHost* inspected_rvh,
-                                                 const std::string& feature,
-                                                 bool enabled) {
-  RuntimeFeaturesMap::iterator it = runtime_features_map_.find(inspected_rvh);
-  if (it == runtime_features_map_.end()) {
-    std::pair<RenderViewHost*, std::set<std::string> > value(
+void DevToolsManager::RuntimePropertyChanged(RenderViewHost* inspected_rvh,
+                                             const std::string& name,
+                                             const std::string& value) {
+  RuntimePropertiesMap::iterator it = runtime_properties_map_.find(inspected_rvh);
+  if (it == runtime_properties_map_.end()) {
+    std::pair<RenderViewHost*, DevToolsRuntimeProperties> value(
         inspected_rvh,
-        std::set<std::string>());
-    it = runtime_features_map_.insert(value).first;
+        DevToolsRuntimeProperties());
+    it = runtime_properties_map_.insert(value).first;
   }
-  if (enabled)
-    it->second.insert(feature);
-  else
-    it->second.erase(feature);
+  it->second[name] = value;
 }
 
 void DevToolsManager::InspectElement(RenderViewHost* inspected_rvh,
                                      int x,
                                      int y) {
-  OpenDevToolsWindow(inspected_rvh);
   IPC::Message* m = new DevToolsAgentMsg_InspectElement(x, y);
   m->set_routing_id(inspected_rvh->routing_id());
   inspected_rvh->Send(m);
+  // TODO(loislo): we should initiate DevTools window opening from within
+  // renderer. Otherwise, we still can hit a race condition here.
+  OpenDevToolsWindow(inspected_rvh);
 }
 
 void DevToolsManager::ClientHostClosing(DevToolsClientHost* host) {
@@ -265,8 +263,8 @@ int DevToolsManager::DetachClientHost(RenderViewHost* from_rvh) {
 
   int cookie = last_orphan_cookie_++;
   orphan_client_hosts_[cookie] =
-      std::pair<DevToolsClientHost*, RuntimeFeatures>(
-          client_host, runtime_features_map_[from_rvh]);
+      std::pair<DevToolsClientHost*, DevToolsRuntimeProperties>(
+          client_host, runtime_properties_map_[from_rvh]);
 
   UnbindClientHost(from_rvh, client_host);
   return cookie;
@@ -291,14 +289,14 @@ void DevToolsManager::SendAttachToAgent(RenderViewHost* inspected_rvh) {
     ChildProcessSecurityPolicy::GetInstance()->GrantReadRawCookies(
         inspected_rvh->process()->id());
 
-    std::vector<std::string> features;
-    RuntimeFeaturesMap::iterator it =
-        runtime_features_map_.find(inspected_rvh);
-    if (it != runtime_features_map_.end()) {
-      features = std::vector<std::string>(it->second.begin(),
-                                          it->second.end());
+    DevToolsRuntimeProperties properties;
+    RuntimePropertiesMap::iterator it =
+        runtime_properties_map_.find(inspected_rvh);
+    if (it != runtime_properties_map_.end()) {
+      properties = DevToolsRuntimeProperties(it->second.begin(),
+                                            it->second.end());
     }
-    IPC::Message* m = new DevToolsAgentMsg_Attach(features);
+    IPC::Message* m = new DevToolsAgentMsg_Attach(properties);
     m->set_routing_id(inspected_rvh->routing_id());
     inspected_rvh->Send(m);
   }
@@ -379,9 +377,10 @@ void DevToolsManager::ToggleDevToolsWindow(
   }
 }
 
-void DevToolsManager::BindClientHost(RenderViewHost* inspected_rvh,
-                                     DevToolsClientHost* client_host,
-                                     const RuntimeFeatures& runtime_features) {
+void DevToolsManager::BindClientHost(
+    RenderViewHost* inspected_rvh,
+    DevToolsClientHost* client_host,
+    const DevToolsRuntimeProperties& runtime_properties) {
   DCHECK(inspected_rvh_to_client_host_.find(inspected_rvh) ==
       inspected_rvh_to_client_host_.end());
   DCHECK(client_host_to_inspected_rvh_.find(client_host) ==
@@ -389,7 +388,7 @@ void DevToolsManager::BindClientHost(RenderViewHost* inspected_rvh,
 
   inspected_rvh_to_client_host_[inspected_rvh] = client_host;
   client_host_to_inspected_rvh_[client_host] = inspected_rvh;
-  runtime_features_map_[inspected_rvh] = runtime_features;
+  runtime_properties_map_[inspected_rvh] = runtime_properties;
 }
 
 void DevToolsManager::UnbindClientHost(RenderViewHost* inspected_rvh,
@@ -401,5 +400,5 @@ void DevToolsManager::UnbindClientHost(RenderViewHost* inspected_rvh,
 
   inspected_rvh_to_client_host_.erase(inspected_rvh);
   client_host_to_inspected_rvh_.erase(client_host);
-  runtime_features_map_.erase(inspected_rvh);
+  runtime_properties_map_.erase(inspected_rvh);
 }
diff --git a/chrome/browser/debugger/devtools_manager.h b/chrome/browser/debugger/devtools_manager.h
index 20835af..1c60a4d 100644
--- a/chrome/browser/debugger/devtools_manager.h
+++ b/chrome/browser/debugger/devtools_manager.h
@@ -1,17 +1,18 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 CHROME_BROWSER_DEBUGGER_DEVTOOLS_MANAGER_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_MANAGER_H_
+#pragma once
 
 #include <map>
-#include <set>
 #include <string>
 
 #include "base/ref_counted.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
+#include "chrome/common/devtools_messages.h"
 
 namespace IPC {
 class Message;
@@ -57,9 +58,9 @@ class DevToolsManager : public DevToolsClientHost::CloseListener,
   void OpenDevToolsWindow(RenderViewHost* inspected_rvh);
   void ToggleDevToolsWindow(RenderViewHost* inspected_rvh,
                             DevToolsToggleAction action);
-  void RuntimeFeatureStateChanged(RenderViewHost* inspected_rvh,
-                                  const std::string& feature,
-                                  bool enabled);
+  void RuntimePropertyChanged(RenderViewHost* inspected_rvh,
+                              const std::string& name,
+                              const std::string& value);
 
   // Starts element inspection in the devtools client.
   // Creates one by means of OpenDevToolsWindow if no client
@@ -82,7 +83,6 @@ class DevToolsManager : public DevToolsClientHost::CloseListener,
 
  private:
   friend class base::RefCounted<DevToolsManager>;
-  typedef std::set<std::string> RuntimeFeatures;
 
   virtual ~DevToolsManager();
 
@@ -111,7 +111,7 @@ class DevToolsManager : public DevToolsClientHost::CloseListener,
 
   void BindClientHost(RenderViewHost* inspected_rvh,
                       DevToolsClientHost* client_host,
-                      const RuntimeFeatures& runtime_features);
+                      const DevToolsRuntimeProperties& runtime_properties);
 
   void UnbindClientHost(RenderViewHost* inspected_rvh,
                         DevToolsClientHost* client_host);
@@ -132,14 +132,15 @@ class DevToolsManager : public DevToolsClientHost::CloseListener,
       ClientHostToInspectedRvhMap;
   ClientHostToInspectedRvhMap client_host_to_inspected_rvh_;
 
-  typedef std::map<RenderViewHost*, RuntimeFeatures>
-      RuntimeFeaturesMap;
-  RuntimeFeaturesMap runtime_features_map_;
+  typedef std::map<RenderViewHost*, DevToolsRuntimeProperties>
+      RuntimePropertiesMap;
+  RuntimePropertiesMap runtime_properties_map_;
 
   RenderViewHost* inspected_rvh_for_reopen_;
   bool in_initial_show_;
 
-  typedef std::map<int, std::pair<DevToolsClientHost*, RuntimeFeatures> >
+  typedef std::map<int,
+                   std::pair<DevToolsClientHost*, DevToolsRuntimeProperties> >
       OrphanClientHosts;
   OrphanClientHosts orphan_client_hosts_;
   int last_orphan_cookie_;
diff --git a/chrome/browser/debugger/devtools_protocol_handler.h b/chrome/browser/debugger/devtools_protocol_handler.h
index fff65eb..92889cc 100644
--- a/chrome/browser/debugger/devtools_protocol_handler.h
+++ b/chrome/browser/debugger/devtools_protocol_handler.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_PROTOCOL_HANDLER_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_PROTOCOL_HANDLER_H_
+#pragma once
 
 #include <string>
 
diff --git a/chrome/browser/debugger/devtools_remote.h b/chrome/browser/debugger/devtools_remote.h
index a0edc6d..9c7953b 100644
--- a/chrome/browser/debugger/devtools_remote.h
+++ b/chrome/browser/debugger/devtools_remote.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_H_
+#pragma once
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
diff --git a/chrome/browser/debugger/devtools_remote_listen_socket.cc b/chrome/browser/debugger/devtools_remote_listen_socket.cc
index 87b88d0..bce2ba4 100644
--- a/chrome/browser/debugger/devtools_remote_listen_socket.cc
+++ b/chrome/browser/debugger/devtools_remote_listen_socket.cc
@@ -20,9 +20,10 @@
 #include "net/base/net_errors.h"
 #endif
 
+#include "base/compiler_specific.h"
 #include "base/eintr_wrapper.h"
 #include "base/platform_thread.h"
-#include "base/string_util.h"
+#include "base/string_number_conversions.h"
 #include "chrome/browser/debugger/devtools_remote.h"
 #include "chrome/browser/debugger/devtools_remote_message.h"
 
@@ -60,7 +61,7 @@ void DevToolsRemoteListenSocket::StartNextField() {
       if (protocol_field_.size() == 0) {  // empty line - end of headers
         const std::string& payload_length_string = GetHeader(
             DevToolsRemoteMessageHeaders::kContentLength, "0");
-        remaining_payload_length_ = StringToInt(payload_length_string);
+        base::StringToInt(payload_length_string, &remaining_payload_length_);
         state_ = PAYLOAD;
         if (remaining_payload_length_ == 0) {  // no payload
           DispatchField();
diff --git a/chrome/browser/debugger/devtools_remote_listen_socket.h b/chrome/browser/debugger/devtools_remote_listen_socket.h
index 9424a76..5497861 100644
--- a/chrome/browser/debugger/devtools_remote_listen_socket.h
+++ b/chrome/browser/debugger/devtools_remote_listen_socket.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_LISTEN_SOCKET_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_LISTEN_SOCKET_H_
+#pragma once
 
 #include <string>
 
diff --git a/chrome/browser/debugger/devtools_remote_listen_socket_unittest.h b/chrome/browser/debugger/devtools_remote_listen_socket_unittest.h
index b839cc7..56835eb 100644
--- a/chrome/browser/debugger/devtools_remote_listen_socket_unittest.h
+++ b/chrome/browser/debugger/devtools_remote_listen_socket_unittest.h
@@ -1,9 +1,10 @@
-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_LISTEN_SOCKET_UNITTEST_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_LISTEN_SOCKET_UNITTEST_H_
+#pragma once
 
 #include "build/build_config.h"
 
@@ -22,7 +23,6 @@
 #include "base/thread.h"
 #include "base/basictypes.h"
 #include "base/message_loop.h"
-#include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/thread.h"
diff --git a/chrome/browser/debugger/devtools_remote_message.cc b/chrome/browser/debugger/devtools_remote_message.cc
index 97c6875..eb63009 100644
--- a/chrome/browser/debugger/devtools_remote_message.cc
+++ b/chrome/browser/debugger/devtools_remote_message.cc
@@ -1,10 +1,11 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/string_util.h"
 #include "chrome/browser/debugger/devtools_remote_message.h"
 
+#include "base/string_number_conversions.h"
+
 const char DevToolsRemoteMessageHeaders::kContentLength[] = "Content-Length";
 const char DevToolsRemoteMessageHeaders::kTool[] = "Tool";
 const char DevToolsRemoteMessageHeaders::kDestination[] = "Destination";
@@ -47,7 +48,7 @@ DevToolsRemoteMessage* DevToolsRemoteMessageBuilder::Create(
     const std::string& content) {
   DevToolsRemoteMessage::HeaderMap headers;
   headers[DevToolsRemoteMessageHeaders::kContentLength] =
-      IntToString(content.size());
+      base::IntToString(content.size());
   headers[DevToolsRemoteMessageHeaders::kTool] = tool;
   headers[DevToolsRemoteMessageHeaders::kDestination] = destination;
   return new DevToolsRemoteMessage(headers, content);
diff --git a/chrome/browser/debugger/devtools_remote_message.h b/chrome/browser/debugger/devtools_remote_message.h
index 0fa5e97..bea9ae5 100644
--- a/chrome/browser/debugger/devtools_remote_message.h
+++ b/chrome/browser/debugger/devtools_remote_message.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_MESSAGE_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_MESSAGE_H_
+#pragma once
 
 #include <string>
 
diff --git a/chrome/browser/debugger/devtools_remote_message_unittest.cc b/chrome/browser/debugger/devtools_remote_message_unittest.cc
index bc84a4c..0b74e3f 100644
--- a/chrome/browser/debugger/devtools_remote_message_unittest.cc
+++ b/chrome/browser/debugger/devtools_remote_message_unittest.cc
@@ -1,18 +1,18 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 <string>
 
-#include "base/string_util.h"
+#include "base/string_number_conversions.h"
+#include "base/scoped_ptr.h"
 #include "chrome/browser/debugger/devtools_remote.h"
 #include "chrome/browser/debugger/devtools_remote_message.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 class DevToolsRemoteMessageTest : public testing::Test {
  public:
-  DevToolsRemoteMessageTest() : testing::Test() {
-  }
+  DevToolsRemoteMessageTest() : testing::Test() {}
 
  protected:
   virtual void SetUp() {
@@ -25,7 +25,7 @@ TEST_F(DevToolsRemoteMessageTest, ConstructInstanceManually) {
   std::string content = "{\"command\":\"ping\"}";
   headers[DevToolsRemoteMessageHeaders::kTool] = "DevToolsService";
   headers[DevToolsRemoteMessageHeaders::kContentLength] =
-      IntToString(content.size());
+      base::IntToString(content.size());
 
   DevToolsRemoteMessage message(headers, content);
   ASSERT_STREQ("DevToolsService",
@@ -41,11 +41,11 @@ TEST_F(DevToolsRemoteMessageTest, ConstructInstanceManually) {
 
 TEST_F(DevToolsRemoteMessageTest, ConstructWithBuilder) {
   std::string content = "Responsecontent";
-  testing::internal::scoped_ptr<DevToolsRemoteMessage> message(
+  scoped_ptr<DevToolsRemoteMessage> message(
       DevToolsRemoteMessageBuilder::instance().Create(
           "V8Debugger",  // tool
-          "2",  // destination
-          content));  // content
+          "2",           // destination
+          content));     // content
 
   ASSERT_EQ(static_cast<DevToolsRemoteMessage::HeaderMap::size_type>(3),
             message->headers().size());
diff --git a/chrome/browser/debugger/devtools_remote_service.cc b/chrome/browser/debugger/devtools_remote_service.cc
index 3f786af9..d67174c 100644
--- a/chrome/browser/debugger/devtools_remote_service.cc
+++ b/chrome/browser/debugger/devtools_remote_service.cc
@@ -16,14 +16,17 @@
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/common/devtools_messages.h"
 
-const std::string DevToolsRemoteServiceCommand::kPing = "ping";
-const std::string DevToolsRemoteServiceCommand::kVersion = "version";
-const std::string DevToolsRemoteServiceCommand::kListTabs = "list_tabs";
+const char DevToolsRemoteServiceCommand::kPing[] = "ping";
+const char DevToolsRemoteServiceCommand::kVersion[] = "version";
+const char DevToolsRemoteServiceCommand::kListTabs[] = "list_tabs";
 
-const std::wstring DevToolsRemoteService::kCommandWide = L"command";
-const std::wstring DevToolsRemoteService::kDataWide = L"data";
-const std::wstring DevToolsRemoteService::kResultWide = L"result";
-const std::string DevToolsRemoteService::kToolName = "DevToolsService";
+const char DevToolsRemoteService::kToolName[] = "DevToolsService";
+
+namespace {
+const char kCommandKey[] = "command";
+const char kDataKey[] = "data";
+const char kResultKey[] = "result";
+}  // namespace
 
 DevToolsRemoteService::DevToolsRemoteService(DevToolsProtocolHandler* delegate)
     : delegate_(delegate) {}
@@ -41,7 +44,7 @@ void DevToolsRemoteService::HandleMessage(
   DictionaryValue* json;
   if (request->IsType(Value::TYPE_DICTIONARY)) {
     json = static_cast<DictionaryValue*>(request.get());
-    if (!json->HasKey(kCommandWide)) {
+    if (!json->HasKey(kCommandKey)) {
       NOTREACHED();  // Broken protocol - no "command" specified
       return;
     }
@@ -59,15 +62,15 @@ void DevToolsRemoteService::ProcessJson(DictionaryValue* json,
   std::string command;
   DictionaryValue response;
 
-  json->GetString(kCommandWide, &command);
-  response.SetString(kCommandWide, command);
+  json->GetString(kCommandKey, &command);
+  response.SetString(kCommandKey, command);
 
   if (command == DevToolsRemoteServiceCommand::kPing) {
-    response.SetInteger(kResultWide, Result::kOk);
-    response.SetString(kDataWide, kOkResponse);
+    response.SetInteger(kResultKey, Result::kOk);
+    response.SetString(kDataKey, kOkResponse);
   } else if (command == DevToolsRemoteServiceCommand::kVersion) {
-    response.SetInteger(kResultWide, Result::kOk);
-    response.SetString(kDataWide, kVersion);
+    response.SetInteger(kResultKey, Result::kOk);
+    response.SetString(kDataKey, kVersion);
   } else if (command == DevToolsRemoteServiceCommand::kListTabs) {
     ListValue* data = new ListValue();
     const InspectableTabProxy::ControllersMap& navcon_map =
@@ -86,12 +89,12 @@ void DevToolsRemoteService::ProcessJson(DictionaryValue* json,
         data->Append(tab);
       }
     }
-    response.SetInteger(kResultWide, Result::kOk);
-    response.Set(kDataWide, data);
+    response.SetInteger(kResultKey, Result::kOk);
+    response.Set(kDataKey, data);
   } else {
     // Unknown protocol command.
     NOTREACHED();
-    response.SetInteger(kResultWide, Result::kUnknownCommand);
+    response.SetInteger(kResultKey, Result::kUnknownCommand);
   }
   std::string response_json;
   base::JSONWriter::Write(&response, false, &response_json);
diff --git a/chrome/browser/debugger/devtools_remote_service.h b/chrome/browser/debugger/devtools_remote_service.h
index 68518ef..bd813bd 100644
--- a/chrome/browser/debugger/devtools_remote_service.h
+++ b/chrome/browser/debugger/devtools_remote_service.h
@@ -1,11 +1,10 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_SERVICE_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_REMOTE_SERVICE_H_
-
-#include <string>
+#pragma once
 
 #include "base/basictypes.h"
 #include "chrome/browser/debugger/devtools_remote.h"
@@ -17,9 +16,9 @@ class Value;
 
 // Contains constants for DevToolsRemoteService tool protocol commands.
 struct DevToolsRemoteServiceCommand {
-  static const std::string kPing;
-  static const std::string kVersion;
-  static const std::string kListTabs;
+  static const char kPing[];
+  static const char kVersion[];
+  static const char kListTabs[];
 };
 
 // Handles Chrome remote debugger protocol service commands.
@@ -31,7 +30,7 @@ class DevToolsRemoteService : public DevToolsRemoteListener {
   virtual void HandleMessage(const DevToolsRemoteMessage& message);
   virtual void OnConnectionLost() {}
 
-  static const std::string kToolName;
+  static const char kToolName[];
 
  private:
   // Operation result returned in the "result" field.
@@ -41,9 +40,6 @@ class DevToolsRemoteService : public DevToolsRemoteListener {
   };
   virtual ~DevToolsRemoteService();
   void ProcessJson(DictionaryValue* json, const DevToolsRemoteMessage& message);
-  static const std::wstring kCommandWide;
-  static const std::wstring kDataWide;
-  static const std::wstring kResultWide;
   DevToolsProtocolHandler* delegate_;
   DISALLOW_COPY_AND_ASSIGN(DevToolsRemoteService);
 };
diff --git a/chrome/browser/debugger/devtools_sanity_unittest.cc b/chrome/browser/debugger/devtools_sanity_unittest.cc
index 346c545..dbaa4e2 100644
--- a/chrome/browser/debugger/devtools_sanity_unittest.cc
+++ b/chrome/browser/debugger/devtools_sanity_unittest.cc
@@ -1,8 +1,11 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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/command_line.h"
+#include "base/path_service.h"
+#include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/debugger/devtools_manager.h"
@@ -18,6 +21,7 @@
 #include "chrome/common/notification_service.h"
 #include "chrome/test/in_process_browser_test.h"
 #include "chrome/test/ui_test_utils.h"
+#include "net/test/test_server.h"
 
 namespace {
 
@@ -47,11 +51,8 @@ const int kActionDelayMs = 500;
 
 const char kConsoleTestPage[] = "files/devtools/console_test_page.html";
 const char kDebuggerTestPage[] = "files/devtools/debugger_test_page.html";
-const char kEvalTestPage[] = "files/devtools/eval_test_page.html";
 const char kJsPage[] = "files/devtools/js_page.html";
 const char kHeapProfilerPage[] = "files/devtools/heap_profiler.html";
-const char kPauseOnExceptionTestPage[] =
-    "files/devtools/pause_on_exception.html";
 const char kPauseWhenLoadingDevTools[] =
     "files/devtools/pause_when_loading_devtools.html";
 const char kPauseWhenScriptIsRunning[] =
@@ -59,14 +60,6 @@ const char kPauseWhenScriptIsRunning[] =
 const char kResourceContentLengthTestPage[] = "files/devtools/image.html";
 const char kResourceTestPage[] = "files/devtools/resource_test_page.html";
 const char kSimplePage[] = "files/devtools/simple_page.html";
-const char kSyntaxErrorTestPage[] =
-    "files/devtools/script_syntax_error.html";
-const char kDebuggerStepTestPage[] =
-    "files/devtools/debugger_step.html";
-const char kDebuggerClosurePage[] =
-    "files/devtools/debugger_closure.html";
-const char kDebuggerIntrinsicPropertiesPage[] =
-    "files/devtools/debugger_intrinsic_properties.html";
 const char kCompletionOnPause[] =
     "files/devtools/completion_on_pause.html";
 const char kPageWithContentScript[] =
@@ -112,8 +105,8 @@ class DevToolsSanityTest : public InProcessBrowserTest {
   }
 
   void OpenDevToolsWindow(const std::string& test_page) {
-    HTTPTestServer* server = StartHTTPServer();
-    GURL url = server->TestServerPage(test_page);
+    ASSERT_TRUE(test_server()->Start());
+    GURL url = test_server()->GetURL(test_page);
     ui_test_utils::NavigateToURL(browser(), url);
 
     inspected_rvh_ = GetInspectedTab()->render_view_host();
@@ -261,21 +254,6 @@ class DevToolsExtensionDebugTest : public DevToolsSanityTest,
   FilePath test_extensions_dir_;
 };
 
-// WebInspector opens.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestHostIsPresent) {
-  RunTest("testHostIsPresent", kSimplePage);
-}
-
-// Tests elements panel basics.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestElementsTreeRoot) {
-  RunTest("testElementsTreeRoot", kSimplePage);
-}
-
-// Tests main resource load.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestMainResource) {
-  RunTest("testMainResource", kSimplePage);
-}
-
 // Tests resources panel enabling.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestEnableResourcesTab) {
   RunTest("testEnableResourcesTab", kSimplePage);
@@ -345,16 +323,6 @@ IN_PROC_BROWSER_TEST_F(DevToolsSanityTest,
   RunTest("testNoScriptDuplicatesOnPanelSwitch", kDebuggerTestPage);
 }
 
-// Tests set breakpoint.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestSetBreakpoint) {
-  RunTest("testSetBreakpoint", kDebuggerTestPage);
-}
-
-// Tests pause on exception.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPauseOnException) {
-  RunTest("testPauseOnException", kPauseOnExceptionTestPage);
-}
-
 // Tests that debugger works correctly if pause event occurs when DevTools
 // frontend is being loaded.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPauseWhenLoadingDevTools) {
@@ -367,79 +335,13 @@ IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestPauseWhenScriptIsRunning) {
   RunTest("testPauseWhenScriptIsRunning", kPauseWhenScriptIsRunning);
 }
 
-// Tests eval on call frame.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestEvalOnCallFrame) {
-  RunTest("testEvalOnCallFrame", kDebuggerTestPage);
-}
-
-#if defined(OS_WIN) || defined(OS_LINUX)
-// Sometimes it times out.
-// See http://crbug.com/45080
-// See http://crbug.com/46299
-#define MAYBE_TestStepOver FLAKY_TestStepOver
-#else
-#define MAYBE_TestStepOver TestStepOver
-#endif
-// Tests step over functionality in the debugger.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestStepOver) {
-  RunTest("testStepOver", kDebuggerStepTestPage);
-}
-
-#if defined(OS_WIN) || defined(OS_LINUX)
-// Sometimes it times out.
-// See http://crbug.com/45080
-// See http://crbug.com/46299
-#define MAYBE_TestStepOut FLAKY_TestStepOut
-#elif defined(OS_CHROMEOS)
-// See http://crbug.com/43479
-#define MAYBE_TestStepOut FLAKY_TestStepOut
-#else
-#define MAYBE_TestStepOut TestStepOut
-#endif
-// Tests step out functionality in the debugger.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestStepOut) {
-  RunTest("testStepOut", kDebuggerStepTestPage);
-}
-
-#if defined(OS_WIN) || defined(OS_LINUX)
-// Sometimes it times out.
-// See http://crbug.com/45080
-// See http://crbug.com/46299
-#define MAYBE_TestStepIn FLAKY_TestStepIn
-#elif defined(OS_CHROMEOS)
-// See http://crbug.com/43479
-#define MAYBE_TestStepIn FLAKY_TestStepIn
+// Fails after WebKit roll 66724:66804, http://crbug.com/54592
+#if defined(OS_LINUX) || defined(OS_WIN)
+#define MAYBE_TestCompletionOnPause FAILS_TestCompletionOnPause
 #else
-#define MAYBE_TestStepIn TestStepIn
-#endif
-// Disable TestStepIn completely while test expectations are not updated
-// in Webkit.  See http://crbug.com/46235
-#undef MAYBE_TestStepIn
-#define MAYBE_TestStepIn DISABLED_TestStepIn
-
-// Tests step in functionality in the debugger.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestStepIn) {
-  RunTest("testStepIn", kDebuggerStepTestPage);
-}
-
-// Tests that scope can be expanded and contains expected variables.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestExpandScope) {
-  RunTest("testExpandScope", kDebuggerClosurePage);
-}
-
-// Tests that intrinsic properties(__proto__, prototype, constructor) are
-// present.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDebugIntrinsicProperties) {
-  RunTest("testDebugIntrinsicProperties", kDebuggerIntrinsicPropertiesPage);
-}
-
-// Tests that execution continues automatically when there is a syntax error in
-// script and DevTools are open.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestAutoContinueOnSyntaxError) {
-  RunTest("testAutoContinueOnSyntaxError", kSyntaxErrorTestPage);
-}
-
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestCompletionOnPause) {
+#define MAYBE_TestCompletionOnPause TestCompletionOnPause
+#endif  // defined(OS_LINUX) || defined(OS_WIN)
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, MAYBE_TestCompletionOnPause) {
   RunTest("testCompletionOnPause", kCompletionOnPause);
 }
 
@@ -448,28 +350,4 @@ IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, DISABLED_TestPauseInEval) {
   RunTest("testPauseInEval", kDebuggerTestPage);
 }
 
-// Tests console eval.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestConsoleEval) {
-  RunTest("testConsoleEval", kEvalTestPage);
-}
-
-// Tests console log.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestConsoleLog) {
-  RunTest("testConsoleLog", kConsoleTestPage);
-}
-
-// Tests eval global values.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestEvalGlobal) {
-  RunTest("testEvalGlobal", kEvalTestPage);
-}
-
-// Test that Storage panel can be shown.
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestShowStoragePanel) {
-  RunTest("testShowStoragePanel", kDebuggerTestPage);
-}
-
-IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestMessageLoopReentrant) {
-  RunTest("testMessageLoopReentrant", kDebuggerTestPage);
-}
-
 }  // namespace
diff --git a/chrome/browser/debugger/devtools_toggle_action.h b/chrome/browser/debugger/devtools_toggle_action.h
index a8c4c53..33b0321 100644
--- a/chrome/browser/debugger/devtools_toggle_action.h
+++ b/chrome/browser/debugger/devtools_toggle_action.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEVTOOLS_TOGGLE_ACTION_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_TOGGLE_ACTION_H_
+#pragma once
 
 enum DevToolsToggleAction {
   DEVTOOLS_TOGGLE_ACTION_NONE,
diff --git a/chrome/browser/debugger/devtools_window.cc b/chrome/browser/debugger/devtools_window.cc
index fc74431..a185444 100644
--- a/chrome/browser/debugger/devtools_window.cc
+++ b/chrome/browser/debugger/devtools_window.cc
@@ -1,17 +1,22 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 "app/l10n_util.h"
 #include "base/command_line.h"
+#include "base/json/json_writer.h"
+#include "base/string_number_conversions.h"
+#include "base/utf_string_conversions.h"
+#include "base/values.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/browser_theme_provider.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_window.h"
-#include "chrome/browser/pref_service.h"
+#include "chrome/browser/extensions/extensions_service.h"
+#include "chrome/browser/in_process_webkit/session_storage_namespace.h"
+#include "chrome/browser/load_notification_details.h"
+#include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
@@ -19,6 +24,7 @@
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
+#include "chrome/browser/themes/browser_theme_provider.h"
 #include "chrome/common/bindings_policy.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
@@ -26,7 +32,7 @@
 #include "chrome/common/url_constants.h"
 #include "grit/generated_resources.h"
 
-const std::wstring DevToolsWindow::kDevToolsApp = L"DevToolsApp";
+const char DevToolsWindow::kDevToolsApp[] = "DevToolsApp";
 
 // static
 TabContents* DevToolsWindow::GetDevToolsContents(TabContents* inspected_tab) {
@@ -59,7 +65,7 @@ DevToolsWindow::DevToolsWindow(Profile* profile,
       is_loaded_(false),
       action_on_load_(DEVTOOLS_TOGGLE_ACTION_NONE) {
   // Create TabContents with devtools.
-  tab_contents_ = new TabContents(profile, NULL, MSG_ROUTING_NONE, NULL);
+  tab_contents_ = new TabContents(profile, NULL, MSG_ROUTING_NONE, NULL, NULL);
   tab_contents_->render_view_host()->AllowBindings(BindingsPolicy::DOM_UI);
   tab_contents_->controller().LoadURL(
       GetDevToolsUrl(), GURL(), PageTransition::START_PAGE);
@@ -133,13 +139,14 @@ void DevToolsWindow::Show(DevToolsToggleAction action) {
     }
   }
 
-  if (!browser_)
-    CreateDevToolsBrowser();
-
   // Avoid consecutive window switching if the devtools window has been opened
   // and the Inspect Element shortcut is pressed in the inspected tab.
   bool should_show_window =
       !browser_ || action != DEVTOOLS_TOGGLE_ACTION_INSPECT;
+
+  if (!browser_)
+    CreateDevToolsBrowser();
+
   if (should_show_window)
     browser_->window()->Show();
   SetAttachedWindow();
@@ -194,9 +201,9 @@ RenderViewHost* DevToolsWindow::GetRenderViewHost() {
 
 void DevToolsWindow::CreateDevToolsBrowser() {
   // TODO(pfeldman): Make browser's getter for this key static.
-  std::wstring wp_key = L"";
+  std::string wp_key;
   wp_key.append(prefs::kBrowserWindowPlacement);
-  wp_key.append(L"_");
+  wp_key.append("_");
   wp_key.append(kDevToolsApp);
 
   PrefService* prefs = g_browser_process->local_state();
@@ -207,12 +214,12 @@ void DevToolsWindow::CreateDevToolsBrowser() {
   const DictionaryValue* wp_pref = prefs->GetDictionary(wp_key.c_str());
   if (!wp_pref) {
     DictionaryValue* defaults = prefs->GetMutableDictionary(wp_key.c_str());
-    defaults->SetInteger(L"left", 100);
-    defaults->SetInteger(L"top", 100);
-    defaults->SetInteger(L"right", 740);
-    defaults->SetInteger(L"bottom", 740);
-    defaults->SetBoolean(L"maximized", false);
-    defaults->SetBoolean(L"always_on_top", false);
+    defaults->SetInteger("left", 100);
+    defaults->SetInteger("top", 100);
+    defaults->SetInteger("right", 740);
+    defaults->SetInteger("bottom", 740);
+    defaults->SetBoolean("maximized", false);
+    defaults->SetBoolean("always_on_top", false);
   }
 
   browser_ = Browser::CreateForDevTools(profile_);
@@ -242,14 +249,43 @@ void DevToolsWindow::SetAttachedWindow() {
                          L"WebInspector.setAttachedWindow(false);");
 }
 
+
+void DevToolsWindow::AddDevToolsExtensionsToClient() {
+  ListValue results;
+  const ExtensionsService* extension_service = tab_contents_->profile()->
+      GetOriginalProfile()->GetExtensionsService();
+  const ExtensionList* extensions = extension_service->extensions();
+
+  for (ExtensionList::const_iterator extension = extensions->begin();
+       extension != extensions->end(); ++extension) {
+    if ((*extension)->devtools_url().is_empty())
+      continue;
+    DictionaryValue* extension_info = new DictionaryValue();
+    extension_info->Set("startPage",
+        new StringValue((*extension)->devtools_url().spec()));
+    results.Append(extension_info);
+  }
+  CallClientFunction(L"WebInspector.addExtensions", results);
+}
+
+void DevToolsWindow::CallClientFunction(const std::wstring& function_name,
+                                         const Value& arg) {
+  std::string json;
+  base::JSONWriter::Write(&arg, false, &json);
+  std::wstring javascript = function_name + L"(" + UTF8ToWide(json) + L");";
+  tab_contents_->render_view_host()->
+      ExecuteJavascriptInWebFrame(L"", javascript);
+}
+
 void DevToolsWindow::Observe(NotificationType type,
                              const NotificationSource& source,
                              const NotificationDetails& details) {
-  if (type == NotificationType::LOAD_STOP) {
+  if (type == NotificationType::LOAD_STOP && !is_loaded_) {
     SetAttachedWindow();
     is_loaded_ = true;
     UpdateTheme();
     DoAction();
+    AddDevToolsExtensionsToClient();
   } else if (type == NotificationType::TAB_CLOSING) {
     if (Source<NavigationController>(source).ptr() ==
             &tab_contents_->controller()) {
@@ -296,7 +332,7 @@ std::string SkColorToRGBAString(SkColor color) {
   // locale specific formatters (e.g., use , instead of . in German).
   return StringPrintf("rgba(%d,%d,%d,%s)", SkColorGetR(color),
       SkColorGetG(color), SkColorGetB(color),
-      DoubleToString(SkColorGetA(color) / 255.0).c_str());
+      base::DoubleToString(SkColorGetA(color) / 255.0).c_str());
 }
 
 GURL DevToolsWindow::GetDevToolsUrl() {
diff --git a/chrome/browser/debugger/devtools_window.h b/chrome/browser/debugger/devtools_window.h
index 0bdcd67..89914a6 100644
--- a/chrome/browser/debugger/devtools_window.h
+++ b/chrome/browser/debugger/devtools_window.h
@@ -1,17 +1,18 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 CHROME_BROWSER_DEBUGGER_DEVTOOLS_WINDOW_H_
 #define CHROME_BROWSER_DEBUGGER_DEVTOOLS_WINDOW_H_
+#pragma once
 
 #include <string>
 
 #include "base/basictypes.h"
-#include "base/scoped_ptr.h"
 #include "chrome/browser/debugger/devtools_client_host.h"
 #include "chrome/browser/debugger/devtools_toggle_action.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
+#include "chrome/common/notification_observer.h"
 #include "chrome/common/notification_registrar.h"
 #include "chrome/common/notification_service.h"
 
@@ -24,13 +25,14 @@ class BrowserWindow;
 class Profile;
 class RenderViewHost;
 class TabContents;
+class Value;
 
 class DevToolsWindow
     : public DevToolsClientHost,
       public NotificationObserver,
       public TabContentsDelegate {
  public:
-  static const std::wstring kDevToolsApp;
+  static const char kDevToolsApp[];
   static TabContents* GetDevToolsContents(TabContents* inspected_tab);
 
   DevToolsWindow(Profile* profile, RenderViewHost* inspected_rvh, bool docked);
@@ -64,7 +66,9 @@ class DevToolsWindow
   void DoAction();
   GURL GetDevToolsUrl();
   void UpdateTheme();
-
+  void AddDevToolsExtensionsToClient();
+  void CallClientFunction(const std::wstring& function_name,
+                          const Value& arg);
   // Overridden from TabContentsDelegate.
   virtual void OpenURLFromTab(TabContents* source,
                               const GURL& url,
@@ -79,10 +83,10 @@ class DevToolsWindow
                               const gfx::Rect& initial_pos,
                               bool user_gesture) {}
   virtual void ActivateContents(TabContents* contents) {}
+  virtual void DeactivateContents(TabContents* contents) {}
   virtual void LoadingStateChanged(TabContents* source) {}
   virtual void CloseContents(TabContents* source) {}
   virtual void MoveContents(TabContents* source, const gfx::Rect& pos) {}
-  virtual bool IsPopup(TabContents* source) { return false; }
   virtual bool CanReloadContents(TabContents* source) const { return false; }
   virtual void URLStarredChanged(TabContents* source, bool starred) {}
   virtual void UpdateTargetURL(TabContents* source, const GURL& url) {}
diff --git a/chrome/browser/debugger/extension_ports_remote_service.cc b/chrome/browser/debugger/extension_ports_remote_service.cc
index d2a05ea..29cc11f 100644
--- a/chrome/browser/debugger/extension_ports_remote_service.cc
+++ b/chrome/browser/debugger/extension_ports_remote_service.cc
@@ -12,7 +12,7 @@
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
-#include "base/string_util.h"
+#include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/debugger/devtools_manager.h"
@@ -25,6 +25,7 @@
 #include "chrome/common/devtools_messages.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/common/render_messages_params.h"
 
 namespace {
 
@@ -74,38 +75,38 @@ namespace {
 // "data" field in this case.
 
 // Commands:
-static const std::string kConnect = "connect";
-static const std::string kDisconnect = "disconnect";
-static const std::string kPostMessage = "postMessage";
+const char kConnect[] = "connect";
+const char kDisconnect[] = "disconnect";
+const char kPostMessage[] = "postMessage";
 // Events:
-static const std::string kOnMessage = "onMessage";
-static const std::string kOnDisconnect = "onDisconnect";
+const char kOnMessage[] = "onMessage";
+const char kOnDisconnect[] = "onDisconnect";
 
 // Constants for the JSON message fields.
 // The type is wstring because the constant is used to get a
 // DictionaryValue field (which requires a wide string).
 
 // Mandatory.
-static const std::wstring kCommandWide = L"command";
+const char kCommandKey[] = "command";
 
 // Always present in messages sent to the external client.
-static const std::wstring kResultWide = L"result";
+const char kResultKey[] = "result";
 
 // Field for command-specific parameters. Not strictly necessary, but
 // makes it more similar to the remote debugger protocol, which should
 // allow easier reuse of client code.
-static const std::wstring kDataWide = L"data";
+const char kDataKey[] = "data";
 
 // Fields within the "data" dictionary:
 
 // Required for "connect":
-static const std::wstring kExtensionIdWide = L"extensionId";
+const char kExtensionIdKey[] = "extensionId";
 // Optional in "connect":
-static const std::wstring kChannelNameWide = L"channelName";
-static const std::wstring kTabIdWide = L"tabId";
+const char kChannelNameKey[] = "channelName";
+const char kTabIdKey[] = "tabId";
 
 // Present under "data" in replies to a successful "connect" .
-static const std::wstring kPortIdWide = L"portId";
+const char kPortIdKey[] = "portId";
 
 }  // namespace
 
@@ -137,10 +138,6 @@ ExtensionPortsRemoteService::ExtensionPortsRemoteService(
 }
 
 ExtensionPortsRemoteService::~ExtensionPortsRemoteService() {
-  NotificationService::current()->Notify(
-      NotificationType::EXTENSION_PORT_DELETED_DEBUG,
-      Source<IPC::Message::Sender>(this),
-      NotificationService::NoDetails());
 }
 
 void ExtensionPortsRemoteService::HandleMessage(
@@ -159,48 +156,48 @@ void ExtensionPortsRemoteService::HandleMessage(
     return;
   }
   content = static_cast<DictionaryValue*>(request.get());
-  if (!content->HasKey(kCommandWide)) {
+  if (!content->HasKey(kCommandKey)) {
     NOTREACHED();  // Broken protocol :(
     return;
   }
   std::string command;
   DictionaryValue response;
 
-  content->GetString(kCommandWide, &command);
-  response.SetString(kCommandWide, command);
+  content->GetString(kCommandKey, &command);
+  response.SetString(kCommandKey, command);
 
   if (!service_) {
     // This happens if we failed to obtain an ExtensionMessageService
     // during initialization.
     NOTREACHED();
-    response.SetInteger(kResultWide, RESULT_NO_SERVICE);
+    response.SetInteger(kResultKey, RESULT_NO_SERVICE);
     SendResponse(response, message.tool(), message.destination());
     return;
   }
 
   int destination = -1;
   if (destinationString.size() != 0)
-    StringToInt(destinationString, &destination);
+    base::StringToInt(destinationString, &destination);
 
   if (command == kConnect) {
     if (destination != -1)  // destination should be empty for this command.
-      response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+      response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     else
       ConnectCommand(content, &response);
   } else if (command == kDisconnect) {
     if (destination == -1)  // Destination required for this command.
-      response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+      response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     else
       DisconnectCommand(destination, &response);
   } else if (command == kPostMessage) {
     if (destination == -1)  // Destination required for this command.
-      response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+      response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
     else
       PostMessageCommand(destination, content, &response);
   } else {
     // Unknown command
     NOTREACHED();
-    response.SetInteger(kResultWide, RESULT_UNKNOWN_COMMAND);
+    response.SetInteger(kResultKey, RESULT_UNKNOWN_COMMAND);
   }
   SendResponse(response, message.tool(), message.destination());
 }
@@ -271,44 +268,44 @@ void ExtensionPortsRemoteService::OnExtensionMessage(
             << ", < " << message << ">";
   // Transpose the information into a JSON message for the external client.
   DictionaryValue content;
-  content.SetString(kCommandWide, kOnMessage);
-  content.SetInteger(kResultWide, RESULT_OK);
+  content.SetString(kCommandKey, kOnMessage);
+  content.SetInteger(kResultKey, RESULT_OK);
   // Turn the stringified message body back into JSON.
   Value* data = base::JSONReader::Read(message, false);
   if (!data) {
     NOTREACHED();
     return;
   }
-  content.Set(kDataWide, data);
-  SendResponse(content, kToolName, IntToString(port_id));
+  content.Set(kDataKey, data);
+  SendResponse(content, kToolName, base::IntToString(port_id));
 }
 
 void ExtensionPortsRemoteService::OnExtensionPortDisconnected(int port_id) {
   LOG(INFO) << "Disconnect event for port " << port_id;
   openPortIds_.erase(port_id);
   DictionaryValue content;
-  content.SetString(kCommandWide, kOnDisconnect);
-  content.SetInteger(kResultWide, RESULT_OK);
-  SendResponse(content, kToolName, IntToString(port_id));
+  content.SetString(kCommandKey, kOnDisconnect);
+  content.SetInteger(kResultKey, RESULT_OK);
+  SendResponse(content, kToolName, base::IntToString(port_id));
 }
 
 void ExtensionPortsRemoteService::ConnectCommand(
     DictionaryValue* content, DictionaryValue* response) {
   // Parse out the parameters.
   DictionaryValue* data;
-  if (!content->GetDictionary(kDataWide, &data)) {
-    response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
+  if (!content->GetDictionary(kDataKey, &data)) {
+    response->SetInteger(kResultKey, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string extension_id;
-  if (!data->GetString(kExtensionIdWide, &extension_id)) {
-    response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
+  if (!data->GetString(kExtensionIdKey, &extension_id)) {
+    response->SetInteger(kResultKey, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string channel_name = "";
-  data->GetString(kChannelNameWide, &channel_name);  // optional.
+  data->GetString(kChannelNameKey, &channel_name);  // optional.
   int tab_id = -1;
-  data->GetInteger(kTabIdWide, &tab_id);  // optional.
+  data->GetInteger(kTabIdKey, &tab_id);  // optional.
   int port_id;
   if (tab_id != -1) {  // Resolve the tab ID.
     const InspectableTabProxy::ControllersMap& navcon_map =
@@ -320,7 +317,7 @@ void ExtensionPortsRemoteService::ConnectCommand(
       tab_contents = it->second->tab_contents();
     if (!tab_contents) {
       LOG(INFO) << "tab not found: " << tab_id;
-      response->SetInteger(kResultWide, RESULT_TAB_NOT_FOUND);
+      response->SetInteger(kResultKey, RESULT_TAB_NOT_FOUND);
       return;
     }
     // Ask the ExtensionMessageService to open the channel.
@@ -341,16 +338,16 @@ void ExtensionPortsRemoteService::ConnectCommand(
   if (port_id == -1) {
     // Failure: probably the extension ID doesn't exist.
     LOG(INFO) << "Connect failed";
-    response->SetInteger(kResultWide, RESULT_CONNECT_FAILED);
+    response->SetInteger(kResultKey, RESULT_CONNECT_FAILED);
     return;
   }
   LOG(INFO) << "Connected: port " << port_id;
   openPortIds_.insert(port_id);
   // Reply to external client with the port ID assigned to the new channel.
   DictionaryValue* reply_data = new DictionaryValue();
-  reply_data->SetInteger(kPortIdWide, port_id);
-  response->Set(kDataWide, reply_data);
-  response->SetInteger(kResultWide, RESULT_OK);
+  reply_data->SetInteger(kPortIdKey, port_id);
+  response->Set(kDataKey, reply_data);
+  response->SetInteger(kResultKey, RESULT_OK);
 }
 
 void ExtensionPortsRemoteService::DisconnectCommand(
@@ -359,20 +356,20 @@ void ExtensionPortsRemoteService::DisconnectCommand(
   PortIdSet::iterator portEntry = openPortIds_.find(port_id);
   if (portEntry == openPortIds_.end()) {  // unknown port ID.
     LOG(INFO) << "unknown port: " << port_id;
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_PORT);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_PORT);
     return;
   }
   DCHECK(service_);
   service_->CloseChannel(port_id);
   openPortIds_.erase(portEntry);
-  response->SetInteger(kResultWide, RESULT_OK);
+  response->SetInteger(kResultKey, RESULT_OK);
 }
 
 void ExtensionPortsRemoteService::PostMessageCommand(
     int port_id, DictionaryValue* content, DictionaryValue* response) {
   Value* data;
-  if (!content->Get(kDataWide, &data)) {
-    response->SetInteger(kResultWide, RESULT_PARAMETER_ERROR);
+  if (!content->Get(kDataKey, &data)) {
+    response->SetInteger(kResultKey, RESULT_PARAMETER_ERROR);
     return;
   }
   std::string message;
@@ -383,12 +380,12 @@ void ExtensionPortsRemoteService::PostMessageCommand(
   PortIdSet::iterator portEntry = openPortIds_.find(port_id);
   if (portEntry == openPortIds_.end()) {  // Unknown port ID.
     LOG(INFO) << "unknown port: " << port_id;
-    response->SetInteger(kResultWide, RESULT_UNKNOWN_PORT);
+    response->SetInteger(kResultKey, RESULT_UNKNOWN_PORT);
     return;
   }
   // Post the message through the ExtensionMessageService.
   DCHECK(service_);
   service_->PostMessageFromRenderer(port_id, message);
   // Confirm to the external client that we sent its message.
-  response->SetInteger(kResultWide, RESULT_OK);
+  response->SetInteger(kResultKey, RESULT_OK);
 }
diff --git a/chrome/browser/debugger/extension_ports_remote_service.h b/chrome/browser/debugger/extension_ports_remote_service.h
index 6067f44..0b4c892 100644
--- a/chrome/browser/debugger/extension_ports_remote_service.h
+++ b/chrome/browser/debugger/extension_ports_remote_service.h
@@ -8,6 +8,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_EXTENSION_PORTS_REMOTE_SERVICE_H_
 #define CHROME_BROWSER_DEBUGGER_EXTENSION_PORTS_REMOTE_SERVICE_H_
+#pragma once
 
 #include <set>
 #include <string>
diff --git a/chrome/browser/debugger/inspectable_tab_proxy.cc b/chrome/browser/debugger/inspectable_tab_proxy.cc
index 2c5924b..96d4e3e 100644
--- a/chrome/browser/debugger/inspectable_tab_proxy.cc
+++ b/chrome/browser/debugger/inspectable_tab_proxy.cc
@@ -1,9 +1,10 @@
-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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 "chrome/browser/debugger/inspectable_tab_proxy.h"
 
+#include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
@@ -28,29 +29,16 @@ void DevToolsClientHostImpl::Close() {
 
 void DevToolsClientHostImpl::SendMessageToClient(
     const IPC::Message& msg) {
+  // TODO(prybin): Restore FrameNavigate.
   IPC_BEGIN_MESSAGE_MAP(DevToolsClientHostImpl, msg)
-    IPC_MESSAGE_HANDLER(DevToolsClientMsg_RpcMessage, OnRpcMessage);
+    IPC_MESSAGE_HANDLER(DevToolsClientMsg_DebuggerOutput, OnDebuggerOutput);
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }
 
-void DevToolsClientHostImpl::OnRpcMessage(const DevToolsMessageData& data) {
-  static const std::string kDebuggerAgentDelegate = "DebuggerAgentDelegate";
-  static const std::string kToolsAgentDelegate = "ToolsAgentDelegate";
-  static const std::string kDebuggerOutput = "debuggerOutput";
-  static const std::string kFrameNavigate = "frameNavigate";
 
-  if (data.class_name == kDebuggerAgentDelegate &&
-      data.method_name == kDebuggerOutput) {
-    DebuggerOutput(data.arguments[0]);
-  } else if (data.class_name == kToolsAgentDelegate &&
-             data.method_name == kFrameNavigate) {
-    FrameNavigate(data.arguments[0]);
-  }
-}
-
-void DevToolsClientHostImpl::DebuggerOutput(const std::string& msg) {
-  service_->DebuggerOutput(id_, msg);
+void DevToolsClientHostImpl::OnDebuggerOutput(const std::string& data) {
+  service_->DebuggerOutput(id_, data);
 }
 
 void DevToolsClientHostImpl::FrameNavigate(const std::string& url) {
@@ -98,7 +86,7 @@ DevToolsClientHost* InspectableTabProxy::NewClientHost(
 void InspectableTabProxy::OnRemoteDebuggerDetached() {
   while (id_to_client_host_map_.size() > 0) {
     IdToClientHostMap::iterator it = id_to_client_host_map_.begin();
-    it->second->debugger_remote_service()->DetachFromTab(IntToString(it->first),
-                                                         NULL);
+    it->second->debugger_remote_service()->DetachFromTab(
+        base::IntToString(it->first), NULL);
   }
 }
diff --git a/chrome/browser/debugger/inspectable_tab_proxy.h b/chrome/browser/debugger/inspectable_tab_proxy.h
index 67b5952..af08232 100644
--- a/chrome/browser/debugger/inspectable_tab_proxy.h
+++ b/chrome/browser/debugger/inspectable_tab_proxy.h
@@ -4,6 +4,7 @@
 
 #ifndef CHROME_BROWSER_DEBUGGER_INSPECTABLE_TAB_PROXY_H_
 #define CHROME_BROWSER_DEBUGGER_INSPECTABLE_TAB_PROXY_H_
+#pragma once
 
 #include <string>
 
@@ -82,8 +83,7 @@ class DevToolsClientHostImpl : public DevToolsClientHost {
 
  private:
   // Message handling routines
-  void OnRpcMessage(const DevToolsMessageData& data);
-  void DebuggerOutput(const std::string& msg);
+  void OnDebuggerOutput(const std::string& msg);
   void FrameNavigate(const std::string& url);
   void TabClosed();