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

chrome/browser/content_settings/tab_specific_content_settings.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/content_settings/tab_specific_content_settings.h"
 
 #include <list>
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
@@ skipping 212 matching lines @@
       content_type != CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA &&
       content_type != CONTENT_SETTINGS_TYPE_PPAPI_BROKER &&
       content_type != CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS &&
       content_type != CONTENT_SETTINGS_TYPE_MIDI_SYSEX) {
     return false;
   }
 
   return content_allowed_[content_type];
 }
 
-const std::set<std::string>&
-    TabSpecificContentSettings::BlockedResourcesForType(
-        ContentSettingsType content_type) const {
-  if (blocked_resources_[content_type].get()) {
-    return *blocked_resources_[content_type];
-  } else {
-    CR_DEFINE_STATIC_LOCAL(std::set<std::string>, empty_set, ());
-    return empty_set;
-  }
-}
-
-void TabSpecificContentSettings::AddBlockedResource(
-    ContentSettingsType content_type,
-    const std::string& resource_identifier) {
-  if (!blocked_resources_[content_type].get())
-    blocked_resources_[content_type].reset(new std::set<std::string>());
-  blocked_resources_[content_type]->insert(resource_identifier);
-}
-
-void TabSpecificContentSettings::OnContentBlocked(
-    ContentSettingsType type,
-    const std::string& resource_identifier) {
+void TabSpecificContentSettings::OnContentBlocked(ContentSettingsType type) {
   DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
       << "Geolocation settings handled by OnGeolocationPermissionSet";
   if (type < 0 || type >= CONTENT_SETTINGS_NUM_TYPES)
     return;
 
   // Media is different from other content setting types since it allows new
   // setting to kick in without reloading the page, and the UI for media is
   // always reflecting the newest permission setting.
   switch (type) {
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC:
     case CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA:
 #if defined(OS_ANDROID)
     case CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER:
 #endif
       content_allowed_[type] = false;
       break;
     default:
       content_allowed_[type] = true;
       break;
   }
 
-  // Unless UI for resource content settings is enabled, ignore the resource
-  // identifier.
-  // TODO(bauerb): The UI to unblock content should be disabled if the content
-  // setting was not set by the user.
-  std::string identifier;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kEnableResourceContentSettings)) {
-    identifier = resource_identifier;
-  }
-  if (!identifier.empty())
-    AddBlockedResource(type, identifier);
-
 #if defined(OS_ANDROID)
   if (type == CONTENT_SETTINGS_TYPE_POPUPS) {
     // For Android we do not have a persistent button that will always be
     // visible for blocked popups.  Instead we have info bars which could be
     // dismissed.  Have to clear the blocked state so we properly notify the
     // relevant pieces again.
     content_blocked_[type] = false;
     content_blockage_indicated_to_user_[type] = false;
   }
 #endif
@@ skipping 45 matching lines @@
 void TabSpecificContentSettings::OnCookiesRead(
     const GURL& url,
     const GURL& frame_url,
     const net::CookieList& cookie_list,
     bool blocked_by_policy) {
   if (cookie_list.empty())
     return;
   if (blocked_by_policy) {
     blocked_local_shared_objects_.cookies()->AddReadCookies(
         frame_url, url, cookie_list);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.cookies()->AddReadCookies(
         frame_url, url, cookie_list);
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnCookieChanged(
     const GURL& url,
     const GURL& frame_url,
     const std::string& cookie_line,
     const net::CookieOptions& options,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.cookies()->AddChangedCookie(
         frame_url, url, cookie_line, options);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.cookies()->AddChangedCookie(
         frame_url, url, cookie_line, options);
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnIndexedDBAccessed(
     const GURL& url,
     const base::string16& description,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.indexed_dbs()->AddIndexedDB(
         url, description);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.indexed_dbs()->AddIndexedDB(
         url, description);
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnLocalStorageAccessed(
     const GURL& url,
     bool local,
     bool blocked_by_policy) {
   LocalSharedObjectsContainer& container = blocked_by_policy ?
       blocked_local_shared_objects_ : allowed_local_shared_objects_;
   CannedBrowsingDataLocalStorageHelper* helper =
       local ? container.local_storages() : container.session_storages();
   helper->AddLocalStorage(url);
 
   if (blocked_by_policy)
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   else
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnWebDatabaseAccessed(
     const GURL& url,
     const base::string16& name,
     const base::string16& display_name,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.databases()->AddDatabase(
         url, UTF16ToUTF8(name), UTF16ToUTF8(display_name));
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.databases()->AddDatabase(
         url, UTF16ToUTF8(name), UTF16ToUTF8(display_name));
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnFileSystemAccessed(
     const GURL& url,
     bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.file_systems()->AddFileSystem(url,
         fileapi::kFileSystemTypeTemporary, 0);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.file_systems()->AddFileSystem(url,
         fileapi::kFileSystemTypeTemporary, 0);
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 
   NotifySiteDataObservers();
 }
 
 void TabSpecificContentSettings::OnGeolocationPermissionSet(
     const GURL& requesting_origin,
     bool allowed) {
   geolocation_usages_state_.OnPermissionSet(requesting_origin, allowed);
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
       content::Source<WebContents>(web_contents()),
       content::NotificationService::NoDetails());
 }
 
 #if defined(OS_ANDROID)
 void TabSpecificContentSettings::OnProtectedMediaIdentifierPermissionSet(
     const GURL& requesting_origin,
     bool allowed) {
   if (allowed) {
     OnContentAllowed(CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
   } else {
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER,
-                     std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
   }
 }
 #endif
 
 TabSpecificContentSettings::MicrophoneCameraState
 TabSpecificContentSettings::GetMicrophoneCameraState() const {
   if (IsContentAllowed(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC) &&
       IsContentAllowed(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA)) {
     return MICROPHONE_CAMERA_ACCESSED;
   } else if (IsContentAllowed(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)) {
@@ skipping 28 matching lines @@
       case MediaStreamDevicesController::MEDIA_NONE:
         NOTREACHED();
         break;
       case MediaStreamDevicesController::MEDIA_ALLOWED:
         OnContentAllowed(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
         break;
       // TODO(grunell): UI should show for what reason access has been blocked.
       case MediaStreamDevicesController::MEDIA_BLOCKED_BY_POLICY:
       case MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER_SETTING:
       case MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER:
-        OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                         std::string());
+        OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
         break;
     }
   }
 
   it = request_permissions.find(content::MEDIA_DEVICE_VIDEO_CAPTURE);
   if (it != request_permissions.end()) {
     media_stream_requested_video_device_ = it->second.requested_device_id;
     switch (it->second.permission) {
       case MediaStreamDevicesController::MEDIA_NONE:
         NOTREACHED();
         break;
       case MediaStreamDevicesController::MEDIA_ALLOWED:
         OnContentAllowed(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
         break;
       // TODO(grunell): UI should show for what reason access has been blocked.
       case MediaStreamDevicesController::MEDIA_BLOCKED_BY_POLICY:
       case MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER_SETTING:
       case MediaStreamDevicesController::MEDIA_BLOCKED_BY_USER:
-        OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                         std::string());
+        OnContentBlocked(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
         break;
     }
   }
 }
 
 void TabSpecificContentSettings::OnMIDISysExAccessed(
     const GURL& requesting_origin) {
   midi_usages_state_.OnPermissionSet(requesting_origin, true);
   OnContentAllowed(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
 void TabSpecificContentSettings::OnMIDISysExAccessBlocked(
     const GURL& requesting_origin) {
   midi_usages_state_.OnPermissionSet(requesting_origin, false);
-  OnContentBlocked(CONTENT_SETTINGS_TYPE_MIDI_SYSEX, std::string());
+  OnContentBlocked(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 }
 
 void TabSpecificContentSettings::ClearBlockedContentSettingsExceptForCookies() {
   for (size_t i = 0; i < arraysize(content_blocked_); ++i) {
     if (i == CONTENT_SETTINGS_TYPE_COOKIES)
       continue;
-    blocked_resources_[i].reset();
     content_blocked_[i] = false;
     content_allowed_[i] = false;
     content_blockage_indicated_to_user_[i] = false;
   }
   load_plugins_link_enabled_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_WEB_CONTENT_SETTINGS_CHANGED,
       content::Source<WebContents>(web_contents()),
       content::NotificationService::NoDetails());
 }
@@ skipping 45 matching lines @@
 }
 
 void TabSpecificContentSettings::ClearMIDIContentSettings() {
   midi_usages_state_.ClearStateMap();
 }
 
 void TabSpecificContentSettings::SetPepperBrokerAllowed(bool allowed) {
   if (allowed) {
     OnContentAllowed(CONTENT_SETTINGS_TYPE_PPAPI_BROKER);
   } else {
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_PPAPI_BROKER, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_PPAPI_BROKER);
   }
 }
 
 void TabSpecificContentSettings::RenderViewForInterstitialPageCreated(
     RenderViewHost* render_view_host) {
   // We want to tell the renderer-side code to ignore content settings for this
   // page.
   render_view_host->Send(new ChromeViewMsg_SetAsInterstitial(
       render_view_host->GetRoutingID()));
 }
@@ skipping 37 matching lines @@
     ClearCookieSpecificContentSettings();
   ClearGeolocationContentSettings();
   ClearMIDIContentSettings();
   ClearPendingProtocolHandler();
 }
 
 void TabSpecificContentSettings::AppCacheAccessed(const GURL& manifest_url,
                                                   bool blocked_by_policy) {
   if (blocked_by_policy) {
     blocked_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
-    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES, std::string());
+    OnContentBlocked(CONTENT_SETTINGS_TYPE_COOKIES);
   } else {
     allowed_local_shared_objects_.appcaches()->AddAppCache(manifest_url);
     OnContentAllowed(CONTENT_SETTINGS_TYPE_COOKIES);
   }
 }
 
 void TabSpecificContentSettings::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
@@ skipping 24 matching lines @@
 }
 
 void TabSpecificContentSettings::RemoveSiteDataObserver(
     SiteDataObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void TabSpecificContentSettings::NotifySiteDataObservers() {
   FOR_EACH_OBSERVER(SiteDataObserver, observer_list_, OnSiteDataAccessed());
 }