Move Infobars core files to the Infobars component

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>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/devtools/devtools_target_impl.h"
 #include "chrome/browser/extensions/api/debugger/debugger_api_constants.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/infobars/confirm_infobar_delegate.h"
-#include "chrome/browser/infobars/infobar.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
 #include "chrome/common/chrome_switches.h"
+#include "components/infobars/core/infobar.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/devtools_client_host.h"
 #include "content/public/browser/devtools_http_handler.h"
 #include "content/public/browser/devtools_manager.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"
@@ skipping 23 matching lines @@
 namespace OnDetach = extensions::api::debugger::OnDetach;
 namespace OnEvent = extensions::api::debugger::OnEvent;
 namespace SendCommand = extensions::api::debugger::SendCommand;
 
 
 // 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,
-      InfoBar* infobar);
+  ExtensionDevToolsClientHost(Profile* profile,
+                              DevToolsAgentHost* agent_host,
+                              const std::string& extension_id,
+                              const std::string& extension_name,
+                              const Debuggee& debuggee,
+                              infobars::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_;
-  InfoBar* infobar_;
+  infobars::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 {
@@ skipping 10 matching lines @@
 }
 
 
 // ExtensionDevToolsInfoBarDelegate -------------------------------------------
 
 class ExtensionDevToolsInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   // 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 InfoBar* Create(RenderViewHost* rvh, const std::string& client_name);
+  static infobars::InfoBar* Create(RenderViewHost* rvh,
+                                   const std::string& client_name);
 
   void set_client_host(ExtensionDevToolsClientHost* client_host) {
     client_host_ = client_host;
   }
 
  private:
   explicit ExtensionDevToolsInfoBarDelegate(const std::string& client_name);
   virtual ~ExtensionDevToolsInfoBarDelegate();
 
   // ConfirmInfoBarDelegate:
   virtual void InfoBarDismissed() OVERRIDE;
   virtual Type GetInfoBarType() const OVERRIDE;
   virtual bool ShouldExpireInternal(
       const NavigationDetails& details) const OVERRIDE;
   virtual base::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
-InfoBar* ExtensionDevToolsInfoBarDelegate::Create(
+infobars::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 =
@@ skipping 14 matching lines @@
 }
 
 ExtensionDevToolsInfoBarDelegate::~ExtensionDevToolsInfoBarDelegate() {
 }
 
 void ExtensionDevToolsInfoBarDelegate::InfoBarDismissed() {
   if (client_host_)
     client_host_->MarkAsDismissed();
 }
 
-InfoBarDelegate::Type ExtensionDevToolsInfoBarDelegate::GetInfoBarType() const {
+infobars::InfoBarDelegate::Type
+ExtensionDevToolsInfoBarDelegate::GetInfoBarType() const {
   return WARNING_TYPE;
 }
 
 bool ExtensionDevToolsInfoBarDelegate::ShouldExpireInternal(
     const NavigationDetails& details) const {
   return false;
 }
 
 base::string16 ExtensionDevToolsInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringFUTF16(IDS_DEV_TOOLS_INFOBAR_LABEL,
@@ skipping 69 matching lines @@
 
 
 // ExtensionDevToolsClientHost ------------------------------------------------
 
 ExtensionDevToolsClientHost::ExtensionDevToolsClientHost(
     Profile* profile,
     DevToolsAgentHost* agent_host,
     const std::string& extension_id,
     const std::string& extension_name,
     const Debuggee& debuggee,
-    InfoBar* infobar)
+    infobars::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);
 
@@ skipping 93 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED) {
     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<InfoBar::RemovedDetails>(details)->first == infobar_) {
+    if (content::Details<infobars::InfoBar::RemovedDetails>(details)->first ==
+        infobar_) {
       infobar_ = NULL;
       SendDetachedEvent();
       Close();
     }
   }
 }
 
 void ExtensionDevToolsClientHost::DispatchOnInspectorFrontend(
     const std::string& message) {
   if (!extensions::ExtensionSystem::Get(profile_)->event_router())
@@ skipping 134 matching lines @@
         keys::kProtocolVersionNotSupportedError,
         params->required_version);
     return false;
   }
 
   if (agent_host_->IsAttached()) {
     FormatErrorMessage(keys::kAlreadyAttachedError);
     return false;
   }
 
-  InfoBar* infobar = NULL;
+  infobars::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());
     if (!infobar) {
       error_ = ErrorUtils::FormatErrorMessage(
           keys::kSilentDebuggingRequired,
           switches::kSilentDebuggerExtensionAPI);
@@ skipping 133 matching lines @@
 
 void DebuggerGetTargetsFunction::SendTargetList(
     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);
 }