Remove HostContentSettingsMap::IsSettingAllowedForType

components/content_settings/core/browser/content_settings_pref.cc

 // Copyright 2015 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 "components/content_settings/core/browser/content_settings_pref.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 15 matching lines @@
 const char kLastUsed[] = "last_used";
 
 // 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 SupportsResourceIdentifiers(ContentSettingsType content_type) {
   return content_type == CONTENT_SETTINGS_TYPE_PLUGINS;
 }
 
+bool IsValueAllowedForType(const base::Value* value, ContentSettingsType type) {
+  const content_settings::ContentSettingsInfo* info =
+      content_settings::ContentSettingsRegistry::GetInstance()->Get(type);
+  if (info) {
+    int setting;
+    if (!value->GetAsInteger(&setting))
+      return false;
+    if (setting == CONTENT_SETTING_DEFAULT)
+      return false;
+    return info->IsSettingValid(IntToContentSetting(setting));
+  } else {

[Bernhard Bauer, 2015/09/28 18:46:09]

You don't need the else if you return in the previous branch anyway; see my
comment on https://codereview.chromium.org/1318083005/.

[raymes, 2015/09/29 05:51:26]

Done.

+    // TODO(raymes): We should permit different types of base::Value for
+    // website settings.
+    return value->GetType() == base::Value::TYPE_DICTIONARY;
+  }
+}
+
 }  // namespace
 
 namespace content_settings {
 
 ContentSettingsPref::ContentSettingsPref(
     ContentSettingsType content_type,
     PrefService* prefs,
     PrefChangeRegistrar* registrar,
     const std::string& pref_name,
     bool incognito,
@@ skipping 25 matching lines @@
                                                 resource_identifier,
                                                 &lock_);
   return value_map_.GetRuleIterator(content_type_, resource_identifier, &lock_);
 }
 
 bool ContentSettingsPref::SetWebsiteSetting(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     const ResourceIdentifier& resource_identifier,
     base::Value* in_value) {
+  DCHECK(!in_value || IsValueAllowedForType(in_value, content_type_));
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(prefs_);
   DCHECK(primary_pattern != ContentSettingsPattern::Wildcard() ||
          secondary_pattern != ContentSettingsPattern::Wildcard() ||
          !resource_identifier.empty());
 
   // At this point take the ownership of the |in_value|.
   scoped_ptr<base::Value> value(in_value);
 
   // Update in memory value map.
@@ skipping 205 matching lines @@
                               resource_identifier,
                               setting_ptr->DeepCopy());
         }
       }
     }
 
     const base::Value* value = nullptr;
     settings_dictionary->GetWithoutPathExpansion(kSettingPath, &value);
 
     if (value) {
-      DCHECK(HostContentSettingsMap::IsValueAllowedForType(value,
-                                                           content_type_));
+      DCHECK(IsValueAllowedForType(value, content_type_));
       value_map_.SetValue(pattern_pair.first,
                           pattern_pair.second,
                           content_type_,
                           ResourceIdentifier(),
                           value->DeepCopy());
       if (content_type_ == CONTENT_SETTINGS_TYPE_COOKIES) {
         ContentSetting s = ValueToContentSetting(value);
         switch (s) {
           case CONTENT_SETTING_ALLOW :
             ++cookies_allow_exception_count;
@@ skipping 166 matching lines @@
 
 void ContentSettingsPref::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