Support shared workers as debug targets for chrome.debugger API

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 24 matching lines @@
 #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/browser/worker_service.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 content::WorkerService;
 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;
 
 class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   // Creates an extension dev tools delegate and adds it to |infobar_service|.
   // Returns a pointer to the delegate if it was successfully added.
   static ExtensionDevToolsInfoBarDelegate* Create(
-      WebContents* web_contents,
+      RenderViewHost* rvh,
       const std::string& client_name);
 
   // Associates DevToolsClientHost with this infobar delegate.
   void AttachClientHost(ExtensionDevToolsClientHost* client_host);
 
   // Notifies infobar delegate that associated DevToolsClientHost will be
   // destroyed.
   void DiscardClientHost();
 
  private:
@@ skipping 12 matching lines @@
 
   std::string client_name_;
   ExtensionDevToolsClientHost* client_host_;
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsInfoBarDelegate);
 };
 
 class ExtensionDevToolsClientHost : public DevToolsClientHost,
                                     public content::NotificationObserver {
  public:
   ExtensionDevToolsClientHost(
-      WebContents* web_contents,
+      Profile* profile,
+      DevToolsAgentHost* agent_host,
       const std::string& extension_id,
       const std::string& extension_name,
       const Debuggee& debuggee,
       ExtensionDevToolsInfoBarDelegate* infobar_delegate);
 
   virtual ~ExtensionDevToolsClientHost();
 
-  bool MatchesContentsAndExtensionId(WebContents* web_contents,
-                                     const std::string& extension_id);
+  std::string extension_id() { return extension_id_; }

[Matt Perry, 2013/04/04 19:11:00]

return const ref

[Vladislav Kaznacheev, 2013/04/05 09:23:02]

Done.

   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_;
+  Profile* profile_;
+  scoped_refptr<DevToolsAgentHost> agent_host_;
   std::string extension_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_;
 
@@ skipping 12 matching lines @@
   }
 
   void Add(ExtensionDevToolsClientHost* client_host) {
     client_hosts_.insert(client_host);
   }
 
   void Remove(ExtensionDevToolsClientHost* client_host) {
     client_hosts_.erase(client_host);
   }
 
-  ExtensionDevToolsClientHost* Lookup(WebContents* contents) {
-    for (std::set<DevToolsClientHost*>::iterator it = client_hosts_.begin();
+  ExtensionDevToolsClientHost* Lookup(DevToolsAgentHost* agent_host,
+                                      const std::string& extension_id) {
+    DevToolsManager* manager = DevToolsManager::GetInstance();
+    for (ClientHostSet::iterator it = client_hosts_.begin();
          it != client_hosts_.end(); ++it) {
-      DevToolsAgentHost* agent_host =
-          DevToolsManager::GetInstance()->GetDevToolsAgentHostFor(*it);
-      if (!agent_host)
-        continue;
-      content::RenderViewHost* rvh = agent_host->GetRenderViewHost();
-      if (rvh && WebContents::FromRenderViewHost(rvh) == contents)
-        return static_cast<ExtensionDevToolsClientHost*>(*it);
+      ExtensionDevToolsClientHost* client_host = *it;
+      if (manager->GetDevToolsAgentHostFor(client_host) == agent_host &&
+          client_host->extension_id() == extension_id)
+        return client_host;
     }
     return NULL;
   }
 
  private:
-  std::set<DevToolsClientHost*> client_hosts_;
+  typedef std::set<ExtensionDevToolsClientHost*> ClientHostSet;
+  ClientHostSet 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 const char kTargetIdField[]  = "id";
 static const char kTargetTypeField[]  = "type";
 static const char kTargetTitleField[]  = "title";
 static const char kTargetAttachedField[]  = "attached";
 static const char kTargetUrlField[]  = "url";
 static const char kTargetFaviconUrlField[] = "faviconUrl";
 
 static const char kTargetTypePage[]  = "page";
 static const char kTargetTypeBackgroundPage[]  = "background_page";
+static const char kTargetTypeWorker[]  = "worker";
 
 static base::Value* SerializePageInfo(RenderViewHost* rvh) {
   WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
   if (!web_contents)
     return NULL;
 
   DevToolsAgentHost* agent_host = DevToolsAgentHost::GetOrCreateFor(rvh);
 
   base::DictionaryValue* dictionary = new base::DictionaryValue();
 
@@ skipping 18 matching lines @@
     content::NavigationEntry* entry = controller.GetActiveEntry();
     if (entry != NULL && entry->GetURL().is_valid()) {
       dictionary->SetString(kTargetFaviconUrlField,
           entry->GetFavicon().url.spec());
     }
   }
 
   return dictionary;
 }
 
+static base::Value* SerializeWorkerInfo(
+    const WorkerService::WorkerInfo& worker) {
+  base::DictionaryValue* dictionary = new base::DictionaryValue;
+
+  scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetForWorker(
+      worker.process_id, worker.route_id));
+  dictionary->SetString(kTargetIdField, agent->GetId());
+  dictionary->SetString(kTargetTypeField, kTargetTypeWorker);
+  dictionary->SetString(kTargetTitleField,
+      UTF16ToUTF8(net::EscapeForHTML(worker.name)));

[Matt Perry, 2013/04/04 19:11:00]

why does this need to be escaped? it's just used as a string, right?

[Vladislav Kaznacheev, 2013/04/05 09:23:02]

It does not really. This code was originally copied from inspect_ui.cc where the
final destination was a web page. Removed conversion here and for regular
targets as well.
On 2013/04/04 19:11:00, Matt Perry wrote:

+  dictionary->SetString(kTargetUrlField, worker.url.spec());
+  dictionary->SetBoolean(kTargetAttachedField, agent->IsAttached());
+
+  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,
+    Profile* profile,
+    DevToolsAgentHost* agent_host,
     const std::string& extension_id,
     const std::string& extension_name,
     const Debuggee& debuggee,
     ExtensionDevToolsInfoBarDelegate* infobar_delegate)
-    : web_contents_(web_contents),
+    : profile_(profile),
+      agent_host_(agent_host),
       extension_id_(extension_id),
       last_request_id_(0),
       infobar_delegate_(infobar_delegate),
       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));
+                 content::Source<Profile>(profile_));
 
   // Attach to debugger and tell it we are ready.
-  scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetOrCreateFor(
-      web_contents_->GetRenderViewHost()));
-  DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(agent, this);
+  DevToolsManager::GetInstance()->
+      RegisterDevToolsClientHostFor(agent_host_, this);
 
   if (infobar_delegate_) {
     infobar_delegate_->AttachClientHost(this);
     registrar_.Add(this,
                    chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
                    content::Source<InfoBarService>(infobar_delegate_->owner()));
   }
 }
 
 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
   // Ensure calling RemoveInfoBar() below won't result in Observe() trying to
   // Close() us.
   registrar_.RemoveAll();
 
   if (infobar_delegate_) {
     infobar_delegate_->DiscardClientHost();
     if (infobar_delegate_->owner())
       infobar_delegate_->owner()->RemoveInfoBar(infobar_delegate_);
   }
   AttachedClientHosts::GetInstance()->Remove(this);
 }
 
-bool ExtensionDevToolsClientHost::MatchesContentsAndExtensionId(
-    WebContents* web_contents,
-    const std::string& extension_id) {
-  return web_contents == web_contents_ && extension_id_ == extension_id;
-}
-
 // DevToolsClientHost interface
 void ExtensionDevToolsClientHost::InspectedContentsClosing() {
   SendDetachedEvent();
   delete this;
 }
 
 void ExtensionDevToolsClientHost::ReplacedWithAnotherClient() {
   detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
 }
 
@@ skipping 19 matching lines @@
   std::string json_args;
   base::JSONWriter::Write(&protocol_request, &json_args);
   DevToolsManager::GetInstance()->DispatchOnInspectorBackend(this, json_args);
 }
 
 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()) {
-    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());
-  }
+  if (!extensions::ExtensionSystem::Get(profile_)->event_router())
+    return;
+
+  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(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     std::string id =
         content::Details<extensions::UnloadedExtensionInfo>(details)->
             extension->id();
     if (id == extension_id_)
         Close();
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED, type);
     if (content::Details<InfoBarRemovedDetails>(details)->first ==
         infobar_delegate_) {
       infobar_delegate_ = NULL;
       SendDetachedEvent();
       Close();
     }
   }
 }
 
 void ExtensionDevToolsClientHost::DispatchOnInspectorFrontend(
     const std::string& message) {
-  Profile* profile =
-      Profile::FromBrowserContext(web_contents_->GetBrowserContext());
-  if (profile == NULL ||
-      !extensions::ExtensionSystem::Get(profile)->event_router())
+  if (!extensions::ExtensionSystem::Get(profile_)->event_router())
     return;
 
   scoped_ptr<Value> result(base::JSONReader::Read(message));
   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;
 
     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<extensions::Event> event(new extensions::Event(
         keys::kOnEvent, args.Pass()));
-    event->restrict_to_profile = profile;
-    extensions::ExtensionSystem::Get(profile)->event_router()->
+    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;
 
     function->SendResponseBody(dictionary);
     pending_requests_.erase(id);
   }
 }
 
 // static
 ExtensionDevToolsInfoBarDelegate* ExtensionDevToolsInfoBarDelegate::Create(
-    WebContents* web_contents,
+    RenderViewHost* rvh,
     const std::string& client_name) {
+  if (!rvh)
+    return NULL;
+
+  WebContents* web_contents = WebContents::FromRenderViewHost(rvh);
+  if (!web_contents)
+    return NULL;
+
   InfoBarService* infobar_service =
       InfoBarService::FromWebContents(web_contents);
   if (!infobar_service)
     return NULL;
+
   return static_cast<ExtensionDevToolsInfoBarDelegate*>(
       infobar_service->AddInfoBar(scoped_ptr<InfoBarDelegate>(
           new ExtensionDevToolsInfoBarDelegate(infobar_service, client_name))));
 }
 
 void ExtensionDevToolsInfoBarDelegate::AttachClientHost(
     ExtensionDevToolsClientHost* client_host) {
   client_host_ = client_host;
 }
 
@@ skipping 35 matching lines @@
     client_host_->MarkAsDismissed();
 }
 
 bool ExtensionDevToolsInfoBarDelegate::Cancel() {
   if (client_host_)
     client_host_->MarkAsDismissed();
   return true;
 }
 
 DebuggerFunction::DebuggerFunction()
-    : contents_(0),
-      client_host_(0) {
+    : client_host_(0) {
+}
+
+DebuggerFunction::~DebuggerFunction() {
 }
 
 void DebuggerFunction::FormatErrorMessage(const std::string& format) {
   if (debuggee_.tab_id)
     error_ = ErrorUtils::FormatErrorMessage(
       format, keys::kTabTargetType, base::IntToString(*debuggee_.tab_id));
   else if (debuggee_.extension_id)
     error_ = ErrorUtils::FormatErrorMessage(
       format, keys::kBackgroundPageTargetType, *debuggee_.extension_id);
   else
     error_ = ErrorUtils::FormatErrorMessage(
       format, keys::kOpaqueTargetType, *debuggee_.target_id);
 }
 
-bool DebuggerFunction::InitWebContents() {
+bool DebuggerFunction::InitAgentHost() {
   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) {
       if (content::HasWebUIScheme(web_contents->GetURL())) {
         error_ = ErrorUtils::FormatErrorMessage(
             keys::kAttachToWebUIError,
             web_contents->GetURL().scheme());
         return false;
       }
-      contents_ = web_contents;
+      agent_host_ = DevToolsAgentHost::GetOrCreateFor(
+          web_contents->GetRenderViewHost());
     }
   } else if (debuggee_.extension_id) {
     extensions::ExtensionHost* extension_host =
         extensions::ExtensionSystem::Get(profile())->process_manager()->
             GetBackgroundHostForExtension(*debuggee_.extension_id);
     if (extension_host) {
-      contents_ = WebContents::FromRenderViewHost(
+      agent_host_ = DevToolsAgentHost::GetOrCreateFor(
           extension_host->render_view_host());
     }
   } else if (debuggee_.target_id) {
-    DevToolsAgentHost* agent_host =
-        DevToolsAgentHost::GetForId(*debuggee_.target_id);
-    if (agent_host) {
-      contents_ = WebContents::FromRenderViewHost(
-          agent_host->GetRenderViewHost());
-    }
+    agent_host_ = DevToolsAgentHost::GetForId(*debuggee_.target_id);
   } else {
     error_ = keys::kInvalidTargetError;
     return false;
   }
 
-  if (!contents_) {
+  if (!agent_host_) {
     FormatErrorMessage(keys::kNoTargetError);
     return false;
   }
   return true;
 }
 
 bool DebuggerFunction::InitClientHost() {
-  if (!InitWebContents())
+  if (!InitAgentHost())
     return false;
 
-  // Don't fetch rvh from the contents since it'll be wrong upon navigation.
-  client_host_ = AttachedClientHosts::GetInstance()->Lookup(contents_);
+  client_host_ = AttachedClientHosts::GetInstance()->
+      Lookup(agent_host_, GetExtension()->id());
 
-  if (!client_host_ ||
-      !client_host_->MatchesContentsAndExtensionId(contents_,
-                                                   GetExtension()->id())) {
+  if (!client_host_) {
     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());
 
   CopyDebuggee(debuggee_, params->target);
-  if (!InitWebContents())
+  if (!InitAgentHost())
     return false;
 
   if (!webkit_glue::IsInspectorProtocolVersionSupported(
       params->required_version)) {
     error_ = ErrorUtils::FormatErrorMessage(
         keys::kProtocolVersionNotSupportedError,
         params->required_version);
     return false;
   }
 
-  scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetOrCreateFor(
-      contents_->GetRenderViewHost()));
-  if (agent->IsAttached()) {
+  if (agent_host_->IsAttached()) {
     FormatErrorMessage(keys::kAlreadyAttachedError);
     return false;
   }
 
   ExtensionDevToolsInfoBarDelegate* infobar_delegate = NULL;
 
   if (!CommandLine::ForCurrentProcess()->
        HasSwitch(switches::kSilentDebuggerExtensionAPI)) {
     // Do not attach to the target if for any reason the infobar cannot be shown
     // for this WebContents instance.
     infobar_delegate = ExtensionDevToolsInfoBarDelegate::Create(
-          contents_, GetExtension()->name());
+          agent_host_->GetRenderViewHost(), GetExtension()->name());
     if (!infobar_delegate) {
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kSilentDebuggingRequired,
           switches::kSilentDebuggerExtensionAPI);
       return false;
     }
   }
 
-  new ExtensionDevToolsClientHost(contents_,
+  new ExtensionDevToolsClientHost(profile(),
+                                  agent_host_,
                                   GetExtension()->id(),
                                   GetExtension()->name(),
                                   debuggee_,
                                   infobar_delegate);
   SendResponse(true);
   return true;
 }
 
 DebuggerDetachFunction::DebuggerDetachFunction() {}
 
@@ skipping 45 matching lines @@
 
   results_ = SendCommand::Results::Create(result);
   SendResponse(true);
 }
 
 DebuggerGetTargetsFunction::DebuggerGetTargetsFunction() {}
 
 DebuggerGetTargetsFunction::~DebuggerGetTargetsFunction() {}
 
 bool DebuggerGetTargetsFunction::RunImpl() {
-  base::ListValue* results_list = new ListValue();
+  base::ListValue* results_list = new base::ListValue();
 
   std::vector<RenderViewHost*> rvh_list =
       DevToolsAgentHost::GetValidRenderViewHosts();
   for (std::vector<RenderViewHost*>::iterator it = rvh_list.begin();
        it != rvh_list.end(); ++it) {
     base::Value* value = SerializePageInfo(*it);
     if (value)
       results_list->Append(value);
   }
 
-  SetResult(results_list);
-  SendResponse(true);
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&DebuggerGetTargetsFunction::CollectWorkerInfo,
+                 this,
+                 results_list),
+      base::Bind(&DebuggerGetTargetsFunction::SendTargetList,
+                 this,
+                 results_list));
   return true;
 }
+
+void DebuggerGetTargetsFunction::CollectWorkerInfo(base::ListValue* list) {
+  std::vector<WorkerService::WorkerInfo> worker_info =
+      WorkerService::GetInstance()->GetWorkers();
+
+  for (size_t i = 0; i < worker_info.size(); ++i)
+    list->Append(SerializeWorkerInfo(worker_info[i]));
+}
+
+void DebuggerGetTargetsFunction::SendTargetList(base::ListValue* list) {
+  SetResult(list);
+  SendResponse(true);
+}