Merge a bunch of CLs to whitelist the Google Talk plug-in when turning on click-to-play.

chrome/browser/content_settings/content_settings_pref_provider.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/content_settings_pref_provider.h"
 
 #include <map>
 #include <string>
 #include <utility>
 
@@ skipping 52 matching lines @@
     settings->RemoveWithoutPathExpansion(type_name, NULL);
   }
 }
 
 // If the given content type supports resource identifiers in user preferences,
 // returns true and sets |pref_key| to the key in the content settings
 // dictionary under which per-resource content settings are stored.
 // Otherwise, returns false.
 bool GetResourceTypeName(ContentSettingsType content_type,
                          std::string* pref_key) {
-  if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS &&
-      CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableResourceContentSettings)) {
+  if (content_type == CONTENT_SETTINGS_TYPE_PLUGINS) {
     *pref_key = kPerPluginPrefName;
     return true;
   }
   return false;
 }
 
 }  // namespace
 
 namespace content_settings {
 
@@ skipping 73 matching lines @@
     const ResourceIdentifier& resource_identifier,
     Value* in_value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(prefs_);
   // Default settings are set using a wildcard pattern for both
   // |primary_pattern| and |secondary_pattern|. Don't store default settings in
   // the |PrefProvider|. The |PrefProvider| handles settings for specific
   // sites/origins defined by the |primary_pattern| and the |secondary_pattern|.
   // Default settings are handled by the |DefaultProvider|.
   if (primary_pattern == ContentSettingsPattern::Wildcard() &&
-      secondary_pattern == ContentSettingsPattern::Wildcard()) {
+      secondary_pattern == ContentSettingsPattern::Wildcard() &&
+      resource_identifier.empty()) {
     return false;
   }
 
   // At this point take the ownership of the |in_value|.
   scoped_ptr<base::Value> value(in_value);
   // Update in memory value map.
   OriginIdentifierValueMap* map_to_modify = &incognito_value_map_;
   if (!is_incognito_)
     map_to_modify = &value_map_;
 
@@ skipping 238 matching lines @@
             found = resource_dictionary->GetIntegerWithoutPathExpansion(
                 resource_identifier, &setting);
             DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
             value_map_.SetValue(pattern_pair.first,
                                 pattern_pair.second,
                                 content_type,
                                 resource_identifier,
                                 Value::CreateIntegerValue(setting));
           }
         }
-      } else {
-        int setting = CONTENT_SETTING_DEFAULT;
-        if (settings_dictionary->GetIntegerWithoutPathExpansion(
-                GetTypeName(ContentSettingsType(i)), &setting)) {
-          DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
-          setting = FixObsoleteCookiePromptMode(content_type,
-                                                ContentSetting(setting));
-          value_map_.SetValue(pattern_pair.first,
-                              pattern_pair.second,
-                              content_type,
-                              ResourceIdentifier(""),
-                              Value::CreateIntegerValue(setting));
-        }
+      }
+      int setting = CONTENT_SETTING_DEFAULT;
+      if (settings_dictionary->GetIntegerWithoutPathExpansion(
+              GetTypeName(ContentSettingsType(i)), &setting)) {
+        DCHECK_NE(CONTENT_SETTING_DEFAULT, setting);
+        setting = FixObsoleteCookiePromptMode(content_type,
+                                              ContentSetting(setting));
+        value_map_.SetValue(pattern_pair.first,
+                            pattern_pair.second,
+                            content_type,
+                            ResourceIdentifier(""),
+                            Value::CreateIntegerValue(setting));
       }
     }
   }
 }
 
 void PrefProvider::UpdateObsoletePatternsPref(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
@@ skipping 13 matching lines @@
       pattern_str, &settings_dictionary);
 
   if (!found && (setting != CONTENT_SETTING_DEFAULT)) {
     settings_dictionary = new DictionaryValue;
     all_settings_dictionary->SetWithoutPathExpansion(
         pattern_str, settings_dictionary);
   }
 
   if (settings_dictionary) {
     std::string res_dictionary_path;
-    if (GetResourceTypeName(content_type, &res_dictionary_path)) {
+    if (GetResourceTypeName(content_type, &res_dictionary_path) &&
+        !resource_identifier.empty()) {
       DictionaryValue* resource_dictionary = NULL;
       found = settings_dictionary->GetDictionary(
           res_dictionary_path, &resource_dictionary);
       if (!found) {
         if (setting == CONTENT_SETTING_DEFAULT)
           return;  // Nothing to remove. Exit early.
         resource_dictionary = new DictionaryValue;
         settings_dictionary->Set(res_dictionary_path, resource_dictionary);
       }
       // Update resource dictionary.
@@ skipping 11 matching lines @@
     } else {
       // Update settings dictionary.
       std::string setting_path = GetTypeName(content_type);
       if (setting == CONTENT_SETTING_DEFAULT) {
         settings_dictionary->RemoveWithoutPathExpansion(setting_path,
                                                         NULL);
       } else {
         settings_dictionary->SetWithoutPathExpansion(
             setting_path, Value::CreateIntegerValue(setting));
       }
-      // Remove the settings dictionary if it is empty.
-      if (settings_dictionary->empty()) {
-        all_settings_dictionary->RemoveWithoutPathExpansion(
-            pattern_str, NULL);
-      }
+    }
+    // Remove the settings dictionary if it is empty.
+    if (settings_dictionary->empty()) {
+      all_settings_dictionary->RemoveWithoutPathExpansion(
+          pattern_str, NULL);
     }
   }
 }
 
 void PrefProvider::UpdatePatternPairsSettings(
       const ContentSettingsPattern& primary_pattern,
       const ContentSettingsPattern& secondary_pattern,
       ContentSettingsType content_type,
       const ResourceIdentifier& resource_identifier,
       const base::Value* value,
       DictionaryValue* pattern_pairs_settings) {
   // Get settings dictionary for the given patterns.
   std::string pattern_str(CreatePatternString(primary_pattern,
                                               secondary_pattern));
   DictionaryValue* settings_dictionary = NULL;
   bool found = pattern_pairs_settings->GetDictionaryWithoutPathExpansion(
       pattern_str, &settings_dictionary);
 
   if (!found && value) {
     settings_dictionary = new DictionaryValue;
     pattern_pairs_settings->SetWithoutPathExpansion(
         pattern_str, settings_dictionary);
   }
 
   if (settings_dictionary) {
     std::string res_dictionary_path;
-    if (GetResourceTypeName(content_type, &res_dictionary_path)) {
+    if (GetResourceTypeName(content_type, &res_dictionary_path) &&
+        !resource_identifier.empty()) {
       DictionaryValue* resource_dictionary = NULL;
       found = settings_dictionary->GetDictionary(
           res_dictionary_path, &resource_dictionary);
       if (!found) {
         if (value == NULL)
           return;  // Nothing to remove. Exit early.
         resource_dictionary = new DictionaryValue;
         settings_dictionary->Set(res_dictionary_path, resource_dictionary);
       }
       // Update resource dictionary.
@@ skipping 556 matching lines @@
 
 void PrefProvider::AssertLockNotHeld() const {
 #if !defined(NDEBUG)
   // |Lock::Acquire()| will assert if the lock is held by this thread.
   lock_.Acquire();
   lock_.Release();
 #endif
 }
 
 }  // namespace content_settings