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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Implements the Chrome Extensions Debugger API.
   6
   7 #include "chrome/browser/extensions/api/debugger/debugger_api.h"
   8
   9 #include <map>
  10 #include <set>
  11
  12 #include "base/command_line.h"
  13 #include "base/json/json_reader.h"
  14 #include "base/json/json_writer.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/singleton.h"
  17 #include "base/scoped_observer.h"
  18 #include "base/stl_util.h"
  19 #include "base/strings/string_number_conversions.h"
  20 #include "base/strings/utf_string_conversions.h"
  21 #include "base/values.h"
  22 #include "chrome/browser/chrome_notification_types.h"
  23 #include "chrome/browser/devtools/devtools_target_impl.h"
  24 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
  25 #include "chrome/browser/extensions/extension_service.h"
  26 #include "chrome/browser/extensions/extension_tab_util.h"
  27 #include "chrome/browser/infobars/infobar_service.h"
  28 #include "chrome/browser/profiles/profile.h"
  29 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
  30 #include "chrome/common/chrome_switches.h"
  31 #include "chrome/grit/generated_resources.h"
  32 #include "components/infobars/core/confirm_infobar_delegate.h"
  33 #include "components/infobars/core/infobar.h"
  34 #include "content/public/browser/devtools_agent_host.h"
  35 #include "content/public/browser/devtools_http_handler.h"
  36 #include "content/public/browser/notification_service.h"
  37 #include "content/public/browser/notification_source.h"
  38 #include "content/public/browser/render_process_host.h"
  39 #include "content/public/browser/render_view_host.h"
  40 #include "content/public/browser/render_widget_host.h"
  41 #include "content/public/browser/web_contents.h"
  42 #include "content/public/common/content_client.h"
  43 #include "content/public/common/url_utils.h"
  44 #include "extensions/browser/event_router.h"
  45 #include "extensions/browser/extension_host.h"
  46 #include "extensions/browser/extension_registry.h"
  47 #include "extensions/browser/extension_registry_observer.h"
  48 #include "extensions/browser/extension_system.h"
  49 #include "extensions/common/constants.h"
  50 #include "extensions/common/error_utils.h"
  51 #include "extensions/common/extension.h"
  52 #include "extensions/common/manifest_constants.h"
  53 #include "extensions/common/permissions/permissions_data.h"
  54 #include "extensions/common/switches.h"
  55 #include "ui/base/l10n/l10n_util.h"
  56
  57 using content::DevToolsAgentHost;
  58 using content::DevToolsHttpHandler;
  59 using content::RenderProcessHost;
  60 using content::RenderViewHost;
  61 using content::RenderWidgetHost;
  62 using content::WebContents;
  63
  64 namespace keys = debugger_api_constants;
  65 namespace Attach = extensions::api::debugger::Attach;
  66 namespace Detach = extensions::api::debugger::Detach;
  67 namespace OnDetach = extensions::api::debugger::OnDetach;
  68 namespace OnEvent = extensions::api::debugger::OnEvent;
  69 namespace SendCommand = extensions::api::debugger::SendCommand;
  70
  71 namespace extensions {
  72 class ExtensionRegistry;
  73
  74 // ExtensionDevToolsClientHost ------------------------------------------------
  75
  76 class ExtensionDevToolsClientHost : public content::DevToolsAgentHostClient,
  77                                     public content::NotificationObserver,
  78                                     public ExtensionRegistryObserver {
  79  public:
  80   ExtensionDevToolsClientHost(Profile* profile,
  81                               DevToolsAgentHost* agent_host,
  82                               const std::string& extension_id,
  83                               const std::string& extension_name,
  84                               const Debuggee& debuggee,
  85                               infobars::InfoBar* infobar);
  86
  87   virtual ~ExtensionDevToolsClientHost();
  88
  89   const std::string& extension_id() { return extension_id_; }
  90   DevToolsAgentHost* agent_host() { return agent_host_.get(); }
  91   void Close();
  92   void SendMessageToBackend(DebuggerSendCommandFunction* function,
  93                             const std::string& method,
  94                             SendCommand::Params::CommandParams* command_params);
  95
  96   // Marks connection as to-be-terminated by the user.
  97   void MarkAsDismissed();
  98
  99   // DevToolsAgentHostClient interface.
 100   virtual void AgentHostClosed(
 101       DevToolsAgentHost* agent_host,
 102       bool replaced_with_another_client) OVERRIDE;
 103   virtual void DispatchProtocolMessage(
 104       DevToolsAgentHost* agent_host,
 105       const std::string& message) OVERRIDE;
 106
 107  private:
 108   void SendDetachedEvent();
 109
 110   // content::NotificationObserver implementation.
 111   virtual void Observe(int type,
 112                        const content::NotificationSource& source,
 113                        const content::NotificationDetails& details) OVERRIDE;
 114
 115   // ExtensionRegistryObserver implementation.
 116   virtual void OnExtensionUnloaded(
 117       content::BrowserContext* browser_context,
 118       const Extension* extension,
 119       UnloadedExtensionInfo::Reason reason) OVERRIDE;
 120
 121   Profile* profile_;
 122   scoped_refptr<DevToolsAgentHost> agent_host_;
 123   std::string extension_id_;
 124   Debuggee debuggee_;
 125   content::NotificationRegistrar registrar_;
 126   int last_request_id_;
 127   typedef std::map<int, scoped_refptr<DebuggerSendCommandFunction> >
 128       PendingRequests;
 129   PendingRequests pending_requests_;
 130   infobars::InfoBar* infobar_;
 131   OnDetach::Reason detach_reason_;
 132
 133   // Listen to extension unloaded notification.
 134   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
 135       extension_registry_observer_;
 136
 137   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 138 };
 139
 140 // The member function declarations come after the other class declarations, so
 141 // they can call members on them.
 142
 143
 144 namespace {
 145
 146 // Helpers --------------------------------------------------------------------
 147
 148 void CopyDebuggee(Debuggee* dst, const Debuggee& src) {
 149   if (src.tab_id)
 150     dst->tab_id.reset(new int(*src.tab_id));
 151   if (src.extension_id)
 152     dst->extension_id.reset(new std::string(*src.extension_id));
 153   if (src.target_id)
 154     dst->target_id.reset(new std::string(*src.target_id));
 155 }
 156
 157
 158 // ExtensionDevToolsInfoBarDelegate -------------------------------------------
 159
 160 class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
 161  public:
 162   // Creates an extension dev tools infobar and delegate and adds the infobar to
 163   // the InfoBarService associated with |rvh|.  Returns the infobar if it was
 164   // successfully added.
 165   static infobars::InfoBar* Create(WebContents* web_contents,
 166                                    const std::string& client_name);
 167
 168   void set_client_host(ExtensionDevToolsClientHost* client_host) {
 169     client_host_ = client_host;
 170   }
 171
 172  private:
 173   explicit ExtensionDevToolsInfoBarDelegate(const std::string& client_name);
 174   virtual ~ExtensionDevToolsInfoBarDelegate();
 175
 176   // ConfirmInfoBarDelegate:
 177   virtual void InfoBarDismissed() OVERRIDE;
 178   virtual Type GetInfoBarType() const OVERRIDE;
 179   virtual bool ShouldExpireInternal(
 180       const NavigationDetails& details) const OVERRIDE;
 181   virtual base::string16 GetMessageText() const OVERRIDE;
 182   virtual int GetButtons() const OVERRIDE;
 183   virtual bool Cancel() OVERRIDE;
 184
 185   std::string client_name_;
 186   ExtensionDevToolsClientHost* client_host_;
 187
 188   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsInfoBarDelegate);
 189 };
 190
 191 // static
 192 infobars::InfoBar* ExtensionDevToolsInfoBarDelegate::Create(
 193     WebContents* web_contents,
 194     const std::string& client_name) {
 195   if (!web_contents)
 196     return NULL;
 197
 198   InfoBarService* infobar_service =
 199       InfoBarService::FromWebContents(web_contents);
 200   if (!infobar_service)
 201     return NULL;
 202
 203   return infobar_service->AddInfoBar(ConfirmInfoBarDelegate::CreateInfoBar(
 204       scoped_ptr<ConfirmInfoBarDelegate>(
 205           new ExtensionDevToolsInfoBarDelegate(client_name))));
 206 }
 207
 208 ExtensionDevToolsInfoBarDelegate::ExtensionDevToolsInfoBarDelegate(
 209     const std::string& client_name)
 210     : ConfirmInfoBarDelegate(),
 211       client_name_(client_name),
 212       client_host_(NULL) {
 213 }
 214
 215 ExtensionDevToolsInfoBarDelegate::~ExtensionDevToolsInfoBarDelegate() {
 216 }
 217
 218 void ExtensionDevToolsInfoBarDelegate::InfoBarDismissed() {
 219   if (client_host_)
 220     client_host_->MarkAsDismissed();
 221 }
 222
 223 infobars::InfoBarDelegate::Type
 224 ExtensionDevToolsInfoBarDelegate::GetInfoBarType() const {
 225   return WARNING_TYPE;
 226 }
 227
 228 bool ExtensionDevToolsInfoBarDelegate::ShouldExpireInternal(
 229     const NavigationDetails& details) const {
 230   return false;
 231 }
 232
 233 base::string16 ExtensionDevToolsInfoBarDelegate::GetMessageText() const {
 234   return l10n_util::GetStringFUTF16(IDS_DEV_TOOLS_INFOBAR_LABEL,
 235                                     base::UTF8ToUTF16(client_name_));
 236 }
 237
 238 int ExtensionDevToolsInfoBarDelegate::GetButtons() const {
 239   return BUTTON_CANCEL;
 240 }
 241
 242 bool ExtensionDevToolsInfoBarDelegate::Cancel() {
 243   InfoBarDismissed();
 244   return true;
 245 }
 246
 247
 248 // AttachedClientHosts --------------------------------------------------------
 249
 250 class AttachedClientHosts {
 251  public:
 252   AttachedClientHosts();
 253   ~AttachedClientHosts();
 254
 255   // Returns the singleton instance of this class.
 256   static AttachedClientHosts* GetInstance();
 257
 258   void Add(ExtensionDevToolsClientHost* client_host);
 259   void Remove(ExtensionDevToolsClientHost* client_host);
 260   ExtensionDevToolsClientHost* Lookup(DevToolsAgentHost* agent_host,
 261                                       const std::string& extension_id);
 262
 263  private:
 264   typedef std::set<ExtensionDevToolsClientHost*> ClientHosts;
 265   ClientHosts client_hosts_;
 266
 267   DISALLOW_COPY_AND_ASSIGN(AttachedClientHosts);
 268 };
 269
 270 AttachedClientHosts::AttachedClientHosts() {
 271 }
 272
 273 AttachedClientHosts::~AttachedClientHosts() {
 274 }
 275
 276 // static
 277 AttachedClientHosts* AttachedClientHosts::GetInstance() {
 278   return Singleton<AttachedClientHosts>::get();
 279 }
 280
 281 void AttachedClientHosts::Add(ExtensionDevToolsClientHost* client_host) {
 282   client_hosts_.insert(client_host);
 283 }
 284
 285 void AttachedClientHosts::Remove(ExtensionDevToolsClientHost* client_host) {
 286   client_hosts_.erase(client_host);
 287 }
 288
 289 ExtensionDevToolsClientHost* AttachedClientHosts::Lookup(
 290     DevToolsAgentHost* agent_host,
 291     const std::string& extension_id) {
 292   for (ClientHosts::iterator it = client_hosts_.begin();
 293        it != client_hosts_.end(); ++it) {
 294     ExtensionDevToolsClientHost* client_host = *it;
 295     if (client_host->agent_host() == agent_host &&
 296         client_host->extension_id() == extension_id)
 297       return client_host;
 298   }
 299   return NULL;
 300 }
 301
 302 }  // namespace
 303
 304
 305 // ExtensionDevToolsClientHost ------------------------------------------------
 306
 307 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
 308     Profile* profile,
 309     DevToolsAgentHost* agent_host,
 310     const std::string& extension_id,
 311     const std::string& extension_name,
 312     const Debuggee& debuggee,
 313     infobars::InfoBar* infobar)
 314     : profile_(profile),
 315       agent_host_(agent_host),
 316       extension_id_(extension_id),
 317       last_request_id_(0),
 318       infobar_(infobar),
 319       detach_reason_(OnDetach::REASON_TARGET_CLOSED),
 320       extension_registry_observer_(this) {
 321   CopyDebuggee(&debuggee_, debuggee);
 322
 323   AttachedClientHosts::GetInstance()->Add(this);
 324
 325   // ExtensionRegistryObserver listen extension unloaded and detach debugger
 326   // from there.
 327   extension_registry_observer_.Add(ExtensionRegistry::Get(profile_));
 328
 329   // RVH-based agents disconnect from their clients when the app is terminating
 330   // but shared worker-based agents do not.
 331   // Disconnect explicitly to make sure that |this| observer is not leaked.
 332   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
 333                  content::NotificationService::AllSources());
 334
 335   // Attach to debugger and tell it we are ready.
 336   agent_host_->AttachClient(this);
 337
 338   if (infobar_) {
 339     static_cast<ExtensionDevToolsInfoBarDelegate*>(
 340         infobar_->delegate())->set_client_host(this);
 341     registrar_.Add(
 342         this,
 343         chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
 344         content::Source<InfoBarService>(
 345             InfoBarService::FromWebContents(agent_host_->GetWebContents())));
 346   }
 347 }
 348
 349 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
 350   // Ensure calling RemoveInfoBar() below won't result in Observe() trying to
 351   // Close() us.
 352   registrar_.RemoveAll();
 353
 354   if (infobar_) {
 355     static_cast<ExtensionDevToolsInfoBarDelegate*>(
 356         infobar_->delegate())->set_client_host(NULL);
 357     InfoBarService* infobar_service =
 358         InfoBarService::FromWebContents(agent_host_->GetWebContents());
 359     infobar_service->RemoveInfoBar(infobar_);
 360   }
 361   AttachedClientHosts::GetInstance()->Remove(this);
 362 }
 363
 364 // DevToolsAgentHostClient implementation.
 365 void ExtensionDevToolsClientHost::AgentHostClosed(
 366     DevToolsAgentHost* agent_host, bool replaced_with_another_client) {
 367   DCHECK(agent_host == agent_host_.get());
 368   if (replaced_with_another_client)
 369     detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
 370   SendDetachedEvent();
 371   delete this;
 372 }
 373
 374 void ExtensionDevToolsClientHost::Close() {
 375   agent_host_->DetachClient();
 376   delete this;
 377 }
 378
 379 void ExtensionDevToolsClientHost::SendMessageToBackend(
 380     DebuggerSendCommandFunction* function,
 381     const std::string& method,
 382     SendCommand::Params::CommandParams* command_params) {
 383   base::DictionaryValue protocol_request;
 384   int request_id = ++last_request_id_;
 385   pending_requests_[request_id] = function;
 386   protocol_request.SetInteger("id", request_id);
 387   protocol_request.SetString("method", method);
 388   if (command_params) {
 389     protocol_request.Set("params",
 390                          command_params->additional_properties.DeepCopy());
 391   }
 392
 393   std::string json_args;
 394   base::JSONWriter::Write(&protocol_request, &json_args);
 395   agent_host_->DispatchProtocolMessage(json_args);
 396 }
 397
 398 void ExtensionDevToolsClientHost::MarkAsDismissed() {
 399   detach_reason_ = OnDetach::REASON_CANCELED_BY_USER;
 400 }
 401
 402 void ExtensionDevToolsClientHost::SendDetachedEvent() {
 403   if (!EventRouter::Get(profile_))
 404     return;
 405
 406   scoped_ptr<base::ListValue> args(OnDetach::Create(debuggee_,
 407                                                     detach_reason_));
 408   scoped_ptr<Event> event(new Event(OnDetach::kEventName, args.Pass()));
 409   event->restrict_to_browser_context = profile_;
 410   EventRouter::Get(profile_)
 411       ->DispatchEventToExtension(extension_id_, event.Pass());
 412 }
 413
 414 void ExtensionDevToolsClientHost::OnExtensionUnloaded(
 415     content::BrowserContext* browser_context,
 416     const Extension* extension,
 417     UnloadedExtensionInfo::Reason reason) {
 418   if (extension->id() == extension_id_)
 419     Close();
 420 }
 421
 422 void ExtensionDevToolsClientHost::Observe(
 423     int type,
 424     const content::NotificationSource& source,
 425     const content::NotificationDetails& details) {
 426   switch (type) {
 427     case chrome::NOTIFICATION_APP_TERMINATING:
 428       Close();
 429       break;
 430     case chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED:
 431       if (content::Details<infobars::InfoBar::RemovedDetails>(details)->first ==
 432           infobar_) {
 433         infobar_ = NULL;
 434         SendDetachedEvent();
 435         Close();
 436       }
 437       break;
 438     default:
 439       NOTREACHED();
 440   }
 441 }
 442
 443 void ExtensionDevToolsClientHost::DispatchProtocolMessage(
 444     DevToolsAgentHost* agent_host, const std::string& message) {
 445   DCHECK(agent_host == agent_host_.get());
 446   if (!EventRouter::Get(profile_))
 447     return;
 448
 449   scoped_ptr<base::Value> result(base::JSONReader::Read(message));
 450   if (!result->IsType(base::Value::TYPE_DICTIONARY))
 451     return;
 452   base::DictionaryValue* dictionary =
 453       static_cast<base::DictionaryValue*>(result.get());
 454
 455   int id;
 456   if (!dictionary->GetInteger("id", &id)) {
 457     std::string method_name;
 458     if (!dictionary->GetString("method", &method_name))
 459       return;
 460
 461     OnEvent::Params params;
 462     base::DictionaryValue* params_value;
 463     if (dictionary->GetDictionary("params", &params_value))
 464       params.additional_properties.Swap(params_value);
 465
 466     scoped_ptr<base::ListValue> args(
 467         OnEvent::Create(debuggee_, method_name, params));
 468     scoped_ptr<Event> event(new Event(OnEvent::kEventName, args.Pass()));
 469     event->restrict_to_browser_context = profile_;
 470     EventRouter::Get(profile_)
 471         ->DispatchEventToExtension(extension_id_, event.Pass());
 472   } else {
 473     DebuggerSendCommandFunction* function = pending_requests_[id].get();
 474     if (!function)
 475       return;
 476
 477     function->SendResponseBody(dictionary);
 478     pending_requests_.erase(id);
 479   }
 480 }
 481
 482
 483 // DebuggerFunction -----------------------------------------------------------
 484
 485 DebuggerFunction::DebuggerFunction()
 486     : client_host_(NULL) {
 487 }
 488
 489 DebuggerFunction::~DebuggerFunction() {
 490 }
 491
 492 void DebuggerFunction::FormatErrorMessage(const std::string& format) {
 493   if (debuggee_.tab_id)
 494     error_ = ErrorUtils::FormatErrorMessage(
 495       format, keys::kTabTargetType, base::IntToString(*debuggee_.tab_id));
 496   else if (debuggee_.extension_id)
 497     error_ = ErrorUtils::FormatErrorMessage(
 498       format, keys::kBackgroundPageTargetType, *debuggee_.extension_id);
 499   else
 500     error_ = ErrorUtils::FormatErrorMessage(
 501       format, keys::kOpaqueTargetType, *debuggee_.target_id);
 502 }
 503
 504 bool DebuggerFunction::InitAgentHost() {
 505   if (debuggee_.tab_id) {
 506     WebContents* web_contents = NULL;
 507     bool result = ExtensionTabUtil::GetTabById(*debuggee_.tab_id,
 508                                                GetProfile(),
 509                                                include_incognito(),
 510                                                NULL,
 511                                                NULL,
 512                                                &web_contents,
 513                                                NULL);
 514     if (result && web_contents) {
 515       // TODO(rdevlin.cronin) This should definitely be GetLastCommittedURL().
 516       GURL url = web_contents->GetVisibleURL();
 517       if (PermissionsData::IsRestrictedUrl(url, url, extension(), &error_))
 518         return false;
 519       agent_host_ = DevToolsAgentHost::GetOrCreateFor(web_contents);
 520     }
 521   } else if (debuggee_.extension_id) {
 522     ExtensionHost* extension_host =
 523         ExtensionSystem::Get(GetProfile())
 524             ->process_manager()
 525             ->GetBackgroundHostForExtension(*debuggee_.extension_id);
 526     if (extension_host) {
 527       if (PermissionsData::IsRestrictedUrl(extension_host->GetURL(),
 528                                            extension_host->GetURL(),
 529                                            extension(),
 530                                            &error_)) {
 531         return false;
 532       }
 533       agent_host_ =
 534           DevToolsAgentHost::GetOrCreateFor(extension_host->host_contents());
 535     }
 536   } else if (debuggee_.target_id) {
 537     agent_host_ = DevToolsAgentHost::GetForId(*debuggee_.target_id);
 538   } else {
 539     error_ = keys::kInvalidTargetError;
 540     return false;
 541   }
 542
 543   if (!agent_host_.get()) {
 544     FormatErrorMessage(keys::kNoTargetError);
 545     return false;
 546   }
 547   return true;
 548 }
 549
 550 bool DebuggerFunction::InitClientHost() {
 551   if (!InitAgentHost())
 552     return false;
 553
 554   client_host_ = AttachedClientHosts::GetInstance()->Lookup(agent_host_.get(),
 555                                                             extension()->id());
 556
 557   if (!client_host_) {
 558     FormatErrorMessage(keys::kNotAttachedError);
 559     return false;
 560   }
 561   return true;
 562 }
 563
 564
 565 // DebuggerAttachFunction -----------------------------------------------------
 566
 567 DebuggerAttachFunction::DebuggerAttachFunction() {
 568 }
 569
 570 DebuggerAttachFunction::~DebuggerAttachFunction() {
 571 }
 572
 573 bool DebuggerAttachFunction::RunAsync() {
 574   scoped_ptr<Attach::Params> params(Attach::Params::Create(*args_));
 575   EXTENSION_FUNCTION_VALIDATE(params.get());
 576
 577   CopyDebuggee(&debuggee_, params->target);
 578   if (!InitAgentHost())
 579     return false;
 580
 581   if (!DevToolsHttpHandler::IsSupportedProtocolVersion(
 582           params->required_version)) {
 583     error_ = ErrorUtils::FormatErrorMessage(
 584         keys::kProtocolVersionNotSupportedError,
 585         params->required_version);
 586     return false;
 587   }
 588
 589   if (agent_host_->IsAttached()) {
 590     FormatErrorMessage(keys::kAlreadyAttachedError);
 591     return false;
 592   }
 593
 594   infobars::InfoBar* infobar = NULL;
 595   if (!CommandLine::ForCurrentProcess()->
 596        HasSwitch(::switches::kSilentDebuggerExtensionAPI)) {
 597     // Do not attach to the target if for any reason the infobar cannot be shown
 598     // for this WebContents instance.
 599     infobar = ExtensionDevToolsInfoBarDelegate::Create(
 600         agent_host_->GetWebContents(), extension()->name());
 601     if (!infobar) {
 602       error_ = ErrorUtils::FormatErrorMessage(
 603           keys::kSilentDebuggingRequired,
 604           ::switches::kSilentDebuggerExtensionAPI);
 605       return false;
 606     }
 607   }
 608
 609   new ExtensionDevToolsClientHost(GetProfile(),
 610                                   agent_host_.get(),
 611                                   extension()->id(),
 612                                   extension()->name(),
 613                                   debuggee_,
 614                                   infobar);
 615   SendResponse(true);
 616   return true;
 617 }
 618
 619
 620 // DebuggerDetachFunction -----------------------------------------------------
 621
 622 DebuggerDetachFunction::DebuggerDetachFunction() {
 623 }
 624
 625 DebuggerDetachFunction::~DebuggerDetachFunction() {
 626 }
 627
 628 bool DebuggerDetachFunction::RunAsync() {
 629   scoped_ptr<Detach::Params> params(Detach::Params::Create(*args_));
 630   EXTENSION_FUNCTION_VALIDATE(params.get());
 631
 632   CopyDebuggee(&debuggee_, params->target);
 633   if (!InitClientHost())
 634     return false;
 635
 636   client_host_->Close();
 637   SendResponse(true);
 638   return true;
 639 }
 640
 641
 642 // DebuggerSendCommandFunction ------------------------------------------------
 643
 644 DebuggerSendCommandFunction::DebuggerSendCommandFunction() {
 645 }
 646
 647 DebuggerSendCommandFunction::~DebuggerSendCommandFunction() {
 648 }
 649
 650 bool DebuggerSendCommandFunction::RunAsync() {
 651   scoped_ptr<SendCommand::Params> params(SendCommand::Params::Create(*args_));
 652   EXTENSION_FUNCTION_VALIDATE(params.get());
 653
 654   CopyDebuggee(&debuggee_, params->target);
 655   if (!InitClientHost())
 656     return false;
 657
 658   client_host_->SendMessageToBackend(this, params->method,
 659       params->command_params.get());
 660   return true;
 661 }
 662
 663 void DebuggerSendCommandFunction::SendResponseBody(
 664     base::DictionaryValue* response) {
 665   base::Value* error_body;
 666   if (response->Get("error", &error_body)) {
 667     base::JSONWriter::Write(error_body, &error_);
 668     SendResponse(false);
 669     return;
 670   }
 671
 672   base::DictionaryValue* result_body;
 673   SendCommand::Results::Result result;
 674   if (response->GetDictionary("result", &result_body))
 675     result.additional_properties.Swap(result_body);
 676
 677   results_ = SendCommand::Results::Create(result);
 678   SendResponse(true);
 679 }
 680
 681
 682 // DebuggerGetTargetsFunction -------------------------------------------------
 683
 684 namespace {
 685
 686 const char kTargetIdField[] = "id";
 687 const char kTargetTypeField[] = "type";
 688 const char kTargetTitleField[] = "title";
 689 const char kTargetAttachedField[] = "attached";
 690 const char kTargetUrlField[] = "url";
 691 const char kTargetFaviconUrlField[] = "faviconUrl";
 692 const char kTargetTypePage[] = "page";
 693 const char kTargetTypeBackgroundPage[] = "background_page";
 694 const char kTargetTypeWorker[] = "worker";
 695 const char kTargetTypeOther[] = "other";
 696 const char kTargetTabIdField[] = "tabId";
 697 const char kTargetExtensionIdField[] = "extensionId";
 698
 699 base::Value* SerializeTarget(const DevToolsTargetImpl& target) {
 700   base::DictionaryValue* dictionary = new base::DictionaryValue();
 701
 702   dictionary->SetString(kTargetIdField, target.GetId());
 703   dictionary->SetString(kTargetTitleField, target.GetTitle());
 704   dictionary->SetBoolean(kTargetAttachedField, target.IsAttached());
 705   dictionary->SetString(kTargetUrlField, target.GetURL().spec());
 706
 707   std::string type = target.GetType();
 708   if (type == kTargetTypePage) {
 709     dictionary->SetInteger(kTargetTabIdField, target.GetTabId());
 710   } else if (type == kTargetTypeBackgroundPage) {
 711     dictionary->SetString(kTargetExtensionIdField, target.GetExtensionId());
 712   } else if (type != kTargetTypeWorker) {
 713     // DevToolsTargetImpl may support more types than the debugger API.
 714     type = kTargetTypeOther;
 715   }
 716   dictionary->SetString(kTargetTypeField, type);
 717
 718   GURL favicon_url = target.GetFaviconURL();
 719   if (favicon_url.is_valid())
 720     dictionary->SetString(kTargetFaviconUrlField, favicon_url.spec());
 721
 722   return dictionary;
 723 }
 724
 725 }  // namespace
 726
 727 DebuggerGetTargetsFunction::DebuggerGetTargetsFunction() {
 728 }
 729
 730 DebuggerGetTargetsFunction::~DebuggerGetTargetsFunction() {
 731 }
 732
 733 bool DebuggerGetTargetsFunction::RunAsync() {
 734   DevToolsTargetImpl::EnumerateAllTargets(
 735       base::Bind(&DebuggerGetTargetsFunction::SendTargetList, this));
 736   return true;
 737 }
 738
 739 void DebuggerGetTargetsFunction::SendTargetList(
 740     const std::vector<DevToolsTargetImpl*>& target_list) {
 741   scoped_ptr<base::ListValue> result(new base::ListValue());
 742   for (size_t i = 0; i < target_list.size(); ++i)
 743     result->Append(SerializeTarget(*target_list[i]));
 744   STLDeleteContainerPointers(target_list.begin(), target_list.end());
 745   SetResult(result.release());
 746   SendResponse(true);
 747 }
 748
 749 }  // namespace extensions