[DevTools] Make DevTools clients talk directly to DevToolsAgentHost instead of using DevToolsManage…

chrome/browser/extensions/api/debugger/debugger_api.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Implements the Chrome Extensions Debugger API.
 
 #include "chrome/browser/extensions/api/debugger/debugger_api.h"
 
 #include <map>
 #include <set>
@@ skipping 13 matching lines @@
 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "content/public/browser/devtools_agent_host.h"
-#include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_http_handler.h"
-#include "content/public/browser/devtools_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_utils.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/common/switches.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using content::DevToolsAgentHost;
-using content::DevToolsClientHost;
 using content::DevToolsHttpHandler;
-using content::DevToolsManager;
 using content::RenderProcessHost;
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 namespace keys = debugger_api_constants;
 namespace Attach = extensions::api::debugger::Attach;
 namespace Detach = extensions::api::debugger::Detach;
 namespace OnDetach = extensions::api::debugger::OnDetach;
 namespace OnEvent = extensions::api::debugger::OnEvent;
 namespace SendCommand = extensions::api::debugger::SendCommand;
 
 namespace extensions {
 class ExtensionRegistry;
 
 // ExtensionDevToolsClientHost ------------------------------------------------
 
-class ExtensionDevToolsClientHost : public DevToolsClientHost,
+class ExtensionDevToolsClientHost : public DevToolsAgentHost::Client,
                                     public content::NotificationObserver,
                                     public ExtensionRegistryObserver {
  public:
   ExtensionDevToolsClientHost(Profile* profile,
                               DevToolsAgentHost* agent_host,
                               const std::string& extension_id,
                               const std::string& extension_name,
                               const Debuggee& debuggee,
                               infobars::InfoBar* infobar);
 
   virtual ~ExtensionDevToolsClientHost();
 
   const std::string& extension_id() { return extension_id_; }
+  DevToolsAgentHost* agent_host() { return agent_host_.get(); }
   void Close();
   void SendMessageToBackend(DebuggerSendCommandFunction* function,
                             const std::string& method,
                             SendCommand::Params::CommandParams* command_params);
 
   // Marks connection as to-be-terminated by the user.
   void MarkAsDismissed();
 
-  // DevToolsClientHost interface
-  virtual void InspectedContentsClosing() OVERRIDE;
-  virtual void DispatchOnInspectorFrontend(const std::string& message) OVERRIDE;
-  virtual void ReplacedWithAnotherClient() OVERRIDE;
+  // DevToolsAgentHost::Client interface.
+  virtual void AgentHostClosed(
+      DevToolsAgentHost* agent_host,
+      bool replaced_with_another_client) OVERRIDE;
+  virtual void DispatchProtocolMessage(
+      DevToolsAgentHost* agent_host,
+      const std::string& message) OVERRIDE;
 
  private:
   void SendDetachedEvent();
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // ExtensionRegistryObserver implementation.
@@ skipping 170 matching lines @@
   client_hosts_.insert(client_host);
 }
 
 void AttachedClientHosts::Remove(ExtensionDevToolsClientHost* client_host) {
   client_hosts_.erase(client_host);
 }
 
 ExtensionDevToolsClientHost* AttachedClientHosts::Lookup(
     DevToolsAgentHost* agent_host,
     const std::string& extension_id) {
-  DevToolsManager* manager = DevToolsManager::GetInstance();
   for (ClientHosts::iterator it = client_hosts_.begin();
        it != client_hosts_.end(); ++it) {
     ExtensionDevToolsClientHost* client_host = *it;
-    if (manager->GetDevToolsAgentHostFor(client_host) == agent_host &&
+    if (client_host->agent_host() == agent_host &&
         client_host->extension_id() == extension_id)
       return client_host;
   }
   return NULL;
 }
 
 }  // namespace
 
 
 // ExtensionDevToolsClientHost ------------------------------------------------
@@ skipping 20 matching lines @@
   // from there.
   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
 
   // RVH-based agents disconnect from their clients when the app is terminating
   // but shared worker-based agents do not.
   // Disconnect explicitly to make sure that |this| observer is not leaked.
   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 
   // Attach to debugger and tell it we are ready.
-  DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(
-      agent_host_.get(), this);
+  agent_host_->AttachClient(this);
 
   if (infobar_) {
     static_cast<ExtensionDevToolsInfoBarDelegate*>(
         infobar_->delegate())->set_client_host(this);
     registrar_.Add(
         this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
         content::Source<InfoBarService>(InfoBarService::FromWebContents(
             WebContents::FromRenderViewHost(
                 agent_host_->GetRenderViewHost()))));
   }
 }
 
 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
   // Ensure calling RemoveInfoBar() below won't result in Observe() trying to
   // Close() us.
   registrar_.RemoveAll();
 
   if (infobar_) {
     static_cast<ExtensionDevToolsInfoBarDelegate*>(
         infobar_->delegate())->set_client_host(NULL);
     InfoBarService* infobar_service = InfoBarService::FromWebContents(
         WebContents::FromRenderViewHost(agent_host_->GetRenderViewHost()));
     infobar_service->RemoveInfoBar(infobar_);
   }
   AttachedClientHosts::GetInstance()->Remove(this);
 }
 
-// DevToolsClientHost interface
-void ExtensionDevToolsClientHost::InspectedContentsClosing() {
+// DevToolsAgentHost::Client implementation.
+void ExtensionDevToolsClientHost::AgentHostClosed(
+    DevToolsAgentHost* agent_host, bool replaced_with_another_client) {
+  DCHECK(agent_host == agent_host_.get());
+  if (replaced_with_another_client)
+    detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
   SendDetachedEvent();
   delete this;
 }
 
-void ExtensionDevToolsClientHost::ReplacedWithAnotherClient() {
-  detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
-}
-
 void ExtensionDevToolsClientHost::Close() {
-  DevToolsManager::GetInstance()->ClientHostClosing(this);
+  agent_host_->DetachClient();
   delete this;
 }
 
 void ExtensionDevToolsClientHost::SendMessageToBackend(
     DebuggerSendCommandFunction* function,
     const std::string& method,
     SendCommand::Params::CommandParams* command_params) {
   base::DictionaryValue protocol_request;
   int request_id = ++last_request_id_;
   pending_requests_[request_id] = function;
   protocol_request.SetInteger("id", request_id);
   protocol_request.SetString("method", method);
   if (command_params) {
     protocol_request.Set("params",
                          command_params->additional_properties.DeepCopy());
   }
 
   std::string json_args;
   base::JSONWriter::Write(&protocol_request, &json_args);
-  DevToolsManager::GetInstance()->DispatchOnInspectorBackend(this, json_args);
+  agent_host_->DispatchOnInspectorBackend(json_args);
 }
 
 void ExtensionDevToolsClientHost::MarkAsDismissed() {
   detach_reason_ = OnDetach::REASON_CANCELED_BY_USER;
 }
 
 void ExtensionDevToolsClientHost::SendDetachedEvent() {
   if (!EventRouter::Get(profile_))
     return;
 
@@ skipping 27 matching lines @@
         infobar_ = NULL;
         SendDetachedEvent();
         Close();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
-void ExtensionDevToolsClientHost::DispatchOnInspectorFrontend(
-    const std::string& message) {
+void ExtensionDevToolsClientHost::DispatchProtocolMessage(
+    DevToolsAgentHost* agent_host, const std::string& message) {
+  DCHECK(agent_host == agent_host_.get());
   if (!EventRouter::Get(profile_))
     return;
 
   scoped_ptr<base::Value> result(base::JSONReader::Read(message));
   if (!result->IsType(base::Value::TYPE_DICTIONARY))
     return;
   base::DictionaryValue* dictionary =
       static_cast<base::DictionaryValue*>(result.get());
 
   int id;
@@ skipping 284 matching lines @@
     const std::vector<DevToolsTargetImpl*>& target_list) {
   scoped_ptr<base::ListValue> result(new base::ListValue());
   for (size_t i = 0; i < target_list.size(); ++i)
     result->Append(SerializeTarget(*target_list[i]));
   STLDeleteContainerPointers(target_list.begin(), target_list.end());
   SetResult(result.release());
   SendResponse(true);
 }
 
 }  // namespace extensions