Update Content Settings Bubbles

chrome/browser/content_setting_bubble_model.cc

 // Copyright (c) 2010 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/content_setting_bubble_model.h"
 
 #include "app/l10n_util.h"
 #include "base/command_line.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/blocked_content_container.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/geolocation/geolocation_content_settings_map.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/browser/tab_contents/tab_specific_content_settings.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "grit/generated_resources.h"
 #include "net/base/net_util.h"
 
 class ContentSettingTitleAndLinkModel : public ContentSettingBubbleModel {
  public:
-  ContentSettingTitleAndLinkModel(TabContents* tab_contents, Profile* profile,
-      ContentSettingsType content_type)
+  ContentSettingTitleAndLinkModel(TabContents* tab_contents,
+                                  Profile* profile,
+                                  ContentSettingsType content_type)
       : ContentSettingBubbleModel(tab_contents, profile, content_type) {
      // Notifications do not have a bubble.
      DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
      SetBlockedResources();
      SetTitle();
      SetManageLink();
   }
 
  private:
   void SetBlockedResources() {
@@ skipping 71 matching lines @@
                    Need_a_setting_for_every_content_settings_type);
     set_manage_link(l10n_util::GetStringUTF8(kLinkIDs[content_type()]));
   }
 
   virtual void OnManageLinkClicked() {
     if (tab_contents())
       tab_contents()->delegate()->ShowContentSettingsWindow(content_type());
   }
 };
 
-class ContentSettingTitleLinkAndInfoModel
+class ContentSettingTitleLinkAndCustomModel
     : public ContentSettingTitleAndLinkModel {
  public:
-  ContentSettingTitleLinkAndInfoModel(TabContents* tab_contents,
-                                      Profile* profile,
-                                      ContentSettingsType content_type)
+  ContentSettingTitleLinkAndCustomModel(TabContents* tab_contents,
+                                        Profile* profile,
+                                        ContentSettingsType content_type)
       : ContentSettingTitleAndLinkModel(tab_contents, profile, content_type) {
-    SetInfoLink();
+    SetCustomLink();
   }
 
  private:
-  void SetInfoLink() {
-    static const int kInfoIDs[] = {
+  void SetCustomLink() {
+    static const int kCustomIDs[] = {
       IDS_BLOCKED_COOKIES_INFO,
-      0,  // Images do not have an info link.
-      0,  // Javascript doesn't have an info link.
-      0,  // Plugins do not have an info link.
-      0,  // Popups do not have an info link.
-      0,  // Geolocation does not have an info link.
+      0,  // Images do not have a custom link.
+      0,  // Javascript doesn't have a custom link.
+      IDS_BLOCKED_PLUGINS_LOAD_ALL,
+      0,  // Popups do not have a custom link.
+      0,  // Geolocation custom links are set within that class.
       0,  // Notifications do not have a bubble.
     };
-    COMPILE_ASSERT(arraysize(kInfoIDs) == CONTENT_SETTINGS_NUM_TYPES,
+    COMPILE_ASSERT(arraysize(kCustomIDs) == CONTENT_SETTINGS_NUM_TYPES,
                    Need_a_setting_for_every_content_settings_type);
-    if (kInfoIDs[content_type()])
-      set_info_link(l10n_util::GetStringUTF8(kInfoIDs[content_type()]));
+    if (kCustomIDs[content_type()])
+      set_custom_link(l10n_util::GetStringUTF8(kCustomIDs[content_type()]));
   }
 
-  virtual void OnInfoLinkClicked() {
-    DCHECK(content_type() == CONTENT_SETTINGS_TYPE_COOKIES);
-    if (tab_contents()) {
-      NotificationService::current()->Notify(
-          NotificationType::COLLECTED_COOKIES_SHOWN,
-          Source<TabSpecificContentSettings>(
-              tab_contents()->GetTabSpecificContentSettings()),
-          NotificationService::NoDetails());
-      tab_contents()->delegate()->ShowCollectedCookiesDialog(tab_contents());
-    }
-  }
+  virtual void OnCustomLinkClicked() {}
 };
 
 
-class ContentSettingSingleRadioGroup : public ContentSettingTitleAndLinkModel {
+class ContentSettingSingleRadioGroup
+    : public ContentSettingTitleLinkAndCustomModel {
  public:
-  ContentSettingSingleRadioGroup(TabContents* tab_contents, Profile* profile,
-      ContentSettingsType content_type)
-      : ContentSettingTitleAndLinkModel(tab_contents, profile, content_type),
+  ContentSettingSingleRadioGroup(TabContents* tab_contents,
+                                 Profile* profile,
+                                 ContentSettingsType content_type)
+      : ContentSettingTitleLinkAndCustomModel(tab_contents, profile,
+                                              content_type),
         block_setting_(CONTENT_SETTING_BLOCK) {
     SetRadioGroup();
   }
 
  private:
   ContentSetting block_setting_;
 
   // Initialize the radio group by setting the appropriate labels for the
   // content type and setting the default value based on the content setting.
   void SetRadioGroup() {
@@ skipping 102 matching lines @@
       AddException(setting, std::string());
     } else {
       for (std::set<std::string>::const_iterator it = resources.begin();
            it != resources.end(); ++it) {
         AddException(setting, *it);
       }
     }
   }
 };
 
+class ContentSettingCookiesBubbleModel
+    : public ContentSettingTitleLinkAndCustomModel {
+ public:
+  ContentSettingCookiesBubbleModel(TabContents* tab_contents,
+                                   Profile* profile,
+                                   ContentSettingsType content_type)
+      : ContentSettingTitleLinkAndCustomModel(tab_contents, profile,
+                                              content_type) {
+    DCHECK_EQ(CONTENT_SETTINGS_TYPE_COOKIES, content_type);
+    set_custom_link_enabled(true);
+  }
+
+ private:
+  virtual void OnCustomLinkClicked() OVERRIDE {
+    if (tab_contents()) {
+      NotificationService::current()->Notify(
+          NotificationType::COLLECTED_COOKIES_SHOWN,
+          Source<TabSpecificContentSettings>(
+              tab_contents()->GetTabSpecificContentSettings()),
+          NotificationService::NoDetails());
+      tab_contents()->delegate()->ShowCollectedCookiesDialog(tab_contents());
+    }
+  }
+};
+
 class ContentSettingPluginBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingPluginBubbleModel(TabContents* tab_contents, Profile* profile,
+  ContentSettingPluginBubbleModel(TabContents* tab_contents,
+                                  Profile* profile,
                                   ContentSettingsType content_type)
       : ContentSettingSingleRadioGroup(tab_contents, profile, content_type) {
     DCHECK_EQ(content_type, CONTENT_SETTINGS_TYPE_PLUGINS);
-    SetLoadPluginsLinkTitle();
+    set_custom_link_enabled(tab_contents && tab_contents->
+        GetTabSpecificContentSettings()->load_plugins_link_enabled());
   }
 
  private:
-  void SetLoadPluginsLinkTitle() {
-    set_load_plugins_link_title(
-        l10n_util::GetStringUTF8(IDS_BLOCKED_PLUGINS_LOAD_ALL));
-   }
-
-  virtual void OnLoadPluginsLinkClicked() {
+  virtual void OnCustomLinkClicked() OVERRIDE {
     UserMetrics::RecordAction(UserMetricsAction("ClickToPlay_LoadAll_Bubble"));
-    if (tab_contents()) {
-      tab_contents()->render_view_host()->LoadBlockedPlugins();
-    }
-    set_load_plugins_link_enabled(false);
-    TabSpecificContentSettings* settings =
-        tab_contents()->GetTabSpecificContentSettings();
-    settings->set_load_plugins_link_enabled(false);
+    DCHECK(tab_contents());
+    tab_contents()->render_view_host()->LoadBlockedPlugins();
+    set_custom_link_enabled(false);
+    tab_contents()->GetTabSpecificContentSettings()->
+        set_load_plugins_link_enabled(false);
   }
 };
 
 class ContentSettingPopupBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingPopupBubbleModel(TabContents* tab_contents, Profile* profile,
-      ContentSettingsType content_type)
+  ContentSettingPopupBubbleModel(TabContents* tab_contents,
+                                 Profile* profile,
+                                 ContentSettingsType content_type)
       : ContentSettingSingleRadioGroup(tab_contents, profile, content_type) {
     SetPopups();
   }
 
  private:
   void SetPopups() {
     // check for crbug.com/53176
     if (!tab_contents()->blocked_content_container())
       return;
     std::vector<TabContents*> blocked_contents;
@@ skipping 24 matching lines @@
 
 class ContentSettingDomainListBubbleModel
     : public ContentSettingTitleAndLinkModel {
  public:
   ContentSettingDomainListBubbleModel(TabContents* tab_contents,
                                       Profile* profile,
                                       ContentSettingsType content_type)
       : ContentSettingTitleAndLinkModel(tab_contents, profile, content_type) {
     DCHECK_EQ(CONTENT_SETTINGS_TYPE_GEOLOCATION, content_type) <<
         "SetDomains currently only supports geolocation content type";
-    SetDomainsAndClearLink();
+    SetDomainsAndCustomLink();
   }
 
  private:
   void MaybeAddDomainList(const std::set<std::string>& hosts, int title_id) {
     if (!hosts.empty()) {
       DomainList domain_list;
       domain_list.title = l10n_util::GetStringUTF8(title_id);
       domain_list.hosts = hosts;
       add_domain_list(domain_list);
     }
   }
-  void SetDomainsAndClearLink() {
+  void SetDomainsAndCustomLink() {
     TabSpecificContentSettings* content_settings =
         tab_contents()->GetTabSpecificContentSettings();
     const GeolocationSettingsState& settings =
         content_settings->geolocation_settings_state();
     GeolocationSettingsState::FormattedHostsPerState formatted_hosts_per_state;
     unsigned int tab_state_flags = 0;
     settings.GetDetailedInfo(&formatted_hosts_per_state, &tab_state_flags);
     // Divide the tab's current geolocation users into sets according to their
     // permission state.
     MaybeAddDomainList(formatted_hosts_per_state[CONTENT_SETTING_ALLOW],
                        IDS_GEOLOCATION_BUBBLE_SECTION_ALLOWED);
 
     MaybeAddDomainList(formatted_hosts_per_state[CONTENT_SETTING_BLOCK],
                        IDS_GEOLOCATION_BUBBLE_SECTION_DENIED);
 
     if (tab_state_flags & GeolocationSettingsState::TABSTATE_HAS_EXCEPTION) {
-      set_clear_link(
-          l10n_util::GetStringUTF8(IDS_GEOLOCATION_BUBBLE_CLEAR_LINK));
+      set_custom_link(l10n_util::GetStringUTF8(
+                      IDS_GEOLOCATION_BUBBLE_CLEAR_LINK));
+      set_custom_link_enabled(true);
     } else if (tab_state_flags &
                GeolocationSettingsState::TABSTATE_HAS_CHANGED) {
-      // It is a slight abuse of the domain list field to use it for the reload
-      // hint, but works fine for now. TODO(joth): If we need to style it
-      // differently, consider adding an explicit field, or generalize the
-      // domain list to be a flat list of style formatted lines.
-      DomainList reload_section;
-      reload_section.title = l10n_util::GetStringUTF8(
-          IDS_GEOLOCATION_BUBBLE_REQUIRE_RELOAD_TO_CLEAR);
-      add_domain_list(reload_section);
+      set_custom_link(l10n_util::GetStringUTF8(
+                      IDS_GEOLOCATION_BUBBLE_REQUIRE_RELOAD_TO_CLEAR));
     }
   }
-  virtual void OnClearLinkClicked() {
+  virtual void OnCustomLinkClicked() OVERRIDE {
     if (!tab_contents())
       return;
     // Reset this embedder's entry to default for each of the requesting
     // origins currently on the page.
     const GURL& embedder_url = tab_contents()->GetURL();
     TabSpecificContentSettings* content_settings =
         tab_contents()->GetTabSpecificContentSettings();
     const GeolocationSettingsState::StateMap& state_map =
         content_settings->geolocation_settings_state().state_map();
     GeolocationContentSettingsMap* settings_map =
         profile()->GetGeolocationContentSettingsMap();
     for (GeolocationSettingsState::StateMap::const_iterator it =
          state_map.begin(); it != state_map.end(); ++it) {
       settings_map->SetContentSetting(it->first, embedder_url,
                                       CONTENT_SETTING_DEFAULT);
     }
   }
 };
 
 // static
 ContentSettingBubbleModel*
     ContentSettingBubbleModel::CreateContentSettingBubbleModel(
         TabContents* tab_contents,
         Profile* profile,
         ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
-    return new ContentSettingTitleLinkAndInfoModel(tab_contents, profile,
-                                                   content_type);
+    return new ContentSettingCookiesBubbleModel(tab_contents, profile,
+                                                content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_POPUPS) {
     return new ContentSettingPopupBubbleModel(tab_contents, profile,
                                               content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     return new ContentSettingDomainListBubbleModel(tab_contents, profile,
                                                    content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS) {
     return new ContentSettingPluginBubbleModel(tab_contents, profile,
                                                content_type);
   }
   return new ContentSettingSingleRadioGroup(tab_contents, profile,
                                             content_type);
 }
 
 ContentSettingBubbleModel::ContentSettingBubbleModel(
-    TabContents* tab_contents, Profile* profile,
+    TabContents* tab_contents,
+    Profile* profile,
     ContentSettingsType content_type)
-    : tab_contents_(tab_contents), profile_(profile),
+    : tab_contents_(tab_contents),
+      profile_(profile),
       content_type_(content_type) {
-  if (tab_contents) {
-    TabSpecificContentSettings* settings =
-        tab_contents->GetTabSpecificContentSettings();
-    set_load_plugins_link_enabled(settings->load_plugins_link_enabled());
-  } else {
-    set_load_plugins_link_enabled(true);
-  }
   registrar_.Add(this, NotificationType::TAB_CONTENTS_DESTROYED,
                  Source<TabContents>(tab_contents));
 }
 
 ContentSettingBubbleModel::~ContentSettingBubbleModel() {
 }
 
 ContentSettingBubbleModel::RadioGroup::RadioGroup() : default_item(0) {}
 
 ContentSettingBubbleModel::RadioGroup::~RadioGroup() {}
 
 ContentSettingBubbleModel::DomainList::DomainList() {}
 
 ContentSettingBubbleModel::DomainList::~DomainList() {}
 
 ContentSettingBubbleModel::BubbleContent::BubbleContent()
-    : load_plugins_link_enabled(false) {
+    : custom_link_enabled(false) {
 }
 
 ContentSettingBubbleModel::BubbleContent::~BubbleContent() {}
 
 
 void ContentSettingBubbleModel::AddBlockedResource(
     const std::string& resource_identifier) {
   bubble_content_.resource_identifiers.insert(resource_identifier);
 }
 
 void ContentSettingBubbleModel::Observe(NotificationType type,
                                         const NotificationSource& source,
                                         const NotificationDetails& details) {
   DCHECK(type == NotificationType::TAB_CONTENTS_DESTROYED);
   DCHECK(source == Source<TabContents>(tab_contents_));
   tab_contents_ = NULL;
 }