Define DevTools content API

chrome/browser/debugger/devtools_window.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/stringprintf.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/themes/theme_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browsing_instance.h"
-#include "content/browser/debugger/devtools_manager.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/load_notification_details.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
-#include "content/common/devtools_messages.h"
 #include "content/public/browser/content_browser_client.h"
-#include "content/public/browser/devtools_frontend_window.h"
+#include "content/public/browser/devtools_agent_host_registry.h"
+#include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/common/bindings_policy.h"
 #include "grit/generated_resources.h"
 
 typedef std::vector<DevToolsWindow*> DevToolsWindowList;
 namespace {
 base::LazyInstance<DevToolsWindowList,
                    base::LeakyLazyInstanceTraits<DevToolsWindowList> >
      g_instances = LAZY_INSTANCE_INITIALIZER;
 }  // namespace
 
+using content::DevToolsAgentHost;
+using content::DevToolsAgentHostRegistry;
+using content::DevToolsClientHost;
+using content::DevToolsManager;
+
 const char DevToolsWindow::kDevToolsApp[] = "DevToolsApp";
 
 // static
 void DevToolsWindow::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kDevToolsOpenDocked,
                              true,
                              PrefService::UNSYNCABLE_PREF);
 }
 
 // static
 TabContentsWrapper* DevToolsWindow::GetDevToolsContents(
     TabContents* inspected_tab) {
   if (!inspected_tab)
     return NULL;
 
+  if (!DevToolsAgentHostRegistry::HasDevToolsAgentHost(
+      inspected_tab->render_view_host()))
+    return NULL;
+  DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+      inspected_tab->render_view_host());
   DevToolsManager* manager = DevToolsManager::GetInstance();
-  DevToolsClientHost* client_host = manager->
-      GetDevToolsClientHostFor(inspected_tab->render_view_host());
+  DevToolsClientHost* client_host = manager->GetDevToolsClientHostFor(agent);
   DevToolsWindow* window = AsDevToolsWindow(client_host);
   if (!window || !window->is_docked())
     return NULL;
   return window->tab_contents();
 }
 
 // static
 bool DevToolsWindow::IsDevToolsWindow(RenderViewHost* window_rvh) {
   if (g_instances == NULL)
     return NULL;
   DevToolsWindowList& instances = g_instances.Get();
   for (DevToolsWindowList::iterator it = instances.begin();
        it != instances.end(); ++it) {
     if ((*it)->tab_contents_->render_view_host() == window_rvh)
       return true;
   }
   return false;
 }
 
 // static
 DevToolsWindow* DevToolsWindow::OpenDevToolsWindowForWorker(
     Profile* profile,
     DevToolsAgentHost* worker_agent) {
   DevToolsWindow* window;
-  DevToolsClientHost* client =
-      DevToolsManager::GetInstance()->GetDevToolsClientHostFor(worker_agent);
+  DevToolsClientHost* client = content::DevToolsManager::GetInstance()->
+      GetDevToolsClientHostFor(worker_agent);
   if (client) {
     window = AsDevToolsWindow(client);
     if (!window)
       return NULL;
   } else {
     window = DevToolsWindow::CreateDevToolsWindowForWorker(profile);
-    DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(worker_agent,
-                                                                  window);
+    DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(
+        worker_agent,
+        window->frontend_host_);
   }
   window->Show(DEVTOOLS_TOGGLE_ACTION_NONE);
   return window;
 }
 
 // static
 DevToolsWindow* DevToolsWindow::CreateDevToolsWindowForWorker(
     Profile* profile) {
   return Create(profile, NULL, false, true);
 }
 
 // static
 DevToolsWindow* DevToolsWindow::OpenDevToolsWindow(
     RenderViewHost* inspected_rvh) {
   return ToggleDevToolsWindow(inspected_rvh, true,
                               DEVTOOLS_TOGGLE_ACTION_NONE);
 }
 
 // static
 DevToolsWindow* DevToolsWindow::ToggleDevToolsWindow(
     RenderViewHost* inspected_rvh,
     DevToolsToggleAction action) {
   return ToggleDevToolsWindow(inspected_rvh, false, action);
 }
 
 void DevToolsWindow::InspectElement(RenderViewHost* inspected_rvh,
                                     int x,
                                     int y) {
-  inspected_rvh->Send(new DevToolsAgentMsg_InspectElement(
-      inspected_rvh->routing_id(),
-      x,
-      y));
+  DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+      inspected_rvh);
+  DevToolsManager::GetInstance()->InspectElement(agent, x, y);
   // TODO(loislo): we should initiate DevTools window opening from within
   // renderer. Otherwise, we still can hit a race condition here.
   OpenDevToolsWindow(inspected_rvh);
 }
 
 
 DevToolsWindow* DevToolsWindow::Create(
     Profile* profile,
     RenderViewHost* inspected_rvh,
     bool docked,
@@ skipping 14 matching lines @@
 DevToolsWindow::DevToolsWindow(TabContentsWrapper* tab_contents,
                                Profile* profile,
                                RenderViewHost* inspected_rvh,
                                bool docked)
     : profile_(profile),
       inspected_tab_(NULL),
       tab_contents_(tab_contents),
       browser_(NULL),
       docked_(docked),
       is_loaded_(false),
-      action_on_load_(DEVTOOLS_TOGGLE_ACTION_NONE) {
+      action_on_load_(DEVTOOLS_TOGGLE_ACTION_NONE),
+      ALLOW_THIS_IN_INITIALIZER_LIST(frontend_host_(

[pfeldman, 2011/11/30 16:43:26]

You could initialize it in the constructor instead.

[yurys, 2011/11/30 17:08:28]

Done.

+          DevToolsClientHost::CreateDevToolsFrontendHost(
+              tab_contents->tab_contents(),
+              this))) {
   g_instances.Get().push_back(this);
   // Wipe out page icon so that the default application icon is used.
   NavigationEntry* entry = tab_contents_->controller().GetActiveEntry();
   entry->favicon().set_bitmap(SkBitmap());
   entry->favicon().set_is_valid(true);
 
   // Install DevTools front-end message handler.
-  content::SetupDevToolsFrontendDelegate(
-      tab_contents->tab_contents(),
-      this);
+//  content::SetupDevToolsFrontendDelegate(

[pfeldman, 2011/11/30 16:43:26]

remove these?

[yurys, 2011/11/30 17:08:28]

Done.

+//      tab_contents->tab_contents(),
+//      this);
 
   // Register on-load actions.
   registrar_.Add(
       this,
       content::NOTIFICATION_LOAD_STOP,
       content::Source<NavigationController>(&tab_contents_->controller()));
   registrar_.Add(
       this,
       content::NOTIFICATION_TAB_CLOSING,
       content::Source<NavigationController>(&tab_contents_->controller()));
@@ skipping 12 matching lines @@
 
 DevToolsWindow::~DevToolsWindow() {
   DevToolsWindowList& instances = g_instances.Get();
   DevToolsWindowList::iterator it = std::find(instances.begin(),
                                               instances.end(),
                                               this);
   DCHECK(it != instances.end());
   instances.erase(it);
 }
 
-void DevToolsWindow::SendMessageToClient(const IPC::Message& message) {
-  RenderViewHost* target_host = tab_contents_->render_view_host();
-  IPC::Message* m =  new IPC::Message(message);
-  m->set_routing_id(target_host->routing_id());
-  target_host->Send(m);
-}
-
 void DevToolsWindow::InspectedTabClosing() {
   if (docked_) {
     // Update dev tools to reflect removed dev tools window.
 
     BrowserWindow* inspected_window = GetInspectedBrowserWindow();
     if (inspected_window)
       inspected_window->UpdateDevTools();
     // In case of docked tab_contents we own it, so delete here.
     delete tab_contents_;
 
@@ skipping 236 matching lines @@
     UpdateTheme();
     DoAction();
     AddDevToolsExtensionsToClient();
   } else if (type == content::NOTIFICATION_TAB_CLOSING) {
     if (content::Source<NavigationController>(source).ptr() ==
             &tab_contents_->controller()) {
       // This happens when browser closes all of its tabs as a result
       // of window.Close event.
       // Notify manager that this DevToolsClientHost no longer exists and
       // initiate self-destuct here.
-      NotifyCloseListener();
+      DevToolsManager::GetInstance()->ClientHostClosing(frontend_host_);
       delete this;
     }
   } else if (type == chrome::NOTIFICATION_BROWSER_THEME_CHANGED) {
     UpdateTheme();
   }
 }
 
 void DevToolsWindow::ScheduleAction(DevToolsToggleAction action) {
   action_on_load_ = action;
   if (is_loaded_)
@@ skipping 100 matching lines @@
     if (inspected_window)
       inspected_window->HandleKeyboardEvent(event);
   }
 }
 
 // static
 DevToolsWindow* DevToolsWindow::ToggleDevToolsWindow(
     RenderViewHost* inspected_rvh,
     bool force_open,
     DevToolsToggleAction action) {
+  DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
+      inspected_rvh);
   DevToolsManager* manager = DevToolsManager::GetInstance();
-
-  DevToolsClientHost* host = manager->GetDevToolsClientHostFor(inspected_rvh);
+  DevToolsClientHost* host = manager->GetDevToolsClientHostFor(agent);
   DevToolsWindow* window = AsDevToolsWindow(host);
   if (host != NULL && window == NULL) {
     // Break remote debugging / extension debugging session.
-    manager->UnregisterDevToolsClientHostFor(inspected_rvh);
+    manager->UnregisterDevToolsClientHostFor(agent);
   }
 
   bool do_open = force_open;
   if (!window) {
     Profile* profile = Profile::FromBrowserContext(
         inspected_rvh->process()->GetBrowserContext());
     bool docked = profile->GetPrefs()->GetBoolean(prefs::kDevToolsOpenDocked);
     window = Create(profile, inspected_rvh, docked, false);
-    manager->RegisterDevToolsClientHostFor(inspected_rvh, window);
+    manager->RegisterDevToolsClientHostFor(agent, window->frontend_host_);
     do_open = true;
   }
 
   // If window is docked and visible, we hide it on toggle. If window is
   // undocked, we show (activate) it.
   if (!window->is_docked() || do_open)
     window->Show(action);
   else
-    manager->UnregisterDevToolsClientHostFor(inspected_rvh);
+    manager->UnregisterDevToolsClientHostFor(agent);
 
   return window;
 }
 
 // static
 DevToolsWindow* DevToolsWindow::AsDevToolsWindow(
     DevToolsClientHost* client_host) {
   if (!client_host || g_instances == NULL)
     return NULL;
   DevToolsWindowList& instances = g_instances.Get();
   for (DevToolsWindowList::iterator it = instances.begin();
        it != instances.end(); ++it) {
-    DevToolsClientHost* client = *it;
-    if (client == client_host)
+    if ((*it)->frontend_host_ == client_host)
       return *it;
   }
   return NULL;
 }
 
-void DevToolsWindow::ForwardToDevToolsAgent(const IPC::Message& message) {
-  DevToolsManager::GetInstance()->ForwardToDevToolsAgent(this, message);
-}
-
 void DevToolsWindow::ActivateWindow() {
   if (!docked_) {
     if (!browser_->window()->IsActive()) {
       browser_->window()->Activate();
     }
   } else {
     BrowserWindow* inspected_window = GetInspectedBrowserWindow();
     if (inspected_window)
       tab_contents_->view()->Focus();
   }
 }
 
 void DevToolsWindow::CloseWindow() {
   DCHECK(docked_);
-  NotifyCloseListener();
+  DevToolsManager::GetInstance()->ClientHostClosing(frontend_host_);
   InspectedTabClosing();
 }
 
 void DevToolsWindow::MoveWindow(int x, int y) {
   if (!docked_) {
     gfx::Rect bounds = browser_->window()->GetBounds();
     bounds.Offset(x, y);
     browser_->window()->SetBounds(bounds);
   }
 }
@@ skipping 13 matching lines @@
                            content);
 }
 
 content::JavaScriptDialogCreator* DevToolsWindow::GetJavaScriptDialogCreator() {
   if (inspected_tab_ && inspected_tab_->tab_contents()->delegate()) {
     return inspected_tab_->tab_contents()->delegate()->
         GetJavaScriptDialogCreator();
   }
   return TabContentsDelegate::GetJavaScriptDialogCreator();
 }