Remove kEnableResourceContentSettings and all the code that uses it since it's been behind a flag f…

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 74 matching lines @@
 
 ContentSettingTitleAndLinkModel::ContentSettingTitleAndLinkModel(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingBubbleModel(web_contents, profile, content_type),
         delegate_(delegate) {
   // Notifications do not have a bubble.
   DCHECK_NE(content_type, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
-  SetBlockedResources();
   SetTitle();
   SetManageLink();
 }
 
-void ContentSettingTitleAndLinkModel::SetBlockedResources() {
-  TabSpecificContentSettings* settings =
-      TabSpecificContentSettings::FromWebContents(web_contents());
-  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);
-  }
-}
-
 void ContentSettingTitleAndLinkModel::SetTitle() {
   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_MESSAGE},
     {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},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_TITLE},
   };
   // Fields as for kBlockedTitleIDs, above.
-  static const ContentSettingsTypeIdEntry
-      kResourceSpecificBlockedTitleIDs[] = {
-        {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_TITLE},
-      };
   static const ContentSettingsTypeIdEntry kAccessedTitleIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_ACCESSED_COOKIES_TITLE},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_ALLOWED_PPAPI_BROKER_TITLE},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_ALLOWED_DOWNLOAD_TITLE},
   };
   const ContentSettingsTypeIdEntry *title_ids = kBlockedTitleIDs;
   size_t num_title_ids = arraysize(kBlockedTitleIDs);
   if (web_contents() &&
       TabSpecificContentSettings::FromWebContents(
           web_contents())->IsContentAllowed(content_type()) &&
       !TabSpecificContentSettings::FromWebContents(
           web_contents())->IsContentBlocked(content_type())) {
     title_ids = kAccessedTitleIDs;
     num_title_ids = arraysize(kAccessedTitleIDs);
-  } else if (!bubble_content().resource_identifiers.empty()) {
-    title_ids = kResourceSpecificBlockedTitleIDs;
-    num_title_ids = arraysize(kResourceSpecificBlockedTitleIDs);
   }
   int title_id =
       GetIdForContentType(title_ids, num_title_ids, content_type());
   if (title_id)
     set_title(l10n_util::GetStringUTF8(title_id));
 }
 
 void ContentSettingTitleAndLinkModel::SetManageLink() {
   static const ContentSettingsTypeIdEntry kLinkIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_LINK},
@@ skipping 62 matching lines @@
                                  Profile* profile,
                                  ContentSettingsType content_type);
   virtual ~ContentSettingSingleRadioGroup();
 
  protected:
   bool settings_changed() const;
   int selected_item() const { return selected_item_; }
 
  private:
   void SetRadioGroup();
-  void AddException(ContentSetting setting,
-                    const std::string& resource_identifier);
+  void AddException(ContentSetting setting);
   virtual void OnRadioClicked(int radio_index) OVERRIDE;
 
   ContentSetting block_setting_;
   int selected_item_;
 };
 
 ContentSettingSingleRadioGroup::ContentSettingSingleRadioGroup(
     Delegate* delegate,
     WebContents* web_contents,
     Profile* profile,
     ContentSettingsType content_type)
     : ContentSettingTitleLinkAndCustomModel(delegate, web_contents, profile,
                                             content_type),
       block_setting_(CONTENT_SETTING_BLOCK),
       selected_item_(0) {
   SetRadioGroup();
 }
 
 ContentSettingSingleRadioGroup::~ContentSettingSingleRadioGroup() {
   if (settings_changed()) {
     ContentSetting setting =
         selected_item_ == kAllowButtonIndex ?
                           CONTENT_SETTING_ALLOW :
                           block_setting_;
-    const std::set<std::string>& resources =
-        bubble_content().resource_identifiers;
-    if (resources.empty()) {
-      AddException(setting, std::string());
-    } else {
-      for (std::set<std::string>::const_iterator it = resources.begin();
-           it != resources.end(); ++it) {
-        AddException(setting, *it);
-      }
-    }
+    AddException(setting);
   }
 }
 
 bool ContentSettingSingleRadioGroup::settings_changed() const {
   return selected_item_ != bubble_content().radio_group.default_item;
 }
 
 // Initialize the radio group by setting the appropriate labels for the
 // content type and setting the default value based on the content setting.
 void ContentSettingSingleRadioGroup::SetRadioGroup() {
   GURL url = web_contents()->GetURL();
   string16 display_host;
   net::AppendFormattedHost(
       url,
       profile()->GetPrefs()->GetString(prefs::kAcceptLanguages),
       &display_host);
 
   if (display_host.empty())
     display_host = ASCIIToUTF16(url.spec());
 
-  const std::set<std::string>& resources =
-      bubble_content().resource_identifiers;
-
   TabSpecificContentSettings* content_settings =
       TabSpecificContentSettings::FromWebContents(web_contents());
   bool allowed =
       !content_settings->IsContentBlocked(content_type());
   DCHECK(!allowed ||
          content_settings->IsContentAllowed(content_type()));
 
   RadioGroup radio_group;
   radio_group.url = url;
 
   static const ContentSettingsTypeIdEntry kBlockedAllowIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_UNBLOCK_ALL},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_BLOCKED_PPAPI_BROKER_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_UNBLOCK},
   };
   // Fields as for kBlockedAllowIDs, above.
-  static const ContentSettingsTypeIdEntry kResourceSpecificBlockedAllowIDs[] = {
-    {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_UNBLOCK},
-  };
   static const ContentSettingsTypeIdEntry kAllowedAllowIDs[] = {
     // TODO(bauerb): The string shouldn't be "unblock" (they weren't blocked).
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_UNBLOCK},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_ALLOWED_PPAPI_BROKER_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_ALLOWED_DOWNLOAD_NO_ACTION},
   };
 
   std::string radio_allow_label;
   if (allowed) {
     int resource_id = GetIdForContentType(kAllowedAllowIDs,
                                           arraysize(kAllowedAllowIDs),
                                           content_type());
     radio_allow_label = (content_type() == CONTENT_SETTINGS_TYPE_COOKIES) ?
         l10n_util::GetStringFUTF8(resource_id, display_host) :
         l10n_util::GetStringUTF8(resource_id);
-  } else if (resources.empty()) {
+  } else {
     radio_allow_label = l10n_util::GetStringFUTF8(
         GetIdForContentType(kBlockedAllowIDs, arraysize(kBlockedAllowIDs),
                             content_type()),
         display_host);
-  } else {
-    radio_allow_label = l10n_util::GetStringFUTF8(
-        GetIdForContentType(kResourceSpecificBlockedAllowIDs,
-                            arraysize(kResourceSpecificBlockedAllowIDs),
-                            content_type()),
-        display_host);
   }
 
   static const ContentSettingsTypeIdEntry kBlockedBlockIDs[] = {
     {CONTENT_SETTINGS_TYPE_COOKIES, IDS_BLOCKED_COOKIES_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_IMAGES, IDS_BLOCKED_IMAGES_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_JAVASCRIPT, IDS_BLOCKED_JAVASCRIPT_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_PLUGINS, IDS_BLOCKED_PLUGINS_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_POPUPS, IDS_BLOCKED_POPUPS_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_PPAPI_BROKER, IDS_BLOCKED_PPAPI_BROKER_NO_ACTION},
     {CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS, IDS_BLOCKED_DOWNLOAD_NO_ACTION},
@@ skipping 14 matching lines @@
         l10n_util::GetStringUTF8(resource_id) :
         l10n_util::GetStringFUTF8(resource_id, display_host);
   } else {
     radio_block_label = l10n_util::GetStringUTF8(
         GetIdForContentType(kBlockedBlockIDs, arraysize(kBlockedBlockIDs),
                             content_type()));
   }
 
   radio_group.radio_items.push_back(radio_allow_label);
   radio_group.radio_items.push_back(radio_block_label);
-  HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
-  CookieSettings* cookie_settings =
-      CookieSettings::Factory::GetForProfile(profile()).get();
-  ContentSetting most_restrictive_setting;
-  SettingSource most_restrictive_setting_source = SETTING_SOURCE_NONE;
-  bool most_restrictive_setting_is_wildcard = false;
+  ContentSetting setting;
+  SettingSource setting_source = SETTING_SOURCE_NONE;
+  bool setting_is_wildcard = false;
 
-  if (resources.empty()) {
-    if (content_type() == CONTENT_SETTINGS_TYPE_COOKIES) {
-      most_restrictive_setting = cookie_settings->GetCookieSetting(
-          url, url, true, &most_restrictive_setting_source);
-    } else {
-      SettingInfo info;
-      scoped_ptr<Value> value(map->GetWebsiteSetting(
-          url, url, content_type(), std::string(), &info));
-      most_restrictive_setting =
-          content_settings::ValueToContentSetting(value.get());
-      most_restrictive_setting_source = info.source;
-      most_restrictive_setting_is_wildcard =
-          info.primary_pattern == ContentSettingsPattern::Wildcard() &&
-          info.secondary_pattern == ContentSettingsPattern::Wildcard();
-    }
+  if (content_type() == CONTENT_SETTINGS_TYPE_COOKIES) {
+    CookieSettings* cookie_settings =
+        CookieSettings::Factory::GetForProfile(profile()).get();
+    setting = cookie_settings->GetCookieSetting(
+        url, url, true, &setting_source);
   } else {
-    most_restrictive_setting = CONTENT_SETTING_ALLOW;
-    for (std::set<std::string>::const_iterator it = resources.begin();
-         it != resources.end(); ++it) {
-      SettingInfo info;
-      scoped_ptr<Value> val(map->GetWebsiteSetting(
-          url, url, content_type(), *it, &info));
-      ContentSetting setting =
-          content_settings::ValueToContentSetting(val.get());
-      if (setting == CONTENT_SETTING_BLOCK) {
-        most_restrictive_setting = CONTENT_SETTING_BLOCK;
-        most_restrictive_setting_source = info.source;
-        most_restrictive_setting_is_wildcard =
-            info.primary_pattern == ContentSettingsPattern::Wildcard() &&
-            info.secondary_pattern == ContentSettingsPattern::Wildcard();
-        break;
-      }
-      if (setting == CONTENT_SETTING_ASK) {
-        most_restrictive_setting = CONTENT_SETTING_ASK;
-        most_restrictive_setting_source = info.source;
-        most_restrictive_setting_is_wildcard =
-            info.primary_pattern == ContentSettingsPattern::Wildcard() &&
-            info.secondary_pattern == ContentSettingsPattern::Wildcard();
-      }
-    }
+    SettingInfo info;
+    HostContentSettingsMap* map = profile()->GetHostContentSettingsMap();
+    scoped_ptr<Value> value(map->GetWebsiteSetting(
+        url, url, content_type(), std::string(), &info));
+    setting = content_settings::ValueToContentSetting(value.get());
+    setting_source = info.source;
+    setting_is_wildcard =
+        info.primary_pattern == ContentSettingsPattern::Wildcard() &&
+        info.secondary_pattern == ContentSettingsPattern::Wildcard();
   }
 
   if (content_type() == CONTENT_SETTINGS_TYPE_PLUGINS &&
-      most_restrictive_setting == CONTENT_SETTING_ALLOW &&
-      most_restrictive_setting_is_wildcard) {
+      setting == CONTENT_SETTING_ALLOW &&
+      setting_is_wildcard) {
     // In the corner case of unrecognized plugins (which are now blocked by
     // default) we indicate the blocked state in the UI and allow the user to
     // whitelist.
     radio_group.default_item = 1;
-  } else if (most_restrictive_setting == CONTENT_SETTING_ALLOW) {
+  } else if (setting == CONTENT_SETTING_ALLOW) {
     radio_group.default_item = kAllowButtonIndex;
     // |block_setting_| is already set to |CONTENT_SETTING_BLOCK|.
   } else {
     radio_group.default_item = 1;
-    block_setting_ = most_restrictive_setting;
+    block_setting_ = setting;
   }
-  if (most_restrictive_setting_source != SETTING_SOURCE_USER) {
+  if (setting_source != SETTING_SOURCE_USER) {
     set_radio_group_enabled(false);
   } else {
     set_radio_group_enabled(true);
   }
   selected_item_ = radio_group.default_item;
   set_radio_group(radio_group);
 }
 
-void ContentSettingSingleRadioGroup::AddException(
-    ContentSetting setting,
-    const std::string& resource_identifier) {
+void ContentSettingSingleRadioGroup::AddException(ContentSetting setting) {
   if (profile()) {
     profile()->GetHostContentSettingsMap()->AddExceptionForURL(
         bubble_content().radio_group.url,
         bubble_content().radio_group.url,
         content_type(),
-        resource_identifier,
         setting);
   }
 }
 
 void ContentSettingSingleRadioGroup::OnRadioClicked(int radio_index) {
   selected_item_ = radio_index;
 }
 
 class ContentSettingCookiesBubbleModel : public ContentSettingSingleRadioGroup {
  public:
@@ skipping 897 matching lines @@
 
 ContentSettingBubbleModel::MediaMenu::~MediaMenu() {}
 
 ContentSettingBubbleModel::BubbleContent::BubbleContent()
     : radio_group_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(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   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;
   }
 }