[DevTools] One infobar per extension.

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 133 matching lines @@
 int ExtensionDevToolsInfoBarDelegate::GetButtons() const {
   return BUTTON_CANCEL;
 }
 
 bool ExtensionDevToolsInfoBarDelegate::Cancel() {
   InfoBarDismissed();
   // InfoBarDismissed() will have closed us already.
   return false;
 }
 
+// ExtensionDevToolsInfoBar ---------------------------------------------------
+
+class ExtensionDevToolsInfoBar;
+using ExtensionInfoBars =
+    std::map<std::string, ExtensionDevToolsInfoBar*>;
+base::LazyInstance<ExtensionInfoBars>::Leaky g_extension_info_bars =
+    LAZY_INSTANCE_INITIALIZER;
+
+class ExtensionDevToolsInfoBar {
+ public:
+  static ExtensionDevToolsInfoBar* Create(
+      const std::string& extension_id,
+      const std::string& extension_name,
+      ExtensionDevToolsClientHost* client_host,
+      const base::Closure& dismissed_callback);
+  void Remove(ExtensionDevToolsClientHost* client_host);
+
+ private:
+  ExtensionDevToolsInfoBar(const std::string& extension_id,
+                           const std::string& extension_name);
+  ~ExtensionDevToolsInfoBar();
+  void InfoBarDismissed();
+
+  std::string extension_id_;
+  std::map<ExtensionDevToolsClientHost*, base::Closure> callbacks_;
+  base::WeakPtr<GlobalConfirmInfoBar> infobar_;
+};
+
+// static
+ExtensionDevToolsInfoBar* ExtensionDevToolsInfoBar::Create(
+      const std::string& extension_id,
+      const std::string& extension_name,
+      ExtensionDevToolsClientHost* client_host,
+      const base::Closure& dismissed_callback) {
+  ExtensionInfoBars::iterator it =
+      g_extension_info_bars.Get().find(extension_id);
+  ExtensionDevToolsInfoBar* infobar = nullptr;
+  if (it != g_extension_info_bars.Get().end())
+    infobar = it->second;
+  else
+    infobar = new ExtensionDevToolsInfoBar(extension_id, extension_name);
+  infobar->callbacks_[client_host] = dismissed_callback;
+  return infobar;
+}
+
+ExtensionDevToolsInfoBar::ExtensionDevToolsInfoBar(
+    const std::string& extension_id,
+    const std::string& extension_name)
+    : extension_id_(extension_id) {
+  g_extension_info_bars.Get()[extension_id] = this;
+
+  // This class closes the |infobar_|, so it's safe to pass Unretained(this).
+  scoped_ptr<ExtensionDevToolsInfoBarDelegate> delegate(
+      new ExtensionDevToolsInfoBarDelegate(
+          base::Bind(&ExtensionDevToolsInfoBar::InfoBarDismissed,
+                     base::Unretained(this)),
+          extension_name));
+  infobar_ = GlobalConfirmInfoBar::Show(delegate.Pass());
+}
+
+ExtensionDevToolsInfoBar::~ExtensionDevToolsInfoBar() {
+  g_extension_info_bars.Get().erase(extension_id_);
+  if (infobar_)
+    infobar_->Close();
+}
+
+void ExtensionDevToolsInfoBar::Remove(
+    ExtensionDevToolsClientHost* client_host) {
+  callbacks_.erase(client_host);
+  if (!callbacks_.size())
+    delete this;
+}
+
+void ExtensionDevToolsInfoBar::InfoBarDismissed() {
+  std::map<ExtensionDevToolsClientHost*, base::Closure> copy = callbacks_;
+  for (const auto& pair: copy)
+    pair.second.Run();
+}
+
 }  // namespace
 
 // ExtensionDevToolsClientHost ------------------------------------------------
 
 using AttachedClientHosts = std::set<ExtensionDevToolsClientHost*>;
 base::LazyInstance<AttachedClientHosts>::Leaky g_attached_client_hosts =
     LAZY_INSTANCE_INITIALIZER;
 
 class ExtensionDevToolsClientHost : public content::DevToolsAgentHostClient,
                                     public content::NotificationObserver,
@@ skipping 39 matching lines @@
                            const Extension* extension,
                            UnloadedExtensionInfo::Reason reason) override;
 
   Profile* profile_;
   scoped_refptr<DevToolsAgentHost> agent_host_;
   std::string extension_id_;
   Debuggee debuggee_;
   content::NotificationRegistrar registrar_;
   int last_request_id_;
   PendingRequests pending_requests_;
-  base::WeakPtr<GlobalConfirmInfoBar> infobar_;
+  ExtensionDevToolsInfoBar* infobar_;
   api::debugger::DetachReason detach_reason_;
 
   // Listen to extension unloaded notification.
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionDevToolsClientHost);
 };
 
 // ExtensionDevToolsClientHost ------------------------------------------------
 
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     Profile* profile,
     DevToolsAgentHost* agent_host,
     const std::string& extension_id,
     const std::string& extension_name,
     const Debuggee& debuggee)
     : profile_(profile),
       agent_host_(agent_host),
       extension_id_(extension_id),
       last_request_id_(0),
+      infobar_(nullptr),
       detach_reason_(api::debugger::DETACH_REASON_TARGET_CLOSED),
       extension_registry_observer_(this) {
   CopyDebuggee(&debuggee_, debuggee);
 
   g_attached_client_hosts.Get().insert(this);
 
   // ExtensionRegistryObserver listen extension unloaded and detach debugger
   // from there.
   extension_registry_observer_.Add(ExtensionRegistry::Get(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.
   agent_host_->AttachClient(this);
 
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           ::switches::kSilentDebuggerExtensionAPI)) {
-    // This class closes the |infobar_|, so it's safe to pass Unretained(this).
-    scoped_ptr<ExtensionDevToolsInfoBarDelegate> delegate(
-        new ExtensionDevToolsInfoBarDelegate(
-            base::Bind(&ExtensionDevToolsClientHost::InfoBarDismissed,
-                       base::Unretained(this)),
-            extension_name));
-    infobar_ = GlobalConfirmInfoBar::Show(delegate.Pass());
+    infobar_ = ExtensionDevToolsInfoBar::Create(
+        extension_id, extension_name, this,
+        base::Bind(&ExtensionDevToolsClientHost::InfoBarDismissed,
+                   base::Unretained(this)));
   }
 }
 
 ExtensionDevToolsClientHost::~ExtensionDevToolsClientHost() {
   if (infobar_)
-    infobar_->Close();
+    infobar_->Remove(this);
   g_attached_client_hosts.Get().erase(this);
 }
 
 // DevToolsAgentHostClient implementation.
 void ExtensionDevToolsClientHost::AgentHostClosed(
     DevToolsAgentHost* agent_host, bool replaced_with_another_client) {
   DCHECK(agent_host == agent_host_.get());
   if (replaced_with_another_client)
     detach_reason_ = api::debugger::DETACH_REASON_REPLACED_WITH_DEVTOOLS;
   SendDetachedEvent();
@@ skipping 360 matching lines @@
     const std::vector<DevToolsTargetImpl*>& target_list) {
   scoped_ptr<base::ListValue> result(new base::ListValue());
   for (size_t i = 0; i < target_list.size(); ++i)
     result->Append(SerializeTarget(*target_list[i]));
   STLDeleteContainerPointers(target_list.begin(), target_list.end());
   SetResult(result.release());
   SendResponse(true);
 }
 
 }  // namespace extensions