Use same base class for popup and plugin blocking UI

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/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 18 matching lines @@
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.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"
 #include "grit/components_strings.h"
+#include "grit/theme_resources.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/resources/grit/ui_resources.h"
 
 using base::UserMetricsAction;
 using content::WebContents;
 using content_settings::SettingInfo;
 using content_settings::SettingSource;
 using content_settings::SETTING_SOURCE_USER;
@@ skipping 23 matching lines @@
     if (entries[i].type == type)
       return entries[i].id;
   }
   return 0;
 }
 
 const content::MediaStreamDevice& GetMediaDeviceById(
     const std::string& device_id,
     const content::MediaStreamDevices& devices) {
   DCHECK(!devices.empty());
-  for (content::MediaStreamDevices::const_iterator it = devices.begin();
-       it != devices.end(); ++it) {
-    if (it->id == device_id)
-      return *(it);
+  for (const content::MediaStreamDevice& device : devices) {
+    if (device.id == device_id)
+      return device;
   }
 
   // A device with the |device_id| was not found. It is likely that the device
   // has been unplugged from the OS. Return the first device as the default
   // device.
   return *devices.begin();
 }
 
 }  // namespace
 
@@ skipping 11 matching lines @@
   SetLearnMoreLink();
 }
 
 void ContentSettingTitleAndLinkModel::SetTitle() {
   TabSpecificContentSettings* content_settings = NULL;
   if (web_contents()) {
     content_settings =
         TabSpecificContentSettings::FromWebContents(web_contents());
   }
 
-  if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS && content_settings &&
-      content_settings->IsContentBlocked(content_type())) {
-    set_plugin_names(content_settings->GetBlockedPluginNames());
-  }
-
   static const ContentSettingsTypeIdEntry kBlockedTitleIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_TITLE},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_TITLE},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_TITLE},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_TITLE},
     {CONTENT_SETTINGS_TYPE_MIXEDSCRIPT,
         IDS_BLOCKED_DISPLAYING_INSECURE_CONTENT},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER,
         IDS_BLOCKED_PPAPI_BROKER_TITLE},
@@ skipping 286 matching lines @@
 }
 
 void ContentSettingSingleRadioGroup::OnRadioClicked(int radio_index) {
   selected_item_ = radio_index;
 }
 
 class ContentSettingCookiesBubbleModel : public ContentSettingSingleRadioGroup {
  public:
   ContentSettingCookiesBubbleModel(Delegate* delegate,
                                    WebContents* web_contents,
-                                   Profile* profile,
-                                   ContentSettingsType content_type);
+                                   Profile* profile);
 
   ~ContentSettingCookiesBubbleModel() override;
 
  private:
   void OnCustomLinkClicked() override;
 };
 
 ContentSettingCookiesBubbleModel::ContentSettingCookiesBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
-    Profile* profile,
-    ContentSettingsType content_type)
-    : ContentSettingSingleRadioGroup(
-          delegate, web_contents, profile, content_type) {
-  DCHECK_EQ(CONTENT_SETTINGS_TYPE_COOKIES, content_type);
+    Profile* profile)
+    : ContentSettingSingleRadioGroup(delegate,
+                                     web_contents,
+                                     profile,
+                                     CONTENT_SETTINGS_TYPE_COOKIES) {
   set_custom_link_enabled(true);
 }
 
 ContentSettingCookiesBubbleModel::~ContentSettingCookiesBubbleModel() {
   // On some plattforms e.g. MacOS X it is possible to close a tab while the
   // cookies settings bubble is open. This resets the web contents to NULL.
   if (settings_changed() && web_contents()) {
     CollectedCookiesInfoBarDelegate::Create(
         InfoBarService::FromWebContents(web_contents()));
   }
 }
 
 void ContentSettingCookiesBubbleModel::OnCustomLinkClicked() {
   if (!web_contents())
     return;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN,
       content::Source<TabSpecificContentSettings>(
           TabSpecificContentSettings::FromWebContents(web_contents())),
       content::NotificationService::NoDetails());
   delegate()->ShowCollectedCookiesDialog(web_contents());
 }
 
 class ContentSettingPluginBubbleModel : public ContentSettingSingleRadioGroup {
  public:
   ContentSettingPluginBubbleModel(Delegate* delegate,
                                   WebContents* web_contents,
-                                  Profile* profile,
-                                  ContentSettingsType content_type);
+                                  Profile* profile);
 
   ~ContentSettingPluginBubbleModel() override;
 
  private:
   void OnCustomLinkClicked() override;
 };
 
 ContentSettingPluginBubbleModel::ContentSettingPluginBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
-    Profile* profile,
-    ContentSettingsType content_type)
-    : ContentSettingSingleRadioGroup(
-          delegate, web_contents, profile, content_type) {
-  DCHECK_EQ(content_type, CONTENT_SETTINGS_TYPE_PLUGINS);
+    Profile* profile)
+    : ContentSettingSingleRadioGroup(delegate,
+                                     web_contents,
+                                     profile,
+                                     CONTENT_SETTINGS_TYPE_PLUGINS) {
   // Disable the "Run all plugins this time" link if the setting is managed and
   // can't be controlled by the user or if the user already clicked on the link
   // and ran all plugins.
   set_custom_link_enabled(!setting_is_managed() &&
                           web_contents &&
                           TabSpecificContentSettings::FromWebContents(
                               web_contents)->load_plugins_link_enabled());
+  // Build blocked plugin list.
+  if (web_contents) {
+    TabSpecificContentSettings* content_settings =
+        TabSpecificContentSettings::FromWebContents(web_contents);
+
+    const std::vector<base::string16>& blocked_plugins =
+        content_settings->blocked_plugin_names();
+    for (const base::string16& blocked_plugin : blocked_plugins) {
+      ListItem plugin_item(
+          ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+              IDR_BLOCKED_PLUGINS),
+          base::UTF16ToUTF8(blocked_plugin), false, 0);
+      add_list_item(plugin_item);
+    }
+  }
 }
 
 ContentSettingPluginBubbleModel::~ContentSettingPluginBubbleModel() {
   if (settings_changed()) {
     // If the user elected to allow all plugins then run plugins at this time.
     if (selected_item() == kAllowButtonIndex)
       OnCustomLinkClicked();
   }
 }
 
@@ skipping 10 matching lines @@
 #endif
   set_custom_link_enabled(false);
   TabSpecificContentSettings::FromWebContents(web_contents())->
       set_load_plugins_link_enabled(false);
 }
 
 class ContentSettingPopupBubbleModel : public ContentSettingSingleRadioGroup {
  public:
   ContentSettingPopupBubbleModel(Delegate* delegate,
                                  WebContents* web_contents,
-                                 Profile* profile,
-                                 ContentSettingsType content_type);
+                                 Profile* profile);
   ~ContentSettingPopupBubbleModel() override {}
 
  private:
-  void SetPopups();
-  void OnPopupClicked(int index) override;
+  void OnListItemClicked(int index) override;
+
+  int32 item_id_from_item_index(int index) const {
+    return bubble_content().list_items[index].item_id;
+  }
 };
 
 ContentSettingPopupBubbleModel::ContentSettingPopupBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
-    Profile* profile,
-    ContentSettingsType content_type)
-    : ContentSettingSingleRadioGroup(
-        delegate, web_contents, profile, content_type) {
-  SetPopups();
-}
-
-
-void ContentSettingPopupBubbleModel::SetPopups() {
-  std::map<int32, GURL> blocked_popups =
-      PopupBlockerTabHelper::FromWebContents(web_contents())
-          ->GetBlockedPopupRequests();
-  for (std::map<int32, GURL>::const_iterator iter = blocked_popups.begin();
-       iter != blocked_popups.end();
-       ++iter) {
-    std::string title(iter->second.spec());
-    // The popup may not have a valid URL.
-    if (title.empty())
-      title = l10n_util::GetStringUTF8(IDS_TAB_LOADING_TITLE);
-    PopupItem popup_item(
-        ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-            IDR_DEFAULT_FAVICON),
-        title,
-        iter->first);
-    add_popup(popup_item);
+    Profile* profile)
+    : ContentSettingSingleRadioGroup(delegate,
+                                     web_contents,
+                                     profile,
+                                     CONTENT_SETTINGS_TYPE_POPUPS) {
+  if (web_contents) {
+    // Build blocked popup list.
+    std::map<int32, GURL> blocked_popups =
+        PopupBlockerTabHelper::FromWebContents(web_contents)
+            ->GetBlockedPopupRequests();
+    for (const std::pair<int32, GURL>& blocked_popup : blocked_popups) {
+      std::string title(blocked_popup.second.spec());
+      // The popup may not have a valid URL.
+      if (title.empty())
+        title = l10n_util::GetStringUTF8(IDS_TAB_LOADING_TITLE);
+      ListItem popup_item(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+                              IDR_DEFAULT_FAVICON),
+                          title, true, blocked_popup.first);
+      add_list_item(popup_item);
+    }
   }
 }
 
-void ContentSettingPopupBubbleModel::OnPopupClicked(int index) {
+void ContentSettingPopupBubbleModel::OnListItemClicked(int index) {
   if (web_contents()) {
-    PopupBlockerTabHelper::FromWebContents(web_contents())->
-        ShowBlockedPopup(bubble_content().popup_items[index].popup_id);
+    PopupBlockerTabHelper::FromWebContents(web_contents())
+        ->ShowBlockedPopup(item_id_from_item_index(index));
   }
 }
 
 // The model of the content settings bubble for media settings.
 class ContentSettingMediaStreamBubbleModel
     : public ContentSettingTitleAndLinkModel {
  public:
   ContentSettingMediaStreamBubbleModel(Delegate* delegate,
                                        WebContents* web_contents,
                                        Profile* profile);
@@ skipping 53 matching lines @@
   SetMediaMenus();
   SetCustomLink();
 }
 
 ContentSettingMediaStreamBubbleModel::~ContentSettingMediaStreamBubbleModel() {
   // On some platforms (e.g. MacOS X) it is possible to close a tab while the
   // media stream bubble is open. This resets the web contents to NULL.
   if (!web_contents())
     return;
 
-  for (MediaMenuMap::const_iterator it = bubble_content().media_menus.begin();
-      it != bubble_content().media_menus.end(); ++it) {
-    if (it->second.selected_device.id != it->second.default_device.id) {
-      UpdateDefaultDeviceForType(it->first, it->second.selected_device.id);
+  for (const std::pair<content::MediaStreamType, MediaMenu>& media_menu :
+       bubble_content().media_menus) {
+    if (media_menu.second.selected_device.id !=
+        media_menu.second.default_device.id) {
+      UpdateDefaultDeviceForType(media_menu.first,
+                                 media_menu.second.selected_device.id);
     }
   }
 
   // Update the media settings if the radio button selection was changed.
   if (selected_item_ != bubble_content().radio_group.default_item) {
     UpdateSettings(radio_item_setting_[selected_item_]);
   }
 }
 
 void ContentSettingMediaStreamBubbleModel::SetTitle() {
@@ skipping 288 matching lines @@
   // Reset this embedder's entry to default for each of the requesting
   // origins currently on the page.
   const GURL& embedder_url = web_contents()->GetURL();
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   const ContentSettingsUsagesState::StateMap& state_map =
       content_settings->geolocation_usages_state().state_map();
   HostContentSettingsMap* settings_map =
       profile()->GetHostContentSettingsMap();
 
-  for (ContentSettingsUsagesState::StateMap::const_iterator it =
-       state_map.begin(); it != state_map.end(); ++it) {
+  for (const std::pair<GURL, ContentSetting>& map_entry : state_map) {
     settings_map->SetContentSetting(
-        ContentSettingsPattern::FromURLNoWildcard(it->first),
+        ContentSettingsPattern::FromURLNoWildcard(map_entry.first),
         ContentSettingsPattern::FromURLNoWildcard(embedder_url),
-        CONTENT_SETTINGS_TYPE_GEOLOCATION,
-        std::string(),
+        CONTENT_SETTINGS_TYPE_GEOLOCATION, std::string(),
         CONTENT_SETTING_DEFAULT);
   }
 }
 
 class ContentSettingMixedScriptBubbleModel
     : public ContentSettingTitleLinkAndCustomModel {
  public:
   ContentSettingMixedScriptBubbleModel(Delegate* delegate,
                                        WebContents* web_contents,
-                                       Profile* profile,
-                                       ContentSettingsType content_type);
+                                       Profile* profile);
 
   ~ContentSettingMixedScriptBubbleModel() override {}
 
  private:
   void OnCustomLinkClicked() override;
 };
 
 ContentSettingMixedScriptBubbleModel::ContentSettingMixedScriptBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
-    Profile* profile,
-    ContentSettingsType content_type)
-    : ContentSettingTitleLinkAndCustomModel(
-        delegate, web_contents, profile, content_type) {
-  DCHECK_EQ(content_type, CONTENT_SETTINGS_TYPE_MIXEDSCRIPT);
+    Profile* profile)
+    : ContentSettingTitleLinkAndCustomModel(delegate,
+                                            web_contents,
+                                            profile,
+                                            CONTENT_SETTINGS_TYPE_MIXEDSCRIPT) {
   content_settings::RecordMixedScriptAction(
       content_settings::MIXED_SCRIPT_ACTION_DISPLAYED_BUBBLE);
   set_custom_link_enabled(true);
 }
 
 void ContentSettingMixedScriptBubbleModel::OnCustomLinkClicked() {
   content_settings::RecordMixedScriptAction(
       content_settings::MIXED_SCRIPT_ACTION_CLICKED_ALLOW);
   DCHECK(web_contents());
   web_contents()->SendToAllFrames(
       new ChromeViewMsg_SetAllowRunningInsecureContent(MSG_ROUTING_NONE, true));
   web_contents()->GetMainFrame()->Send(new ChromeViewMsg_ReloadFrame(
       web_contents()->GetMainFrame()->GetRoutingID()));
 }
 
 ContentSettingRPHBubbleModel::ContentSettingRPHBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
-    ProtocolHandlerRegistry* registry,
-    ContentSettingsType content_type)
-    : ContentSettingTitleAndLinkModel(
-          delegate, web_contents, profile, content_type),
+    ProtocolHandlerRegistry* registry)
+    : ContentSettingTitleAndLinkModel(delegate,
+                                      web_contents,
+                                      profile,
+                                      CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS),
       selected_item_(0),
       registry_(registry),
       pending_handler_(ProtocolHandler::EmptyProtocolHandler()),
       previous_handler_(ProtocolHandler::EmptyProtocolHandler()) {
-  DCHECK_EQ(CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS, content_type);
-
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents);
   pending_handler_ = content_settings->pending_protocol_handler();
   previous_handler_ = content_settings->previous_protocol_handler();
 
   base::string16 protocol;
   if (pending_handler_.protocol() == "mailto") {
     protocol = l10n_util::GetStringUTF16(
         IDS_REGISTER_PROTOCOL_HANDLER_MAILTO_NAME);
   } else if (pending_handler_.protocol() == "webcal") {
@@ skipping 102 matching lines @@
   } else {
     registry_->OnAcceptRegisterProtocolHandler(previous_handler_);
   }
 }
 
 class ContentSettingMidiSysExBubbleModel
     : public ContentSettingTitleAndLinkModel {
  public:
   ContentSettingMidiSysExBubbleModel(Delegate* delegate,
                                      WebContents* web_contents,
-                                     Profile* profile,
-                                     ContentSettingsType content_type);
+                                     Profile* profile);
   ~ContentSettingMidiSysExBubbleModel() override {}
 
  private:
   void MaybeAddDomainList(const std::set<std::string>& hosts, int title_id);
   void SetDomainsAndCustomLink();
   void OnCustomLinkClicked() override;
 };
 
 ContentSettingMidiSysExBubbleModel::ContentSettingMidiSysExBubbleModel(
     Delegate* delegate,
     WebContents* web_contents,
-    Profile* profile,
-    ContentSettingsType content_type)
-    : ContentSettingTitleAndLinkModel(
-        delegate, web_contents, profile, content_type) {
-  DCHECK_EQ(CONTENT_SETTINGS_TYPE_MIDI_SYSEX, content_type);
+    Profile* profile)
+    : ContentSettingTitleAndLinkModel(delegate,
+                                      web_contents,
+                                      profile,
+                                      CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
   SetDomainsAndCustomLink();
 }
 
 void ContentSettingMidiSysExBubbleModel::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);
@@ skipping 33 matching lines @@
   // Reset this embedder's entry to default for each of the requesting
   // origins currently on the page.
   const GURL& embedder_url = web_contents()->GetURL();
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   const ContentSettingsUsagesState::StateMap& state_map =
       content_settings->midi_usages_state().state_map();
   HostContentSettingsMap* settings_map =
       profile()->GetHostContentSettingsMap();
 
-  for (ContentSettingsUsagesState::StateMap::const_iterator it =
-       state_map.begin(); it != state_map.end(); ++it) {
+  for (const std::pair<GURL, ContentSetting>& map_entry : state_map) {
     settings_map->SetContentSetting(
-        ContentSettingsPattern::FromURLNoWildcard(it->first),
+        ContentSettingsPattern::FromURLNoWildcard(map_entry.first),
         ContentSettingsPattern::FromURLNoWildcard(embedder_url),
-        CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
-        std::string(),
+        CONTENT_SETTINGS_TYPE_MIDI_SYSEX, std::string(),
         CONTENT_SETTING_DEFAULT);
   }
 }
 
 // static
 ContentSettingBubbleModel*
     ContentSettingBubbleModel::CreateContentSettingBubbleModel(
         Delegate* delegate,
         WebContents* web_contents,
         Profile* profile,
         ContentSettingsType content_type) {
   if (content_type == CONTENT_SETTINGS_TYPE_COOKIES) {
-    return new ContentSettingCookiesBubbleModel(delegate, web_contents, profile,
-                                                content_type);
+    return new ContentSettingCookiesBubbleModel(delegate, web_contents,
+                                                profile);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_POPUPS) {
-    return new ContentSettingPopupBubbleModel(delegate, web_contents, profile,
-                                              content_type);
+    return new ContentSettingPopupBubbleModel(delegate, web_contents, profile);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_GEOLOCATION) {
     return new ContentSettingDomainListBubbleModel(delegate, web_contents,
                                                    profile, content_type);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM) {
     return new ContentSettingMediaStreamBubbleModel(delegate, web_contents,
                                                     profile);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS) {
-    return new ContentSettingPluginBubbleModel(delegate, web_contents, profile,
-                                               content_type);
+    return new ContentSettingPluginBubbleModel(delegate, web_contents, profile);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_MIXEDSCRIPT) {
     return new ContentSettingMixedScriptBubbleModel(delegate, web_contents,
-                                                    profile, content_type);
+                                                    profile);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_PROTOCOL_HANDLERS) {
     ProtocolHandlerRegistry* registry =
         ProtocolHandlerRegistryFactory::GetForBrowserContext(profile);
     return new ContentSettingRPHBubbleModel(delegate, web_contents, profile,
-                                            registry, content_type);
+                                            registry);
   }
   if (content_type == CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
     return new ContentSettingMidiSysExBubbleModel(delegate, web_contents,
-                                                  profile, content_type);
+                                                  profile);
   }
   return new ContentSettingSingleRadioGroup(delegate, web_contents, profile,
                                             content_type);
 }
 
 ContentSettingBubbleModel::ContentSettingBubbleModel(
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : web_contents_(web_contents),
@@ skipping 35 matching lines @@
   if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) {
     DCHECK_EQ(web_contents_,
               content::Source<WebContents>(source).ptr());
     web_contents_ = NULL;
   } else {
     DCHECK_EQ(chrome::NOTIFICATION_PROFILE_DESTROYED, type);
     DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
     profile_ = NULL;
   }
 }