Introduce a resource identifier for content settings.

chrome/browser/host_content_settings_map.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/host_content_settings_map.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chrome_thread.h"
@@ skipping 14 matching lines @@
 #include "net/base/static_cookie_policy.h"
 
 namespace {
 // The version of the pattern format implemented. Version 1 includes the
 // following patterns:
 //   - [*.]domain.tld (matches domain.tld and all sub-domains)
 //   - host (matches an exact hostname)
 //   - a.b.c.d (matches an exact IPv4 ip)
 //   - [a:b:c:d:e:f:g:h] (matches an exact IPv6 ip)
 //   - file:///tmp/test.html (a complete URL without a host)
+// Version 2 adds a resource identifier for plugins.
+// TODO(jochen): update once this feature is no longer behind a flag.
 const int kContentSettingsPatternVersion = 1;
 
 // The format of a domain wildcard.
 const char kDomainWildcard[] = "[*.]";
 
 // The length of kDomainWildcard (without the trailing '\0')
 const size_t kDomainWildcardLength = arraysize(kDomainWildcard) - 1;
 
+// The preference keys where resource identifiers are stored for
+// ContentSettingsType values that support resource identifiers.
+const char* kResourceTypeNames[CONTENT_SETTINGS_NUM_TYPES] = {
+  NULL,
+  NULL,
+  NULL,
+  "per_plugin",
+  NULL,
+  NULL,  // Not used for Geolocation
+  NULL,  // Not used for Notifications
+};
+
+// The names of the ContentSettingsType values, for use with dictionary prefs.
+const char* kTypeNames[CONTENT_SETTINGS_NUM_TYPES] = {
+  "cookies",
+  "images",
+  "javascript",
+  "plugins",
+  "popups",
+  NULL,  // Not used for Geolocation
+  NULL,  // Not used for Notifications
+};
+
+// The default setting for each content type.
+const ContentSetting kDefaultSettings[CONTENT_SETTINGS_NUM_TYPES] = {
+  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_COOKIES
+  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_IMAGES
+  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_JAVASCRIPT
+  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_PLUGINS
+  CONTENT_SETTING_BLOCK,  // CONTENT_SETTINGS_TYPE_POPUPS
+  CONTENT_SETTING_ASK,    // Not used for Geolocation
+  CONTENT_SETTING_ASK,    // Not used for Notifications
+};
+
+// True if a given content settings type requires additional resource
+// identifiers.
+const bool kRequiresResourceIdentifier[CONTENT_SETTINGS_NUM_TYPES] = {
+  false,  // CONTENT_SETTINGS_TYPE_COOKIES
+  false,  // CONTENT_SETTINGS_TYPE_IMAGES
+  false,  // CONTENT_SETTINGS_TYPE_JAVASCRIPT
+  true,   // CONTENT_SETTINGS_TYPE_PLUGINS
+  false,  // CONTENT_SETTINGS_TYPE_POPUPS
+  false,  // Not used for Geolocation
+  false,  // Not used for Notifications
+};
+
+// Returns true if we should allow all content types for this URL.  This is
+// true for various internal objects like chrome:// URLs, so UI and other
+// things users think of as "not webpages" don't break.
+static bool ShouldAllowAllContent(const GURL& url) {
+  return url.SchemeIs(chrome::kChromeInternalScheme) ||
+         url.SchemeIs(chrome::kChromeUIScheme) ||
+         url.SchemeIs(chrome::kExtensionScheme) ||
+         url.SchemeIs(chrome::kGearsScheme) ||
+         url.SchemeIs(chrome::kUserScriptScheme);
+}
 }  // namespace
 
 // static
 HostContentSettingsMap::Pattern HostContentSettingsMap::Pattern::FromURL(
     const GURL& url) {
   return Pattern(!url.has_host() || url.HostIsIPAddress() ?
       net::GetHostOrSpecFromURL(url) :
       std::string(kDomainWildcard) + url.host());
 }
 
@@ skipping 26 matching lines @@
     return pattern_ == host;
 
   const size_t match =
       host.rfind(pattern_.substr(kDomainWildcardLength));
 
   return (match != std::string::npos) &&
          (match == 0 || host[match - 1] == '.') &&
          (match + pattern_.length() - kDomainWildcardLength == host.length());
 }
 
-// static
-const wchar_t*
-    HostContentSettingsMap::kTypeNames[CONTENT_SETTINGS_NUM_TYPES] = {
-  L"cookies",
-  L"images",
-  L"javascript",
-  L"plugins",
-  L"popups",
-  NULL,  // Not used for Geolocation
-  NULL,  // Not used for Notifications
-};
-
-// static
-const ContentSetting
-    HostContentSettingsMap::kDefaultSettings[CONTENT_SETTINGS_NUM_TYPES] = {
-  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_COOKIES
-  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_IMAGES
-  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_JAVASCRIPT
-  CONTENT_SETTING_ALLOW,  // CONTENT_SETTINGS_TYPE_PLUGINS
-  CONTENT_SETTING_BLOCK,  // CONTENT_SETTINGS_TYPE_POPUPS
-  CONTENT_SETTING_ASK,    // Not used for Geolocation
-  CONTENT_SETTING_ASK,    // Not used for Notifications
-};
-
 HostContentSettingsMap::HostContentSettingsMap(Profile* profile)
     : profile_(profile),
       block_third_party_cookies_(false),
       is_off_the_record_(profile_->IsOffTheRecord()),
       updating_preferences_(false) {
   PrefService* prefs = profile_->GetPrefs();
 
   // Migrate obsolete cookie pref.
   if (prefs->HasPrefPath(prefs::kCookieBehavior)) {
     int cookie_behavior = prefs->GetInteger(prefs::kCookieBehavior);
@@ skipping 10 matching lines @@
   }
 
   // Migrate obsolete popups pref.
   if (prefs->HasPrefPath(prefs::kPopupWhitelistedHosts)) {
     const ListValue* whitelist_pref =
         prefs->GetList(prefs::kPopupWhitelistedHosts);
     for (ListValue::const_iterator i(whitelist_pref->begin());
          i != whitelist_pref->end(); ++i) {
       std::string host;
       (*i)->GetAsString(&host);
-      SetContentSetting(Pattern(host), CONTENT_SETTINGS_TYPE_POPUPS,
+      SetContentSetting(Pattern(host), CONTENT_SETTINGS_TYPE_POPUPS, "",
                         CONTENT_SETTING_ALLOW);
     }
     prefs->ClearPref(prefs::kPopupWhitelistedHosts);
   }
 
   // Migrate obsolete per-host pref.
   if (prefs->HasPrefPath(prefs::kPerHostContentSettings)) {
     const DictionaryValue* all_settings_dictionary =
         prefs->GetDictionary(prefs::kPerHostContentSettings);
     for (DictionaryValue::key_iterator i(all_settings_dictionary->begin_keys());
          i != all_settings_dictionary->end_keys(); ++i) {
       const std::string& host(*i);
       Pattern pattern(std::string(kDomainWildcard) + host);
       DictionaryValue* host_settings_dictionary = NULL;
       bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
           host, &host_settings_dictionary);
       DCHECK(found);
       ContentSettings settings;
       GetSettingsFromDictionary(host_settings_dictionary, &settings);
       for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
-        if (settings.settings[j] != CONTENT_SETTING_DEFAULT)
+        if (settings.settings[j] != CONTENT_SETTING_DEFAULT &&
+            !RequiresResourceIdentifier(ContentSettingsType(j)))
           SetContentSetting(
-              pattern, ContentSettingsType(j), settings.settings[j]);
+              pattern, ContentSettingsType(j), "", settings.settings[j]);
       }
     }
     prefs->ClearPref(prefs::kPerHostContentSettings);
   }
 
   // Read global defaults.
   DCHECK_EQ(arraysize(kTypeNames),
             static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
   ReadDefaultSettings(false);
 
@@ skipping 39 matching lines @@
 }
 
 ContentSetting HostContentSettingsMap::GetDefaultContentSetting(
     ContentSettingsType content_type) const {
   AutoLock auto_lock(lock_);
   return default_content_settings_.settings[content_type];
 }
 
 ContentSetting HostContentSettingsMap::GetContentSetting(
     const GURL& url,
-    ContentSettingsType content_type) const {
-  return GetContentSettings(url).settings[content_type];
+    ContentSettingsType content_type,
+    const std::string& resource_identifier) const {
+  ContentSetting setting = GetNonDefaultContentSetting(url,
+                                                       content_type,
+                                                       resource_identifier);
+  if (setting == CONTENT_SETTING_DEFAULT)
+    return GetDefaultContentSetting(content_type);
+  return setting;
+}
+
+ContentSetting HostContentSettingsMap::GetNonDefaultContentSetting(
+    const GURL& url,
+    ContentSettingsType content_type,
+    const std::string& resource_identifier) const {
+  if (ShouldAllowAllContent(url))
+    return CONTENT_SETTING_ALLOW;
+
+  if (!RequiresResourceIdentifier(content_type))
+    return GetNonDefaultContentSettings(url).settings[content_type];
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableClickToPlay)) {
+    DCHECK(!resource_identifier.empty());
+  }
+
+  AutoLock auto_lock(lock_);
+
+  const std::string host(net::GetHostOrSpecFromURL(url));
+  ContentSettingsTypeResourceIdentifierPair
+      requested_setting(content_type, resource_identifier);
+
+  // Check for exact matches first.
+  HostContentSettings::const_iterator i(host_content_settings_.find(host));
+  if (i != host_content_settings_.end() &&
+      i->second.content_settings_for_resources.find(requested_setting) !=
+      i->second.content_settings_for_resources.end()) {
+    return i->second.content_settings_for_resources.find(
+        requested_setting)->second;
+  }
+
+  // If this map is not for an off-the-record profile, these searches will never
+  // match. The additional off-the-record exceptions always overwrite the
+  // regular ones.
+  i = off_the_record_settings_.find(host);
+  if (i != off_the_record_settings_.end() &&
+      i->second.content_settings_for_resources.find(requested_setting) !=
+      i->second.content_settings_for_resources.end()) {
+    return i->second.content_settings_for_resources.find(
+        requested_setting)->second;
+  }
+
+  // Match patterns starting with the most concrete pattern match.
+  for (std::string key = std::string(kDomainWildcard) + host; ; ) {
+    HostContentSettings::const_iterator i(off_the_record_settings_.find(key));
+    if (i != off_the_record_settings_.end() &&
+        i->second.content_settings_for_resources.find(requested_setting) !=
+        i->second.content_settings_for_resources.end()) {
+      return i->second.content_settings_for_resources.find(
+          requested_setting)->second;
+    }
+
+    i = host_content_settings_.find(key);
+    if (i != host_content_settings_.end() &&
+        i->second.content_settings_for_resources.find(requested_setting) !=
+        i->second.content_settings_for_resources.end()) {
+      return i->second.content_settings_for_resources.find(
+          requested_setting)->second;
+    }
+
+    const size_t next_dot = key.find('.', kDomainWildcardLength);
+    if (next_dot == std::string::npos)
+      break;
+    key.erase(kDomainWildcardLength, next_dot - kDomainWildcardLength + 1);
+  }
+
+  return CONTENT_SETTING_DEFAULT;
 }
 
 ContentSettings HostContentSettingsMap::GetContentSettings(
     const GURL& url) const {
+  ContentSettings output = GetNonDefaultContentSettings(url);
+
+  // Make the remaining defaults explicit.
+  for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
+    if (output.settings[j] == CONTENT_SETTING_DEFAULT ||
+        RequiresResourceIdentifier(ContentSettingsType(j)))
+      output.settings[j] = default_content_settings_.settings[j];
+
+  return output;
+}
+
+ContentSettings HostContentSettingsMap::GetNonDefaultContentSettings(
+    const GURL& url) const {
   if (ShouldAllowAllContent(url))
       return ContentSettings(CONTENT_SETTING_ALLOW);
 
   AutoLock auto_lock(lock_);
 
   const std::string host(net::GetHostOrSpecFromURL(url));
   ContentSettings output;
   for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
     output.settings[j] = CONTENT_SETTING_DEFAULT;
 
   // Check for exact matches first.
   HostContentSettings::const_iterator i(host_content_settings_.find(host));
   if (i != host_content_settings_.end())
-    output = i->second;
+    output = i->second.content_settings;
 
   // If this map is not for an off-the-record profile, these searches will never
   // match. The additional off-the-record exceptions always overwrite the
   // regular ones.
   i = off_the_record_settings_.find(host);
   if (i != off_the_record_settings_.end()) {
     for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
-      if (i->second.settings[j] != CONTENT_SETTING_DEFAULT)
-        output.settings[j] = i->second.settings[j];
+      if (i->second.content_settings.settings[j] != CONTENT_SETTING_DEFAULT)
+        output.settings[j] = i->second.content_settings.settings[j];
   }
 
   // Match patterns starting with the most concrete pattern match.
   for (std::string key = std::string(kDomainWildcard) + host; ; ) {
     HostContentSettings::const_iterator i(off_the_record_settings_.find(key));
     if (i != off_the_record_settings_.end()) {
       for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
         if (output.settings[j] == CONTENT_SETTING_DEFAULT)
-          output.settings[j] = i->second.settings[j];
+          output.settings[j] = i->second.content_settings.settings[j];
       }
     }
     i = host_content_settings_.find(key);
     if (i != host_content_settings_.end()) {
       for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j) {
         if (output.settings[j] == CONTENT_SETTING_DEFAULT)
-          output.settings[j] = i->second.settings[j];
+          output.settings[j] = i->second.content_settings.settings[j];
       }
     }
     const size_t next_dot = key.find('.', kDomainWildcardLength);
     if (next_dot == std::string::npos)
       break;
     key.erase(kDomainWildcardLength, next_dot - kDomainWildcardLength + 1);
   }
 
-  // Make the remaining defaults explicit.
-  for (int j = 0; j < CONTENT_SETTINGS_NUM_TYPES; ++j)
-    if (output.settings[j] == CONTENT_SETTING_DEFAULT)
-      output.settings[j] = default_content_settings_.settings[j];
-
   return output;
 }
 
 void HostContentSettingsMap::GetSettingsForOneType(
     ContentSettingsType content_type,
+    const std::string& resource_identifier,
     SettingsForOneType* settings) const {
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableClickToPlay)) {
+    DCHECK(!RequiresResourceIdentifier(content_type) ||
+           !resource_identifier.empty());
+  }
   DCHECK(settings);
   settings->clear();
 
   const HostContentSettings* map_to_return =
       is_off_the_record_ ? &off_the_record_settings_ : &host_content_settings_;
+  ContentSettingsTypeResourceIdentifierPair
+      requested_setting(content_type, resource_identifier);
 
   AutoLock auto_lock(lock_);
   for (HostContentSettings::const_iterator i(map_to_return->begin());
        i != map_to_return->end(); ++i) {
-    ContentSetting setting = i->second.settings[content_type];
+    ContentSetting setting;
+    if (RequiresResourceIdentifier(content_type)) {
+      if (i->second.content_settings_for_resources.find(requested_setting) !=
+          i->second.content_settings_for_resources.end())
+        setting = i->second.content_settings_for_resources.find(
+            requested_setting)->second;
+      else
+        setting = CONTENT_SETTING_DEFAULT;
+    } else {
+     setting = i->second.content_settings.settings[content_type];
+    }
     if (setting != CONTENT_SETTING_DEFAULT) {
       // Use of push_back() relies on the map iterator traversing in order of
       // ascending keys.
       settings->push_back(std::make_pair(Pattern(i->first), setting));
     }
   }
 }
 
 void HostContentSettingsMap::SetDefaultContentSetting(
     ContentSettingsType content_type,
     ContentSetting setting) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   PrefService* prefs = profile_->GetPrefs();
 
   // The default settings may not be directly modified for OTR sessions.
   // Instead, they are synced to the main profile's setting.
   if (is_off_the_record_) {
     NOTREACHED();
     return;
   }
 
   DictionaryValue* default_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kDefaultContentSettings);
-  std::wstring dictionary_path(kTypeNames[content_type]);
+  std::string dictionary_path(kTypeNames[content_type]);
   updating_preferences_ = true;
   {
     AutoLock auto_lock(lock_);
     ScopedPrefUpdate update(prefs, prefs::kDefaultContentSettings);
     if ((setting == CONTENT_SETTING_DEFAULT) ||
         (setting == kDefaultSettings[content_type])) {
       default_content_settings_.settings[content_type] =
           kDefaultSettings[content_type];
       default_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
                                                               NULL);
     } else {
       default_content_settings_.settings[content_type] = setting;
       default_settings_dictionary->SetWithoutPathExpansion(
           dictionary_path, Value::CreateIntegerValue(setting));
     }
   }
   updating_preferences_ = false;
 
-  NotifyObservers(ContentSettingsDetails(content_type));
+  NotifyObservers(ContentSettingsDetails(Pattern(), content_type, ""));
 }
 
-void HostContentSettingsMap::SetContentSetting(const Pattern& pattern,
-                                               ContentSettingsType content_type,
-                                               ContentSetting setting) {
+void HostContentSettingsMap::SetContentSetting(
+    const Pattern& pattern,
+    ContentSettingsType content_type,
+    const std::string& resource_identifier,
+    ContentSetting setting) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableClickToPlay)) {
+    DCHECK(!RequiresResourceIdentifier(content_type) ||
+           !resource_identifier.empty());
+  }
 
   bool early_exit = false;
-  std::wstring wide_pattern(UTF8ToWide(pattern.AsString()));
+  std::string pattern_str(pattern.AsString());
   PrefService* prefs = NULL;
   DictionaryValue* all_settings_dictionary = NULL;
   HostContentSettings* map_to_modify = &off_the_record_settings_;
   if (!is_off_the_record_) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
     map_to_modify = &host_content_settings_;
   }
 
   {
     AutoLock auto_lock(lock_);
     if (!map_to_modify->count(pattern.AsString()))
-      (*map_to_modify)[pattern.AsString()] = ContentSettings();
+      (*map_to_modify)[pattern.AsString()].content_settings = ContentSettings();
     HostContentSettings::iterator
         i(map_to_modify->find(pattern.AsString()));
-    ContentSettings& settings = i->second;
-    settings.settings[content_type] = setting;
-    if (AllDefault(settings)) {
+    ContentSettings& settings = i->second.content_settings;
+    if (RequiresResourceIdentifier(content_type)) {
+      settings.settings[content_type] = CONTENT_SETTING_DEFAULT;
+      if (setting != CONTENT_SETTING_DEFAULT) {
+        i->second.content_settings_for_resources[
+            ContentSettingsTypeResourceIdentifierPair(content_type,
+            resource_identifier)] = setting;
+      } else {
+        i->second.content_settings_for_resources.erase(
+            ContentSettingsTypeResourceIdentifierPair(content_type,
+            resource_identifier));
+      }
+    } else {
+      settings.settings[content_type] = setting;
+    }
+    if (AllDefault(i->second)) {
       map_to_modify->erase(i);
       if (all_settings_dictionary)
-        all_settings_dictionary->RemoveWithoutPathExpansion(wide_pattern, NULL);
+        all_settings_dictionary->RemoveWithoutPathExpansion(pattern_str, NULL);
 
       // We can't just return because |NotifyObservers()| needs to be called,
       // without |lock_| being held.
       early_exit = true;
     }
   }
 
   if (!early_exit && all_settings_dictionary) {
-    DictionaryValue* host_settings_dictionary;
+    DictionaryValue* host_settings_dictionary = NULL;
     bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
-        wide_pattern, &host_settings_dictionary);
+        pattern_str, &host_settings_dictionary);
     if (!found) {
       host_settings_dictionary = new DictionaryValue;
       all_settings_dictionary->SetWithoutPathExpansion(
-          wide_pattern, host_settings_dictionary);
+          pattern_str, host_settings_dictionary);
       DCHECK_NE(setting, CONTENT_SETTING_DEFAULT);
     }
-    std::wstring dictionary_path(kTypeNames[content_type]);
-    if (setting == CONTENT_SETTING_DEFAULT) {
-      host_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
-                                                           NULL);
+    if (RequiresResourceIdentifier(content_type)) {
+      std::string dictionary_path(kResourceTypeNames[content_type]);
+      DictionaryValue* resource_dictionary = NULL;
+      found = host_settings_dictionary->GetDictionary(
+          dictionary_path, &resource_dictionary);
+      if (!found) {
+        resource_dictionary = new DictionaryValue;
+        host_settings_dictionary->Set(dictionary_path, resource_dictionary);
+      }
+      if (setting == CONTENT_SETTING_DEFAULT) {
+        resource_dictionary->RemoveWithoutPathExpansion(resource_identifier,
+                                                        NULL);
+      } else {
+        resource_dictionary->SetWithoutPathExpansion(
+            resource_identifier, Value::CreateIntegerValue(setting));
+      }
     } else {
-      host_settings_dictionary->SetWithoutPathExpansion(
-          dictionary_path, Value::CreateIntegerValue(setting));
+      std::string dictionary_path(kTypeNames[content_type]);
+      if (setting == CONTENT_SETTING_DEFAULT) {
+        host_settings_dictionary->RemoveWithoutPathExpansion(dictionary_path,
+                                                             NULL);
+      } else {
+        host_settings_dictionary->SetWithoutPathExpansion(
+            dictionary_path, Value::CreateIntegerValue(setting));
+      }
     }
   }
 
   updating_preferences_ = true;
   if (!is_off_the_record_)
     ScopedPrefUpdate update(prefs, prefs::kContentSettingsPatterns);
   updating_preferences_ = false;
 
-  NotifyObservers(ContentSettingsDetails(pattern, content_type));
+  NotifyObservers(ContentSettingsDetails(pattern, content_type, ""));
 }
 
 void HostContentSettingsMap::AddExceptionForURL(
     const GURL& url,
     ContentSettingsType content_type,
+    const std::string& resource_identifier,
     ContentSetting setting) {
   // Make sure there is no entry that would override the pattern we are about
   // to insert for exactly this URL.
   SetContentSetting(Pattern::FromURLNoWildcard(url),
                     content_type,
+                    resource_identifier,
                     CONTENT_SETTING_DEFAULT);
-  SetContentSetting(Pattern::FromURL(url), content_type, setting);
+  SetContentSetting(Pattern::FromURL(url),
+                    content_type,
+                    resource_identifier,
+                    setting);
 }
 
 void HostContentSettingsMap::ClearSettingsForOneType(
     ContentSettingsType content_type) {
   DCHECK(kTypeNames[content_type] != NULL);  // Don't call this for Geolocation.
 
   PrefService* prefs = NULL;
   DictionaryValue* all_settings_dictionary = NULL;
   HostContentSettings* map_to_modify = &off_the_record_settings_;
 
   if (!is_off_the_record_) {
     prefs = profile_->GetPrefs();
     all_settings_dictionary =
       prefs->GetMutableDictionary(prefs::kContentSettingsPatterns);
     map_to_modify = &host_content_settings_;
   }
 
   {
     AutoLock auto_lock(lock_);
     for (HostContentSettings::iterator i(map_to_modify->begin());
          i != map_to_modify->end(); ) {
-      if (i->second.settings[content_type] != CONTENT_SETTING_DEFAULT) {
-        i->second.settings[content_type] = CONTENT_SETTING_DEFAULT;
-        std::wstring wide_host(UTF8ToWide(i->first));
+      if (RequiresResourceIdentifier(content_type) ||
+          i->second.content_settings.settings[content_type] !=
+          CONTENT_SETTING_DEFAULT) {
+        if (RequiresResourceIdentifier(content_type))
+          i->second.content_settings_for_resources.clear();
+        i->second.content_settings.settings[content_type] =
+            CONTENT_SETTING_DEFAULT;
+        std::string host(i->first);
         if (AllDefault(i->second)) {
           if (all_settings_dictionary)
             all_settings_dictionary->
-                RemoveWithoutPathExpansion(wide_host, NULL);
+                RemoveWithoutPathExpansion(host, NULL);
           map_to_modify->erase(i++);
         } else if (all_settings_dictionary) {
           DictionaryValue* host_settings_dictionary;
           bool found =
               all_settings_dictionary->GetDictionaryWithoutPathExpansion(
-                  wide_host, &host_settings_dictionary);
+                  host, &host_settings_dictionary);
           DCHECK(found);
           host_settings_dictionary->RemoveWithoutPathExpansion(
               kTypeNames[content_type], NULL);
           ++i;
         }
       } else {
         ++i;
       }
     }
   }
 
   updating_preferences_ = true;
   if (!is_off_the_record_)
     ScopedPrefUpdate update(prefs, prefs::kContentSettingsPatterns);
   updating_preferences_ = false;
 
-  NotifyObservers(ContentSettingsDetails(content_type));
+  NotifyObservers(ContentSettingsDetails(Pattern(), content_type, ""));
+}
+
+bool HostContentSettingsMap::RequiresResourceIdentifier(
+    ContentSettingsType content_type) const {
+// TODO(bauerb): Enable once all call sites are adopted.
+#if 0
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kEnableClickToPlay))
+    return kRequiresResourceIdentifier[content_type];
+  else
+#endif
+    return false;
 }
 
 void HostContentSettingsMap::SetBlockThirdPartyCookies(bool block) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   // This setting may not be directly modified for OTR sessions.  Instead, it
   // is synced to the main profile's setting.
   if (is_off_the_record_) {
     NOTREACHED();
     return;
@@ skipping 23 matching lines @@
     block_third_party_cookies_ = false;
   }
 
   if (!is_off_the_record_) {
     PrefService* prefs = profile_->GetPrefs();
     updating_preferences_ = true;
     prefs->ClearPref(prefs::kDefaultContentSettings);
     prefs->ClearPref(prefs::kContentSettingsPatterns);
     prefs->ClearPref(prefs::kBlockThirdPartyCookies);
     updating_preferences_ = false;
-    NotifyObservers(ContentSettingsDetails());
+    NotifyObservers(
+        ContentSettingsDetails(Pattern(), CONTENT_SETTINGS_TYPE_DEFAULT, ""));
   }
 }
 
 bool HostContentSettingsMap::IsOffTheRecord() {
   return profile_->IsOffTheRecord();
 }
 
 void HostContentSettingsMap::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
@@ skipping 10 matching lines @@
       ReadExceptions(true);
     } else if (prefs::kBlockThirdPartyCookies == *name) {
       AutoLock auto_lock(lock_);
       block_third_party_cookies_ = profile_->GetPrefs()->GetBoolean(
           prefs::kBlockThirdPartyCookies);
     } else {
       NOTREACHED() << "Unexpected preference observed";
       return;
     }
 
-    if (!is_off_the_record_)
-      NotifyObservers(ContentSettingsDetails());
+    if (!is_off_the_record_) {
+      NotifyObservers(
+          ContentSettingsDetails(Pattern(), CONTENT_SETTINGS_TYPE_DEFAULT, ""));
+    }
   } else if (NotificationType::PROFILE_DESTROYED == type) {
     UnregisterObservers();
   } else {
     NOTREACHED() << "Unexpected notification";
   }
 }
 
 HostContentSettingsMap::~HostContentSettingsMap() {
   UnregisterObservers();
 }
 
-// static
-bool HostContentSettingsMap::ShouldAllowAllContent(const GURL& url) {
-  return url.SchemeIs(chrome::kChromeInternalScheme) ||
-         url.SchemeIs(chrome::kChromeUIScheme) ||
-         url.SchemeIs(chrome::kExtensionScheme) ||
-         url.SchemeIs(chrome::kGearsScheme) ||
-         url.SchemeIs(chrome::kUserScriptScheme);
-}
-
 void HostContentSettingsMap::GetSettingsFromDictionary(
     const DictionaryValue* dictionary,
     ContentSettings* settings) {
   for (DictionaryValue::key_iterator i(dictionary->begin_keys());
        i != dictionary->end_keys(); ++i) {
     const std::string& content_type(*i);
-    int setting = CONTENT_SETTING_DEFAULT;
-    bool found = dictionary->GetIntegerWithoutPathExpansion(content_type,
-                                                            &setting);
-    DCHECK(found);
     for (size_t type = 0; type < arraysize(kTypeNames); ++type) {
-      if ((kTypeNames[type] != NULL) &&
-          (WideToUTF8(kTypeNames[type]) == content_type)) {
+      if ((kTypeNames[type] != NULL) && (kTypeNames[type] == content_type)) {
+        int setting = CONTENT_SETTING_DEFAULT;
+        bool found = dictionary->GetIntegerWithoutPathExpansion(content_type,
+                                                                &setting);
+        DCHECK(found);
         settings->settings[type] = IntToContentSetting(setting);
         break;
       }
     }
   }
   if (!CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableCookiePrompt)) {
     // Migrate obsolete cookie prompt mode.
     if (settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] ==
         CONTENT_SETTING_ASK)
       settings->settings[CONTENT_SETTINGS_TYPE_COOKIES] = CONTENT_SETTING_BLOCK;
   }
 }
 
+void HostContentSettingsMap::GetResourceSettingsFromDictionary(
+    const DictionaryValue* dictionary,
+    ResourceContentSettings* settings) {
+  for (DictionaryValue::key_iterator i(dictionary->begin_keys());
+       i != dictionary->end_keys(); ++i) {
+    const std::string& content_type(*i);
+    for (size_t type = 0; type < arraysize(kResourceTypeNames); ++type) {
+      if ((kResourceTypeNames[type] != NULL) &&
+          (kResourceTypeNames[type] == content_type)) {
+        DictionaryValue* resource_dictionary = NULL;
+        bool found = dictionary->GetDictionary(content_type,
+                                               &resource_dictionary);
+        DCHECK(found);
+        for (DictionaryValue::key_iterator j(resource_dictionary->begin_keys());
+             j != resource_dictionary->end_keys(); ++j) {
+          const std::string& resource_identifier(*j);
+          int setting = CONTENT_SETTING_DEFAULT;
+          bool found = resource_dictionary->GetIntegerWithoutPathExpansion(
+              resource_identifier, &setting);
+          DCHECK(found);
+          (*settings)[ContentSettingsTypeResourceIdentifierPair(
+              ContentSettingsType(type), resource_identifier)] =
+                  ContentSetting(setting);
+        }
+
+        break;
+      }
+    }
+  }
+}
+
 void HostContentSettingsMap::ForceDefaultsToBeExplicit() {
   DCHECK_EQ(arraysize(kDefaultSettings),
             static_cast<size_t>(CONTENT_SETTINGS_NUM_TYPES));
 
   for (int i = 0; i < CONTENT_SETTINGS_NUM_TYPES; ++i) {
     if (default_content_settings_.settings[i] == CONTENT_SETTING_DEFAULT)
       default_content_settings_.settings[i] = kDefaultSettings[i];
   }
 }
 
-bool HostContentSettingsMap::AllDefault(const ContentSettings& settings) const {
-  for (size_t i = 0; i < arraysize(settings.settings); ++i) {
-    if (settings.settings[i] != CONTENT_SETTING_DEFAULT)
+bool HostContentSettingsMap::AllDefault(
+    const ExtendedContentSettings& settings) const {
+  for (size_t i = 0; i < arraysize(settings.content_settings.settings); ++i) {
+    if (settings.content_settings.settings[i] != CONTENT_SETTING_DEFAULT)
       return false;
   }
-  return true;
+  return settings.content_settings_for_resources.empty();
 }
 
 void HostContentSettingsMap::ReadDefaultSettings(bool overwrite) {
   PrefService* prefs = profile_->GetPrefs();
   const DictionaryValue* default_settings_dictionary =
       prefs->GetDictionary(prefs::kDefaultContentSettings);
   if (overwrite)
     default_content_settings_ = ContentSettings();
   // Careful: The returned value could be NULL if the pref has never been set.
   if (default_settings_dictionary != NULL) {
@@ skipping 15 matching lines @@
          i != all_settings_dictionary->end_keys(); ++i) {
       const std::string& pattern(*i);
       if (!Pattern(pattern).IsValid())
         LOG(WARNING) << "Invalid pattern stored in content settings";
       DictionaryValue* pattern_settings_dictionary = NULL;
       bool found = all_settings_dictionary->GetDictionaryWithoutPathExpansion(
           pattern, &pattern_settings_dictionary);
       DCHECK(found);
       ContentSettings settings;
       GetSettingsFromDictionary(pattern_settings_dictionary, &settings);
-      host_content_settings_[pattern] = settings;
+      host_content_settings_[pattern].content_settings = settings;
+      GetResourceSettingsFromDictionary(
+          pattern_settings_dictionary,
+          &host_content_settings_[pattern].content_settings_for_resources);
     }
   }
 }
 
 void HostContentSettingsMap::NotifyObservers(
     const ContentSettingsDetails& details) {
   NotificationService::current()->Notify(
       NotificationType::CONTENT_SETTINGS_CHANGED,
       Source<HostContentSettingsMap>(this),
       Details<const ContentSettingsDetails>(&details));
 }
 
 void HostContentSettingsMap::UnregisterObservers() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   if (!profile_)
     return;
   PrefService* prefs = profile_->GetPrefs();
   prefs->RemovePrefObserver(prefs::kDefaultContentSettings, this);
   prefs->RemovePrefObserver(prefs::kContentSettingsPatterns, this);
   prefs->RemovePrefObserver(prefs::kBlockThirdPartyCookies, this);
   notification_registrar_.Remove(this, NotificationType::PROFILE_DESTROYED,
                                  Source<Profile>(profile_));
   profile_ = NULL;
 }