Infobar system refactor.

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 50 matching lines @@
 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;
 
-namespace {
-class ExtensionDevToolsInfoBarDelegate;
-}  // namespace
-
 
 // ExtensionDevToolsClientHost ------------------------------------------------
 
 class ExtensionDevToolsClientHost : public DevToolsClientHost,
                                     public content::NotificationObserver {
  public:
   ExtensionDevToolsClientHost(
       Profile* profile,
       DevToolsAgentHost* agent_host,
       const std::string& extension_id,
       const std::string& extension_name,
       const Debuggee& debuggee,
-      ExtensionDevToolsInfoBarDelegate* infobar);
+      InfoBar* infobar);
 
   virtual ~ExtensionDevToolsClientHost();
 
   const std::string& extension_id() { return 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.
@@ skipping 14 matching lines @@
 
   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_;
+  InfoBar* infobar_;
   OnDetach::Reason detach_reason_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
 // The member function declarations come after the other class declarations, so
 // they can call members on them.
 
 
 namespace {
 
 // Helpers --------------------------------------------------------------------
 
 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));
 }
 
 
 // ExtensionDevToolsInfoBarDelegate -------------------------------------------
 
 class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
-  // Creates an extension dev tools infobar delegate and adds it to the
-  // InfoBarService associated with |rvh|.  Returns the delegate if it was
+  // Creates an extension dev tools infobar and delegate and adds the infobar to
+  // the InfoBarService associated with |rvh|.  Returns the infobar if it was
   // successfully added.
-  static ExtensionDevToolsInfoBarDelegate* Create(
-      RenderViewHost* rvh,
-      const std::string& client_name);
+  static InfoBar* Create(RenderViewHost* rvh, const std::string& client_name);
 
   void set_client_host(ExtensionDevToolsClientHost* client_host) {
     client_host_ = client_host;
   }
 
  private:
-  ExtensionDevToolsInfoBarDelegate(InfoBarService* infobar_service,
-                                   const std::string& client_name);
+  explicit ExtensionDevToolsInfoBarDelegate(const std::string& client_name);
   virtual ~ExtensionDevToolsInfoBarDelegate();
 
   // ConfirmInfoBarDelegate:
   virtual void InfoBarDismissed() OVERRIDE;
   virtual Type GetInfoBarType() const OVERRIDE;
   virtual bool ShouldExpireInternal(
       const content::LoadCommittedDetails& details) const OVERRIDE;
   virtual string16 GetMessageText() const OVERRIDE;
   virtual int GetButtons() const OVERRIDE;
   virtual bool Cancel() OVERRIDE;
 
   std::string client_name_;
   ExtensionDevToolsClientHost* client_host_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsInfoBarDelegate);
 };
 
 // static
-ExtensionDevToolsInfoBarDelegate* ExtensionDevToolsInfoBarDelegate::Create(
+InfoBar* ExtensionDevToolsInfoBarDelegate::Create(
     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))));
+  return infobar_service->AddInfoBar(ConfirmInfoBarDelegate::CreateInfoBar(
+      scoped_ptr<ConfirmInfoBarDelegate>(
+          new ExtensionDevToolsInfoBarDelegate(client_name))));
 }
 
 ExtensionDevToolsInfoBarDelegate::ExtensionDevToolsInfoBarDelegate(
-    InfoBarService* infobar_service,
     const std::string& client_name)
-    : ConfirmInfoBarDelegate(infobar_service),
+    : ConfirmInfoBarDelegate(),
       client_name_(client_name),
       client_host_(NULL) {
 }
 
 ExtensionDevToolsInfoBarDelegate::~ExtensionDevToolsInfoBarDelegate() {
 }
 
 void ExtensionDevToolsInfoBarDelegate::InfoBarDismissed() {
   if (client_host_)
     client_host_->MarkAsDismissed();
@@ skipping 82 matching lines @@
 
 
 // ExtensionDevToolsClientHost ------------------------------------------------
 
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     Profile* profile,
     DevToolsAgentHost* agent_host,
     const std::string& extension_id,
     const std::string& extension_name,
     const Debuggee& debuggee,
-    ExtensionDevToolsInfoBarDelegate* infobar)
+    InfoBar* infobar)
     : profile_(profile),
       agent_host_(agent_host),
       extension_id_(extension_id),
       last_request_id_(0),
       infobar_(infobar),
       detach_reason_(OnDetach::REASON_TARGET_CLOSED) {
   CopyDebuggee(&debuggee_, debuggee);
 
   AttachedClientHosts::GetInstance()->Add(this);
 
   // Detach from debugger when extension unloads.
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
 
   // RVH-based agents disconnect from their clients when the app is terminating
   // but shared worker-based agents do not.
   // Disconnect explicitly to make sure that |this| observer is not leaked.
   registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
                  content::NotificationService::AllSources());
 
   // Attach to debugger and tell it we are ready.
   DevToolsManager::GetInstance()->RegisterDevToolsClientHostFor(
       agent_host_.get(), this);
 
   if (infobar_) {
-    infobar_->set_client_host(this);
+    static_cast<ExtensionDevToolsInfoBarDelegate*>(
+        infobar_->delegate())->set_client_host(this);
     registrar_.Add(
         this, chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
         content::Source<InfoBarService>(InfoBarService::FromWebContents(
             WebContents::FromRenderViewHost(
                 agent_host_->GetRenderViewHost()))));
   }
 }
 
 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
   // Ensure calling RemoveInfoBar() below won't result in Observe() trying to
   // Close() us.
   registrar_.RemoveAll();
 
   if (infobar_) {
-    infobar_->set_client_host(NULL);
+    static_cast<ExtensionDevToolsInfoBarDelegate*>(
+        infobar_->delegate())->set_client_host(NULL);
     InfoBarService::FromWebContents(WebContents::FromRenderViewHost(
         agent_host_->GetRenderViewHost()))->RemoveInfoBar(infobar_);
   }
   AttachedClientHosts::GetInstance()->Remove(this);
 }
 
 // DevToolsClientHost interface
 void ExtensionDevToolsClientHost::InspectedContentsClosing() {
   SendDetachedEvent();
   delete this;
@@ skipping 49 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED) {
     if (content::Details<extensions::UnloadedExtensionInfo>(details)->
         extension->id() == extension_id_)
       Close();
   } else if (type == chrome::NOTIFICATION_APP_TERMINATING) {
     Close();
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED, type);
-    if (content::Details<InfoBarRemovedDetails>(details)->first == infobar_) {
+    if (content::Details<InfoBar::RemovedDetails>(details)->first == infobar_) {
       infobar_ = NULL;
       SendDetachedEvent();
       Close();
     }
   }
 }
 
 void ExtensionDevToolsClientHost::DispatchOnInspectorFrontend(
     const std::string& message) {
   if (!extensions::ExtensionSystem::Get(profile_)->event_router())
@@ skipping 129 matching lines @@
         keys::kProtocolVersionNotSupportedError,
         params->required_version);
     return false;
   }
 
   if (agent_host_->IsAttached()) {
     FormatErrorMessage(keys::kAlreadyAttachedError);
     return false;
   }
 
-  ExtensionDevToolsInfoBarDelegate* infobar = NULL;
+  InfoBar* infobar = 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 = ExtensionDevToolsInfoBarDelegate::Create(
-          agent_host_->GetRenderViewHost(), GetExtension()->name());
+        agent_host_->GetRenderViewHost(), GetExtension()->name());
     if (!infobar) {
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kSilentDebuggingRequired,
           switches::kSilentDebuggerExtensionAPI);
       return false;
     }
   }
 
   new ExtensionDevToolsClientHost(profile(), agent_host_.get(),
                                   GetExtension()->id(), GetExtension()->name(),
@@ skipping 190 matching lines @@
 }
 
 void DebuggerGetTargetsFunction::SendTargetList(
     base::ListValue* list,
     const WorkerInfoList& worker_info) {
   for (size_t i = 0; i < worker_info.size(); ++i)
     list->Append(SerializeWorkerInfo(worker_info[i]));
   SetResult(list);
   SendResponse(true);
 }