DevTools: provide the debugger detach reason in chrome.debugger.onDetach extension 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 37 matching lines @@
 using content::WebContents;
 using extensions::api::debugger::Debuggee;
 
 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:
   ExtensionDevToolsInfoBarDelegate(
       InfoBarTabHelper* infobar_helper,
-      const std::string& client_name);
+      const std::string& client_name,
+      ExtensionDevToolsClientHost* client_host);
   virtual ~ExtensionDevToolsInfoBarDelegate();
 
+  // Notifies infobar delegate that associated DevToolsClientHost will be
+  // destroyed.
+  void DiscardClientHost();
+
  private:
   // ConfirmInfoBarDelegate:
   virtual bool ShouldExpire(
       const content::LoadCommittedDetails& details) const OVERRIDE;
   virtual int GetButtons() const OVERRIDE;
   virtual Type GetInfoBarType() const OVERRIDE;
   virtual string16 GetMessageText() const OVERRIDE;
+  virtual void InfoBarDismissed() OVERRIDE;
+  virtual bool Cancel() OVERRIDE;
 
   std::string client_name_;
+  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);
 
   ~ExtensionDevToolsClientHost();
 
   bool MatchesContentsAndExtensionId(WebContents* web_contents,
                                      const std::string& extension_id);
   void Close();
   void SendMessageToBackend(SendCommandDebuggerFunction* function,
                             const std::string& method,
                             SendCommand::Params::CommandParams* command_params);
 
+  // Mark methods below determine the connection termination reason.
+  void MarkAsReplaced();
+  void MarkAsDismissed();
+
   // DevToolsClientHost interface
   virtual void InspectedContentsClosing() OVERRIDE;
   virtual void DispatchOnInspectorFrontend(const std::string& message) OVERRIDE;
   virtual void ContentsReplaced(WebContents* web_contents) OVERRIDE;
   virtual void FrameNavigating(const std::string& url) OVERRIDE {}
 
  private:
   void SendDetachedEvent();
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details);
 
   WebContents* web_contents_;
   std::string extension_id_;
   int tab_id_;
   content::NotificationRegistrar registrar_;
   int last_request_id_;
   typedef std::map<int, scoped_refptr<SendCommandDebuggerFunction> >
       PendingRequests;
   PendingRequests pending_requests_;
   ExtensionDevToolsInfoBarDelegate* infobar_delegate_;
+  OnDetach::Reason detach_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
 namespace {
 
 class AttachedClientHosts {
  public:
   AttachedClientHosts() {}
 
   // Returns the singleton instance of this class
   static AttachedClientHosts* GetInstance() {
     return Singleton<AttachedClientHosts>::get();
   }
 
   void Add(ExtensionDevToolsClientHost* client_host) {
     client_hosts_.insert(client_host);
   }
 
   void Remove(ExtensionDevToolsClientHost* client_host) {
     client_hosts_.erase(client_host);
   }
 
+  ExtensionDevToolsClientHost* AsExtensionDevToolsClientHost(
+      DevToolsClientHost* client_host) {
+    for (std::set<DevToolsClientHost*>::iterator it = client_hosts_.begin();
+         it != client_hosts_.end(); ++it) {
+      if (client_host == *it)
+        return static_cast<ExtensionDevToolsClientHost*>(*it);
+    }
+    return NULL;
+  }
+
   ExtensionDevToolsClientHost* Lookup(WebContents* contents) {
     for (std::set<DevToolsClientHost*>::iterator it = client_hosts_.begin();
          it != client_hosts_.end(); ++it) {
       DevToolsAgentHost* agent_host =
           DevToolsManager::GetInstance()->GetDevToolsAgentHostFor(*it);
       if (!agent_host)
         continue;
       content::RenderViewHost* rvh =
           DevToolsAgentHostRegistry::GetRenderViewHost(agent_host);
       if (rvh && WebContents::FromRenderViewHost(rvh) == contents)
@@ skipping 10 matching lines @@
 
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     WebContents* web_contents,
     const std::string& extension_id,
     const std::string& extension_name,
     int tab_id)
     : web_contents_(web_contents),
       extension_id_(extension_id),
       tab_id_(tab_id),
       last_request_id_(0),
-      infobar_delegate_(NULL) {
+      infobar_delegate_(NULL),
+      detach_reason_(OnDetach::REASON_TARGET_CLOSED) {
   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.
   DevToolsAgentHost* agent = DevToolsAgentHostRegistry::GetDevToolsAgentHost(
       web_contents_->GetRenderViewHost());
   DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(agent, this);
 
   InfoBarTabHelper* infobar_helper =
       TabContents::FromWebContents(web_contents_)->infobar_tab_helper();
-  infobar_delegate_ =
-      new ExtensionDevToolsInfoBarDelegate(infobar_helper, extension_name);
+  infobar_delegate_ = new ExtensionDevToolsInfoBarDelegate(infobar_helper,
+                                                           extension_name,
+                                                           this);
   if (infobar_helper->AddInfoBar(infobar_delegate_)) {
     registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
                    content::Source<InfoBarTabHelper>(infobar_helper));
   } else {
     infobar_delegate_ = NULL;
   }
 }
 
 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
   // Ensure calling RemoveInfoBar() below won't result in Observe() trying to
   // Close() us.
   registrar_.RemoveAll();
 
   if (infobar_delegate_) {
+    infobar_delegate_->DiscardClientHost();
     TabContents* tab_contents = TabContents::FromWebContents(web_contents_);
     InfoBarTabHelper* helper = tab_contents->infobar_tab_helper();
     if (helper)
       helper->RemoveInfoBar(infobar_delegate_);
   }
   AttachedClientHosts::GetInstance()->Remove(this);
 }
 
 bool ExtensionDevToolsClientHost::MatchesContentsAndExtensionId(
     WebContents* web_contents,
@@ skipping 28 matching lines @@
   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);
 }
 
+void ExtensionDevToolsClientHost::MarkAsReplaced() {
+  detach_reason_ = OnDetach::REASON_REPLACED_WITH_DEVTOOLS;
+}
+
+void ExtensionDevToolsClientHost::MarkAsDismissed() {
+  detach_reason_ = OnDetach::REASON_CANCELED_BY_USER;
+}
+
 void ExtensionDevToolsClientHost::SendDetachedEvent() {
   Profile* profile =
       Profile::FromBrowserContext(web_contents_->GetBrowserContext());
   if (profile != NULL && profile->GetExtensionEventRouter()) {
     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_));
     profile->GetExtensionEventRouter()->DispatchEventToExtension(
         extension_id_, keys::kOnDetach, args.Pass(), profile, GURL());
   }
 }
 
 void ExtensionDevToolsClientHost::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
@@ skipping 47 matching lines @@
     if (!function)
       return;
 
     function->SendResponseBody(dictionary);
     pending_requests_.erase(id);
   }
 }
 
 ExtensionDevToolsInfoBarDelegate::ExtensionDevToolsInfoBarDelegate(
     InfoBarTabHelper* infobar_helper,
-    const std::string& client_name)
+    const std::string& client_name,
+    ExtensionDevToolsClientHost* client_host)
     : ConfirmInfoBarDelegate(infobar_helper),
-      client_name_(client_name) {
+      client_name_(client_name),
+      client_host_(client_host) {
 }
 
 ExtensionDevToolsInfoBarDelegate::~ExtensionDevToolsInfoBarDelegate() {
 }
 
+void ExtensionDevToolsInfoBarDelegate::DiscardClientHost() {
+  client_host_ = NULL;
+}
+
 bool ExtensionDevToolsInfoBarDelegate::ShouldExpire(
     const content::LoadCommittedDetails& details) const {
   return false;
 }
 
 int ExtensionDevToolsInfoBarDelegate::GetButtons() const {
   return BUTTON_CANCEL;
 }
 
 InfoBarDelegate::Type ExtensionDevToolsInfoBarDelegate::GetInfoBarType() const {
   return WARNING_TYPE;
 }
 
 string16 ExtensionDevToolsInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringFUTF16(IDS_DEV_TOOLS_INFOBAR_LABEL,
                                     UTF8ToUTF16(client_name_));
 }
 
+void ExtensionDevToolsInfoBarDelegate::InfoBarDismissed() {
+  if (client_host_)
+    client_host_->MarkAsDismissed();
+}
+
+bool ExtensionDevToolsInfoBarDelegate::Cancel() {
+  if (client_host_)
+    client_host_->MarkAsDismissed();
+  return true;
+}
+
 DebuggerFunction::DebuggerFunction()
     : contents_(0),
       tab_id_(0),
       client_host_(0) {
 }
 
 bool DebuggerFunction::InitTabContents() {
   // Find the TabContents that contains this tab id.
   contents_ = NULL;
   TabContents* tab_contents = NULL;
@@ skipping 120 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);
 }
+
+// static
+void DebuggerApi::MarkDevToolsClientHostAsReplaced(
+    DevToolsClientHost* client_host) {
+  ExtensionDevToolsClientHost* host = AttachedClientHosts::GetInstance()->
+      AsExtensionDevToolsClientHost(client_host);
+  if (host)
+    host->MarkAsReplaced();
+}