Allow chrome.debugger API to attach to extension background pages.

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>
 
+#include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/api/infobars/confirm_infobar_delegate.h"
 #include "chrome/browser/api/infobars/infobar_service.h"
 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
 #include "chrome/browser/extensions/event_router.h"
+#include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/chrome_notification_types.h"
-#include "chrome/common/extensions/api/debugger.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.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_constants.h"
 #include "extensions/common/error_utils.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 using content::DevToolsAgentHost;
 using content::DevToolsClientHost;
 using content::DevToolsManager;
+using content::RenderProcessHost;
+using content::RenderViewHost;
+using content::RenderWidgetHost;
 using content::WebContents;
-using extensions::api::debugger::Debuggee;
 using extensions::ErrorUtils;
 
 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;
 
 class ExtensionDevToolsClientHost;
@@ skipping 31 matching lines @@
   ExtensionDevToolsClientHost* client_host_;
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsInfoBarDelegate);
 };
 
 class ExtensionDevToolsClientHost : public DevToolsClientHost,
                                     public content::NotificationObserver {
  public:
   ExtensionDevToolsClientHost(WebContents* web_contents,
                               const std::string& extension_id,
                               const std::string& extension_name,
-                              int tab_id);
+                              const Debuggee& debuggee);
 
   virtual ~ExtensionDevToolsClientHost();
 
   bool MatchesContentsAndExtensionId(WebContents* web_contents,
                                      const std::string& extension_id);
   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;
 
  private:
   void SendDetachedEvent();
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   WebContents* web_contents_;
   std::string extension_id_;
-  int tab_id_;
+  Debuggee debuggee_;
   content::NotificationRegistrar registrar_;
   int last_request_id_;
   typedef std::map<int, scoped_refptr<DebuggerSendCommandFunction> >
       PendingRequests;
   PendingRequests pending_requests_;
   ExtensionDevToolsInfoBarDelegate* infobar_delegate_;
   OnDetach::Reason detach_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
@@ skipping 30 matching lines @@
     }
     return NULL;
   }
 
  private:
   std::set<DevToolsClientHost*> client_hosts_;
 };
 
 }  // namespace
 
+static void CopyDebuggee(Debuggee & dst, const Debuggee& src) {
+  if (src.tab_id)
+    dst.tab_id.reset(new int(*src.tab_id));
+  if (src.extension_id)
+    dst.extension_id.reset(new std::string(*src.extension_id));
+}
+
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     WebContents* web_contents,
     const std::string& extension_id,
     const std::string& extension_name,
-    int tab_id)
+    const Debuggee& debuggee)
     : web_contents_(web_contents),
       extension_id_(extension_id),
-      tab_id_(tab_id),
       last_request_id_(0),
       infobar_delegate_(NULL),
       detach_reason_(OnDetach::REASON_TARGET_CLOSED) {
+  CopyDebuggee(debuggee_, debuggee);
+
   AttachedClientHosts::GetInstance()->Add(this);
 
   // Detach from debugger when extension unloads.
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile));
 
   // Attach to debugger and tell it we are ready.
   scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetFor(
       web_contents_->GetRenderViewHost()));
   DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(agent, this);
 
-  InfoBarService* infobar_service =
-      InfoBarService::FromWebContents(web_contents_);
-  infobar_delegate_ = ExtensionDevToolsInfoBarDelegate::Create(infobar_service,
-                                                               extension_name,
-                                                               this);
-  if (infobar_delegate_) {
-    registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
-                   content::Source<InfoBarService>(infobar_service));
+  if (!CommandLine::ForCurrentProcess()->
+      HasSwitch(switches::kExtensionDebuggingSilent)) {
+    InfoBarService* infobar_service =
+        InfoBarService::FromWebContents(web_contents_);
+    infobar_delegate_ = ExtensionDevToolsInfoBarDelegate::Create(
+        infobar_service, extension_name, this);
+    if (infobar_delegate_) {
+      registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
+                     content::Source<InfoBarService>(infobar_service));
+    }
   }
 }
 
 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
   // Ensure calling RemoveInfoBar() below won't result in Observe() trying to
   // Close() us.
   registrar_.RemoveAll();
 
   if (infobar_delegate_) {
     infobar_delegate_->DiscardClientHost();
@@ skipping 47 matching lines @@
 
 void ExtensionDevToolsClientHost::MarkAsDismissed() {
   detach_reason_ = OnDetach::REASON_CANCELED_BY_USER;
 }
 
 void ExtensionDevToolsClientHost::SendDetachedEvent() {
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   if (profile != NULL &&
       extensions::ExtensionSystem::Get(profile)->event_router()) {
-    Debuggee debuggee;
-    debuggee.tab_id = tab_id_;
-    scoped_ptr<base::ListValue> args(OnDetach::Create(debuggee,
+    scoped_ptr<base::ListValue> args(OnDetach::Create(debuggee_,
                                                       detach_reason_));
     scoped_ptr<extensions::Event> event(new extensions::Event(
         keys::kOnDetach, args.Pass()));
     event->restrict_to_profile = profile;
     extensions::ExtensionSystem::Get(profile)->event_router()->
         DispatchEventToExtension(extension_id_, event.Pass());
   }
 }
 
 void ExtensionDevToolsClientHost::Observe(
@@ skipping 29 matching lines @@
   if (!result->IsType(Value::TYPE_DICTIONARY))
     return;
   DictionaryValue* dictionary = static_cast<DictionaryValue*>(result.get());
 
   int id;
   if (!dictionary->GetInteger("id", &id)) {
     std::string method_name;
     if (!dictionary->GetString("method", &method_name))
       return;
 
-    Debuggee debuggee;
-    debuggee.tab_id = tab_id_;
-
     OnEvent::Params params;
     DictionaryValue* params_value;
     if (dictionary->GetDictionary("params", &params_value))
       params.additional_properties.Swap(params_value);
 
-    scoped_ptr<ListValue> args(OnEvent::Create(debuggee, method_name, params));
+    scoped_ptr<ListValue> args(OnEvent::Create(debuggee_, method_name, params));
     scoped_ptr<extensions::Event> event(new extensions::Event(
         keys::kOnEvent, args.Pass()));
     event->restrict_to_profile = profile;
     extensions::ExtensionSystem::Get(profile)->event_router()->
         DispatchEventToExtension(extension_id_, event.Pass());
   } else {
     DebuggerSendCommandFunction* function = pending_requests_[id];
     if (!function)
       return;
 
@@ skipping 53 matching lines @@
 }
 
 bool ExtensionDevToolsInfoBarDelegate::Cancel() {
   if (client_host_)
     client_host_->MarkAsDismissed();
   return true;
 }
 
 DebuggerFunction::DebuggerFunction()
     : contents_(0),
-      tab_id_(0),
       client_host_(0) {
 }
 
+void DebuggerFunction::FormatErrorMessage(const std::string& format) {
+  error_ = ErrorUtils::FormatErrorMessage(
+      format,
+      debuggee_.tab_id ?
+          keys::kTabTargetType :
+          keys::kExtensionTargetType,
+      debuggee_.tab_id ?
+          base::IntToString(*debuggee_.tab_id) :
+          *debuggee_.extension_id);
+}
+
+static WebContents* FindWebContentsForExtension(

[Matt Perry, 2013/02/20 19:52:01]

There can be multiple WebContents for an extension. If you're looking for the
background page, use ExtensionProcessManager::GetBackgroundHostForExtension.

[Vladislav Kaznacheev, 2013/02/21 09:39:09]

Thanks for the pointer! Done.
On 2013/02/20 19:52:01, Matt Perry wrote:

+    const extensions::Extension* extension) {
+  for (RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
+       !it.IsAtEnd(); it.Advance()) {
+    RenderProcessHost* render_process_host = it.GetCurrentValue();
+    DCHECK(render_process_host);
+
+    // Ignore processes that don't have a connection, such as crashed tabs.
+    if (!render_process_host->HasConnection())
+      continue;
+
+    RenderProcessHost::RenderWidgetHostsIterator rwit(
+        render_process_host->GetRenderWidgetHostsIterator());
+    for (; !rwit.IsAtEnd(); rwit.Advance()) {
+      const RenderWidgetHost* widget = rwit.GetCurrentValue();
+      DCHECK(widget);
+      if (!widget || !widget->IsRenderView())
+        continue;
+
+      RenderViewHost* rvh =
+          RenderViewHost::From(const_cast<RenderWidgetHost*>(widget));
+
+      WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
+      if (web_contents) {
+        GURL url = web_contents->GetURL();
+        if (url.host() == extension->id()) {
+          return web_contents;
+        }
+      }
+    }
+  }
+  return NULL;
+}
+
 bool DebuggerFunction::InitWebContents() {
   // Find the WebContents that contains this tab id.
   contents_ = NULL;
-  WebContents* web_contents = NULL;
-  bool result = ExtensionTabUtil::GetTabById(
-      tab_id_, profile(), include_incognito(), NULL, NULL, &web_contents, NULL);
-  if (!result || !web_contents) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        keys::kNoTabError,
-        base::IntToString(tab_id_));
-    return false;
+  if (debuggee_.tab_id) {
+    WebContents* web_contents = NULL;
+    bool result = ExtensionTabUtil::GetTabById(
+        *debuggee_.tab_id, profile(), include_incognito(), NULL, NULL,
+        &web_contents, NULL);
+    if (!result || !web_contents) {
+      FormatErrorMessage(keys::kNoTargetError);
+      return false;
+    }
+    contents_ = web_contents;
+
+    if (content::HasWebUIScheme(contents_->GetURL())) {
+      error_ = ErrorUtils::FormatErrorMessage(
+          keys::kAttachToWebUIError,
+          contents_->GetURL().scheme());
+      return false;
+    }
+
+    return true;
   }
-  contents_ = web_contents;
 
-  if (content::HasWebUIScheme(contents_->GetURL())) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        keys::kAttachToWebUIError,
-        contents_->GetURL().scheme());
+  if (debuggee_.extension_id) {
+    if (!CommandLine::ForCurrentProcess()->
+        HasSwitch(switches::kExtensionDebuggingSilent)) {
+      error_ = ErrorUtils::FormatErrorMessage(
+          keys::kSilentDebuggingRequired,
+          switches::kExtensionDebuggingSilent);
+      return false;
+    }
+
+    const extensions::Extension* extension = profile()->GetExtensionService()->
+        extensions()->GetByID(*debuggee_.extension_id);
+    if (extension) {
+      contents_ = FindWebContentsForExtension(extension);
+      if (contents_)
+        return true;
+    }
+
+    FormatErrorMessage(keys::kNoTargetError);
     return false;
   }
 
-  return true;
+  error_ = keys::kInvalidTargetError;
+  return false;
 }
 
 bool DebuggerFunction::InitClientHost() {
   if (!InitWebContents())
     return false;
 
   // Don't fetch rvh from the contents since it'll be wrong upon navigation.
   client_host_ = AttachedClientHosts::GetInstance()->Lookup(contents_);
 
   if (!client_host_ ||
       !client_host_->MatchesContentsAndExtensionId(contents_,
                                                    GetExtension()->id())) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        keys::kNotAttachedError,
-        base::IntToString(tab_id_));
+    FormatErrorMessage(keys::kNotAttachedError);
     return false;
   }
   return true;
 }
 
 DebuggerAttachFunction::DebuggerAttachFunction() {}
 
 DebuggerAttachFunction::~DebuggerAttachFunction() {}
 
 bool DebuggerAttachFunction::RunImpl() {
   scoped_ptr<Attach::Params> params(Attach::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  tab_id_ = params->target.tab_id;
+  CopyDebuggee(debuggee_, params->target);
   if (!InitWebContents())
     return false;
 
   if (!webkit_glue::IsInspectorProtocolVersionSupported(
       params->required_version)) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kProtocolVersionNotSupportedError,
         params->required_version);
     return false;
   }
 
   scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetFor(
       contents_->GetRenderViewHost()));
   DevToolsClientHost* client_host = DevToolsManager::GetInstance()->
       GetDevToolsClientHostFor(agent);
 
   if (client_host != NULL) {
-    error_ = ErrorUtils::FormatErrorMessage(
-        keys::kAlreadyAttachedError,
-        base::IntToString(tab_id_));
+    FormatErrorMessage(keys::kAlreadyAttachedError);
     return false;
   }
 
   new ExtensionDevToolsClientHost(contents_,
                                   GetExtension()->id(),
                                   GetExtension()->name(),
-                                  tab_id_);
+                                  debuggee_);
   SendResponse(true);
   return true;
 }
 
 DebuggerDetachFunction::DebuggerDetachFunction() {}
 
 DebuggerDetachFunction::~DebuggerDetachFunction() {}
 
 bool DebuggerDetachFunction::RunImpl() {
   scoped_ptr<Detach::Params> params(Detach::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  tab_id_ = params->target.tab_id;
+  CopyDebuggee(debuggee_, params->target);
   if (!InitClientHost())
     return false;
 
   client_host_->Close();
   SendResponse(true);
   return true;
 }
 
 DebuggerSendCommandFunction::DebuggerSendCommandFunction() {}
 
 DebuggerSendCommandFunction::~DebuggerSendCommandFunction() {}
 
 bool DebuggerSendCommandFunction::RunImpl() {
   scoped_ptr<SendCommand::Params> params(SendCommand::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  tab_id_ = params->target.tab_id;
+  CopyDebuggee(debuggee_, params->target);
   if (!InitClientHost())
     return false;
 
   client_host_->SendMessageToBackend(this, params->method,
       params->command_params.get());
   return true;
 }
 
 void DebuggerSendCommandFunction::SendResponseBody(
     DictionaryValue* response) {
   Value* error_body;
   if (response->Get("error", &error_body)) {
     base::JSONWriter::Write(error_body, &error_);
     SendResponse(false);
     return;
   }
 
   DictionaryValue* result_body;
   SendCommand::Results::Result result;
   if (response->GetDictionary("result", &result_body))
     result.additional_properties.Swap(result_body);
 
   results_ = SendCommand::Results::Create(result);
   SendResponse(true);
 }