Re-factor location bar/toolbar code to get rid of the browser dependency.

chrome/browser/ui/content_settings/content_setting_bubble_model.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.
 
 #include "chrome/browser/ui/content_settings/content_setting_bubble_model.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/favicon/favicon_tab_helper.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
 #include "chrome/browser/ui/blocked_content/blocked_content_tab_helper_delegate.h"
-#include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/collected_cookies_infobar_delegate.h"
+#include "chrome/browser/ui/content_settings/content_setting_bubble_model_delegate.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/render_messages.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
@@ skipping 21 matching lines @@
     if (entries[i].type == type)
       return entries[i].id;
   }
   return 0;
 }
 
 }  // namespace
 
 class ContentSettingTitleAndLinkModel : public ContentSettingBubbleModel {
  public:
-  ContentSettingTitleAndLinkModel(Browser* browser,
+  ContentSettingTitleAndLinkModel(Delegate* delegate,
                                   TabContentsWrapper* tab_contents,
                                   Profile* profile,
                                   ContentSettingsType content_type)
       : ContentSettingBubbleModel(tab_contents, profile, content_type),
-        browser_(browser) {
+        delegate_(delegate) {
      // Notifications do not have a bubble.
      DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
      SetBlockedResources();
      SetTitle();
      SetManageLink();
   }
 
   virtual ~ContentSettingTitleAndLinkModel() {}
-  Browser* browser() const { return browser_; }
+  Delegate* delegate() const { return delegate_; }
 
  private:
   void SetBlockedResources() {
     TabSpecificContentSettings* settings = tab_contents()->content_settings();
     const std::set<std::string>& resources = settings->BlockedResourcesForType(
         content_type());
     for (std::set<std::string>::const_iterator it = resources.begin();
         it != resources.end(); ++it) {
       AddBlockedResource(*it);
     }
@@ skipping 39 matching lines @@
       {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_LINK},
       {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LINK},
       {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_LINK},
       {CONTENT_SETTINGS_TYPE_GEOLOCATION, IDS_GEOLOCATION_BUBBLE_MANAGE_LINK},
     };
     set_manage_link(l10n_util::GetStringUTF8(
         GetIdForContentType(kLinkIDs, arraysize(kLinkIDs), content_type())));
   }
 
   virtual void OnManageLinkClicked() {
-    if (browser_)
-      browser_->ShowContentSettingsPage(content_type());
+    if (delegate_)
+      delegate_->ShowContentSettingsPage(content_type());
   }
 
-  Browser* browser_;
+  Delegate* delegate_;
 };
 
 class ContentSettingTitleLinkAndCustomModel
     : public ContentSettingTitleAndLinkModel {
  public:
-  ContentSettingTitleLinkAndCustomModel(Browser* browser,
+  ContentSettingTitleLinkAndCustomModel(Delegate* delegate,
                                         TabContentsWrapper* tab_contents,
                                         Profile* profile,
                                         ContentSettingsType content_type)
       : ContentSettingTitleAndLinkModel(
-            browser, tab_contents, profile, content_type) {
+            delegate, tab_contents, profile, content_type) {
     SetCustomLink();
   }
 
   virtual ~ContentSettingTitleLinkAndCustomModel() {}
 
  private:
   void SetCustomLink() {
     static const ContentSettingsTypeIdEntry kCustomIDs[] = {
       {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_INFO},
       {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_LOAD_ALL},
     };
     int custom_link_id =
         GetIdForContentType(kCustomIDs, arraysize(kCustomIDs), content_type());
     if (custom_link_id)
       set_custom_link(l10n_util::GetStringUTF8(custom_link_id));
   }
 
   virtual void OnCustomLinkClicked() {}
 };
 
 
 class ContentSettingSingleRadioGroup
     : public ContentSettingTitleLinkAndCustomModel {
  public:
-  ContentSettingSingleRadioGroup(Browser* browser,
+  ContentSettingSingleRadioGroup(Delegate* delegate,
                                  TabContentsWrapper* tab_contents,
                                  Profile* profile,
                                  ContentSettingsType content_type)
-      : ContentSettingTitleLinkAndCustomModel(browser, tab_contents, profile,
+      : ContentSettingTitleLinkAndCustomModel(delegate, tab_contents, profile,
                                               content_type),
         block_setting_(CONTENT_SETTING_BLOCK),
         selected_item_(0) {
     SetRadioGroup();
   }
 
   virtual ~ContentSettingSingleRadioGroup() {
     if (settings_changed()) {
       ContentSetting setting =
           selected_item_ == 0 ? CONTENT_SETTING_ALLOW : block_setting_;
@@ skipping 137 matching lines @@
     }
   }
 
   virtual void OnRadioClicked(int radio_index) {
     selected_item_ = radio_index;
   }
 };
 
 class ContentSettingCookiesBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingCookiesBubbleModel(Browser* browser,
+  ContentSettingCookiesBubbleModel(Delegate* delegate,
                                    TabContentsWrapper* tab_contents,
                                    Profile* profile,
                                    ContentSettingsType content_type)
       : ContentSettingSingleRadioGroup(
-            browser, tab_contents, profile, content_type) {
+            delegate, tab_contents, profile, content_type) {
     DCHECK_EQ(CONTENT_SETTINGS_TYPE_COOKIES, content_type);
     set_custom_link_enabled(true);
   }
 
   virtual ~ContentSettingCookiesBubbleModel() {
     if (settings_changed()) {
       InfoBarTabHelper* infobar_helper = tab_contents()->infobar_tab_helper();
       infobar_helper->AddInfoBar(
           new CollectedCookiesInfoBarDelegate(infobar_helper));
     }
   }
 
  private:
   virtual void OnCustomLinkClicked() OVERRIDE {
     if (!tab_contents())
       return;
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN,
         content::Source<TabSpecificContentSettings>(
             tab_contents()->content_settings()),
         content::NotificationService::NoDetails());
-    browser()->ShowCollectedCookiesDialog(tab_contents());
+    delegate()->ShowCollectedCookiesDialog(tab_contents());
   }
 };
 
 class ContentSettingPluginBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingPluginBubbleModel(Browser* browser,
+  ContentSettingPluginBubbleModel(Delegate* delegate,
                                   TabContentsWrapper* tab_contents,
                                   Profile* profile,
                                   ContentSettingsType content_type)
       : ContentSettingSingleRadioGroup(
-            browser, tab_contents, profile, content_type) {
+            delegate, tab_contents, profile, content_type) {
     DCHECK_EQ(content_type, CONTENT_SETTINGS_TYPE_PLUGINS);
     set_custom_link_enabled(tab_contents && tab_contents->content_settings()->
         load_plugins_link_enabled());
   }
 
   virtual ~ContentSettingPluginBubbleModel() {}
 
  private:
   virtual void OnCustomLinkClicked() OVERRIDE {
     content::RecordAction(UserMetricsAction("ClickToPlay_LoadAll_Bubble"));
     DCHECK(tab_contents());
     content::RenderViewHost* host =
         tab_contents()->web_contents()->GetRenderViewHost();
     host->Send(new ChromeViewMsg_LoadBlockedPlugins(host->GetRoutingID()));
     set_custom_link_enabled(false);
     tab_contents()->content_settings()->set_load_plugins_link_enabled(false);
   }
 };
 
 class ContentSettingPopupBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingPopupBubbleModel(Browser* browser,
+  ContentSettingPopupBubbleModel(Delegate* delegate,
                                  TabContentsWrapper* tab_contents,
                                  Profile* profile,
                                  ContentSettingsType content_type)
       : ContentSettingSingleRadioGroup(
-            browser, tab_contents, profile, content_type) {
+            delegate, tab_contents, profile, content_type) {
     SetPopups();
   }
 
   virtual ~ContentSettingPopupBubbleModel() {}
 
  private:
   void SetPopups() {
     std::vector<TabContentsWrapper*> blocked_contents;
     tab_contents()->blocked_content_tab_helper()->
         GetBlockedContents(&blocked_contents);
@@ skipping 16 matching lines @@
     if (tab_contents()) {
       tab_contents()->blocked_content_tab_helper()->
           LaunchForContents(bubble_content().popup_items[index].tab_contents);
     }
   }
 };
 
 class ContentSettingDomainListBubbleModel
     : public ContentSettingTitleAndLinkModel {
  public:
-  ContentSettingDomainListBubbleModel(Browser* browser,
+  ContentSettingDomainListBubbleModel(Delegate* delegate,
                                       TabContentsWrapper* tab_contents,
                                       Profile* profile,
                                       ContentSettingsType content_type)
       : ContentSettingTitleAndLinkModel(
-            browser, tab_contents, profile, content_type) {
+            delegate, tab_contents, profile, content_type) {
     DCHECK_EQ(CONTENT_SETTINGS_TYPE_GEOLOCATION, content_type) <<
         "SetDomains currently only supports geolocation content type";
     SetDomainsAndCustomLink();
   }
 
   virtual ~ContentSettingDomainListBubbleModel() {}
 
  private:
   void MaybeAddDomainList(const std::set<std::string>& hosts, int title_id) {
     if (!hosts.empty()) {
@@ skipping 50 matching lines @@
           CONTENT_SETTINGS_TYPE_GEOLOCATION,
           std::string(),
           CONTENT_SETTING_DEFAULT);
     }
   }
 };
 
 // static
 ContentSettingBubbleModel*
     ContentSettingBubbleModel::CreateContentSettingBubbleModel(
-        Browser* browser,
+        Delegate* delegate,
         TabContentsWrapper* tab_contents,
         Profile* profile,
         ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
-    return new ContentSettingCookiesBubbleModel(browser, tab_contents, profile,
+    return new ContentSettingCookiesBubbleModel(delegate, tab_contents, profile,
                                                 content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_POPUPS) {
-    return new ContentSettingPopupBubbleModel(browser, tab_contents, profile,
+    return new ContentSettingPopupBubbleModel(delegate, tab_contents, profile,
                                               content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
-    return new ContentSettingDomainListBubbleModel(browser, tab_contents,
+    return new ContentSettingDomainListBubbleModel(delegate, tab_contents,
                                                    profile, content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS) {
-    return new ContentSettingPluginBubbleModel(browser, tab_contents, profile,
+    return new ContentSettingPluginBubbleModel(delegate, tab_contents, profile,
                                                content_type);
   }
-  return new ContentSettingSingleRadioGroup(browser, tab_contents, profile,
+  return new ContentSettingSingleRadioGroup(delegate, tab_contents, profile,
                                             content_type);
 }
 
 ContentSettingBubbleModel::ContentSettingBubbleModel(
     TabContentsWrapper* tab_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : tab_contents_(tab_contents),
       profile_(profile),
       content_type_(content_type) {
@@ skipping 38 matching lines @@
       tab_contents_ = NULL;
       break;
     case chrome::NOTIFICATION_PROFILE_DESTROYED:
       DCHECK(source == content::Source<Profile>(profile_));
       profile_ = NULL;
       break;
     default:
       NOTREACHED();
   }
 }