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 58 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,

[msw, 2015/03/21 00:25:19]

nit: un-wrap "delegate, web_contents, profile," here and elsewhere?

[meacer, 2015/03/23 18:19:40]

Did you mean the formatting? This is the |git cl format| output :/

+                                     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 {
+class PluginBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingPluginBubbleModel(Delegate* delegate,
-                                  WebContents* web_contents,
-                                  Profile* profile,
-                                  ContentSettingsType content_type);
+  PluginBubbleModel(Delegate* delegate,
+                    WebContents* web_contents,
+                    Profile* profile);
 
-  ~ContentSettingPluginBubbleModel() override;
+  ~PluginBubbleModel() override;
 
  private:
   void OnCustomLinkClicked() override;
+
+  void SetListItems();
 };
 
-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);
+PluginBubbleModel::PluginBubbleModel(Delegate* delegate,
+                                     WebContents* web_contents,
+                                     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());
+  SetListItems();

[msw, 2015/03/21 00:25:19]

nit: inline this?

[meacer, 2015/03/23 18:19:40]

Done.

 }
 
-ContentSettingPluginBubbleModel::~ContentSettingPluginBubbleModel() {
+PluginBubbleModel::~PluginBubbleModel() {
   if (settings_changed()) {
     // If the user elected to allow all plugins then run plugins at this time.
     if (selected_item() == kAllowButtonIndex)
       OnCustomLinkClicked();
   }
 }
 
-void ContentSettingPluginBubbleModel::OnCustomLinkClicked() {
+void PluginBubbleModel::SetListItems() {
+  if (!web_contents())
+    return;
+  TabSpecificContentSettings* content_settings =
+      TabSpecificContentSettings::FromWebContents(web_contents());
+
+  const std::vector<base::string16>& blocked_plugins =
+      content_settings->blocked_plugin_names();
+  for (auto iter = blocked_plugins.begin(); iter != blocked_plugins.end();
+       ++iter) {
+    // TODO(meacer): Link to chrome://plugins#plugin_id from here.
+    ListItem plugin_item(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+                             IDR_BLOCKED_PLUGINS),
+                         base::UTF16ToUTF8(*iter), false, 0);
+    add_list_item(plugin_item);
+  }
+}
+
+void PluginBubbleModel::OnCustomLinkClicked() {
   content::RecordAction(UserMetricsAction("ClickToPlay_LoadAll_Bubble"));
   // Web contents can be NULL if the tab was closed while the plugins
   // settings bubble is visible.
   if (!web_contents())
     return;
 #if defined(ENABLE_PLUGINS)
   // TODO(bauerb): We should send the identifiers of blocked plugins here.
   ChromePluginServiceFilter::GetInstance()->AuthorizeAllPlugins(
       web_contents(), true, std::string());
 #endif
   set_custom_link_enabled(false);
   TabSpecificContentSettings::FromWebContents(web_contents())->
       set_load_plugins_link_enabled(false);
 }
 
-class ContentSettingPopupBubbleModel : public ContentSettingSingleRadioGroup {
+class PopupBubbleModel : public ContentSettingSingleRadioGroup {
  public:
-  ContentSettingPopupBubbleModel(Delegate* delegate,
-                                 WebContents* web_contents,
-                                 Profile* profile,
-                                 ContentSettingsType content_type);
-  ~ContentSettingPopupBubbleModel() override {}
+  PopupBubbleModel(Delegate* delegate,
+                   WebContents* web_contents,
+                   Profile* profile);
+  ~PopupBubbleModel() override {}
 
  private:
-  void SetPopups();
-  void OnPopupClicked(int index) override;
+  void OnListItemClicked(int index) override;
+
+  void SetListItems();
+
+  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();
+PopupBubbleModel::PopupBubbleModel(Delegate* delegate,
+                                   WebContents* web_contents,
+                                   Profile* profile)
+    : ContentSettingSingleRadioGroup(delegate,
+                                     web_contents,
+                                     profile,
+                                     CONTENT_SETTINGS_TYPE_POPUPS) {
+  SetListItems();
 }
 
-
-void ContentSettingPopupBubbleModel::SetPopups() {
+void PopupBubbleModel::SetListItems() {

[msw, 2015/03/21 00:25:19]

ditto nit: inline this?

[meacer, 2015/03/23 18:19:40]

Done.

   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();
+  for (auto 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);
+    ListItem popup_item(ui::ResourceBundle::GetSharedInstance().GetImageNamed(
+                            IDR_DEFAULT_FAVICON),
+                        title, true, iter->first);
+    add_list_item(popup_item);
   }
 }
 
-void ContentSettingPopupBubbleModel::OnPopupClicked(int index) {
+void PopupBubbleModel::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 381 matching lines @@
         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 52 matching lines @@
 }
 
 // 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 PopupBubbleModel(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 PluginBubbleModel(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;
   }
 }