Add chrome.debugger.getTargets method to discover available debug targets.

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 16 matching lines @@
 #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/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/favicon_status.h"
+#include "content/public/browser/navigation_entry.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"
@@ skipping 129 matching lines @@
       if (rvh && WebContents::FromRenderViewHost(rvh) == contents)
         return static_cast<ExtensionDevToolsClientHost*>(*it);
     }
     return NULL;
   }
 
  private:
   std::set<DevToolsClientHost*> client_hosts_;
 };
 
+static extensions::ExtensionHost* GetExtensionBackgroundHost(
+    WebContents* web_contents) {
+  Profile* profile =
+      Profile::FromBrowserContext(web_contents->GetBrowserContext());
+  if (!profile)
+    return NULL;
+
+  extensions::ExtensionHost* extension_host =
+      extensions::ExtensionSystem::Get(profile)->process_manager()->
+          GetBackgroundHostForExtension(web_contents->GetURL().host());
+
+  if (extension_host && extension_host->host_contents() == web_contents)
+    return extension_host;
+
+  return NULL;
+}
+
+static base::DictionaryValue* SerializePageInfo(RenderViewHost* rvh) {
+  DevToolsAgentHost* agent_host = DevToolsAgentHost::GetFor(rvh);
+
+  base::DictionaryValue* dictionary = new base::DictionaryValue;

[pfeldman, 2013/03/15 11:25:45]

new base::DictionaryValue()

[Vladislav Kaznacheev, 2013/03/18 06:40:36]

Done.

+
+  dictionary->SetString("id", agent_host->GetId());

[pfeldman, 2013/03/15 11:25:45]

You should use constants for these.

[Vladislav Kaznacheev, 2013/03/18 06:40:37]

Done.

+
+  WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
+  extensions::ExtensionHost* extension_host =
+      GetExtensionBackgroundHost(web_contents);
+  if (extension_host) {
+    dictionary->SetString("type", "extension");

[pfeldman, 2013/03/15 11:25:45]

I don't think we are ready to finalize this field.

[Vladislav Kaznacheev, 2013/03/18 06:40:37]

Do you mean you prefer this called "other"? Please elaborate.
On 2013/03/15 11:25:45, pfeldman wrote:

+    dictionary->SetString("title", extension_host->extension()->name());
+  } else {
+    dictionary->SetString("type", "page");
+    if (web_contents)
+      dictionary->SetString("title",
+          UTF16ToUTF8(net::EscapeForHTML(web_contents->GetTitle())));
+  }
+
+  dictionary->SetBoolean("attached",
+      !!DevToolsManager::GetInstance()->GetDevToolsClientHostFor(agent_host));
+  if (web_contents) {
+    dictionary->SetString("url", web_contents->GetURL().spec());
+    content::NavigationController& controller = web_contents->GetController();
+    content::NavigationEntry* entry = controller.GetActiveEntry();
+    if (entry != NULL && entry->GetURL().is_valid()) {
+      dictionary->SetString("faviconUrl", entry->GetFavicon().url.spec());
+    }
+  }
+
+  return dictionary;
+}
+
 }  // 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));
+  if (src.target_id)
+    dst.target_id.reset(new std::string(*src.target_id));
 }
 
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     WebContents* web_contents,
     const std::string& extension_id,
     const std::string& extension_name,
     const Debuggee& debuggee)
     : web_contents_(web_contents),
       extension_id_(extension_id),
       last_request_id_(0),
@@ skipping 221 matching lines @@
 DebuggerFunction::DebuggerFunction()
     : contents_(0),
       client_host_(0) {
 }
 
 void DebuggerFunction::FormatErrorMessage(const std::string& format) {
   error_ = ErrorUtils::FormatErrorMessage(
       format,
       debuggee_.tab_id ?
           keys::kTabTargetType :
-          keys::kExtensionTargetType,
+          debuggee_.extension_id ?

[pfeldman, 2013/03/15 11:25:45]

Consider extracting this.

[Vladislav Kaznacheev, 2013/03/18 06:40:37]

Done.

+              keys::kExtensionTargetType :
+              keys::kOpaqueTargetType,
       debuggee_.tab_id ?
           base::IntToString(*debuggee_.tab_id) :
-          *debuggee_.extension_id);
+          debuggee_.extension_id ?
+            *debuggee_.extension_id :
+            *debuggee_.target_id);
 }
 
 bool DebuggerFunction::InitWebContents() {
   // Find the WebContents that contains this tab id.
   contents_ = NULL;
   if (debuggee_.tab_id) {
     WebContents* web_contents = NULL;
     bool result = ExtensionTabUtil::GetTabById(
         *debuggee_.tab_id, profile(), include_incognito(), NULL, NULL,
         &web_contents, NULL);
@@ skipping 28 matching lines @@
     if (host) {
       contents_ = WebContents::FromRenderViewHost(host->render_view_host());
       if (contents_)
         return true;
     }
 
     FormatErrorMessage(keys::kNoTargetError);
     return false;
   }
 
+  if (debuggee_.target_id) {
+    DevToolsAgentHost* agent_host =
+        DevToolsAgentHost::GetForId(*debuggee_.target_id);
+    if (agent_host) {
+      contents_ = WebContents::FromRenderViewHost(
+          agent_host->GetRenderViewHost());
+
+      if (!CommandLine::ForCurrentProcess()->
+           HasSwitch(switches::kSilentDebuggerExtensionAPI)) {
+        // Allow only tabs, reject background pages.
+        if (GetExtensionBackgroundHost(contents_)) {
+          error_ = ErrorUtils::FormatErrorMessage(
+              keys::kSilentDebuggingRequired,
+              switches::kSilentDebuggerExtensionAPI);
+          return false;
+        }
+      }
+      return true;
+    }
+    FormatErrorMessage(keys::kNoTargetError);
+    return false;
+  }
+
   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_);
@@ skipping 89 matching lines @@
   }
 
   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);
 }
+
+DebuggerGetTargetsFunction::DebuggerGetTargetsFunction() {}
+
+DebuggerGetTargetsFunction::~DebuggerGetTargetsFunction() {}
+
+bool DebuggerGetTargetsFunction::RunImpl() {
+  base::ListValue* results_list = new ListValue();
+
+  std::vector<RenderViewHost*> rvh_list =
+      DevToolsAgentHost::GetValidRenderViewHosts();
+  for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
+       it != rvh_list.end(); ++it)
+    results_list->Append(SerializePageInfo(*it));
+
+  SetResult(results_list);
+  SendResponse(true);
+  return true;
+}