DevTools: Nuke legacy debugger.

Review URL: http://codereview.chromium.org/146027

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

38 files changed, 17 insertions, 4269 deletions

diff --git a/chrome/browser/automation/automation_provider.cc b/chrome/browser/automation/automation_provider.cc
index bcfd7a5..5db7a8a 100755
--- a/chrome/browser/automation/automation_provider.cc
+++ b/chrome/browser/automation/automation_provider.cc
@@ -700,30 +700,6 @@ class DomOperationNotificationObserver : public NotificationObserver {
   AutomationProvider* automation_;
 };
 
-class DomInspectorNotificationObserver : public NotificationObserver {
- public:
-  explicit DomInspectorNotificationObserver(AutomationProvider* automation)
-      : automation_(automation) {
-    registrar_.Add(this, NotificationType::DOM_INSPECT_ELEMENT_RESPONSE,
-                   NotificationService::AllSources());
-  }
-
-  ~DomInspectorNotificationObserver() {
-  }
-
-  virtual void Observe(NotificationType type, const NotificationSource& source,
-      const NotificationDetails& details) {
-    if (NotificationType::DOM_INSPECT_ELEMENT_RESPONSE == type) {
-      Details<int> dom_inspect_details(details);
-      automation_->ReceivedInspectElementResponse(*(dom_inspect_details.ptr()));
-    }
-  }
-
- private:
-  NotificationRegistrar registrar_;
-  AutomationProvider* automation_;
-};
-
 #if defined(OS_WIN)
 // TODO(port): Enable when printing is ported.
 class DocumentPrintedNotificationObserver : public NotificationObserver {
@@ -814,7 +790,6 @@ AutomationProvider::AutomationProvider(Profile* profile)
       new AutomationAutocompleteEditTracker(this));
   new_tab_ui_load_observer_.reset(new NewTabUILoadObserver(this));
   dom_operation_observer_.reset(new DomOperationNotificationObserver(this));
-  dom_inspector_observer_.reset(new DomInspectorNotificationObserver(this));
 }
 
 AutomationProvider::~AutomationProvider() {
diff --git a/chrome/browser/browser.cc b/chrome/browser/browser.cc
index 141356a..5ce3891 100644
--- a/chrome/browser/browser.cc
+++ b/chrome/browser/browser.cc
@@ -18,7 +18,6 @@
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/character_encoding.h"
-#include "chrome/browser/debugger/debugger_host.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_manager.h"
@@ -74,7 +73,6 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_url_handler.h"
 #include "chrome/browser/cert_store.h"
-#include "chrome/browser/debugger/debugger_window.h"
 #include "chrome/browser/download/save_package.h"
 #include "chrome/browser/ssl/ssl_error_info.h"
 #include "chrome/browser/task_manager.h"
@@ -1075,26 +1073,6 @@ void Browser::OpenCreateShortcutsDialog() {
 #endif
 }
 
-void Browser::OpenDebuggerWindow() {
-#if defined(OS_WIN)
-#ifndef CHROME_DEBUGGER_DISABLED
-  UserMetrics::RecordAction(L"Debugger", profile_);
-  // Only one debugger instance can exist at a time right now.
-  // TODO(erikkay): need an alert, dialog, something
-  // or better yet, fix the one instance limitation
-  DebuggerHost* host = DebuggerWindow::GetAnyExistingDebugger();
-  if (host) {
-    host->ShowWindow();
-    return;
-  }
-  debugger_window_ = new DebuggerWindow();
-  debugger_window_->Show(GetSelectedTabContents());
-#endif  // CHROME_DEBUGGER_DISABLED
-#else
-  NOTIMPLEMENTED();
-#endif  // defined(OS_WIN)
-}
-
 void Browser::OpenJavaScriptConsole() {
   UserMetrics::RecordAction(L"ShowJSConsole", profile_);
   GetSelectedTabContents()->render_view_host()->
@@ -1358,7 +1336,6 @@ void Browser::ExecuteCommandWithDisposition(
     // Show various bits of UI
     case IDC_OPEN_FILE:             OpenFile();                    break;
     case IDC_CREATE_SHORTCUTS:      OpenCreateShortcutsDialog();   break;
-    case IDC_DEBUGGER:              OpenDebuggerWindow();          break;
     case IDC_JS_CONSOLE:            OpenJavaScriptConsole();       break;
     case IDC_TASK_MANAGER:          OpenTaskManager();             break;
     case IDC_SELECT_PROFILE:        OpenSelectProfileDialog();     break;
@@ -2115,14 +2092,6 @@ void Browser::InitCommandState() {
   // Show various bits of UI
   command_updater_.UpdateCommandEnabled(IDC_OPEN_FILE, true);
   command_updater_.UpdateCommandEnabled(IDC_CREATE_SHORTCUTS, false);
-#if defined(OS_WIN)
-  // Command line debugger conflicts with the new oop one.
-  bool in_proc_devtools = CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kDisableOutOfProcessDevTools);
-  command_updater_.UpdateCommandEnabled(IDC_DEBUGGER,
-      // The debugger doesn't work in single process mode.
-      in_proc_devtools && !RenderProcessHost::run_renderer_in_process());
-#endif
   command_updater_.UpdateCommandEnabled(IDC_JS_CONSOLE, true);
   command_updater_.UpdateCommandEnabled(IDC_TASK_MANAGER, true);
   command_updater_.UpdateCommandEnabled(IDC_SELECT_PROFILE, true);
diff --git a/chrome/browser/browser.h b/chrome/browser/browser.h
index bdaf9f9..b5d619f 100644
--- a/chrome/browser/browser.h
+++ b/chrome/browser/browser.h
@@ -353,7 +353,6 @@ class Browser : public TabStripModelDelegate,
   // Show various bits of UI
   void OpenFile();
   void OpenCreateShortcutsDialog();
-  void OpenDebuggerWindow();
   void OpenJavaScriptConsole();
   void OpenTaskManager();
   void OpenSelectProfileDialog();
@@ -752,9 +751,6 @@ class Browser : public TabStripModelDelegate,
   // non-NULL, it may or may not be visible.
   scoped_ptr<FindBarController> find_bar_controller_;
 
-  // Debugger Window, created lazily
-  scoped_refptr<DebuggerWindow> debugger_window_;
-
   // Dialog box used for opening and saving files.
   scoped_refptr<SelectFileDialog> select_file_dialog_;
 
diff --git a/chrome/browser/debugger/debugger.vsprops b/chrome/browser/debugger/debugger.vsprops
deleted file mode 100644
index 342fffc..0000000
--- a/chrome/browser/debugger/debugger.vsprops
+++ /dev/null
@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioPropertySheet
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="debugger"
-	InheritedPropertySheets="$(SolutionDir)..\build\common.vsprops;$(SolutionDir)..\breakpad\using_breakpad.vsprops;$(SolutionDir)..\third_party\libpng\using_libpng.vsprops;$(SolutionDir)..\skia\using_skia.vsprops;$(SolutionDir)..\third_party\zlib\using_zlib.vsprops;$(SolutionDir)..\tools\grit\build\using_generated_resources.vsprops;$(SolutionDir)..\third_party\icu38\build\using_icu.vsprops;$(SolutionDir)..\third_party\libxml\build\using_libxml.vsprops;$(SolutionDir)..\third_party\npapi\using_npapi.vsprops;$(SolutionDir)third_party\wtl\using_wtl.vsprops"
-	>
-	<Tool
-		Name="VCCLCompilerTool"
-		AdditionalIncludeDirectories="&quot;$(OutDir)\webkit&quot;;$(SolutionDir)\third_party\webkit\out"
-	/>
-	<Tool
-		Name="VCResourceCompilerTool"
-		AdditionalIncludeDirectories="$(IntDir)"
-	/>
-</VisualStudioPropertySheet>
diff --git a/chrome/browser/debugger/debugger_disabled.vcproj b/chrome/browser/debugger/debugger_disabled.vcproj
deleted file mode 100644
index 750ae30..0000000
--- a/chrome/browser/debugger/debugger_disabled.vcproj
+++ /dev/null
@@ -1,155 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioProject
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="debugger_disabled"
-	ProjectGUID="{369B9881-3F2C-464D-A96C-E281405DF8F6}"
-	RootNamespace="debugger_disabled"
-	Keyword="Win32Proj"
-	>
-	<Platforms>
-		<Platform
-			Name="Win32"
-		/>
-	</Platforms>
-	<ToolFiles>
-	</ToolFiles>
-	<Configurations>
-		<Configuration
-			Name="Debug|Win32"
-			ConfigurationType="4"
-			InheritedPropertySheets="$(SolutionDir)..\build\debug.vsprops;.\debugger_disabled.vsprops"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-		<Configuration
-			Name="Release|Win32"
-			ConfigurationType="4"
-			InheritedPropertySheets="$(SolutionDir)..\build\release.vsprops;.\debugger_disabled.vsprops"
-			>
-			<Tool
-				Name="VCPreBuildEventTool"
-			/>
-			<Tool
-				Name="VCCustomBuildTool"
-			/>
-			<Tool
-				Name="VCXMLDataGeneratorTool"
-			/>
-			<Tool
-				Name="VCWebServiceProxyGeneratorTool"
-			/>
-			<Tool
-				Name="VCMIDLTool"
-			/>
-			<Tool
-				Name="VCCLCompilerTool"
-			/>
-			<Tool
-				Name="VCManagedResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCResourceCompilerTool"
-			/>
-			<Tool
-				Name="VCPreLinkEventTool"
-			/>
-			<Tool
-				Name="VCLibrarianTool"
-			/>
-			<Tool
-				Name="VCALinkTool"
-			/>
-			<Tool
-				Name="VCXDCMakeTool"
-			/>
-			<Tool
-				Name="VCBscMakeTool"
-			/>
-			<Tool
-				Name="VCFxCopTool"
-			/>
-			<Tool
-				Name="VCPostBuildEventTool"
-			/>
-		</Configuration>
-	</Configurations>
-	<References>
-	</References>
-	<Files>
-		<File
-			RelativePath=".\debugger_contents.cc"
-			>
-		</File>
-		<File
-			RelativePath=".\debugger_contents.h"
-			>
-		</File>
-		<File
-			RelativePath=".\debugger_shell.h"
-			>
-		</File>
-		<File
-			RelativePath=".\debugger_window.cc"
-			>
-		</File>
-		<File
-			RelativePath=".\debugger_window.h"
-			>
-		</File>
-		<File
-			RelativePath=".\debugger_wrapper.cc"
-			>
-		</File>
-		<File
-			RelativePath=".\debugger_wrapper.h"
-			>
-		</File>
-	</Files>
-	<Globals>
-	</Globals>
-</VisualStudioProject>
diff --git a/chrome/browser/debugger/debugger_disabled.vsprops b/chrome/browser/debugger/debugger_disabled.vsprops
deleted file mode 100644
index 2d955b4..0000000
--- a/chrome/browser/debugger/debugger_disabled.vsprops
+++ /dev/null
@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="Windows-1252"?>
-<VisualStudioPropertySheet
-	ProjectType="Visual C++"
-	Version="8.00"
-	Name="debugger_disabled"
-	InheritedPropertySheets="$(SolutionDir)..\build\common.vsprops;$(SolutionDir)..\breakpad\using_breakpad.vsprops;$(SolutionDir)..\third_party\libpng\using_libpng.vsprops;$(SolutionDir)..\skia\using_skia.vsprops;$(SolutionDir)..\third_party\zlib\using_zlib.vsprops;$(SolutionDir)..\tools\grit\build\using_generated_resources.vsprops;$(SolutionDir)..\third_party\icu38\build\using_icu.vsprops;$(SolutionDir)..\third_party\libxml\build\using_libxml.vsprops;$(SolutionDir)..\third_party\npapi\using_npapi.vsprops;$(SolutionDir)\tools\build\win\debugger_disabled.vsprops;$(SolutionDir)third_party\wtl\using_wtl.vsprops"
-	>
-	<Tool
-		Name="VCCLCompilerTool"
-		AdditionalIncludeDirectories="&quot;$(OutDir)\webkit&quot;;$(SolutionDir)\third_party\webkit\out"
-	/>
-</VisualStudioPropertySheet>
diff --git a/chrome/browser/debugger/debugger_host_impl.cpp b/chrome/browser/debugger/debugger_host_impl.cpp
deleted file mode 100644
index e8b586a..0000000
--- a/chrome/browser/debugger/debugger_host_impl.cpp
+++ /dev/null
@@ -1,171 +0,0 @@
-// Copyright (c) 2006-2008 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/debugger_host_impl.h"
-
-#include "base/json_reader.h"
-#include "base/string_util.h"
-#include "base/values.h"
-#include "chrome/browser/debugger/debugger_io.h"
-#include "chrome/browser/debugger/debugger_wrapper.h"
-#include "chrome/browser/renderer_host/render_view_host.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
-#include "chrome/common/notification_registrar.h"
-#include "chrome/common/notification_service.h"
-
-class TabContentsReference : public NotificationObserver {
- public:
-  TabContentsReference(TabContents *c) : navigation_controller_(NULL) {
-    navigation_controller_ = &c->controller();
-    registrar_.Add(this, NotificationType::TAB_CLOSING,
-                   Source<NavigationController>(navigation_controller_));
-  }
-
-  virtual ~TabContentsReference() {
-  }
-
-  // NotificationObserver impl
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details) {
-    registrar_.RemoveAll();
-    navigation_controller_ = NULL;
-  }
-
-  TabContents* GetTabContents() {
-    return navigation_controller_ ?
-        navigation_controller_->tab_contents() : NULL;
-  }
-
- private:
-  NotificationRegistrar registrar_;
-  NavigationController* navigation_controller_;
-
-  DISALLOW_COPY_AND_ASSIGN(TabContentsReference);
-};
-
-
-DebuggerHostImpl::DebuggerHostImpl(DebuggerInputOutput* io)
-    : io_(io),
-      debugger_ready_(true) {
-}
-
-DebuggerHostImpl::~DebuggerHostImpl() {
-  io_->Stop();
-  io_ = NULL;
-}
-
-void DebuggerHostImpl::Start() {
-  io_->Start(this);
-}
-
-void DebuggerHostImpl::Debug(TabContents* tab) {
-  tab_reference_.reset(new TabContentsReference(tab));
-}
-
-void DebuggerHostImpl::DebugMessage(const std::wstring& msg) {
-
-  Value* msg_value = JSONReader::Read(WideToUTF8(msg), false);
-  if (!msg_value) {
-    msg_value = Value::CreateStringValue(L"Message parse error!");
-  }
-  ListValue* argv = new ListValue;
-  argv->Append(msg_value);
-  io_->CallFunctionInPage(L"response", argv);
-}
-
-void DebuggerHostImpl::OnDebugAttach() {
-  std::wstring title;
-  const TabContents* t = GetTabContentsBeingDebugged();
-  if (t) {
-    title = UTF16ToWideHack(t->GetTitle());
-  }
-
-  ListValue* argv = new ListValue;
-  argv->Append(Value::CreateStringValue(title));
-  io_->CallFunctionInPage(L"on_attach", argv);
-}
-
-void DebuggerHostImpl::OnDebugDisconnect() {
-  ListValue* argv = new ListValue;
-  io_->CallFunctionInPage(L"on_disconnect", argv);
-}
-
-void DebuggerHostImpl::DidDisconnect() {
-  // TODO(yurys): just send Detach from here?
-  ListValue* argv = new ListValue;
-  io_->CallFunctionInPage(L"exit", argv);
-}
-
-void DebuggerHostImpl::OnDebuggerHostMsg(const ListValue* args) {
-  if (args->GetSize() < 1) {
-    NOTREACHED();
-    return;
-  }
-  std::wstring methodName;
-  Value* value = NULL;
-  if (!args->Get(0, &value) || !value->GetAsString(&methodName)) {
-    NOTREACHED();
-    return;
-  }
-
-  const TabContents* t = GetTabContentsBeingDebugged();
-  if (t == NULL) {
-    NOTREACHED();
-    return;
-  }
-  RenderViewHost* host = t->render_view_host();
-
-  if (methodName == L"attach") {
-    host->DebugAttach();
-  } else if (methodName == L"detach") {
-    host->DebugDetach();
-  } else if (methodName == L"debugBreak") {
-    std::wstring force;
-    Value* value = NULL;
-    if (!args->Get(1, &value) || !value->GetAsString(&force)) {
-      NOTREACHED();
-      return;
-    }
-    host->DebugBreak(force == L"true");
-  } else if (methodName == L"sendToDebugger") {
-    std::wstring cmd;
-    Value* value = NULL;
-    if (!args->Get(1, &value) || !value->GetAsString(&cmd)) {
-      NOTREACHED();
-      return;
-    }
-    host->DebugCommand(cmd);
-
-  } else if (methodName == L"setDebuggerReady") {
-    std::wstring ready;
-    Value* value = NULL;
-    if (!args->Get(1, &value) || !value->GetAsString(&ready)) {
-      NOTREACHED();
-      return;
-    }
-    io_->SetDebuggerReady(ready == L"true");
-  } else if (methodName == L"setDebuggerBreak") {
-    std::wstring brk;
-    Value* value = NULL;
-    if (!args->Get(1, &value) || !value->GetAsString(&brk)) {
-      NOTREACHED();
-      return;
-    }
-    io_->SetDebuggerBreak(brk == L"true");
-  }
-}
-
-TabContents* DebuggerHostImpl::GetTabContentsBeingDebugged() const {
-  if (tab_reference_ != NULL) {
-    return tab_reference_->GetTabContents();
-  } else {
-    return NULL;
-  }
-}
-
-bool DebuggerHostImpl::ShowWindow() {
-  return io_->ShowWindow();
-}
-
diff --git a/chrome/browser/debugger/debugger_host_impl.h b/chrome/browser/debugger/debugger_host_impl.h
deleted file mode 100644
index 66204e3..0000000
--- a/chrome/browser/debugger/debugger_host_impl.h
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (c) 2006-2008 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_DEBUGGER_HOST_IMPL_H__
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_HOST_IMPL_H__
-
-#include "base/scoped_ptr.h"
-#include "chrome/browser/debugger/debugger_host.h"
-
-class DebuggerInputOutput;
-class TabContents;
-class TabContentsReference;
-
-class DebuggerHostImpl : public DebuggerHost {
- public:
-  DebuggerHostImpl(DebuggerInputOutput *io);
-  virtual ~DebuggerHostImpl();
-
-  virtual void Start();
-
-  // Start debugging the specified tab
-  virtual void Debug(TabContents* tab);
-  // A message from the V8 debugger in the renderer being debugged via
-  // RenderViewHost
-  virtual void DebugMessage(const std::wstring& msg);
-  // We've been successfully attached to a renderer.
-  virtual void OnDebugAttach();
-  // The renderer we're attached to is gone.
-  virtual void OnDebugDisconnect();
-
-  virtual void DidDisconnect();
-
-  // Handles messages from debugger UI.
-  virtual void OnDebuggerHostMsg(const ListValue* args);
-
-  virtual bool ShowWindow();
-
- private:
-  TabContents* GetTabContentsBeingDebugged() const;
-
-  scoped_refptr<DebuggerInputOutput> io_;
-  // reference to the tab being debugged by this instance
-  scoped_ptr<TabContentsReference> tab_reference_;
-  // If the debugger is ready to process another command or is busy.
-  bool debugger_ready_;
-
-  DISALLOW_COPY_AND_ASSIGN(DebuggerHostImpl);
-};
-
-#endif  // CHROME_BROWSER_DEBUGGER_DEBUGGER_HOST_IMPL_H__
diff --git a/chrome/browser/debugger/debugger_io.h b/chrome/browser/debugger/debugger_io.h
deleted file mode 100644
index 296acaa..0000000
--- a/chrome/browser/debugger/debugger_io.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright (c) 2006-2008 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_DEBUGGER_IO_H_
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_IO_H_
-
-#include <string>
-
-#include "base/basictypes.h"
-#include "base/ref_counted.h"
-
-class DebuggerHost;
-class ListValue;
-
-class DebuggerInputOutput
-    : public base::RefCountedThreadSafe<DebuggerInputOutput> {
-public:
-  DebuggerInputOutput() {}
-  virtual ~DebuggerInputOutput() {}
-
-  // Called when Debugger is ready to begin.
-  virtual void Start(DebuggerHost* debugger) { debugger_ = debugger; }
-
-  // Called when Debugger is shutting down
-  virtual void Stop() {}
-
-  // Outputs a string to the connection.
-  virtual void Output(const std::string& out) = 0;
-  virtual void Output(const std::wstring& out) = 0;
-  virtual void OutputLine(const std::string& out) = 0;
-  virtual void OutputLine(const std::wstring& out) = 0;
-  virtual void OutputPrompt(const std::string& prompt) = 0;
-  virtual void OutputPrompt(const std::wstring& prompt) = 0;
-
-  // called by debugger debugger - ready is false when a command has just been
-  // entered and true when a response to that command has been received
-  virtual void SetDebuggerReady(bool ready) {}
-  // called by debugger debugger - brk is false when the web page being debugged
-  // is running, and true when the page is stopped at a breakpoint
-  virtual void SetDebuggerBreak(bool brk) {}
-
-  // sends message to debugger UI page in order to invoke JS function in it
-  virtual void CallFunctionInPage(const std::wstring& name,
-                                  ListValue* argv) {}
-
-  // Shows the debugger UI and returns true if it has any.
-  virtual bool ShowWindow() { return false; }
-
-protected:
-  DebuggerHost* debugger_;
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(DebuggerInputOutput);
-};
-
-#endif // CHROME_BROWSER_DEBUGGER_DEBUGGER_IO_H_
diff --git a/chrome/browser/debugger/debugger_io_socket.cc b/chrome/browser/debugger/debugger_io_socket.cc
deleted file mode 100644
index 537907e..0000000
--- a/chrome/browser/debugger/debugger_io_socket.cc
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright (c) 2006-2008 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/debugger_io_socket.h"
-
-#include "base/string_util.h"
-#include "base/thread.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/debugger/debugger_shell.h"
-#include "net/base/telnet_server.h"
-#include "v8/include/v8.h"
-
-////////////////////////////////////////////////
-
-DebuggerInputOutputSocket::DebuggerInputOutputSocket(int port)
-    : server_(0), connection_(0), port_(port) {
-  ui_loop_ = MessageLoop::current();
-  io_loop_ = g_browser_process->io_thread()->message_loop();
-}
-
-void DebuggerInputOutputSocket::Start(DebuggerHost* debugger) {
-  DebuggerInputOutput::Start(debugger);
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &DebuggerInputOutputSocket::StartListening));
-}
-
-void DebuggerInputOutputSocket::StartListening() {
-  DCHECK(MessageLoop::current() == io_loop_);
-  server_ = TelnetServer::Listen("127.0.0.1", port_, this);
-}
-
-DebuggerInputOutputSocket::~DebuggerInputOutputSocket() {
-  // Stop() must be called prior to this being called
-  DCHECK(connection_.get() == NULL);
-  DCHECK(server_.get() == NULL);
-}
-
-void DebuggerInputOutputSocket::Stop() {
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &DebuggerInputOutputSocket::StopListening));
-}
-
-void DebuggerInputOutputSocket::StopListening() {
-  connection_ = NULL;
-  server_ = NULL;
-}
-
-void DebuggerInputOutputSocket::DidAccept(ListenSocket *server,
-                                 ListenSocket *connection) {
-  DCHECK(MessageLoop::current() == io_loop_);
-  if (connection_ == NULL) {
-    connection_ = connection;
-    connection_->AddRef();
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        debugger_, &DebuggerHost::DidConnect));
-  } else {
-    delete connection;
-  }
-}
-
-void DebuggerInputOutputSocket::Output(const std::wstring& out) {
-  OutputLater(out, false);
-}
-
-void DebuggerInputOutputSocket::OutputLine(const std::wstring& out) {
-  OutputLater(out, true);
-}
-
-void DebuggerInputOutputSocket::OutputPrompt(const std::wstring& prompt) {
-  Output(prompt);
-}
-
-void DebuggerInputOutputSocket::Output(const std::string& out) {
-  OutputLater(out, false);
-}
-
-void DebuggerInputOutputSocket::OutputLine(const std::string& out) {
-  OutputLater(out, true);
-}
-
-void DebuggerInputOutputSocket::OutputPrompt(const std::string& prompt) {
-  Output(prompt);
-}
-
-void DebuggerInputOutputSocket::OutputLater(const std::wstring& out, bool lf) {
-  std::string utf8 = WideToUTF8(out);
-  OutputLater(utf8, lf);
-}
-
-void DebuggerInputOutputSocket::OutputLater(const std::string& out, bool lf) {
-  io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-      this, &DebuggerInputOutputSocket::OutputToSocket, out, lf));
-}
-
-void DebuggerInputOutputSocket::OutputToSocket(const std::string& out,
-                                               bool lf) {
-  DCHECK(MessageLoop::current() == io_loop_);
-  if (connection_) {
-    if (out.length()) {
-      connection_->Send(out, lf);
-    }
-  } else {
-    logging::LogMessage("CONSOLE", 0).stream() << "V8 debugger: " << out;
-  }
-}
-
-void DebuggerInputOutputSocket::DidRead(ListenSocket *connection,
-                                     const std::string& data) {
-  DCHECK(MessageLoop::current() == io_loop_);
-  if (connection == connection_) {
-    const std::wstring wstr = UTF8ToWide(data);
-    ui_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        debugger_, &DebuggerHost::ProcessCommand, wstr));
-  } else {
-    // TODO(erikkay): assert?
-  }
-}
-
-void DebuggerInputOutputSocket::DidClose(ListenSocket *sock) {
-  DCHECK(MessageLoop::current() == io_loop_);
-  if (connection_ == sock) {
-    connection_ = NULL;
-    sock->Release();
-  } else {
-    // TODO(erikkay): assert?
-  }
-}
diff --git a/chrome/browser/debugger/debugger_io_socket.h b/chrome/browser/debugger/debugger_io_socket.h
deleted file mode 100644
index c78c861..0000000
--- a/chrome/browser/debugger/debugger_io_socket.h
+++ /dev/null
@@ -1,63 +0,0 @@
-// Copyright (c) 2006-2008 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_DEBUGGER_IO_SOCKET_H__
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_IO_SOCKET_H__
-
-#include "chrome/browser/debugger/debugger_io.h"
-#include "net/base/listen_socket.h"
-
-class DebuggerHost;
-class MessageLoop;
-
-// Interaction with the underlying Socket object MUST happen in the IO thread.
-// However, Debugger will call into this object from the main thread.  As a
-// result we wind up having helper methods that we call with InvokeLater into
-// the IO thread.
-
-class DebuggerInputOutputSocket : public DebuggerInputOutput,
-                                  public ListenSocket::ListenSocketDelegate {
-public:
-  DebuggerInputOutputSocket(int port);
-  virtual ~DebuggerInputOutputSocket();
-
-  // SocketDelegate - called in IO thread by Socket
-  virtual void DidAccept(ListenSocket* server, ListenSocket* connection);
-  virtual void DidRead(ListenSocket* connection, const std::string& data);
-  virtual void DidClose(ListenSocket* sock);
-
-  // Overrides - called from the main thread by Debugger
-  // these in turn call helper methods in the IO thread.
-  virtual void Output(const std::wstring& out);
-  virtual void OutputLine(const std::wstring& out);
-  virtual void OutputPrompt(const std::wstring& prompt);
-  virtual void Output(const std::string& out);
-  virtual void OutputLine(const std::string& out);
-  virtual void OutputPrompt(const std::string& prompt);
-  virtual void Start(DebuggerHost* debugger);
-  // Stop must be called prior to this object being released, so that cleanup
-  // can happen in the IO thread.
-  virtual void Stop();
-
-private:
-
-  // The following methods are called from the IO thread.
-
-  // Creates a TelnetServer listing on 127:0.0.1:port_
-  void StartListening();
-  void StopListening();
-  void OutputLater(const std::wstring& out, bool lf);
-  void OutputLater(const std::string& out, bool lf);
-  void OutputToSocket(const std::string& out, bool lf);
-
-  scoped_refptr<ListenSocket> server_;
-  scoped_refptr<ListenSocket> connection_;
-  MessageLoop* ui_loop_;
-  MessageLoop* io_loop_;
-  int port_;
-
-  DISALLOW_EVIL_CONSTRUCTORS(DebuggerInputOutputSocket);
-};
-
-#endif // CHROME_BROWSER_DEBUGGER_DEBUGGER_IO_SOCKET_H__
diff --git a/chrome/browser/debugger/debugger_node.cc b/chrome/browser/debugger/debugger_node.cc
deleted file mode 100644
index aef58a7..0000000
--- a/chrome/browser/debugger/debugger_node.cc
+++ /dev/null
@@ -1,301 +0,0 @@
-// Copyright (c) 2006-2008 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/debugger_node.h"
-
-#include "base/process_util.h"
-#include "base/string_util.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/browser_list.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/renderer_host/render_process_host.h"
-#include "chrome/browser/renderer_host/render_view_host.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
-#include "chrome/browser/debugger/debugger_shell.h"
-#include "chrome/common/notification_service.h"
-
-DebuggerNode::DebuggerNode() : data_(NULL), valid_(true) {
-}
-
-void DebuggerNode::Observe(NotificationType type,
-                           const NotificationSource& source,
-                           const NotificationDetails& details) {
-  registrar_.RemoveAll();
-  data_ = NULL;
-  Invalidate();
-}
-
-DebuggerNode::~DebuggerNode() {
-}
-
-
-v8::Handle<v8::Value> DebuggerNode::IndexGetter(uint32_t index,
-                                                const v8::AccessorInfo& info) {
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerNode::PropGetter(v8::Handle<v8::String> prop,
-                                               const v8::AccessorInfo& info) {
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerNode::Function(const v8::Arguments& args) {
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerNode::NewInstance() {
-  DebuggerNodeWrapper *wrap = new DebuggerNodeWrapper(this);
-  wrap->AddRef();
-  v8::Local<v8::External> node = v8::External::New(wrap);
-  // TODO(erikkay): cache these templates?
-  v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
-  if (IsFunction()) {
-    templ->SetCallHandler(&DebuggerNode::NodeFunc, node);
-    v8::Local<v8::Function> f = templ->GetFunction();
-    return f;
-  }
-  v8::Local<v8::ObjectTemplate> instance = templ->InstanceTemplate();
-  if (IsObject()) {
-    instance->SetNamedPropertyHandler(&DebuggerNode::NodeGetter, 0, 0, 0, 0,
-                                      node);
-    // TODO(erikkay): verify that the interceptor does not have to be
-    // behind the object
-  }
-  if (IsCollection()) {
-    instance->SetIndexedPropertyHandler(&DebuggerNode::NodeIndex, 0, 0, 0, 0,
-                                        node);
-  }
-  v8::Local<v8::Object> ret = instance->NewInstance();
-  v8::Persistent<v8::Object> p = v8::Persistent<v8::Object>::New(ret);
-  p.MakeWeak(wrap, &DebuggerShell::HandleWeakReference);
-  return ret;
-}
-
-v8::Handle<v8::Value> DebuggerNode::NodeGetter(v8::Local<v8::String> prop,
-                                            const v8::AccessorInfo& info) {
-  DebuggerNodeWrapper* w = static_cast<DebuggerNodeWrapper*>(v8::External::Cast(
-        *info.Data())->Value());
-  DebuggerNode* n = w->node();
-  return (n->IsValid() && n->IsObject()) ? n->PropGetter(prop, info) :
-      static_cast<v8::Handle<v8::Value> >(v8::Undefined());
-}
-
-v8::Handle<v8::Value> DebuggerNode::NodeIndex(uint32_t index,
-                                           const v8::AccessorInfo& info) {
-  DebuggerNodeWrapper* w = static_cast<DebuggerNodeWrapper*>(v8::External::Cast(
-      *info.Data())->Value());
-  DebuggerNode* n = w->node();
-  return (n->IsValid() && n->IsCollection()) ? n->IndexGetter(index, info) :
-      static_cast<v8::Handle<v8::Value> >(v8::Undefined());
-}
-
-v8::Handle<v8::Value> DebuggerNode::NodeFunc(const v8::Arguments& args) {
-  DebuggerNodeWrapper* w = static_cast<DebuggerNodeWrapper*>(v8::External::Cast(
-      *args.Data())->Value());
-  DebuggerNode* n = w->node();
-  return (n->IsValid() && n->IsFunction()) ? n->Function(args) :
-      static_cast<v8::Handle<v8::Value> >(v8::Undefined());
-}
-
-
-/////////////////////////////////////////////
-
-ChromeNode::ChromeNode(DebuggerShell* debugger) {
-  debugger_ = debugger;
-}
-
-ChromeNode::~ChromeNode() {
-}
-
-v8::Handle<v8::Value> ChromeNode::PropGetter(v8::Handle<v8::String> prop,
-                                             const v8::AccessorInfo& info) {
-  if (prop->Equals(v8::String::New("pid")))
-    return v8::Number::New(base::GetCurrentProcId());
-  if (prop->Equals(v8::String::New("browser")))
-    return BrowserListNode::BrowserList()->NewInstance();
-  if (prop->Equals(v8::String::New("setDebuggerReady"))) {
-    return (new FunctionNode<DebuggerShell>(DebuggerShell::SetDebuggerReady,
-                                            debugger_))->NewInstance();
-  }
-  if (prop->Equals(v8::String::New("setDebuggerBreak"))) {
-    return (new FunctionNode<DebuggerShell>(DebuggerShell::SetDebuggerBreak,
-                                            debugger_))->NewInstance();
-  }
-  return prop->Equals(v8::String::New("foo")) ?
-      static_cast<v8::Handle<v8::Value> >(v8::Undefined()) :
-      static_cast<v8::Handle<v8::Value> >(prop);
-}
-
-/////////////////////////////////////////////
-
-BrowserNode::BrowserNode(Browser *b) {
-  data_ = b;
-  registrar_.Add(this, NotificationType::BROWSER_CLOSED, Source<Browser>(b));
-}
-
-BrowserNode* BrowserNode::BrowserAtIndex(int index) {
-  if (index >= 0) {
-    BrowserList::const_iterator iter = BrowserList::begin();
-    for (; (iter != BrowserList::end()) && (index > 0); ++iter, --index)
-      ;
-    if (iter != BrowserList::end())
-      return new BrowserNode(*iter);
-  }
-  return NULL;
-}
-
-BrowserNode::~BrowserNode() {
-}
-
-Browser* BrowserNode::GetBrowser() {
-  return IsValid() ? static_cast<Browser*>(data_) : NULL;
-}
-
-v8::Handle<v8::Value> BrowserNode::PropGetter(v8::Handle<v8::String> prop,
-                                              const v8::AccessorInfo& info) {
-  Browser* b = GetBrowser();
-  if (b != NULL) {
-    if (prop->Equals(v8::String::New("title"))) {
-      return v8::String::New(UTF16ToUTF8(
-          b->GetSelectedTabContents()->GetTitle()).c_str());
-    }
-    if (prop->Equals(v8::String::New("tab")))
-      return TabListNode::TabList(b)->NewInstance();
-  }
-  return v8::Undefined();
-}
-
-/////////////////////////////////////////////
-
-BrowserListNode* BrowserListNode::BrowserList() {
-  // TODO(erikkay): cache
-  return new BrowserListNode();
-}
-
-BrowserListNode::BrowserListNode() {
-}
-
-BrowserListNode::~BrowserListNode() {
-}
-
-v8::Handle<v8::Value> BrowserListNode::IndexGetter(
-    uint32_t index,
-    const v8::AccessorInfo& info) {
-  BrowserNode* b = BrowserNode::BrowserAtIndex(index);
-  return b ? b->NewInstance() :
-      static_cast<v8::Handle<v8::Value> >(v8::Undefined());
-}
-
-/////////////////////////////////////////////
-
-TabListNode::TabListNode(Browser* b) {
-  data_ = b;
-  registrar_.Add(this, NotificationType::BROWSER_CLOSED, Source<Browser>(b));
-}
-
-TabListNode::~TabListNode() {
-}
-
-TabListNode* TabListNode::TabList(Browser* b) {
-  return new TabListNode(b);
-}
-
-Browser* TabListNode::GetBrowser() {
-  return IsValid() ? static_cast<Browser*>(data_) : NULL;
-}
-
-v8::Handle<v8::Value> TabListNode::IndexGetter(uint32_t index,
-                                               const v8::AccessorInfo& info) {
-  Browser* b = GetBrowser();
-  if (b != NULL) {
-    TabContents* tab_contents = b->GetTabContentsAt(index);
-    if (tab_contents)
-      return (new TabNode(tab_contents))->NewInstance();
-  }
-  return v8::Undefined();
-}
-
-/////////////////////////////////////////////
-
-TabNode::TabNode(TabContents* c) {
-  NavigationController* controller = &c->controller();
-  data_ = controller;
-  registrar_.Add(this, NotificationType::TAB_CLOSING,
-                 Source<NavigationController>(controller));
-}
-
-TabNode::~TabNode() {
-}
-
-TabContents* TabNode::GetTab() {
-  return IsValid() ?
-      static_cast<NavigationController*>(data_)->tab_contents() : NULL;
-}
-
-v8::Handle<v8::Value> TabNode::SendToDebugger(const v8::Arguments& args,
-                                              TabContents* tab) {
-  RenderViewHost* host = tab->render_view_host();
-  if (args.Length() == 1) {
-    std::wstring cmd;
-    v8::Handle<v8::Value> obj = args[0];
-    DebuggerShell::ObjectToString(obj, &cmd);
-    host->DebugCommand(cmd);
-  }
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> TabNode::Attach(const v8::Arguments& args,
-                                      TabContents* tab) {
-  RenderViewHost* host = tab->render_view_host();
-  host->DebugAttach();
-  return v8::Int32::New(host->process()->process().pid());
-}
-
-v8::Handle<v8::Value> TabNode::Detach(const v8::Arguments& args,
-                                      TabContents* tab) {
-  RenderViewHost* host = tab->render_view_host();
-  host->DebugDetach();
-  return v8::Int32::New(host->process()->process().pid());
-}
-
-v8::Handle<v8::Value> TabNode::Break(const v8::Arguments& args,
-                                     TabContents* tab) {
-  tab->render_view_host()->DebugBreak((args.Length() >= 1) ?
-      args[0]->BooleanValue() : false);
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> TabNode::PropGetter(v8::Handle<v8::String> prop,
-                                          const v8::AccessorInfo& info) {
-  TabContents* tab = GetTab();
-  if (tab != NULL) {
-    if (prop->Equals(v8::String::New("title")))
-      return v8::String::New(UTF16ToUTF8(tab->GetTitle()).c_str());
-    if (prop->Equals(v8::String::New("attach"))) {
-      return (new FunctionNode<TabContents>(TabNode::Attach,
-                                            tab))->NewInstance();
-    }
-    if (prop->Equals(v8::String::New("detach"))) {
-      return (new FunctionNode<TabContents>(TabNode::Detach,
-                                            tab))->NewInstance();
-    }
-    if (prop->Equals(v8::String::New("sendToDebugger"))) {
-      return (new FunctionNode<TabContents>(TabNode::SendToDebugger,
-                                            tab))->NewInstance();
-    }
-    if (prop->Equals(v8::String::New("debugBreak"))) {
-      return (new FunctionNode<TabContents>(TabNode::Break,
-                                            tab))->NewInstance();
-    }
-  }
-  return v8::Undefined();
-}
-
-
-//////////////////////////////////
-
-template<class T>
-v8::Handle<v8::Value> FunctionNode<T>::Function(const v8::Arguments &args) {
-  return function_(args, data_);
-}
diff --git a/chrome/browser/debugger/debugger_node.h b/chrome/browser/debugger/debugger_node.h
deleted file mode 100644
index 8b243f6..0000000
--- a/chrome/browser/debugger/debugger_node.h
+++ /dev/null
@@ -1,218 +0,0 @@
-// Copyright (c) 2006-2008 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.
-
-// Proxy objects for exposing Chrome internals to V8.  Adds some convenience
-// methods to simplify properties, indexes and functions, as well as helping
-// with object lifetime bi-directionally.
-
-// TODO: this code is temporary and will be converted to use IDL
-// Also note that it's missing a lot of functionality and isn't correct.
-// For example, objects aren't being cached properly (browser.foo = 1 wouldn't
-// be remembered), and setters aren't implemented to begin with.
-
-#ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_NODE_H_
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_NODE_H_
-
-#include "base/basictypes.h"
-#include "base/scoped_ptr.h"
-#include "base/ref_counted.h"
-#include "chrome/common/notification_registrar.h"
-#include "v8/include/v8.h"
-
-class Browser;
-class TabContents;
-class DebuggerShell;
-class NotificationService;
-class TabContents;
-
-class DebuggerNode : public NotificationObserver {
- public:
-  DebuggerNode();
-  virtual ~DebuggerNode();
-
-  // does your object handle array references? (e.g. myobj[0])
-  virtual bool IsCollection() = 0;
-  // does your object work as a function (e.g. myobj())
-  virtual bool IsFunction() = 0;
-  // does your object contain other named properties? (e.g. myobj.foo)
-  virtual bool IsObject() = 0;
-
-  // Is the underlying C++ object valid or not?  It's possible for the JS object
-  // to be alive after the underlying C++ object has gone away.  In that case,
-  // the DebuggerNode stays around but is marked as invalid.
-  bool IsValid() { return valid_; }
-  virtual void Invalidate() { valid_ = false; }
-
-  // Callback for DebuggerNode subclasses which use the NotificationService to
-  // track object validity.
-  virtual void Observe(NotificationType type,
-                       const NotificationSource& source,
-                       const NotificationDetails& details);
-
-  // Index getter callback from V8 for objects where IsCollection is true
-  virtual v8::Handle<v8::Value> IndexGetter(uint32_t index,
-                                            const v8::AccessorInfo& info);
-  // Index getter callback from V8 for objects where IsObject is true
-  virtual v8::Handle<v8::Value> PropGetter(v8::Handle<v8::String> prop,
-                                           const v8::AccessorInfo& info);
-  // Functor callback from V8 for objects where IsFunction is true
-  virtual v8::Handle<v8::Value> Function(const v8::Arguments& args);
-
-  // Create a new instance of this JS object.
-  virtual v8::Handle<v8::Value> NewInstance();
-
-  // Generic DebuggerNode named property getter
-  static v8::Handle<v8::Value> NodeGetter(v8::Local<v8::String> prop,
-                                          const v8::AccessorInfo& info);
-  // Generic DebuggerNode index getter
-  static v8::Handle<v8::Value> NodeIndex(uint32_t index,
-                                         const v8::AccessorInfo& info);
-  // Generic DebuggerNode functor
-  static v8::Handle<v8::Value> NodeFunc(const v8::Arguments& args);
-
- protected:
-  NotificationRegistrar registrar_;
-  void* data_;
-  bool valid_;
-};
-
-// A wrapper around the proxy to handle calling virtual methods during callbacks
-// from V8 after a static_cast from void*.
-// The point here is that we'd like to be able to stick DebuggerNode* objects
-// into V8.  To do that, we need to cast them to void*, which means we need
-// this additional layer of wrapper to protect them from the harmful effects
-// of static_cast.  Rather than passing in a DebuggerNode*, we instead pass in
-// a DebuggerNodeWrapper*.  Since this is what's being referenced by V8, we
-// also handle lifetime issues (RefCounted) in the wrapper.
-class DebuggerNodeWrapper : public base::RefCounted<DebuggerNodeWrapper> {
- public:
-  DebuggerNodeWrapper(DebuggerNode* node) : node_(node) {}
-  virtual ~DebuggerNodeWrapper() {}
-  DebuggerNode* node() { return node_.get(); }
- private:
-  scoped_ptr<DebuggerNode> node_;
-};
-
-// top level chrome object implements:
-// * pid() - process id of chrome browser process
-// * browser[] - returns collection of browser objects
-class ChromeNode : public DebuggerNode {
- public:
-  ChromeNode(DebuggerShell* debugger);
-  virtual ~ChromeNode();
-
-  bool IsCollection() { return false; }
-  bool IsFunction() { return false; }
-  bool IsObject() { return true; }
-
-  virtual v8::Handle<v8::Value> PropGetter(v8::Handle<v8::String> prop,
-                                           const v8::AccessorInfo& info);
-
- private:
-  DebuggerShell* debugger_;
-};
-
-// browser collection, simply returns the n'th browser from BrowserList
-class BrowserListNode : public DebuggerNode {
- public:
-  bool IsCollection() { return true; }
-  bool IsFunction() { return false; }
-  bool IsObject() { return false; }
-
-  virtual v8::Handle<v8::Value> IndexGetter(uint32_t index,
-                                            const v8::AccessorInfo& info);
-  static BrowserListNode* BrowserList();
-
- private:
-  BrowserListNode();
-  virtual ~BrowserListNode();
-};
-
-// Wrapper around Browser object.  implements:
-// * title - title of the current tab
-// * tab[] - collection of tabs
-class BrowserNode : public DebuggerNode {
- public:
-  bool IsCollection() { return false; }
-  bool IsFunction() { return false; }
-  bool IsObject() { return true; }
-
-  static BrowserNode* BrowserAtIndex(int index);
-
-  virtual v8::Handle<v8::Value> PropGetter(v8::Handle<v8::String> prop,
-                                           const v8::AccessorInfo& info);
-
- private:
-  BrowserNode(Browser* b);
-  Browser* GetBrowser();
-  virtual ~BrowserNode();
-};
-
-// tab collection, simply returns the n'th TabContents from Browser
-class TabListNode : public DebuggerNode {
- public:
-  bool IsCollection() { return true; }
-  bool IsFunction() { return false; }
-  bool IsObject() { return false; }
-
-  virtual v8::Handle<v8::Value> IndexGetter(uint32_t index,
-                                            const v8::AccessorInfo& info);
-  static TabListNode* TabList(Browser* b);
-
- private:
-  TabListNode(Browser* b);
-  virtual ~TabListNode();
-  Browser* GetBrowser();
-};
-
-// Wrapper around TabContents.  Implements:
-// * title - tab title
-// * attach - starts debugging in this tab (currently this just means log msgs)
-// * detach - stops debugging in this tab
-// * eval(xpath, expr), eval(expr) - evaluates JS expr in xpath iframe context
-class TabNode : public DebuggerNode {
- public:
-  bool IsCollection() { return false; }
-  bool IsFunction() { return false; }
-  bool IsObject() { return true; }
-
-  TabNode(TabContents* c);
-  virtual v8::Handle<v8::Value> PropGetter(v8::Handle<v8::String> prop,
-                                           const v8::AccessorInfo& info);
- private:
-
-  static v8::Handle<v8::Value> SendToDebugger(const v8::Arguments& args,
-                                              TabContents* data);
-  static v8::Handle<v8::Value> Attach(const v8::Arguments& args,
-                                      TabContents* data);
-  static v8::Handle<v8::Value> Detach(const v8::Arguments& args,
-                                      TabContents* data);
-  static v8::Handle<v8::Value> Break(const v8::Arguments& args,
-                                     TabContents* data);
-
-  virtual ~TabNode();
-  TabContents* GetTab();
-};
-
-template<class T>
-class FunctionNode : public DebuggerNode {
- public:
-  bool IsCollection() { return false; }
-  bool IsFunction() { return true; }
-  bool IsObject() { return false; }
-
-  typedef v8::Handle<v8::Value> (*Callback)(const v8::Arguments& args, T* data);
-
-  FunctionNode(Callback f, T* data)
-      : function_(f), data_(data) {}
-
-private:
-  // Functor callback from V8 for objects where IsFunction is true
-  virtual v8::Handle<v8::Value> Function(const v8::Arguments& args);
-
-  Callback function_;
-  T* data_;
-};
-
-#endif // CHROME_BROWSER_DEBUGGER_DEBUGGER_NODE_H_
diff --git a/chrome/browser/debugger/debugger_shell.cc b/chrome/browser/debugger/debugger_shell.cc
deleted file mode 100644
index d6d5324..0000000
--- a/chrome/browser/debugger/debugger_shell.cc
+++ /dev/null
@@ -1,431 +0,0 @@
-// Copyright (c) 2006-2008 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/debugger_shell.h"
-
-#include "build/build_config.h"
-
-#include "app/resource_bundle.h"
-#include "base/file_util.h"
-#include "base/path_service.h"
-#include "base/string_util.h"
-#include "base/thread.h"
-#include "chrome/browser/browser.h"
-#include "chrome/browser/browser_list.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/debugger/debugger_io.h"
-#include "chrome/browser/debugger/debugger_node.h"
-#include "chrome/browser/renderer_host/render_process_host.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
-#include "chrome/common/chrome_paths.h"
-
-#include "grit/debugger_resources.h"
-
-DebuggerShell::DebuggerShell(DebuggerInputOutput* io) : io_(io),
-                                                        debugger_ready_(true) {
-}
-
-DebuggerShell::~DebuggerShell() {
-  io_->Stop();
-  io_ = NULL;
-
-  v8::Locker locked;
-  v8::HandleScope scope;
-  SubshellFunction("exit", 0, NULL);
-  v8::V8::RemoveMessageListeners(&DelegateMessageListener);
-  v8_this_.Dispose();
-  v8_context_.Dispose();
-  shell_.Dispose();
-}
-
-void DebuggerShell::Start() {
-  io_->Start(this);
-
-  v8::Locker locked;
-  v8::HandleScope scope;
-
-  v8_this_ = v8::Persistent<v8::External>::New(v8::External::New(this));
-
-  v8::V8::AddMessageListener(&DelegateMessageListener, v8_this_);
-
-  v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
-
-  // shell function
-  v8::Local<v8::FunctionTemplate> shell_template =
-    v8::FunctionTemplate::New(&DelegateSubshell, v8_this_);
-  global_template->Set(v8::String::New("shell"), shell_template);
-
-  // print function
-  v8::Local<v8::FunctionTemplate> print_template =
-    v8::FunctionTemplate::New(&DelegatePrint, v8_this_);
-  global_template->Set(v8::String::New("print"), print_template);
-
-  // source function
-  v8::Local<v8::FunctionTemplate> source_template =
-    v8::FunctionTemplate::New(&DelegateSource, v8_this_);
-  global_template->Set(v8::String::New("source"), source_template);
-
-  v8_context_ = v8::Context::New(NULL, global_template);
-  v8::Context::Scope ctx(v8_context_);
-
-  // This doesn't really leak. It's wrapped by the NewInstance() return value.
-  ChromeNode* chrome = new ChromeNode(this);
-  v8_context_->Global()->Set(v8::String::New("chrome"),
-                             chrome->NewInstance());
-
-  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-  const std::string& debugger_shell_js =
-      rb.GetDataResource(IDR_DEBUGGER_SHELL_JS);
-  CompileAndRun(debugger_shell_js, "chrome.dll/debugger_shell.js");
-}
-
-void DebuggerShell::HandleWeakReference(v8::Persistent<v8::Value> obj,
-                                        void* data) {
-  DebuggerNodeWrapper* node = static_cast<DebuggerNodeWrapper*>(data);
-  node->Release();
-}
-
-v8::Handle<v8::Value> DebuggerShell::SetDebuggerReady(const v8::Arguments& args,
-                                                      DebuggerShell* debugger) {
-  if (args[0]->IsBoolean()) {
-    bool flag = args[0]->BooleanValue();
-    debugger->debugger_ready_ = flag;
-    debugger->GetIo()->SetDebuggerReady(flag);
-  }
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerShell::SetDebuggerBreak(const v8::Arguments& args,
-                                                      DebuggerShell* debugger) {
-  if (args[0]->IsBoolean()) {
-    bool flag = args[0]->BooleanValue();
-    debugger->GetIo()->SetDebuggerBreak(flag);
-  }
-  return v8::Undefined();
-}
-
-DebuggerInputOutput* DebuggerShell::GetIo() {
-  return io_.get();
-}
-
-v8::Handle<v8::Value> DebuggerShell::DelegateSubshell(
-    const v8::Arguments& args) {
-  DebuggerShell* debugger =
-    static_cast<DebuggerShell*>(v8::External::Cast(*args.Data())->Value());
-  return debugger->Subshell(args);
-}
-
-v8::Handle<v8::Value> DebuggerShell::Subshell(const v8::Arguments& args) {
-  if (args.Length() != 1) {
-    return v8::Undefined();
-  }
-  if (!shell_.IsEmpty()) {
-    shell_.Dispose();
-    shell_.Clear();
-    v8_context_->Global()->Delete(v8::String::New("shell_"));
-  }
-  if (args[0]->IsFunction()) {
-    v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(args[0]);
-    v8::Local<v8::Object> obj = func->NewInstance();
-    if (!obj->IsUndefined()) {
-      shell_ = v8::Persistent<v8::Object>::New(obj);
-      v8_context_->Global()->Set(v8::String::New("shell_"), shell_);
-    }
-  } else if (args[0]->IsObject()) {
-    shell_ =
-        v8::Persistent<v8::Object>::New(v8::Local<v8::Object>::Cast(args[0]));
-    v8_context_->Global()->Set(v8::String::New("shell_"), shell_);
-  }
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerShell::SubshellFunction(const char* func,
-                                              int argc,
-                                              v8::Handle<v8::Value>* argv) {
-  if (!shell_.IsEmpty()) {
-    v8::Context::Scope scope(v8_context_);
-    v8::Local<v8::Value> function = shell_->Get(v8::String::New(func));
-    if (function->IsFunction()) {
-      v8::Local<v8::Value> ret =
-        v8::Function::Cast(*function)->Call(shell_, argc, argv);
-      return ret;
-    }
-  }
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerShell::DelegatePrint(const v8::Arguments& args) {
-  DebuggerShell* debugger =
-    static_cast<DebuggerShell*>(v8::External::Cast(*args.Data())->Value());
-  return debugger->Print(args);
-}
-
-v8::Handle<v8::Value> DebuggerShell::Print(const v8::Arguments& args) {
-  int len = args.Length();
-  for (int i = 0; i < len; i++) {
-    PrintObject(args[i]);
-  }
-  return v8::Undefined();
-}
-
-v8::Handle<v8::Value> DebuggerShell::DelegateSource(const v8::Arguments& args) {
-  DebuggerShell* debugger =
-    static_cast<DebuggerShell*>(v8::External::Cast(*args.Data())->Value());
-  std::wstring path;
-  if (args.Length() == 0) {
-    debugger->LoadUserConfig();
-  } else {
-    ObjectToString(args[0], &path);
-    bool ret = debugger->LoadFile(path);
-    if (!ret) {
-      return v8::String::New("failed to load");
-    }
-  }
-  return v8::Undefined();
-}
-
-void DebuggerShell::DelegateMessageListener(v8::Handle<v8::Message> message,
-                                    v8::Handle<v8::Value> data) {
-  DCHECK(!data.IsEmpty());
-  DebuggerShell* debugger =
-    static_cast<DebuggerShell*>(v8::External::Cast(*data)->Value());
-  debugger->MessageListener(message);
-}
-
-void DebuggerShell::MessageListener(v8::Handle<v8::Message> message) {
-  v8::HandleScope scope;
-  v8::Local<v8::String> msg_str = message->Get();
-  PrintObject(msg_str);
-
-  v8::Handle<v8::Value> data = message->GetScriptResourceName();
-  if (!data.IsEmpty() && !data->IsUndefined()) {
-    std::wstring out;
-    ObjectToString(data, &out);
-    int line_number = message->GetLineNumber();
-    if (line_number >= 0)
-      out += StringPrintf(L":%d", line_number);
-    PrintLine(out);
-    data = message->GetSourceLine();
-    if (!data->IsUndefined()) {
-      ObjectToString(data, &out);
-      PrintLine(out);
-    }
-  }
-}
-
-void DebuggerShell::Debug(TabContents* tab) {
-  v8::Locker locked;
-  v8::HandleScope outer;
-  v8::Context::Scope scope(v8_context_);
-
-  v8::Local<v8::Object> global = v8_context_->Global();
-  v8::Local<v8::Value> function = global->Get(v8::String::New("debug"));
-  if (function->IsFunction()) {
-    TabNode* node = new TabNode(tab);
-    v8::Handle<v8::Value> argv[] = {node->NewInstance()};
-    PrintObject(v8::Function::Cast(*function)->Call(global, 1, argv));
-  }
-}
-
-void DebuggerShell::DebugMessage(const std::wstring& msg) {
-  v8::Locker locked;
-  v8::HandleScope scope;
-
-  if (msg.length()) {
-    if ((msg[0] == L'{' || msg[0] == L'[' || msg[0] == L'(') &&
-        (!shell_.IsEmpty())) {
-      // v8's wide String constructor requires uint16 rather than wchar
-      const uint16* data = reinterpret_cast<const uint16* >(msg.c_str());
-      v8::Handle<v8::Value> argv[] = {v8::String::New(data)};
-      PrintObject(SubshellFunction("response", 1, argv));
-      PrintPrompt();
-    } else {
-      if (msg[msg.length() - 1] == L'\n')
-        PrintString(msg);
-      else
-        PrintLine(msg);
-    }
-  }
-}
-
-void DebuggerShell::OnDebugAttach() {
-  v8::Locker locked;
-  v8::HandleScope scope;
-  SubshellFunction("on_attach", 0, NULL);
-}
-
-void DebuggerShell::OnDebugDisconnect() {
-  v8::Locker locked;
-  v8::HandleScope scope;
-  SubshellFunction("on_disconnect", 0, NULL);
-}
-
-void DebuggerShell::ObjectToString(v8::Handle<v8::Value> result,
-                                   std::wstring* str) {
-  v8::HandleScope scope;
-  if (!result.IsEmpty() && !result->IsUndefined()) {
-    v8::Local<v8::String> str_obj = result->ToString();
-    if (!str_obj.IsEmpty()) {
-      int length = str_obj->Length();
-      wchar_t* buf = new wchar_t[length + 1];
-      int size = str_obj->Write(reinterpret_cast<uint16_t*>(buf));
-      str->clear();
-      str->append(buf, size);
-      delete[] buf;
-    }
-  }
-}
-
-void DebuggerShell::ObjectToString(v8::Handle<v8::Value> result,
-                                   std::string* str) {
-  v8::HandleScope scope;
-  if (!result.IsEmpty() && !result->IsUndefined()) {
-    v8::Local<v8::String> str_obj = result->ToString();
-    if (!str_obj.IsEmpty()) {
-      int length = str_obj->Length();
-      char* buf = new char[length + 1];
-      str_obj->WriteAscii(buf);
-      str->clear();
-      str->append(buf);
-      delete[] buf;
-    }
-  }
-}
-
-void DebuggerShell::PrintObject(v8::Handle<v8::Value> result, bool crlf) {
-  if (!result.IsEmpty() && !result->IsUndefined()) {
-    std::wstring out;
-    ObjectToString(result, &out);
-    if (crlf) {
-      PrintLine(out);
-    } else if (out.length()) {
-      PrintString(out);
-    }
-  }
-}
-
-void DebuggerShell::PrintString(const std::wstring& out) {
-  if (io_)
-    io_->Output(out);
-}
-
-void DebuggerShell::PrintLine(const std::wstring& out) {
-  if (io_)
-    io_->OutputLine(out);
-}
-
-void DebuggerShell::PrintString(const std::string& out) {
-  if (io_)
-    io_->Output(out);
-}
-
-void DebuggerShell::PrintLine(const std::string& out) {
-  if (io_)
-    io_->OutputLine(out);
-}
-
-void DebuggerShell::PrintPrompt() {
-  std::wstring out = L"Chrome> ";
-  if (!shell_.IsEmpty()) {
-    if (!debugger_ready_)
-      return;
-    v8::Locker locked;
-    v8::HandleScope outer;
-    v8::Handle<v8::Value> result = CompileAndRun("shell_.prompt()");
-    if (!result.IsEmpty() && !result->IsUndefined()) {
-      ObjectToString(result, &out);
-    }
-  }
-  if (io_)
-    io_->OutputPrompt(out);
-}
-
-void DebuggerShell::ProcessCommand(const std::wstring& data) {
-  v8::Locker locked;
-  v8::HandleScope outer;
-  v8::Context::Scope scope(v8_context_);
-  if (!shell_.IsEmpty() && data.substr(0, 7) != L"source(") {
-    if (data == L"exit") {
-      PrintObject(SubshellFunction("exit", 0, NULL));
-      v8_context_->Global()->Delete(v8::String::New("shell_"));
-      shell_.Dispose();
-      shell_.Clear();
-    } else {
-      const uint16* utf16 = reinterpret_cast<const uint16*>(data.c_str());
-      v8::Handle<v8::Value> argv[] = {v8::String::New(utf16)};
-      PrintObject(SubshellFunction("command", 1, argv));
-    }
-  } else if (data.length()) {
-    //TODO(erikkay): change everything to wstring
-    v8::Handle<v8::Value> result = CompileAndRun(data);
-    PrintObject(result);
-  }
-  PrintPrompt();
-}
-
-bool DebuggerShell::LoadFile(const std::wstring& file) {
-  if (file_util::PathExists(file)) {
-    std::string contents;
-    if (file_util::ReadFileToString(file, &contents)) {
-      std::string afile = WideToUTF8(file);
-      CompileAndRun(contents, afile);
-      return true;
-    }
-  }
-  return false;
-}
-
-void DebuggerShell::LoadUserConfig() {
-  std::wstring path;
-  PathService::Get(chrome::DIR_USER_DATA, &path);
-  file_util::AppendToPath(&path, L"debugger_custom.js");
-  LoadFile(path);
-}
-
-void DebuggerShell::DidConnect() {
-  v8::Locker locked;
-  v8::HandleScope outer;
-  v8::Context::Scope scope(v8_context_);
-
-  LoadUserConfig();
-
-  PrintPrompt();
-}
-
-void DebuggerShell::DidDisconnect() {
-  v8::Locker locked;
-  v8::HandleScope outer;
-  SubshellFunction("exit", 0, NULL);
-}
-
-v8::Handle<v8::Value> DebuggerShell::CompileAndRun(
-    const std::string& str,
-    const std::string& filename) {
-  const std::wstring wstr = UTF8ToWide(str);
-  return CompileAndRun(wstr, filename);
-}
-
-v8::Handle<v8::Value> DebuggerShell::CompileAndRun(
-    const std::wstring& wstr,
-    const std::string& filename) {
-  v8::Locker locked;
-  v8::Context::Scope scope(v8_context_);
-  v8::Handle<v8::String> scriptname;
-  if (filename.length() > 0) {
-    scriptname = v8::String::New(filename.c_str());
-  } else {
-    scriptname = v8::String::New("");
-  }
-  const uint16* utf16 = reinterpret_cast<const uint16*>(wstr.c_str());
-  v8::ScriptOrigin origin = v8::ScriptOrigin(scriptname);
-  v8::Local<v8::Script> code =
-      v8::Script::Compile(v8::String::New(utf16), &origin);
-  if (!code.IsEmpty()) {
-    v8::Local<v8::Value> result = code->Run();
-    if (!result.IsEmpty()) {
-      return result;
-    }
-  }
-  return v8::Undefined();
-}
diff --git a/chrome/browser/debugger/debugger_shell.h b/chrome/browser/debugger/debugger_shell.h
deleted file mode 100644
index a031c7e..0000000
--- a/chrome/browser/debugger/debugger_shell.h
+++ /dev/null
@@ -1,138 +0,0 @@
-// Copyright (c) 2006-2008 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.
-
-// A browser-side server debugger built with V8 providing a scriptable
-// interface to a JavaScript debugger as well as browser automation.
-// Supports multiple user interfaces including a command-line debugger
-// accessible from a Chrome window or telnet.
-
-// NOTE: DON'T include this file outside of the debugger project.  In order to
-// build in the KJS solution, you should instead use debugger_wrapper.h.
-// If DebuggerWraper doesn't expose the interface you need, extend it to do so.
-// See comments in debugger_wrapper.h for more details.
-
-#ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_SHELL_H_
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_SHELL_H_
-
-#include "base/basictypes.h"
-#include "base/ref_counted.h"
-#include "chrome/browser/debugger/debugger_host.h"
-
-#ifdef CHROME_DEBUGGER_DISABLED
-
-#include "base/logging.h"
-
-class DebuggerShell : public base::RefCountedThreadSafe<DebuggerShell> {
- public:
-  DebuggerShell() {
-    LOG(ERROR) << "Debugger not enabled for KJS";
-  }
-  virtual ~DebuggerShell() {}
-  void Start() {}
-  void DebugMessage(const std::wstring& msg) {}
-  void OnDebugDisconnect() {}
-  void OnDebugAttach() {}
-};
-
-#else
-
-#include "debugger_io.h"
-#include "debugger_node.h"
-#include "v8/include/v8.h"
-
-class DebuggerInputOutput;
-class MessageLoop;
-class TabContents;
-
-class DebuggerShell : public DebuggerHost {
- public:
-  DebuggerShell(DebuggerInputOutput *io);
-  virtual ~DebuggerShell();
-
-  // call before other methods
-  void Start();
-
-  // Start debugging the specified tab
-  void Debug(TabContents* tab);
-
-  // A message from the V8 debugger in the renderer being debugged via
-  // RenderViewHost
-  void DebugMessage(const std::wstring& msg);
-
-  // The renderer we're attached to is gone.
-  void OnDebugAttach();
-
-  // The renderer we're attached to is gone.
-  void OnDebugDisconnect();
-
-  // SocketInputOutput callback methods
-  void DidConnect();
-  void DidDisconnect();
-  void ProcessCommand(const std::wstring& data);
-
-  static v8::Handle<v8::Value> SetDebuggerReady(const v8::Arguments& args,
-                                                DebuggerShell* debugger);
-  static v8::Handle<v8::Value> SetDebuggerBreak(const v8::Arguments& args,
-                                                DebuggerShell* debugger);
-
-  // For C++ objects which are tied to JS objects (e.g. DebuggerNode),
-  // we need to know when the underlying JS objects have been collected
-  // so that we can clean up the C++ object as well.
-  static void HandleWeakReference(v8::Persistent<v8::Value> obj, void* data);
-
-  // populates str with the ascii string value of result
-  static void ObjectToString(v8::Handle<v8::Value> result, std::string* str);
-  static void ObjectToString(v8::Handle<v8::Value> result, std::wstring* str);
-
-  DebuggerInputOutput* GetIo();
-
- private:
-  void PrintObject(v8::Handle<v8::Value> result, bool crlf = true);
-  void PrintLine(const std::wstring& out);
-  void PrintString(const std::wstring& out);
-  void PrintLine(const std::string& out);
-  void PrintString(const std::string& out);
-  void PrintPrompt();
-  v8::Handle<v8::Value> CompileAndRun(const std::wstring& wstr,
-                                      const std::string& filename = "");
-  v8::Handle<v8::Value> CompileAndRun(const std::string& str,
-                                      const std::string& filename = "");
-
-  bool LoadFile(const std::wstring& file);
-  void LoadUserConfig();
-
-  // Log/error messages from V8
-  static void DelegateMessageListener(v8::Handle<v8::Message> message,
-                                      v8::Handle<v8::Value> data);
-
-  void MessageListener(v8::Handle<v8::Message> message);
-
-  // global shell() function designed to allow command-line processing by
-  // javascript code rather than by this object.
-  static v8::Handle<v8::Value> DelegateSubshell(const v8::Arguments& args);
-  v8::Handle<v8::Value> Subshell(const v8::Arguments& args);
-  v8::Handle<v8::Value> SubshellFunction(const char* func,
-                                         int argc,
-                                         v8::Handle<v8::Value>* argv);
-
-  // print message to the debugger
-  static v8::Handle<v8::Value> DelegatePrint(const v8::Arguments& args);
-  v8::Handle<v8::Value> Print(const v8::Arguments& args);
-
-  // load and execute javascript file
-  static v8::Handle<v8::Value> DelegateSource(const v8::Arguments& args);
-
-  v8::Persistent<v8::Context> v8_context_;
-  v8::Persistent<v8::External> v8_this_;
-  v8::Persistent<v8::Object> shell_;
-  scoped_refptr<DebuggerInputOutput> io_;
-
-  // If the debugger is ready to process another command or is busy.
-  bool debugger_ready_;
-
-  DISALLOW_COPY_AND_ASSIGN(DebuggerShell);
-};
-
-#endif // else CHROME_DEBUGGER_DISABLED
-#endif // CHROME_BROWSER_DEBUGGER_DEBUGGER_SHELL_H_
diff --git a/chrome/browser/debugger/debugger_shell_stubs.cc b/chrome/browser/debugger/debugger_shell_stubs.cc
deleted file mode 100644
index edf1d4f..0000000
--- a/chrome/browser/debugger/debugger_shell_stubs.cc
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2009 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/debugger_shell.h"
-
-#ifndef CHROME_DEBUGGER_DISABLED
-DebuggerShell::DebuggerShell(DebuggerInputOutput *io) { }
-DebuggerShell::~DebuggerShell() { }
-void DebuggerShell::Start() { NOTIMPLEMENTED(); }
-void DebuggerShell::Debug(TabContents* tab) { NOTIMPLEMENTED(); }
-void DebuggerShell::DebugMessage(const std::wstring& msg) { NOTIMPLEMENTED(); }
-void DebuggerShell::OnDebugAttach() { NOTIMPLEMENTED(); }
-void DebuggerShell::OnDebugDisconnect() { NOTIMPLEMENTED(); }
-void DebuggerShell::DidConnect() { NOTIMPLEMENTED(); }
-void DebuggerShell::DidDisconnect() { NOTIMPLEMENTED(); }
-void DebuggerShell::ProcessCommand(const std::wstring& data) {
-  NOTIMPLEMENTED();
-}
-#endif  // !CHROME_DEBUGGER_DISABLED
diff --git a/chrome/browser/debugger/debugger_view.cc b/chrome/browser/debugger/debugger_view.cc
deleted file mode 100644
index 8775aa5..0000000
--- a/chrome/browser/debugger/debugger_view.cc
+++ /dev/null
@@ -1,164 +0,0 @@
-// Copyright (c) 2006-2008 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/debugger_view.h"
-
-#include "app/gfx/canvas.h"
-#include "app/resource_bundle.h"
-#include "base/logging.h"
-#include "base/string_util.h"
-#include "base/json_writer.h"
-#include "base/values.h"
-#include "chrome/browser/browser_list.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/debugger/debugger_shell.h"
-#include "chrome/browser/debugger/debugger_window.h"
-#include "chrome/browser/debugger/debugger_wrapper.h"
-#include "chrome/browser/dom_ui/chrome_url_data_manager.h"
-#include "chrome/browser/renderer_host/render_view_host.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
-#include "chrome/browser/view_ids.h"
-#include "chrome/browser/views/tab_contents/tab_contents_container.h"
-#include "chrome/common/url_constants.h"
-#include "grit/debugger_resources.h"
-#include "views/grid_layout.h"
-#include "views/controls/scrollbar/native_scroll_bar.h"
-#include "views/controls/scroll_view.h"
-#include "views/standard_layout.h"
-#include "views/view.h"
-
-DebuggerView::DebuggerView(DebuggerWindow* window)
-    : window_(window), output_ready_(false) {
-  web_container_ = new TabContentsContainer;
-  AddChildView(web_container_);
-  AddAccelerator(views::Accelerator(VK_ESCAPE, false, false, false));
-}
-
-DebuggerView::~DebuggerView() {
-}
-
-gfx::Size DebuggerView::GetPreferredSize() {
-  return gfx::Size(700, 400);
-}
-
-void DebuggerView::Layout() {
-  web_container_->SetBounds(0, 0, width(), height());
-}
-
-
-void DebuggerView::ViewHierarchyChanged(bool is_add,
-                                        views::View* parent,
-                                        views::View* child) {
-  if (is_add && child == this) {
-    DCHECK(GetWidget());
-    OnInit();
-  }
-}
-
-void DebuggerView::Paint(gfx::Canvas* canvas) {
-#ifndef NDEBUG
-  SkPaint paint;
-  canvas->FillRectInt(SK_ColorCYAN, x(), y(), width(), height());
-#endif
-}
-
-void DebuggerView::SetOutputViewReady() {
-  output_ready_ = true;
-  for (std::vector<std::wstring>::iterator i = pending_output_.begin();
-       i != pending_output_.end(); ++i) {
-    Output(*i);
-  }
-  pending_output_.clear();
-
-  for (std::vector<std::string>::const_iterator i = pending_events_.begin();
-       i != pending_events_.end(); ++i) {
-    ExecuteJavascript(*i);
-  }
-  pending_events_.clear();
-}
-
-void DebuggerView::Output(const std::string& out) {
-  Output(UTF8ToWide(out));
-}
-
-void DebuggerView::Output(const std::wstring& out) {
-  if (!output_ready_) {
-    pending_output_.push_back(out);
-    return;
-  }
-
-  DictionaryValue* body = new DictionaryValue;
-  body->Set(L"text", Value::CreateStringValue(out));
-  SendEventToPage(L"appendText", body);
-}
-
-void DebuggerView::OnInit() {
-  // We can't create the TabContents until we've actually been put into a real
-  // view hierarchy somewhere.
-  Profile* profile = BrowserList::GetLastActive()->profile();
-  tab_contents_ = new TabContents(profile, NULL, MSG_ROUTING_NONE, NULL);
-
-  tab_contents_->set_delegate(this);
-  web_container_->ChangeTabContents(tab_contents_);
-  tab_contents_->render_view_host()->AllowDOMUIBindings();
-
-  GURL contents(std::string(chrome::kChromeUIScheme) +
-                "://inspector/debugger.html");
-  tab_contents_->controller().LoadURL(contents, GURL(),
-                                      PageTransition::START_PAGE);
-}
-
-void DebuggerView::OnShow() {
-  tab_contents_->Focus();
-}
-
-void DebuggerView::OnClose() {
-  web_container_->ChangeTabContents(NULL);
-  delete tab_contents_;
-}
-
-void DebuggerView::OpenURLFromTab(TabContents* source,
-                               const GURL& url,
-                               const GURL& referrer,
-                               WindowOpenDisposition disposition,
-                               PageTransition::Type transition) {
-  BrowserList::GetLastActive()->OpenURL(url, referrer, disposition,
-                                        transition);
-}
-
-
-void DebuggerView::SendEventToPage(const std::wstring& name,
-                                   Value* body) {
-  DictionaryValue msg;
-  msg.SetString(L"type", L"event");
-  msg.SetString(L"event", name);
-  msg.Set(L"body", body);
-
-  std::string json;
-  JSONWriter::Write(&msg, false, &json);
-
-  const std::string js =
-    StringPrintf("DebuggerIPC.onMessageReceived(%s)", json.c_str());
-  if (output_ready_) {
-    ExecuteJavascript(js);
-  } else {
-    pending_events_.push_back(js);
-  }
-}
-
-void DebuggerView::ExecuteJavascript(const std::string& js) {
-  tab_contents_->render_view_host()->ExecuteJavascriptInWebFrame(L"",
-      UTF8ToWide(js));
-}
-
-void DebuggerView::LoadingStateChanged(TabContents* source) {
-  if (!source->is_loading())
-    SetOutputViewReady();
-}
-
-bool DebuggerView::AcceleratorPressed(const views::Accelerator& accelerator) {
-  DCHECK(accelerator.GetKeyCode() == VK_ESCAPE);
-  window_->window()->Close();
-  return true;
-}
diff --git a/chrome/browser/debugger/debugger_view.h b/chrome/browser/debugger/debugger_view.h
deleted file mode 100644
index 6790497..0000000
--- a/chrome/browser/debugger/debugger_view.h
+++ /dev/null
@@ -1,102 +0,0 @@
-// Copyright (c) 2006-2008 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.
-
-// Simple UI for the command-line V8 debugger consisting of a text field for
-// entry and an output view consisting of (potentially wrapped) lines of text.
-
-// TODO(erikkay): investigate replacing this with a DHTML interface
-
-#ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_VIEW_H__
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_VIEW_H__
-
-#include "app/gfx/font.h"
-#include "base/gfx/size.h"
-#include "chrome/browser/tab_contents/tab_contents_delegate.h"
-#include "views/view.h"
-
-class DebuggerView;
-class DebuggerWindow;
-class TabContents;
-class TabContentsContainer;
-class Value;
-
-class DebuggerView : public views::View,
-                     public TabContentsDelegate {
- public:
-  explicit DebuggerView(DebuggerWindow* window);
-  virtual ~DebuggerView();
-
-  // Output a line of text to the debugger view
-  void Output(const std::string& out);
-  void Output(const std::wstring& out);
-
-  void OnInit();
-
-  // Called when the window is shown.
-  void OnShow();
-
-  // Called when the window is being closed.
-  void OnClose();
-
-  void SetOutputViewReady();
-
-  // Overridden from views::View:
-  virtual std::string GetClassName() const {
-    return "DebuggerView";
-  }
-  virtual gfx::Size GetPreferredSize();
-  virtual void Layout();
-  virtual void Paint(gfx::Canvas* canvas);
-  virtual void ViewHierarchyChanged(bool is_add,
-                                    views::View* parent,
-                                    views::View* child);
-
-  // Overridden from PageNavigator (TabContentsDelegate's base interface):
-  virtual void OpenURLFromTab(TabContents* source,
-                              const GURL& url,
-                              const GURL& referrer,
-                              WindowOpenDisposition disposition,
-                              PageTransition::Type transition);
-
-  // Overridden from TabContentsDelegate:
-  virtual void NavigationStateChanged(const TabContents* source,
-                                      unsigned changed_flags) {}
-  virtual void AddNewContents(TabContents* source,
-                              TabContents* new_contents,
-                              WindowOpenDisposition disposition,
-                              const gfx::Rect& initial_pos,
-                              bool user_gesture) {}
-  virtual void ActivateContents(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 void ToolbarSizeChanged(TabContents* source, bool is_animating) {}
-  virtual void URLStarredChanged(TabContents* source, bool) {}
-  virtual void UpdateTargetURL(TabContents* source, const GURL& url) {}
-  virtual bool CanBlur() const { return false; }
-
-  // To pass messages from DebuggerHost to debugger UI.
-  // Note that this method will take ownership of body.
-  void SendEventToPage(const std::wstring& name, Value* body);
-
-  // Handles escape key and close the debug window.
-  virtual bool AcceleratorPressed(const views::Accelerator& accelerator);
-
- private:
-  void ExecuteJavascript(const std::string& js);
-
-  DebuggerWindow* window_;
-  gfx::Font font_;
-  TabContents* tab_contents_;
-  TabContentsContainer* web_container_;
-  std::vector<std::wstring> pending_output_;
-  std::vector<std::string> pending_events_;
-  bool output_ready_;
-
-  DISALLOW_EVIL_CONSTRUCTORS(DebuggerView);
-};
-
-
-#endif // CHROME_BROWSER_DEBUGGER_DEBUGGER_VIEW_H__
diff --git a/chrome/browser/debugger/debugger_window.cc b/chrome/browser/debugger/debugger_window.cc
deleted file mode 100644
index 7b3738b..0000000
--- a/chrome/browser/debugger/debugger_window.cc
+++ /dev/null
@@ -1,181 +0,0 @@
-// Copyright (c) 2006-2008 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/debugger_window.h"
-
-#include "app/l10n_util.h"
-#include "base/string_util.h"
-#include "base/values.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/debugger/debugger_host_impl.h"
-#include "chrome/browser/debugger/debugger_view.h"
-#include "chrome/browser/debugger/debugger_wrapper.h"
-#include "chrome/browser/tab_contents/constrained_window.h"
-#include "chrome/browser/tab_contents/tab_contents.h"
-#include "grit/generated_resources.h"
-
-DebuggerWindow::DebuggerWindow() : window_(NULL),
-                             view_(NULL),
-                             debugger_ready_(true),
-                             debugger_break_(false) {
-}
-
-DebuggerWindow::~DebuggerWindow() {
-}
-
-DebuggerHost* DebuggerWindow::GetAnyExistingDebugger() {
-  DebuggerWrapper* wrapper = g_browser_process->debugger_wrapper();
-  if (!wrapper)
-    return NULL;
-  return wrapper->GetDebugger();
-}
-
-void DebuggerWindow::Show(TabContents* tab) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (ShowWindow())
-    return;
-  view_ = new DebuggerView(this);
-  window_ = views::Window::CreateChromeWindow(NULL, gfx::Rect(), this);
-  window_->Show();
-  view_->OnShow();
-  debugger_ready_ = true;
-  debugger_break_ = false;
-  DebuggerHostImpl* debugger = new DebuggerHostImpl(this);
-  DebuggerWrapper* wrapper = g_browser_process->debugger_wrapper();
-  if (!wrapper) {
-    g_browser_process->InitDebuggerWrapper(0);
-    wrapper = g_browser_process->debugger_wrapper();
-  }
-  wrapper->SetDebugger(debugger);
-  debugger->Start();
-  // TODO(erikkay): this method name should really change, or maybe even
-  // go away / merge into start.  It's a legacy from the telnet code.
-  debugger->DidConnect();
-  debugger->Debug(tab);
-#endif
-}
-
-
-///////////////////////////////////////////////////////////////////
-// DebuggerInputOutput overrides
-
-void DebuggerWindow::Output(const std::wstring &out) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (view_)
-    view_->Output(out);
-#endif
-}
-
-void DebuggerWindow::OutputLine(const std::wstring &out) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (view_)
-    view_->Output(out);
-#endif
-}
-
-void DebuggerWindow::OutputPrompt(const std::wstring& prompt) {
-}
-
-void DebuggerWindow::Output(const std::string &out) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (view_)
-    view_->Output(out);
-#endif
-}
-
-void DebuggerWindow::OutputLine(const std::string &out) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (view_)
-    view_->Output(out);
-#endif
-}
-
-void DebuggerWindow::OutputPrompt(const std::string& prompt) {
-}
-
-void DebuggerWindow::Start(DebuggerHost* debugger) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  DebuggerInputOutput::Start(debugger);
-#endif
-}
-
-void DebuggerWindow::SetDebuggerReady(bool ready) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (debugger_ready_ != ready) {
-    debugger_ready_ = ready;
-    if (window_)
-      window_->UpdateWindowTitle();
-  }
-#endif
-}
-
-void DebuggerWindow::SetDebuggerBreak(bool brk) {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (debugger_break_ != brk) {
-    debugger_break_ = brk;
-    if (window_) {
-      window_->UpdateWindowTitle();
-      if (brk)
-        window_->Activate();
-    }
-  }
-#endif
-}
-
-void DebuggerWindow::CallFunctionInPage(const std::wstring& name,
-                                        ListValue* argv) {
-  if (view_) {
-    DictionaryValue* body = new DictionaryValue;
-    body->Set(L"arguments", argv);
-    view_->SendEventToPage(name, body);
-  } else {
-    delete argv;
-  }
-}
-
-bool DebuggerWindow::ShowWindow() {
-#ifndef CHROME_DEBUGGER_DISABLED
-  if (window_) {
-    window_->Show();
-    view_->OnShow();
-    return true;
-  }
-#endif
-  return false;
-}
-
-///////////////////////////////////////////////////////////////////
-// views::WindowDelegate methods
-
-std::wstring DebuggerWindow::GetWindowTitle() const {
-  if (!debugger_ready_) {
-    return l10n_util::GetString(IDS_DEBUGGER_TITLE_BUSY);
-  } else if (debugger_break_) {
-    return l10n_util::GetString(IDS_DEBUGGER_TITLE_BREAK);
-  } else {
-    return l10n_util::GetString(IDS_DEBUGGER_TITLE_RUNNING);
-  }
-}
-
-void DebuggerWindow::WindowClosing() {
-#ifndef CHROME_DEBUGGER_DISABLED
-  view_->OnClose();
-#endif
-  window_ = NULL;
-  view_ = NULL;
-#ifndef CHROME_DEBUGGER_DISABLED
-  debugger_->DidDisconnect();
-#endif
-  debugger_ = NULL;
-  DebuggerWrapper* wrapper = g_browser_process->debugger_wrapper();
-  wrapper->SetDebugger(NULL);
-}
-
-bool DebuggerWindow::CanResize() const {
-  return true;
-}
-
-views::View* DebuggerWindow::GetContentsView() {
-  return view_;
-}
diff --git a/chrome/browser/debugger/debugger_window.h b/chrome/browser/debugger/debugger_window.h
deleted file mode 100644
index b22fe16..0000000
--- a/chrome/browser/debugger/debugger_window.h
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) 2006-2008 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_DEBUGGER_WINDOW_H__
-#define CHROME_BROWSER_DEBUGGER_DEBUGGER_WINDOW_H__
-
-#include "chrome/browser/debugger/debugger_io.h"
-#include "views/window/window.h"
-#include "views/window/window_delegate.h"
-
-class DebuggerHost;
-class DebuggerView;
-class ListValue;
-class TabContents;
-
-class DebuggerWindow : public DebuggerInputOutput,
-                       public views::WindowDelegate {
- public:
-  DebuggerWindow();
-  virtual ~DebuggerWindow();
-
-  // returns true if a debugger has already been instantiated
-  static DebuggerHost* GetAnyExistingDebugger();
-
-  // Show the window
-  void Show(TabContents* tab);
-
-  // overrides from DebuggerInputOutput
-  virtual void Output(const std::wstring& out);
-  virtual void OutputLine(const std::wstring& out);
-  virtual void OutputPrompt(const std::wstring& prompt);
-  virtual void Output(const std::string& out);
-  virtual void OutputLine(const std::string& out);
-  virtual void OutputPrompt(const std::string& prompt);
-  virtual void Start(DebuggerHost* debugger);
-  virtual void SetDebuggerReady(bool ready);
-  virtual void SetDebuggerBreak(bool brk);
-  virtual bool ShowWindow();
-
-  // Note that this method will take ownership of argv.
-  virtual void CallFunctionInPage(const std::wstring& name,
-                                  ListValue* argv);
-
-  // views::WindowDelegate methods:
-  virtual std::wstring GetWindowTitle() const;
-  virtual void WindowClosing();
-  virtual bool CanResize() const;
-  virtual views::View* GetContentsView();
-
- private:
-  views::Window* window_;
-  DebuggerView* view_;
-
-  bool debugger_ready_;
-  bool debugger_break_;
-
-  DISALLOW_EVIL_CONSTRUCTORS(DebuggerWindow);
-};
-
-#endif // CHROME_BROWSER_DEBUGGER_DEBUGGER_WINDOW_H__
diff --git a/chrome/browser/debugger/debugger_wrapper.cc b/chrome/browser/debugger/debugger_wrapper.cc
index 5f01b9d..fa2fac6 100644
--- a/chrome/browser/debugger/debugger_wrapper.cc
+++ b/chrome/browser/debugger/debugger_wrapper.cc
@@ -4,36 +4,21 @@
 
 #include "chrome/browser/debugger/debugger_wrapper.h"
 
-#include "base/command_line.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/debugger/debugger_shell.h"
-#include "chrome/browser/debugger/debugger_io_socket.h"
-#include "chrome/browser/debugger/debugger_host.h"
 #include "chrome/browser/debugger/debugger_remote_service.h"
 #include "chrome/browser/debugger/devtools_protocol_handler.h"
 #include "chrome/browser/debugger/devtools_remote_service.h"
-#include "chrome/common/chrome_switches.h"
 
 DebuggerWrapper::DebuggerWrapper(int port) {
-#ifndef CHROME_DEBUGGER_DISABLED
   if (port > 0) {
-    if (CommandLine::ForCurrentProcess()->HasSwitch(
-        switches::kDisableOutOfProcessDevTools)) {
-      DebuggerInputOutputSocket *io = new DebuggerInputOutputSocket(port);
-      debugger_ = new DebuggerShell(io);
-      debugger_->Start();
-    } else {
-      proto_handler_ = new DevToolsProtocolHandler(port);
-      proto_handler_->RegisterDestination(
-          new DevToolsRemoteService(proto_handler_),
-          DevToolsRemoteService::kToolName);
-      proto_handler_->RegisterDestination(
-          new DebuggerRemoteService(proto_handler_),
-          DebuggerRemoteService::kToolName);
-      proto_handler_->Start();
-    }
+    proto_handler_ = new DevToolsProtocolHandler(port);
+    proto_handler_->RegisterDestination(
+        new DevToolsRemoteService(proto_handler_),
+        DevToolsRemoteService::kToolName);
+    proto_handler_->RegisterDestination(
+        new DebuggerRemoteService(proto_handler_),
+        DebuggerRemoteService::kToolName);
+    proto_handler_->Start();
   }
-#endif
 }
 
 DebuggerWrapper::~DebuggerWrapper() {
@@ -41,26 +26,3 @@ DebuggerWrapper::~DebuggerWrapper() {
     proto_handler_->Stop();
   }
 }
-
-void DebuggerWrapper::SetDebugger(DebuggerHost* debugger) {
-  debugger_ = debugger;
-}
-
-DebuggerHost* DebuggerWrapper::GetDebugger() {
-  return debugger_.get();
-}
-
-void DebuggerWrapper::DebugMessage(const std::wstring& msg) {
-  if (debugger_.get())
-    debugger_->DebugMessage(msg);
-}
-
-void DebuggerWrapper::OnDebugAttach() {
-  if (debugger_.get())
-    debugger_->OnDebugAttach();
-}
-
-void DebuggerWrapper::OnDebugDisconnect() {
-  if (debugger_.get())
-    debugger_->OnDebugDisconnect();
-}
diff --git a/chrome/browser/debugger/debugger_wrapper.h b/chrome/browser/debugger/debugger_wrapper.h
index 943b816..1a29566 100644
--- a/chrome/browser/debugger/debugger_wrapper.h
+++ b/chrome/browser/debugger/debugger_wrapper.h
@@ -5,15 +5,6 @@
 // Include this file if you need to access the Debugger outside of the debugger
 // project.  Don't include debugger.h directly.  If there's functionality from
 // Debugger needed, add new wrapper methods to this file.
-//
-// This is a workaround to enable the Debugger without breaking the KJS build.
-// It wraps all methods in Debugger which are called from outside of the
-// debugger project.  Each solution has its own project with debugger files.
-// KJS has only debugger_wrapper* and debugger.h, and defines
-// CHROME_DEBUGGER_DISABLED, which makes it compile only a stub version of
-// Debugger that doesn't reference V8.  Meanwhile the V8 solution includes all
-// of the debugger files without CHROME_DEBUGGER_DISABLED so the full
-// functionality is enabled.
 
 #ifndef CHROME_BROWSER_DEBUGGER_DEBUGGER_WRAPPER_H_
 #define CHROME_BROWSER_DEBUGGER_DEBUGGER_WRAPPER_H_
@@ -33,16 +24,7 @@ class DebuggerWrapper : public base::RefCountedThreadSafe<DebuggerWrapper> {
 
   virtual ~DebuggerWrapper();
 
-  void SetDebugger(DebuggerHost* debugger);
-  DebuggerHost* GetDebugger();
-
-  void DebugMessage(const std::wstring& msg);
-
-  void OnDebugAttach();
-  void OnDebugDisconnect();
-
  private:
-  scoped_refptr<DebuggerHost> debugger_;
   scoped_refptr<DevToolsProtocolHandler> proto_handler_;
 };
 
diff --git a/chrome/browser/debugger/resources/debugger.css b/chrome/browser/debugger/resources/debugger.css
deleted file mode 100644
index ed9df2f..0000000
--- a/chrome/browser/debugger/resources/debugger.css
+++ /dev/null
@@ -1,35 +0,0 @@
-/** 
- * Style for javascript debugger.  See debugger.html.
- */
-
-html,body {
-  margin: 0px;
-  padding: 0px;
-  height: 100%;
-}
-#output {
-  font-family: monospace;
-  background-color: #ffffff;
-  min-height: 100%;
-}
-#outer {
-  height: 100%;
-  width: 100%;
-  white-space: pre-wrap;
-  padding: 0px 0px 24px 0px;
-}
-#command-line {
-  bottom: 0px;
-  /* not quite sure why this 5px is necessary */
-  right: 5px;
-  left: 0px;
-  position: fixed;
-  padding: 0px;
-  margin: 0px;
-}
-#command-line-text {
-  height: 20px;
-  display: block;
-  width: 100%;
-  font-family: monospace;
-}
diff --git a/chrome/browser/debugger/resources/debugger.html b/chrome/browser/debugger/resources/debugger.html
deleted file mode 100644
index 7eab990..0000000
--- a/chrome/browser/debugger/resources/debugger.html
+++ /dev/null
@@ -1,34 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
- "http://www.w3.org/TR/html4/strict.dtd"> 
-<html>
-<!--
- The UI for the javascript debugger window.
--->
-  <head>
-    <title>JavaScript Debugger</title>
-    <meta http-equiv="Content-Type" content="text/html; charset=UTF8" />
-    <link rel="stylesheet" href="debugger.css" type="text/css" />
-    <script type="text/javascript" src="debugger.js"></script>
-  </head>
-
-  <body>
-  
-    <table id='outer'>
-      <tr>
-        <td valign='bottom' id='output'>Chrome JavaScript Debugger<br />Type 'help' for a list of commands.<br /></td>
-      </tr>
-    </table>
-
-    <div id='command-line'>
-      <!-- TODO(erikkay) - use addEventListener instead -->
-      <input id='command-line-text'
-             onkeydown="return keydown(event);"
-             onkeypress="return keypress(event);" type="text" />
-    </div>
-
-  <script type="text/javascript" language="javascript">
-    loaded();
-  </script>
-  
-  </body>
-</html>
diff --git a/chrome/browser/debugger/resources/debugger.js b/chrome/browser/debugger/resources/debugger.js
deleted file mode 100644
index a52a5c0..0000000
--- a/chrome/browser/debugger/resources/debugger.js
+++ /dev/null
@@ -1,124 +0,0 @@
-/**
- * @fileoverview Helper functions and objects for the JS debugger UI.
- * @see debugger.html
- */
-
-/**
- * Called at the end of <body>.
- */
-function loaded() {
-  focusOnCommandLine();
-};
-
-/**
- * Sets focus to command-line-text element.
- */
-function focusOnCommandLine() {
-  var input = document.getElementById('command-line-text');
-  input.focus();
-};
-
-/**
- * Called by chrome code when there's output to display.
- */
-function appendText(txt) {
-  var output = document.getElementById('output');
-  output.appendChild(document.createTextNode(txt));
-  output.appendChild(document.createElement('br'));
-  document.body.scrollTop = document.body.scrollHeight;
-};
-
-// command object stores command-line history state.
-var command = {
-  history: [],
-  history_index: 0,
-  pending: null
-};
-
-/**
- * Execute a debugger command, add it to the command history and display it in
- * the output window.
- */
-function executeCommand(str) {
-  appendText("$ " + str);
-  // Sends field.value to DebuggerContents.HandleCommand.
-  chrome.send("command", [str]);
-  command.history.push(str);
-  command.history_index = command.history.length;
-  command.pending = null;
-};
-
-/**
- * Display the previous history item in the given text field.
- */
-function selectPreviousCommand(field) {
-  if (command.history_index > 0) {
-    // Remember the current field value as a pending command if we're at the
-    // end (it's something the user typed in).
-    if (command.history_index == command.history.length)
-      command.pending = field.value;
-    command.history_index--;
-    field.value = command.history[command.history_index];
-    field.select();
-  }
-};
-
-/**
- * Display the next history item in the given text field.
- */
-function selectNextCommand(field) {
-  if (command.history_index < command.history.length) {
-    command.history_index++;
-    if (command.history_index == command.history.length) {
-      field.value = command.pending || "";
-    } else {
-      field.value = command.history[command.history_index];
-    }
-    field.select();
-  }
-};
-
-
-/**
- * command-line-text's onkeypress handler
- */
-function keypress(e) {
-  var field = e.target;
-  var key = e.keyCode;
-  if (key == 13) { // enter
-    executeCommand(field.value);
-    field.value = "";
-    return false;
-  }
-  return true;
-};
-
-/**
- * command-line-text's onkeydown handler
- */
-function keydown(e) {
-  var field = e.target;
-  var key = e.keyCode;
-  if (key == 38) { // up arrow
-    selectPreviousCommand(field);
-    return false;
-  } else if (key == 40) { // down arrow
-    selectNextCommand(field);
-    return false;
-  }
-  return true;
-};
-
-/**
- * Called by chrome code to set the current state as to whether the debugger
- * is stopped at a breakpoint or is running.
- */
-function setDebuggerBreak(is_broken) {
-  var out = document.getElementById('output');
-  if (is_broken) {
-    out.style.color = "black";
-    focusOnCommandLine();
-  } else {
-    out.style.color = "gray";
-  }
-};
diff --git a/chrome/browser/debugger/resources/debugger_resources.grd b/chrome/browser/debugger/resources/debugger_resources.grd
deleted file mode 100644
index 37c1ff4..0000000
--- a/chrome/browser/debugger/resources/debugger_resources.grd
+++ /dev/null
@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<grit latest_public_release="0" current_release="1">
-  <outputs>
-    <output filename="grit/debugger_resources.h" type="rc_header">
-      <emit emit_type='prepend'></emit>
-    </output>
-    <output filename="debugger_resources.rc" type="rc_all" />
-    <output filename="debugger_resources.pak" type="data_package" />
-  </outputs>
-  <release seq="1">
-    <includes>
-      <include name="IDR_DEBUGGER_SHELL_JS" file="debugger_shell.js" type="BINDATA" />
-      <include name="IDR_DEBUGGER_HTML" file="debugger.html" type="BINDATA" />
-      <include name="IDR_DEBUGGER_CSS" file="debugger.css" type="BINDATA" />
-      <include name="IDR_DEBUGGER_JS" file="debugger.js" type="BINDATA" />
-    </includes>
-  </release>
-</grit>
\ No newline at end of file
diff --git a/chrome/browser/debugger/resources/debugger_shell.js b/chrome/browser/debugger/resources/debugger_shell.js
deleted file mode 100644
index 70114b0..0000000
--- a/chrome/browser/debugger/resources/debugger_shell.js
+++ /dev/null
@@ -1,1378 +0,0 @@
-/**
- * @fileoverview Shell objects and global helper functions for Chrome 
- * automation shell / debugger.  This file is loaded into the global namespace
- * of the interactive shell, so users can simply call global functions 
- * directly.
- */
-
-// TODO(erikkay): look into how this can be split up into multiple files
-// It's currently loaded explicitly by Chrome, so maybe I need an "include"
-// or "source" builtin to allow a core source file to reference multiple
-// sub-files.
-
-/**
- * Sequence number of the DebugCommand.
- */
-DebugCommand.next_seq_ = 0;
-
-/**
- * Command messages to be sent to the debugger.
- * @constructor
- */
-function DebugCommand(str) {
-  this.command = undefined;
-  // first, strip off of the leading word as the command
-  var argv = str.split(' ');
-  this.user_command = argv.shift();
-  // the rest of the string is argv to the command
-  str = argv.join(' ');
-  if (DebugCommand.aliases[this.user_command])
-    this.user_command = DebugCommand.aliases[this.user_command];
- if (this.parseArgs_(str) == 1)
-   this.type = "request";	
- if (this.command == undefined)	
-   this.command = this.user_command;
-};
-
-// Mapping of some control characters to avoid the \uXXXX syntax for most
-// commonly used control cahracters.
-const ctrlCharMap_ = {
-  '\b': '\\b',
-  '\t': '\\t',
-  '\n': '\\n',
-  '\f': '\\f',
-  '\r': '\\r',
-  '"' : '\\"',
-  '\\': '\\\\'
-};
-
-// Regular expression matching ", \ and control characters (0x00 - 0x1F)
-// globally.
-const ctrlCharMatch_ = /["\\\\\x00-\x1F]/g;
-
-/**
- * Convert a String to its JSON representation.
- * @param {String} value - String to be converted
- * @return {String} JSON formatted String
- */
-DebugCommand.stringToJSON = function(value) {
-  // Check for" , \ and control characters (0x00 - 0x1F).
-  if (ctrlCharMatch_.test(value)) {
-    // Replace ", \ and control characters (0x00 - 0x1F).
-    return '"' + value.replace(ctrlCharMatch_, function (char) {
-        // Use charmap if possible.
-        var mapped = ctrlCharMap_[char];
-        if (mapped) return mapped;
-        mapped = char.charCodeAt();
-        // Convert control character to unicode escape sequence.
-        var dig1 = (Math.floor(mapped / 16));
-        var dig2 = (mapped % 16)
-        return '\\u00' + dig1.toString(16) + dig2.toString(16);
-      })
-    + '"';
-  }
-
-  // Simple string with no special characters.
-  return '"' + value + '"';
-};
-
-/**
- * @return {bool} True if x is an integer.
- */
-DebugCommand.isInt = function(x) { 
-   var y = parseInt(x); 
-   if (isNaN(y))
-     return false; 
-   return x == y && x.toString() == y.toString(); 
-};
-
-/**
- * @return {float} log base 10 of num
- */
-DebugCommand.log10 = function(num) {
-  return Math.log(num)/Math.log(10);
-};
-
-/**
- * Take an object and encode it (non-recursively) as a JSON dict.
- * @param {Object} obj - object to encode
- */
-DebugCommand.toJSON = function(obj) {
-  // TODO(erikkay): use a real JSON library
-  var json = '{';
-  for (var key in obj) {
-    if (json.length > 1)
-      json += ",";
-    var val = obj[key];
-    if (!DebugCommand.isInt(val)) {
-      val = DebugCommand.stringToJSON(val.toString());
-    }
-    json += '"' + key + '":' + val;
-  }
-  json += '}';
-  return json;
-};
-
-/**
- * Encode the DebugCommand object into the V8 debugger JSON protocol format.
- * @see http://wiki/Main/V8Debugger
- */
-DebugCommand.prototype.toJSONProtocol = function() {
-  // TODO(erikkay): use a real JSON library
-  var json = '{';
-  json += '"seq":"' + this.seq;
-  json += '","type":"' + this.type;
-  json += '","command":"' + this.command + '"';
-  if (this.arguments) {
-    json += ',"arguments":' + DebugCommand.toJSON(this.arguments);
-  }
-  json += '}'
-  return json;
-}
-
-/**
- * Encode the contents of this message and send it to the debugger.
- * @param {Object} tab - tab being debugged.  This is an internal
- *     Chrome object.
- */
-DebugCommand.prototype.sendToDebugger = function(tab) {
-  this.seq = DebugCommand.next_seq_++;
-  str = this.toJSONProtocol();
-  dprint("sending: " + str);
-  tab.sendToDebugger(str);
-};
-
-DebugCommand.trim = function(str) {
-  return str.replace(/^\s*/, '').replace(/\s*$/, '');
-};
-
-/**
- * Strip off a trailing parameter after a ':'. As the identifier for the
- * source can contain ':' characters (e.g. 'http://www....) something after
- * a ':' is only considered a parameter if it is numeric. 
- * @return {Array} two element array, the trimmed string and the parameter,
- *   or -1 if no parameter
- */
-DebugCommand.stripTrailingParameter = function(str, opt_separator) {
-  var sep = opt_separator || ':';
-  var index = str.lastIndexOf(sep);
-  // If a separator character if found strip if numeric.
-  if (index != -1) {
-    var value = parseInt(str.substring(index + 1, str.length), 10);
-    if (isNaN(value) || value < 0) {
-      return [str, -1];
-    }
-    str = str.substring(0, index);
-    return [str, value];
-  }
-  return [str, -1];
-};
-
-/**
- * Format source and location strings based on source location input data.
- * @param {Object} script - script information object
- * @param {String} source - source code for the current location
- * @param {int} line - line number (0-based)
- * @param {String} func - function name
- * @return {array} [location(string), source line(string), line number(int)]
- */
-DebugCommand.getSourceLocation = function(script, source, line, func) {
-  // source line is 0-based, we present as 1-based
-  line++;
-
-  // TODO(erikkay): take column into account as well
-  if (source)
-    source = "" + line + ": " + source;
-  var location = '';
-  if (func) {
-    location = func + ", ";
-  }
-  location += script ? script.name : '[no source]';
-  return [location, source, line];
-};
-
-/**
- * Aliases for debugger commands.
- */
-DebugCommand.aliases = {
-  'b': 'break',
-  'bi': 'break_info',
-  'br': 'break',
-  'bt': 'backtrace',
-  'c': 'continue',
-  'f': 'frame',
-  'h': 'help',
-  '?': 'help',
-  'ls': 'source',
-  'n': 'next',
-  'p': 'print',
-  's': 'step',
-  'so': 'stepout',
-};
-
-/**
- * Parses arguments to "args" and "locals" command, and initializes
- * the underlying DebugCommand (which is a frame request).
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseArgsAndLocals_ = function(str) {
-  this.command = "frame";
-  return str.length ? -1 : 1;
-};
-
-/**
- * Parses arguments to "break_info" command, and executes it.
- * "break_info" has an optional argument, which is the breakpoint
- * identifier.
- * @see DebugCommand.commands
- * @param {string} str - The arguments to be parsed.
- * @return -1 for usage error, 0 for success
- */
-DebugCommand.prototype.parseBreakInfo_ = function(str) {
-  this.type = "shell";
-
-  // Array of breakpoints to be printed by this command
-  // (default to all breakpoints)
-  var breakpointsToPrint = shell_.breakpoints;
-
-  if (str.length > 0) {
-    // User specified an invalid breakpoint (not a number)
-    if (!str.match(/^\s*\d+\s*$/))  
-      return -1; // invalid usage
-
-    // Check that the specified breakpoint identifier exists
-    var id = parseInt(str);
-    var info = shell_.breakpoints[id];
-    if (!info) {
-      print("Error: Invalid breakpoint");
-      return 0; // success (of sorts)
-    }
-    breakpointsToPrint = [info];
-  } else {
-    // breakpointsToPrint.length isn't accurate, because of
-    // deletions
-    var num_breakpoints = 0;
-    for (var i in breakpointsToPrint) num_breakpoints++;
-    
-    print("Num breakpoints: " + num_breakpoints);
-  }
-
-  DebugShell.printBreakpoints_(breakpointsToPrint);
-
-  return 0; // success
-}
-
-/**
- * Parses arguments to "step" command. 
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseStep_ = function(str, opt_stepaction) {
-  this.command = "continue";
-  action = opt_stepaction || "in";
-  this.arguments = {"stepaction" : action}
-  if (str.length) {
-    count = parseInt(str);
-    if (count > 0) {
-      this.arguments["stepcount"] = count;
-    } else {
-      return -1;
-    }
-  }
-  return 1;
-};
-
-/**
- * Parses arguments to "step" command. 
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseStepOut_ = function(str) {
-  return this.parseStep_(str, "out");
-};
-
-/**
- * Parses arguments to "next" command. 
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseNext_ = function(str) {
-  return this.parseStep_(str, "next");
-};
-
-/**
- * Parse the arguments to "print" command.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return 1 - always succeeds
- */
-DebugCommand.prototype.parsePrint_ = function(str) {
-  this.command = "evaluate";
-  this.arguments = { "expression" : str };
-  // If the page is in the running state, then we force the expression to
-  // evaluate in the global context to avoid evaluating in a random context.
-  if (shell_.running)
-    this.arguments["global"] = true;
-  return 1;
-};
-
-/**
- * Handle the response to a "print" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ProtocolPacket} evaluate_response - the V8 debugger response object
- */
-DebugCommand.responsePrint_ = function(evaluate_response) {
-  body = evaluate_response.body();
-  if (body['text'] != undefined) {
-    print(body['text']);
-  } else {
-    // TODO(erikkay): is "text" ever not set?
-    print("can't print response");
-  }
-};
-
-/**
- * Parses arguments to "break" command.  See DebugCommand.commands below
- * for syntax details.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success, 0 for handled internally
- */
-DebugCommand.prototype.parseBreak_ = function(str) {
-  function stripTrailingParameter() {
-    var ret = DebugCommand.stripTrailingParameter(str, ':');
-    str = ret[0];
-    return ret[1];
-  }
-  
-  if (str.length == 0) {
-    this.command = "break";
-    return 1;
-  } else {
-    var parts = str.split(/\s+/);
-    var condition = null;
-    if (parts.length > 1) {
-      str = parts.shift();
-      condition = parts.join(" ");
-    }
-  
-    this.command = "setbreakpoint";
-
-    // Locate ...[:line[:column]] if present.
-    var line = -1;
-    var column = -1;
-    line = stripTrailingParameter();
-    if (line != -1) {
-      line -= 1;
-      var l = stripTrailingParameter();
-      if (l != -1) {
-        column = line;
-        line = l - 1;
-      }
-    }
-
-    if (line == -1 && column == -1) {
-      this.arguments = { 'type' : 'function',
-                         'target' : str };
-    } else {
-      var script = shell_.matchScript(str, line);
-      if (script) {
-        this.arguments = { 'type' : 'script',
-                           'target' : script.name };
-      } else {
-        this.arguments = { 'type' : 'function',
-                           'target' : str };
-      }
-      this.arguments.line = line;
-      if (column != -1)
-        this.arguments.position = column;
-    }
-    if (condition)
-      this.arguments.condition = condition;
-  }
-  return 1;
-};
-
-/**
- * Handle the response to a "break" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ResponsePacket} setbreakpoint_response - the V8 debugger response
- *     object
- */
-DebugCommand.responseBreak_ = function(setbreakpoint_response) {
-  var body = setbreakpoint_response.body();
-  var info = new BreakpointInfo(
-      parseInt(body.breakpoint),
-      msg.command.arguments.type,
-      msg.command.arguments.target,
-      msg.command.arguments.line,
-      msg.command.arguments.position,
-      msg.command.arguments.condition);
-  shell_.addedBreakpoint(info);
-};
-
-/**
- * Parses arguments to "backtrace" command.  See DebugCommand.commands below
- * for syntax details.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
- DebugCommand.prototype.parseBacktrace_ = function(str) {
-  if (str.length > 0) {
-    var parts = str.split(/\s+/);
-    var non_empty_parts = parts.filter(function(s) { return s.length > 0; });
-    // We need exactly two arguments.
-    if (non_empty_parts.length != 2) {
-      return -1;
-    }
-    var from = parseInt(non_empty_parts[0], 10);
-    var to = parseInt(non_empty_parts[1], 10);
-    // The two arguments have to be integers.
-    if (from != non_empty_parts[0] || to != non_empty_parts[1]) {
-      return -1;
-    }
-    this.arguments = { 'fromFrame': from, 'toFrame': to + 1 };
-  } else {
-    // Default to fetching the first 10 frames.
-    this.arguments = { 'fromFrame': 0, 'toFrame': 10 };
-  }
-  return 1;
-};
-
-/**
- * Handle the response to a "backtrace" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ResponsePacket} backtrace_response - the V8 debugger response object
- */
-DebugCommand.responseBacktrace_ = function(backtrace_response) {
-  body = backtrace_response.body();
-  if (body && body.totalFrames) {
-    print('Frames #' + body.fromFrame + ' to #' + (body.toFrame - 1) +
-	  ' of ' + body.totalFrames + ":");
-    for (var i = 0; i < body.frames.length; i++) {
-      print(body.frames[i].text);
-    }
-  } else {
-    print("unimplemented (sorry)");
-  }
-};
-
-
-/**
- * Parses arguments to "clear" command.  See DebugCommand.commands below
- * for syntax details.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseClearCommand_ = function(str) {
-  this.command = "clearbreakpoint";
-  if (str.length > 0) {
-    var i = parseInt(str, 10);
-    if (i != str) {
-      return -1;
-    }
-    this.arguments = { 'breakpoint': i };
-  }
-  return 1;
-}
-
-/**
- * Handle the response to a "clear" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ResponsePacket} clearbreakpoint_response - the V8 debugger response
- *     object
- */
-DebugCommand.responseClear_ = function(clearbreakpoint_response) {
-  var body = clearbreakpoint_response.body();
-  shell_.clearedBreakpoint(parseInt(msg.command.arguments.breakpoint));
-}
-
-
-/**
- * Parses arguments to "continue" command.  See DebugCommand.commands below
- * for syntax details.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseContinueCommand_ = function(str) {
-  this.command = "continue";
-  if (str.length > 0) {
-    return -1;
-  }
-  return 1;
-}
-
-/**
- * Parses arguments to "frame" command.  See DebugCommand.commands below
- * for syntax details.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseFrame_ = function(str) {
-  if (str.length > 0) {
-    var i = parseInt(str, 10);
-    if (i != str) {
-      return -1;
-    }
-    this.arguments = { 'number': i };
-  }
-  return 1;
-};
-
-/**
- * Handle the response to a "frame" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ResponsePacket} frame_response - the V8 debugger response object
- */
-DebugCommand.responseFrame_ = function(frame_response) {
-  var body = frame_response.body();
-  var func = frame_response.lookup(body.func.ref);
-  loc = DebugCommand.getSourceLocation(func.script, 
-      body.sourceLineText, body.line, func.name);
-  print("#" + (body.index <= 9 ? '0' : '') + body.index + " " + loc[0]);
-  print(loc[1]);
-  shell_.current_frame = body.index;
-  shell_.current_line = loc[2];
-  shell_.current_script = func.script;
-};
-
-/**
- * Handle the response to a "args" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ProtocolPacket} frame_response - the V8 debugger response object (for
- *     "frame" command)
- */
-DebugCommand.responseArgs_ = function(frame_response) {
-  var body = frame_response.body();
-  DebugCommand.printVariables_(body.arguments, frame_response);
-}
-
-/**
- * Handle the response to a "locals" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {Object} msg - the V8 debugger response object (for "frame" command)
- */
-DebugCommand.responseLocals_ = function(frame_response) {
-  var body = frame_response.body();
-  DebugCommand.printVariables_(body.locals, frame_response);
-}
-
-DebugCommand.printVariables_ = function(variables, protocol_packet) {
-  for (var i = 0; i < variables.length; i++) {
-    print(variables[i].name + " = " +
-        DebugCommand.toPreviewString_(protocol_packet.lookup(variables[i].value.ref)));
-  }
-}
-
-DebugCommand.toPreviewString_ = function(value) {
-  // TODO(ericroman): pretty print arrays and objects, recursively.
-  // TODO(ericroman): truncate length of preview if too long?
-  if (value.type == "string") {
-    // Wrap the string in quote marks and JS-escape
-    return DebugCommand.stringToJSON(value.text);
-  }
-  return value.text;
-}
-
-/**
- * Parses arguments to "scripts" command.
- * @see DebugCommand.commands
- * @param {string} str - The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseScripts_ = function(str) {
-  return 1
-};
-
-/**
- * Handle the response to a "scripts" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ResponsePacket} scripts_response - the V8 debugger response object
- */
-DebugCommand.responseScripts_ = function(scripts_response) {
-  scripts = scripts_response.body();
-  shell_.scripts = [];
-  for (var i in scripts) {
-    var script = scripts[i];
-
-    // Add this script to the internal list of scripts.
-    shell_.scripts.push(script);
-    
-    // Print result if this response was the result of a user command.
-    if (scripts_response.command.from_user) {
-      var name = script.name;
-      if (name) {
-        if (script.lineOffset > 0) {
-          print(name + " (lines " + script.lineOffset + "-" +
-                (script.lineOffset + script.lineCount - 1) + ")");
-        } else {
-          print(name + " (lines " + script.lineCount + ")");
-        }
-      } else {
-        // For unnamed scripts (typically eval) display some source.
-        var sourceStart = script.sourceStart;
-        if (sourceStart.length > 40)
-          sourceStart = sourceStart.substring(0, 37) + '...';
-        print("[unnamed] (source:\"" + sourceStart + "\")");
-      }
-    }
-  }
-};
-
-/**
- * Parses arguments to "source" command.
- * @see DebugCommand.commands
- * @param {string} str - The arguments to be parsed.
- * @return -1 for usage error, 1 for success
- */
-DebugCommand.prototype.parseSource_ = function(str) {
-  this.arguments = {};
-  if (this.current_frame > 0)
-    this.arguments.frame = this.current_frame;
-  if (str.length) {
-    var args = str.split(" ");
-    if (args.length == 1) {
-      // with 1 argument n, we print 10 lines starting at n
-      var num = parseInt(args[0]);
-      if (num > 0) {
-        this.arguments.fromLine = num - 1;
-        this.arguments.toLine = this.arguments.fromLine + 10;
-      } else {
-        return -1;
-      }
-    } else if (args.length == 2) {
-      // with 2 arguments x and y, we print from line x to line x + y
-      var from = parseInt(args[0]);
-      var len = parseInt(args[1]);
-      if (from > 0 && len > 0) {
-        this.arguments.fromLine = from - 1;
-        this.arguments.toLine = this.arguments.fromLine + len;
-      } else {
-        return -1;
-      }
-    } else {
-      return -1;
-    }
-    if (this.arguments.fromLine < 0)
-      return -1;
-    if (this.arguments.toLine <= this.arguments.fromLine)
-      return -1;
-  } else if (shell_.current_line > 0) {
-    // with no arguments, we print 11 lines with the current line as the center
-    this.arguments.fromLine =
-        Math.max(0, shell_.current_line - 6);
-    this.arguments.toLine = this.arguments.fromLine + 11;
-  }
-  return 1;
-};
-
-/**
- * Handle the response to a "source" command and display output to user.
- * @see http://wiki/Main/V8Debugger
- * @param {ProtocolPacket} source_response - the V8 debugger response object
- */
-DebugCommand.responseSource_ = function(source_response) {
-  var body = source_response.body();
-  var from_line = parseInt(body.fromLine) + 1;
-  var source = body.source;
-  var lines = source.split('\n');
-  var maxdigits = 1 + Math.floor(DebugCommand.log10(from_line + lines.length))
-  for (var num in lines) {
-    // there's an extra newline at the end
-    if (num >= (lines.length - 1) && lines[num].length == 0)
-      break;
-    spacer = maxdigits - (1 + Math.floor(DebugCommand.log10(from_line)))
-    var line = "";
-    if (from_line == shell_.current_line) {
-      for (var i = 0; i < (maxdigits + 2); i++)
-        line += ">";
-    } else {
-      for (var i = 0; i < spacer; i++)
-        line += " ";
-      line += from_line + ": ";
-    }
-    line += lines[num];
-    print(line);
-    from_line++;
-  }
-};
-
-/**
- * Parses arguments to "help" command.  See DebugCommand.commands below
- * for syntax details.
- * @see DebugCommand.commands
- * @param {string} str The arguments to be parsed.
- * @return 0 for handled internally
- */
-DebugCommand.parseHelp_ = function(str) {
-  DebugCommand.help(str);
-  return 0;
-};
-
-/**
- * Takes argument and evaluates it in the context of the shell to allow commands
- * to be escaped to the outer shell.  Used primarily for development purposes.
- * @see DebugCommand.commands
- * @param {string} str The expression to be evaluated
- * @return 0 for handled internally
- */
-DebugCommand.parseShell_ = function(str) {
-  print(eval(str));
-  return 0;
-}
-
-DebugCommand.parseShellDebug_ = function(str) {
-  shell_.debug = !shell_.debug;
-  if (shell_.debug) {
-    print("shell debugging enabled");
-  } else {
-    print("shell debugging disabled");
-  }
-  return 0;
-}
-
-/**
- * Parses a user-entered command string.
- * @param {string} str The arguments to be parsed.
- */
-DebugCommand.prototype.parseArgs_ = function(str) {
-  if (str.length)
-    str = DebugCommand.trim(str); 
-  var cmd = DebugCommand.commands[this.user_command];
-  if (cmd) {
-    var parse = cmd['parse'];
-    if (parse == undefined) {
-      print('>>>can\'t find parse func for ' + this.user_command);
-      this.type = "error";
-    } else {
-      var ret = parse.call(this, str);
-      if (ret > 0) {
-        // Command gererated a debugger request.
-        this.type = "request";
-      } else if (ret == 0) {
-        // Command handeled internally.
-        this.type = "handled";
-      } else if (ret < 0) {
-        // Command error.
-        this.type = "handled";
-        DebugCommand.help(this.user_command);
-      }
-    }
-  } else {
-    this.type = "handled";
-    print('unknown command: ' + this.user_command);
-    DebugCommand.help();
-  }
-};
-
-/**
- * Displays command help or all help.
- * @param {string} opt_str Which command to print help for.
- */
-DebugCommand.help = function(opt_str) {
-  if (opt_str) {
-    var cmd = DebugCommand.commands[opt_str];
-    var usage = cmd.usage;
-    print('usage: ' + usage);
-    // Print additional details for the command.
-    if (cmd.help) {
-      print(cmd.help);
-    }
-  } else {
-    if (shell_.running) {
-      print('Status: page is running');
-    } else {
-      print('Status: page is paused');
-    }
-    print('Available commands:');
-    for (var key in DebugCommand.commands) {
-      var cmd = DebugCommand.commands[key];
-      if (!cmd['hidden'] && (!shell_.running || cmd['while_running'])) {
-        var usage = cmd.usage;
-        print('   ' + usage);
-      }
-    }
-  }
-};
-
-/**
- * Valid commands, their argument parser and their associated usage text.
- */
-DebugCommand.commands = {
-  'args': { 'parse': DebugCommand.prototype.parseArgsAndLocals_, 
-            'usage': 'args',
-            'help': 'summarize the arguments to the current function.',
-            'response': DebugCommand.responseArgs_ },
-  'break': { 'parse': DebugCommand.prototype.parseBreak_, 
-             'response': DebugCommand.responseBreak_,
-             'usage': 'break [location] <condition>',
-             'help': 'location is one of <function> | <script:function> | <script:line> | <script:line:pos>',
-             'while_running': true },
-  'break_info': { 'parse': DebugCommand.prototype.parseBreakInfo_, 
-                  'usage': 'break_info [breakpoint #]',
-                  'help': 'list the current breakpoints, or the details on a single one',
-                  'while_running': true },
-  'backtrace': { 'parse': DebugCommand.prototype.parseBacktrace_,
-                 'response': DebugCommand.responseBacktrace_,
-                 'usage': 'backtrace [from frame #] [to frame #]' },  
-  'clear': { 'parse': DebugCommand.prototype.parseClearCommand_, 
-             'response': DebugCommand.responseClear_,
-             'usage': 'clear <breakpoint #>',
-             'while_running': true },
-  'continue': { 'parse': DebugCommand.prototype.parseContinueCommand_, 
-                'usage': 'continue' },
-  'frame': { 'parse': DebugCommand.prototype.parseFrame_, 
-             'response': DebugCommand.responseFrame_,
-             'usage': 'frame <frame #>' },
-  'help': { 'parse': DebugCommand.parseHelp_, 
-            'usage': 'help [command]',
-            'while_running': true },
-  'locals': { 'parse': DebugCommand.prototype.parseArgsAndLocals_, 
-              'usage': 'locals',
-              'help': 'summarize the local variables for current frame',
-              'response': DebugCommand.responseLocals_ },
-  'next': { 'parse': DebugCommand.prototype.parseNext_, 
-            'usage': 'next' } ,
-  'print': { 'parse': DebugCommand.prototype.parsePrint_,
-             'response': DebugCommand.responsePrint_,
-             'usage': 'print <expression>',
-             'while_running': true },
-  'scripts': { 'parse': DebugCommand.prototype.parseScripts_,
-              'response': DebugCommand.responseScripts_,
-              'usage': 'scripts',
-              'while_running': true },
-  'source': { 'parse': DebugCommand.prototype.parseSource_,
-               'response': DebugCommand.responseSource_,
-               'usage': 'source [from line] | [<from line> <num lines>]' },
-  'step': { 'parse': DebugCommand.prototype.parseStep_, 
-            'usage': 'step' },
-  'stepout': { 'parse': DebugCommand.prototype.parseStepOut_,
-               'usage': 'stepout' },
-  // local eval for debugging - remove this later
-  'shell': { 'parse': DebugCommand.parseShell_,
-             'usage': 'shell <expression>',
-             'while_running': true,
-             'hidden': true },
-  'shelldebug': { 'parse': DebugCommand.parseShellDebug_,
-                  'usage': 'shelldebug',
-                  'while_running': true,
-                  'hidden': true },
-};
-
-
-/**
- * Debug shell using the new JSON protocol
- * @param {Object} tab - which tab is to be debugged.  This is an internal
- *     Chrome object.
- * @constructor
- */
-function DebugShell(tab) {
-  this.tab = tab;
-  this.tab.attach();
-  this.ready = true;
-  this.running = true;
-  this.current_command = undefined;
-  this.pending_commands = [];
-  // The auto continue flag is used to indicate whether the JavaScript execution
-  // should automatically continue after a break event and the processing of
-  // pending commands. This is used to make it possible for the user to issue
-  // commands, e.g. setting break points, without making an explicit break. In
-  // this case the debugger will silently issue a forced break issue the command
-  // and silently continue afterwards.
-  this.auto_continue = false;
-  this.debug = false;
-  this.current_line = -1;
-  this.current_pos = -1;
-  this.current_frame = 0;
-  this.current_script = undefined;
-  this.scripts = [];
-
-  // Mapping of breakpoints id --> info.
-  // Must use numeric keys.
-  this.breakpoints = [];
-};
-
-DebugShell.prototype.set_ready = function(ready) {
-  if (ready != this.ready) {
-    this.ready = ready;
-    chrome.setDebuggerReady(this.ready);
-  }
-};
-
-DebugShell.prototype.set_running = function(running) {
-  if (running != this.running) {
-    this.running = running;
-    chrome.setDebuggerBreak(!this.running);
-  }
-};
-
-/**
- * Execute a constructed DebugCommand object if possible, otherwise pend.
- * @param cmd {DebugCommand} - command to execute
- */
-DebugShell.prototype.process_command = function(cmd) {
-  dprint("Running: " + (this.running ? "yes" : "no"));
-
-  // The "break" commands needs to be handled seperatly
-  if (cmd.command == "break") {
-    if (this.running) {
-      // Schedule a break.
-      print("Stopping JavaScript execution...");
-      this.tab.debugBreak(false);
-    } else {
-      print("JavaScript execution already stopped.");
-    }
-    return;
-  }
-  
-  // If page is running an break needs to be issued.
-  if (this.running) {
-    // Some requests are not valid when the page is running.
-    var cmd_info = DebugCommand.commands[cmd.user_command];
-    if (!cmd_info['while_running']) {
-      print(cmd.user_command + " can only be run while paused");
-      return;
-    }
-
-    // Add the command as pending before scheduling a break.    
-    this.pending_commands.push(cmd);
-    dprint("pending command: " + cmd.toJSONProtocol());
-
-    // Schedule a forced break and enable auto continue.
-    this.tab.debugBreak(true);
-    this.auto_continue = true;
-    this.set_ready(false);
-    return;
-  }
-  
-  // If waiting for a response add command as pending otherwise send the
-  // command.
-  if (this.current_command) {
-    this.pending_commands.push(cmd);
-    dprint("pending command: " + cmd.toJSONProtocol());
-  } else {
-    this.current_command = cmd;
-    cmd.sendToDebugger(this.tab);
-    this.set_ready(false);
-  }
-};
-
-/**
- * Handle a break event from the debugger.
- * @param msg {Object} - event protocol message to handle
- */
-DebugShell.prototype.event_break = function(break_event) {
-  this.current_frame = 0;
-  this.set_running(false);
-  var body = break_event.body();
-  if (body) {
-    this.current_script = body.script;
-    var loc = DebugCommand.getSourceLocation(body.script,
-        body.sourceLineText, body.sourceLine, body.invocationText);
-    var location = loc[0];
-    var source = loc[1];
-    this.current_line = loc[2];
-    if (body.breakpoints) {
-      // Always disable auto continue if a real break point is hit.
-      this.auto_continue = false;
-      var breakpoints = body.breakpoints;
-      print("paused at breakpoint " + breakpoints.join(",") + ": " + 
-            location);
-      for (var i = 0; i < breakpoints.length; i++)
-        this.didHitBreakpoint(parseInt(breakpoints[i]));
-    } else if (body.scriptData == "") {
-      print("paused");
-    } else {
-      // step, stepout, next, "break" and a "debugger" line in the code
-      // are all treated the same (they're not really distinguishable anyway)
-      if (location != this.last_break_location) {
-        // We only print the location (function + script) when it changes, 
-        // so as we step, you only see the source line when you transition
-        // to a new script and/or function. Also if auto continue is enables
-        // don't print the break location.
-        if (!this.auto_continue)
-          print(location);
-      }
-    }
-    // Print th current source line unless auto continue is enabled.
-    if (source && !this.auto_continue)
-      print(source);
-    this.last_break_location = location;
-  }
-  if (!this.auto_continue)
-    this.set_ready(true);
-};
-
-/**
- * Handle an exception event from the debugger.
- * @param msg {ResponsePacket} - exception_event protocol message to handle
- */
-DebugShell.prototype.event_exception = function(exception_event) {
-  this.set_running(false);
-  this.set_ready(true);
-  var body = exception_event.body();
-  if (body) {
-    if (body["uncaught"]) {
-      print("uncaught exception " + body["exception"].text);
-    } else {
-      print("paused at exception " + body["exception"].text);
-    }
-  }
-};
-
-DebugShell.prototype.matchScript = function(script_match, line) {
-  var script = null;
-  // In the v8 debugger, all scripts have a name, line offset and line count
-  // Script names are usually URLs which are a pain to have to type again and
-  // again, so we match the tail end of the script name.  This makes it easy
-  // to type break foo.js:23 rather than
-  // http://www.foo.com/bar/baz/quux/test/foo.js:23.  In addition to the tail
-  // of the name we also look at the lines the script cover.  If there are
-  // several scripts with the same tail including the requested line we match
-  // the first one encountered.
-  // TODO(sgjesse) Find how to handle several matching scripts.
-  var candidate_scripts = [];
-  for (var i in this.scripts) {
-    if (this.scripts[i].name &&
-        this.scripts[i].name.indexOf(script_match) >= 0) {
-      candidate_scripts.push(this.scripts[i]);
-    }
-  }
-  for (var i in candidate_scripts) {
-    var s = candidate_scripts[i];
-    var from = s.lineOffset;
-    var to = from + s.lineCount;
-    if (from <= line && line < to) {
-      script = s;
-      break;
-    }
-  }
-  if (script)
-    return script;
-  else
-    return null;
-}
-
-// The Chrome Subshell interface requires:
-// prompt(), command(), response(), exit() and on_disconnect()
-
-/** 
- * Called by Chrome Shell to get a prompt string to display.
- */
-DebugShell.prototype.prompt = function() {
-  if (this.current_command)
-    return '';
-  if (!this.running)
-    return 'v8(paused)> ';
-  else
-    return 'v8(running)> ';
-};
-
-/**
- * Called by Chrome Shell when command input has been received from the user.
- */
-DebugShell.prototype.command = function(str) {
-  if (this.tab) {
-    str = DebugCommand.trim(str);
-    if (str.length) {
-      var cmd = new DebugCommand(str);
-      cmd.from_user = true;
-      if (cmd.type == "request")
-        this.process_command(cmd);
-    }
-  } else {
-    print(">>not connected to a tab");
-  }
-};
-
-/**
- * Called by Chrome Shell when a response to a previous command has been
- * received.
- */
-DebugShell.prototype.response = function(str) {
-  var response;
-  try {
-    dprint("received: " + str);
-    response = new ProtocolPackage(str);
-  } catch (error) {
-    print(error.toString(), str);
-    return;
-  }
-  if (response.type() == "event") {
-    ev = response.event();
-    if (ev == "break") {
-      this.event_break(response);
-    } else if (ev == "exception") {
-      this.event_exception(response);
-    }
-  } else if (response.type() == "response") {
-    if (response.requestSeq() != undefined) {
-      if (!this.current_command || this.current_command.seq != response.requestSeq()){
-        throw("received response to unknown command " + str);
-      }
-    } else {
-      // TODO(erikkay): should we reject these when they happen?
-      print(">>no request_seq in response " + str);
-    }
-    var cmd = DebugCommand.commands[this.current_command.user_command]
-    response.command = this.current_command;
-    this.current_command = null
-    this.set_running(response.running());
-    if (!response.success()) {
-      print(response.message());
-    } else {
-      var handler = cmd['response'];
-      if (handler != undefined) {
-        handler.call(this, response);
-      }
-    }
-    this.set_ready(true);
-  }
-
-  // Process next pending command if any.
-  if (this.pending_commands.length) {
-    this.process_command(this.pending_commands.shift());
-  } else if (this.auto_continue) {
-    // If no more pending commands and auto continue is active issue a continue command.
-    this.auto_continue = false;
-    this.process_command(new DebugCommand("continue"));
-  }
-};
-
-/**
- * Called when a breakpoint has been set.
- * @param {BreakpointInfo} info - details of breakpoint set.
- */
-DebugShell.prototype.addedBreakpoint = function(info) {
-  print("set breakpoint #" + info.id);
-  this.breakpoints[info.id] = info;
-}
-
-/**
- * Called when a breakpoint has been cleared.
- * @param {int} id - the breakpoint number that was cleared.
- */
-DebugShell.prototype.clearedBreakpoint = function(id) {
-  assertIsNumberType(id, "clearedBreakpoint called with invalid id");
-
-  print("cleared breakpoint #" + id);
-  delete this.breakpoints[id];
-}
-
-/**
- * Called when a breakpoint has been reached.
- * @param {int} id - the breakpoint number that was hit.
- */
-DebugShell.prototype.didHitBreakpoint = function(id) {
-  assertIsNumberType(id, "didHitBreakpoint called with invalid id");
-
-  var info = this.breakpoints[id];
-  if (!info)
-    throw "Could not find breakpoint #" + id;
-
-  info.hit_count ++;
-}
-
-/**
- * Print a summary of the specified breakpoints.
- *
- * @param {Array<BreakpointInfo>} breakpointsToPrint - List of breakpoints. The
- *     index is unused (id is determined from the info).
- */
-DebugShell.printBreakpoints_ = function(breakpoints) {
-  // TODO(ericroman): this would look much nicer if we could output as an HTML
-  // table. I tried outputting as formatted text table, but this looks aweful
-  // once it triggers wrapping (which is very likely if the target is a script)
-
-  // Output as a comma separated list of key=value
-  for (var i in breakpoints) {
-    var b = breakpoints[i];
-    var props = ["id", "hit_count", "type", "target", "line", "position",
-        "condition"];
-    var propertyList = [];
-    for (var i = 0; i < props.length; i++) {
-      var prop = props[i];
-      var val = b[prop];
-      if (val != undefined)
-        propertyList.push(prop + "=" + val);
-    }
-    print(propertyList.join(", "));
-  }
-}
-
-/**
- * Called by Chrome Shell when the outer shell is detaching from debugging
- * this tab.
- */
-DebugShell.prototype.exit = function() {
-  if (this.tab) {
-    this.tab.detach();
-    this.tab = null;
-  }
-};
-
-/**
- * Called by the Chrome Shell when the tab that the shell is debugging
- * have attached.
- */
-DebugShell.prototype.on_attach = function() {
-  var title = this.tab.title;
-  if (!title)
-    title = "Untitled";
-  print('attached to ' + title);
-  // on attach, we update our current script list
-  var cmd = new DebugCommand("scripts");
-  cmd.from_user = false;
-  this.process_command(cmd);
-};
-
-
-/**
- * Called by the Chrome Shell when the tab that the shell is debugging
- * went away.
- */
-DebugShell.prototype.on_disconnect = function() {
-  print(">>lost connection to tab");
-  this.tab = null;
-};
-
-
-/**
- * Protocol packages send from the debugger.
- * @param {string} json - raw protocol packet as JSON string.
- * @constructor
- */
-function ProtocolPackage(json) {
-  this.packet_ = eval('(' + json + ')');
-  this.refs_ = [];
-  if (this.packet_.refs) {
-    for (var i = 0; i < this.packet_.refs.length; i++) {
-      this.refs_[this.packet_.refs[i].handle] = this.packet_.refs[i];
-    }
-  }
-}
-
-
-/**
- * Get the packet type.
- * @return {String} the packet type
- */
-ProtocolPackage.prototype.type = function() {
-  return this.packet_.type;
-}
-
-
-/**
- * Get the packet event.
- * @return {Object} the packet event
- */
-ProtocolPackage.prototype.event = function() {
-  return this.packet_.event;
-}
-
-
-/**
- * Get the packet request sequence.
- * @return {number} the packet request sequence
- */
-ProtocolPackage.prototype.requestSeq = function() {
-  return this.packet_.request_seq;
-}
-
-
-/**
- * Get the packet request sequence.
- * @return {number} the packet request sequence
- */
-ProtocolPackage.prototype.running = function() {
-  return this.packet_.running ? true : false;
-}
-
-
-ProtocolPackage.prototype.success = function() {
-  return this.packet_.success ? true : false;
-}
-
-
-ProtocolPackage.prototype.message = function() {
-  return this.packet_.message;
-}
-
-
-ProtocolPackage.prototype.body = function() {
-  return this.packet_.body;
-}
-
-
-ProtocolPackage.prototype.lookup = function(handle) {
-  return this.refs_[handle];
-}
-
-
-/**
- * Structure that holds the details about a breakpoint.
- * @constructor
- *
- * @param {int} id - breakpoint number
- * @param {string} type - "script" or "function"
- * @param {string} target - either a function name, or script url
- * @param {int} line - line number in the script, or undefined
- * @param {int} position - column in the script, or undefined
- * @param {string} condition - boolean expression, or undefined
- */
-function BreakpointInfo(id, type, target, line, position, condition) {
-  this.id = id;
-  this.type = type;
-  this.target = target;
-
-  if (line != undefined)
-    this.line = line;
-  if (position != undefined)
-    this.position = position;
-  if (condition != undefined)
-    this.condition = condition;
-
-  this.hit_count = 0;
-
-  // Check that the id is numeric, otherwise will run into problems later
-  assertIsNumberType(this.id, "id is not a number");
-}
-
-/**
- * Global function to enter the debugger using DebugShell.
- * User can access this in the external shell by simply typing "debug()".
- * This is called by the Chrome Shell when the shell attaches to a tab.
- * @param {Object} opt_tab - which tab is to be debugged.  This is an internal
- *     Chrome object.
- */
-function debug(opt_tab) {
-  shell(new DebugShell(opt_tab || chrome.browser[0].tab[0]));
-};
-
-/**
- * Print debugging message when DebugShell's debug flag is true.
- */
-function dprint(str) {
-  if (shell_ && shell_.debug) {
-    print(str);  
-  }
-};
-
-/**
- * Helper that throws error if x is not a number
- * @param x {object} - object to test type of
- * @param error_message {string} - error to throw on failure
- */
-function assertIsNumberType(x, error_message) {
-  if (typeof x != "number")
-    throw error_message;
-}
diff --git a/chrome/browser/dom_ui/debugger_ui.cc b/chrome/browser/dom_ui/debugger_ui.cc
deleted file mode 100644
index fd29146..0000000
--- a/chrome/browser/dom_ui/debugger_ui.cc
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright (c) 2006-2008 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/dom_ui/debugger_ui.h"
-
-#include "app/resource_bundle.h"
-#include "base/command_line.h"
-#include "base/file_util.h"
-#include "base/message_loop.h"
-#include "base/string_util.h"
-#include "base/thread.h"
-#include "base/values.h"
-#include "chrome/browser/browser_process.h"
-#include "chrome/browser/debugger/debugger_shell.h"
-#include "chrome/browser/debugger/debugger_wrapper.h"
-#include "chrome/browser/dom_ui/chrome_url_data_manager.h"
-#include "chrome/common/chrome_switches.h"
-#include "chrome/common/url_constants.h"
-#include "net/base/mime_util.h"
-
-#include "grit/debugger_resources.h"
-
-namespace {
-
-class DebuggerHTMLSource : public ChromeURLDataManager::DataSource {
- public:
-  // Creates our datasource and sets our user message to a specific message
-  // from our string bundle.
-  DebuggerHTMLSource()
-      : DataSource("debugger", MessageLoop::current()) { }
-
-  // Called when the network layer has requested a resource underneath
-  // the path we registered.
-  virtual void StartDataRequest(const std::string& path, int request_id) {
-    int resource_id = 0;
-
-    if (!path.length()) {
-      resource_id = IDR_DEBUGGER_HTML;
-    } else if (path == "debugger.js") {
-      resource_id = IDR_DEBUGGER_JS;
-    } else if (path == "debugger.css") {
-      resource_id = IDR_DEBUGGER_CSS;
-    } else {
-      SendResponse(request_id, NULL);
-      return;
-    }
-
-    std::wstring debugger_path =
-        CommandLine::ForCurrentProcess()->GetSwitchValue(
-            switches::kJavaScriptDebuggerPath);
-    std::string data_str;
-    if (!debugger_path.empty() && file_util::PathExists(debugger_path)) {
-      if (path.empty())
-        file_util::AppendToPath(&debugger_path, L"debugger.html");
-      else
-        file_util::AppendToPath(&debugger_path, UTF8ToWide(path));
-      if (!file_util::ReadFileToString(debugger_path, &data_str)) {
-        SendResponse(request_id, NULL);
-        return;
-      }
-    } else {
-      ResourceBundle& rb = ResourceBundle::GetSharedInstance();
-      data_str = rb.GetDataResource(resource_id);
-    }
-    scoped_refptr<RefCountedBytes> data_bytes(new RefCountedBytes);
-    data_bytes->data.resize(data_str.size());
-    std::copy(data_str.begin(), data_str.end(), data_bytes->data.begin());
-
-    SendResponse(request_id, data_bytes);
-  }
-
-  virtual std::string GetMimeType(const std::string& path) const {
-    // Currently but three choices {"", "debugger.js", "debugger.css"}.
-    // Map the extension to mime-type, defaulting to "text/html".
-    std::string mime_type("text/html");
-#if defined(OS_WIN)
-    FilePath file_path(ASCIIToWide(path));
-#elif defined(OS_POSIX)
-    FilePath file_path(path);
-#endif
-    net::GetMimeTypeFromFile(file_path, &mime_type);
-    return mime_type;
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DebuggerHTMLSource);
-};
-
-
-class DebuggerHandler : public DOMMessageHandler {
- public:
-  explicit DebuggerHandler(DOMUI* dom_ui) : DOMMessageHandler(dom_ui) {
-    dom_ui->RegisterMessageCallback("DebuggerHostMessage",
-        NewCallback(this, &DebuggerHandler::HandleDebuggerHostMessage));
-  }
-
-  void HandleDebuggerHostMessage(const Value* content) {
-    if (!content || !content->IsType(Value::TYPE_LIST)) {
-      NOTREACHED();
-      return;
-    }
-    const ListValue* args = static_cast<const ListValue*>(content);
-    if (args->GetSize() < 1) {
-      NOTREACHED();
-      return;
-    }
-
-#ifndef CHROME_DEBUGGER_DISABLED
-    DebuggerWrapper* wrapper = g_browser_process->debugger_wrapper();
-    DebuggerHost* debugger_host = wrapper->GetDebugger();
-    if (!debugger_host) {
-      NOTREACHED();
-      return;
-    }
-    debugger_host->OnDebuggerHostMsg(args);
-#endif
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DebuggerHandler);
-};
-
-}  // namespace
-
-DebuggerUI::DebuggerUI(TabContents* contents) : DOMUI(contents) {
-  AddMessageHandler(new DebuggerHandler(this));
-
-  DebuggerHTMLSource* html_source = new DebuggerHTMLSource();
-  g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
-      NewRunnableMethod(&chrome_url_data_manager,
-      &ChromeURLDataManager::AddDataSource,
-      html_source));
-}
diff --git a/chrome/browser/dom_ui/debugger_ui.h b/chrome/browser/dom_ui/debugger_ui.h
deleted file mode 100644
index f64fc36..0000000
--- a/chrome/browser/dom_ui/debugger_ui.h
+++ /dev/null
@@ -1,20 +0,0 @@
-// Copyright (c) 2006-2008 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.
-//
-// This file defines utility functions for working with strings.
-
-#ifndef CHROME_BROWSER_DOM_UI_DEBUGGER_UI_H_
-#define CHROME_BROWSER_DOM_UI_DEBUGGER_UI_H_
-
-#include "chrome/browser/dom_ui/dom_ui.h"
-
-class DebuggerUI : public DOMUI {
- public:
-  DebuggerUI(TabContents* contents);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(DebuggerUI);
-};
-
-#endif  // CHROME_BROWSER_DOM_UI_DEBUGGER_UI_H_
diff --git a/chrome/browser/dom_ui/dom_ui_factory.cc b/chrome/browser/dom_ui/dom_ui_factory.cc
index c2dea2d..c5576cf 100644
--- a/chrome/browser/dom_ui/dom_ui_factory.cc
+++ b/chrome/browser/dom_ui/dom_ui_factory.cc
@@ -5,7 +5,6 @@
 #include "chrome/browser/dom_ui/dom_ui_factory.h"
 
 #include "chrome/browser/dom_ui/downloads_ui.h"
-#include "chrome/browser/dom_ui/debugger_ui.h"
 #include "chrome/browser/dom_ui/devtools_ui.h"
 #include "chrome/browser/dom_ui/history_ui.h"
 #include "chrome/browser/dom_ui/html_dialog_ui.h"
@@ -80,12 +79,6 @@ static bool CreateDOMUI(const GURL& url, TabContents* tab_contents,
     return true;
   }
 
-  if (url.host() == chrome::kChromeUIInspectorHost) {
-    if (new_ui)
-      *new_ui = new DebuggerUI(tab_contents);
-    return true;
-  }
-
   if (url.host() == chrome::kChromeUIDevToolsHost) {
     if (new_ui)
       *new_ui = new DevToolsUI(tab_contents);
diff --git a/chrome/browser/gtk/standard_menus.cc b/chrome/browser/gtk/standard_menus.cc
index 17689a4..160f7a0 100644
--- a/chrome/browser/gtk/standard_menus.cc
+++ b/chrome/browser/gtk/standard_menus.cc
@@ -33,8 +33,6 @@ struct MenuCreateMaterial encoding_menu_materials[] = {
 struct MenuCreateMaterial developer_menu_materials[] = {
   { MENU_NORMAL, IDC_VIEW_SOURCE, IDS_VIEW_SOURCE, 0, NULL,
     GDK_u, GDK_CONTROL_MASK },
-  { MENU_NORMAL, IDC_DEBUGGER, IDS_DEBUGGER, 0, NULL,
-    GDK_l, GDK_CONTROL_MASK | GDK_SHIFT_MASK },
   { MENU_NORMAL, IDC_JS_CONSOLE, IDS_JS_CONSOLE, 0, NULL,
     GDK_j, GDK_CONTROL_MASK | GDK_SHIFT_MASK },
   { MENU_NORMAL, IDC_TASK_MANAGER, IDS_TASK_MANAGER, 0, NULL,
diff --git a/chrome/browser/renderer_host/browser_render_process_host.cc b/chrome/browser/renderer_host/browser_render_process_host.cc
index 2463b39..2fd6289 100644
--- a/chrome/browser/renderer_host/browser_render_process_host.cc
+++ b/chrome/browser/renderer_host/browser_render_process_host.cc
@@ -274,7 +274,6 @@ bool BrowserRenderProcessHost::Init() {
     switches::kUseLowFragHeapCrt,
     switches::kEnableWebWorkers,
     switches::kEnableStatsTable,
-    switches::kDisableOutOfProcessDevTools,
     switches::kAutoSpellCorrect,
     switches::kDisableAudio,
     switches::kSimpleDataSource,
@@ -293,7 +292,7 @@ bool BrowserRenderProcessHost::Init() {
   // NOTE: This is subtly different than just passing along whether
   // --enable-extenisons is present in the browser process. For example, there
   // is also an extensions.enabled preference, and there may be various special
-  // cases about whether to allow extensions to load. 
+  // cases about whether to allow extensions to load.
   //
   // This introduces a race condition where the first renderer never gets
   // extensions enabled, so we also set the flag if extensions_enabled(). This
diff --git a/chrome/browser/renderer_host/render_view_host.cc b/chrome/browser/renderer_host/render_view_host.cc
index 90d0fbc..3a8cb2c 100644
--- a/chrome/browser/renderer_host/render_view_host.cc
+++ b/chrome/browser/renderer_host/render_view_host.cc
@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "app/resource_bundle.h"
-#include "base/command_line.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ -16,7 +15,6 @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/cross_site_request_manager.h"
-#include "chrome/browser/debugger/debugger_wrapper.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/metrics/user_metrics.h"
@@ -33,7 +31,6 @@
 #include "chrome/common/notification_type.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/result_codes.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/url_constants.h"
@@ -104,7 +101,6 @@ RenderViewHost::RenderViewHost(SiteInstance* instance,
       instance_(instance),
       delegate_(delegate),
       waiting_for_drag_context_response_(false),
-      debugger_attached_(false),
       enabled_bindings_(0),
       pending_request_id_(0),
       modal_dialog_count_(0),
@@ -123,7 +119,9 @@ RenderViewHost::RenderViewHost(SiteInstance* instance,
 }
 
 RenderViewHost::~RenderViewHost() {
-  OnDebugDisconnect();
+  DevToolsManager* devtools_manager = g_browser_process->devtools_manager();
+  if (devtools_manager)  // NULL in tests
+    devtools_manager->UnregisterDevToolsClientHostFor(this);
 
   // Be sure to clean up any leftover state from cross-site requests.
   Singleton<CrossSiteRequestManager>()->SetHasPendingCrossSiteRequest(
@@ -467,27 +465,6 @@ void RenderViewHost::AddMessageToConsole(
       routing_id(), frame_xpath, message, level));
 }
 
-void RenderViewHost::DebugCommand(const std::wstring& cmd) {
-  Send(new ViewMsg_DebugCommand(routing_id(), cmd));
-}
-
-void RenderViewHost::DebugAttach() {
-  if (!debugger_attached_)
-    Send(new ViewMsg_DebugAttach(routing_id()));
-}
-
-void RenderViewHost::DebugDetach() {
-  if (debugger_attached_) {
-    Send(new ViewMsg_DebugDetach(routing_id()));
-    debugger_attached_ = false;
-  }
-}
-
-void RenderViewHost::DebugBreak(bool force) {
-  if (debugger_attached_)
-    Send(new ViewMsg_DebugBreak(routing_id(), force));
-}
-
 void RenderViewHost::Undo() {
   Send(new ViewMsg_Undo(routing_id()));
 }
@@ -586,27 +563,13 @@ void RenderViewHost::CopyImageAt(int x, int y) {
 }
 
 void RenderViewHost::InspectElementAt(int x, int y) {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableOutOfProcessDevTools)) {
-    DevToolsManager* manager = g_browser_process->devtools_manager();
-    manager->InspectElement(this, x, y);
-  } else {
-    ChildProcessSecurityPolicy::GetInstance()->
-        GrantInspectElement(process()->pid());
-    Send(new ViewMsg_InspectElement(routing_id(), x, y));
-  }
+  DevToolsManager* manager = g_browser_process->devtools_manager();
+  manager->InspectElement(this, x, y);
 }
 
 void RenderViewHost::ShowJavaScriptConsole() {
-  if (!CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableOutOfProcessDevTools)) {
-    DevToolsManager* manager = g_browser_process->devtools_manager();
-    manager->OpenDevToolsWindow(this);
-  } else {
-    ChildProcessSecurityPolicy::GetInstance()->
-        GrantInspectElement(process()->pid());
-    Send(new ViewMsg_ShowJavaScriptConsole(routing_id()));
-  }
+  DevToolsManager* manager = g_browser_process->devtools_manager();
+  manager->OpenDevToolsWindow(this);
 }
 
 void RenderViewHost::DragSourceEndedAt(
@@ -798,15 +761,11 @@ void RenderViewHost::OnMessageReceived(const IPC::Message& msg) {
     IPC_MESSAGE_HANDLER(ViewHostMsg_UpdateDragCursor, OnUpdateDragCursor)
     IPC_MESSAGE_HANDLER(ViewHostMsg_TakeFocus, OnTakeFocus)
     IPC_MESSAGE_HANDLER(ViewHostMsg_PageHasOSDD, OnMsgPageHasOSDD)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_InspectElement_Reply,
-                        OnMsgInspectElementReply)
     IPC_MESSAGE_FORWARD(ViewHostMsg_DidGetPrintedPagesCount,
                         delegate_,
                         RenderViewHostDelegate::DidGetPrintedPagesCount)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DidPrintPage, DidPrintPage)
     IPC_MESSAGE_HANDLER(ViewHostMsg_AddMessageToConsole, OnAddMessageToConsole)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DebuggerOutput, OnDebuggerOutput);
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DidDebugAttach, DidDebugAttach);
     IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToDevToolsAgent,
                         OnForwardToDevToolsAgent);
     IPC_MESSAGE_HANDLER(ViewHostMsg_ForwardToDevToolsClient,
@@ -923,7 +882,6 @@ void RenderViewHost::OnMsgRenderViewGone() {
   RendererExited();
 
   delegate_->RenderViewGone(this);
-  OnDebugDisconnect();
 }
 
 // Called when the renderer navigates.  For every frame loaded, we'll get this
@@ -1262,10 +1220,6 @@ void RenderViewHost::OnMsgPageHasOSDD(int32 page_id, const GURL& doc_url,
   delegate_->PageHasOSDD(this, page_id, doc_url, autodetected);
 }
 
-void RenderViewHost::OnMsgInspectElementReply(int num_resources) {
-  delegate_->InspectElementReply(num_resources);
-}
-
 void RenderViewHost::DidPrintPage(
     const ViewHostMsg_DidPrintPage_Params& params) {
   delegate_->DidPrintPage(params);
@@ -1277,20 +1231,6 @@ void RenderViewHost::OnAddMessageToConsole(const std::wstring& message,
   std::wstring msg = StringPrintf(L"\"%ls,\" source: %ls (%d)", message.c_str(),
                                   source_id.c_str(), line_no);
   logging::LogMessage("CONSOLE", 0).stream() << msg;
-  if (debugger_attached_)
-    g_browser_process->debugger_wrapper()->DebugMessage(msg);
-}
-
-void RenderViewHost::OnDebuggerOutput(const std::wstring& output) {
-  if (debugger_attached_)
-    g_browser_process->debugger_wrapper()->DebugMessage(output);
-}
-
-void RenderViewHost::DidDebugAttach() {
-  if (!debugger_attached_) {
-    debugger_attached_ = true;
-    g_browser_process->debugger_wrapper()->OnDebugAttach();
-  }
 }
 
 void RenderViewHost::OnForwardToDevToolsAgent(const IPC::Message& message) {
@@ -1407,11 +1347,7 @@ void RenderViewHost::WindowMoveOrResizeStarted() {
 }
 
 void RenderViewHost::NotifyRendererUnresponsive() {
-  // If the debugger is attached, we're going to be unresponsive anytime it's
-  // stopped at a breakpoint.
-  if (!debugger_attached_) {
-    delegate_->RendererUnresponsive(this, is_waiting_for_unload_ack_);
-  }
+  delegate_->RendererUnresponsive(this, is_waiting_for_unload_ack_);
 }
 
 void RenderViewHost::NotifyRendererResponsive() {
@@ -1453,16 +1389,6 @@ void RenderViewHost::ForwardEditCommand(const std::string& name,
   Send(message);
 }
 
-void RenderViewHost::OnDebugDisconnect() {
-  if (debugger_attached_) {
-    debugger_attached_ = false;
-    g_browser_process->debugger_wrapper()->OnDebugDisconnect();
-  }
-  DevToolsManager* devtools_manager = g_browser_process->devtools_manager();
-  if (devtools_manager)  // NULL in tests
-    devtools_manager->UnregisterDevToolsClientHostFor(this);
-}
-
 void RenderViewHost::ForwardMessageFromExternalHost(const std::string& message,
                                                     const std::string& origin,
                                                     const std::string& target) {
diff --git a/chrome/browser/renderer_host/render_view_host.h b/chrome/browser/renderer_host/render_view_host.h
index 101bc2b..84051f2 100644
--- a/chrome/browser/renderer_host/render_view_host.h
+++ b/chrome/browser/renderer_host/render_view_host.h
@@ -244,20 +244,6 @@ class RenderViewHost : public RenderWidgetHost {
                            const string16& message,
                            const WebKit::WebConsoleMessage::Level&);
 
-  // Send command to the debugger
-  void DebugCommand(const std::wstring& cmd);
-
-  // Attach to the V8 instance for debugging
-  void DebugAttach();
-
-  // Detach from the V8 instance for debugging
-  void DebugDetach();
-
-  // Cause the V8 debugger to trigger a debug break. If the force flag is set
-  // force a debug break even if no JS code is running (this actually causes a
-  // simple JS script to be executed).
-  void DebugBreak(bool force);
-
   // Edit operations.
   void Undo();
   void Redo();
@@ -529,14 +515,10 @@ class RenderViewHost : public RenderWidgetHost {
   void OnUpdateDragCursor(bool is_drop_target);
   void OnTakeFocus(bool reverse);
   void OnMsgPageHasOSDD(int32 page_id, const GURL& doc_url, bool autodetected);
-  void OnMsgInspectElementReply(int num_resources);
   void DidPrintPage(const ViewHostMsg_DidPrintPage_Params& params);
-  void OnDebugMessage(const std::string& message);
   void OnAddMessageToConsole(const std::wstring& message,
                              int32 line_no,
                              const std::wstring& source_id);
-  void OnDebuggerOutput(const std::wstring& output);
-  void DidDebugAttach();
   void OnUpdateInspectorSettings(const std::wstring& raw_settings);
   void OnForwardToDevToolsAgent(const IPC::Message& message);
   void OnForwardToDevToolsClient(const IPC::Message& message);
@@ -582,8 +564,6 @@ class RenderViewHost : public RenderWidgetHost {
 
   void UpdateBackForwardListCount();
 
-  void OnDebugDisconnect();
-
   // The SiteInstance associated with this RenderViewHost.  All pages drawn
   // in this RenderViewHost are part of this SiteInstance.  Should not change
   // over time.
@@ -596,9 +576,6 @@ class RenderViewHost : public RenderWidgetHost {
   // information.
   bool waiting_for_drag_context_response_;
 
-  // is the debugger attached to us or not
-  bool debugger_attached_;
-
   // A bitwise OR of bindings types that have been enabled for this RenderView.
   // See BindingsPolicy for details.
   int enabled_bindings_;
diff --git a/chrome/browser/renderer_host/render_view_host_delegate.h b/chrome/browser/renderer_host/render_view_host_delegate.h
index d1b0ecb..fd52627 100644
--- a/chrome/browser/renderer_host/render_view_host_delegate.h
+++ b/chrome/browser/renderer_host/render_view_host_delegate.h
@@ -353,9 +353,6 @@ class RenderViewHostDelegate {
                            int32 page_id, const GURL& doc_url,
                            bool autodetected) { }
 
-  // Notification that the inspect element window has been opened
-  virtual void InspectElementReply(int num_resources) { }
-
   // Notification that the render view has calculated the number of printed
   // pages.
   virtual void DidGetPrintedPagesCount(int cookie, int number_pages) {
diff --git a/chrome/browser/tab_contents/tab_contents.cc b/chrome/browser/tab_contents/tab_contents.cc
index e9190cd..c19719b 100644
--- a/chrome/browser/tab_contents/tab_contents.cc
+++ b/chrome/browser/tab_contents/tab_contents.cc
@@ -2036,14 +2036,6 @@ void TabContents::PageHasOSDD(RenderViewHost* render_view_host,
       autodetected);
 }
 
-void TabContents::InspectElementReply(int num_resources) {
-  // We have received reply from inspect element request. Notify the
-  // automation provider in case we need to notify automation client.
-  NotificationService::current()->Notify(
-      NotificationType::DOM_INSPECT_ELEMENT_RESPONSE, Source<TabContents>(this),
-      Details<int>(&num_resources));
-}
-
 void TabContents::DidGetPrintedPagesCount(int cookie, int number_pages) {
   printing_.DidGetPrintedPagesCount(cookie, number_pages);
 }
diff --git a/chrome/browser/tab_contents/tab_contents.h b/chrome/browser/tab_contents/tab_contents.h
index e7d172d..e675400 100644
--- a/chrome/browser/tab_contents/tab_contents.h
+++ b/chrome/browser/tab_contents/tab_contents.h
@@ -817,7 +817,6 @@ class TabContents : public PageNavigator,
                                    const std::wstring& value);
   virtual void PageHasOSDD(RenderViewHost* render_view_host,
                            int32 page_id, const GURL& url, bool autodetected);
-  virtual void InspectElementReply(int num_resources);
   virtual void DidGetPrintedPagesCount(int cookie, int number_pages);
   virtual void DidPrintPage(const ViewHostMsg_DidPrintPage_Params& params);
   virtual GURL GetAlternateErrorPageURL() const;
diff --git a/chrome/browser/views/toolbar_view.cc b/chrome/browser/views/toolbar_view.cc
index f3e3f33..83c9107 100644
--- a/chrome/browser/views/toolbar_view.cc
+++ b/chrome/browser/views/toolbar_view.cc
@@ -1036,11 +1036,6 @@ void ToolbarView::CreateDevToolsMenuContents() {
   devtools_menu_contents_.reset(new views::SimpleMenuModel(this));
   devtools_menu_contents_->AddItem(IDC_VIEW_SOURCE,
                                    l10n_util::GetString(IDS_VIEW_SOURCE));
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kDisableOutOfProcessDevTools)) {
-    devtools_menu_contents_->AddItem(IDC_DEBUGGER,
-                                     l10n_util::GetString(IDS_DEBUGGER));
-  }
   devtools_menu_contents_->AddItem(IDC_JS_CONSOLE,
                                    l10n_util::GetString(IDS_JS_CONSOLE));
   devtools_menu_contents_->AddItem(IDC_TASK_MANAGER,