Store base::Value in ContentSettingPatternSource instead of an enum

chrome/browser/extensions/api/content_settings/content_settings_store.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/extensions/api/content_settings/content_settings_store.h"
 
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <utility>
 
 #include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_api_constants.h"
 #include "chrome/browser/extensions/api/content_settings/content_settings_helpers.h"
 #include "components/content_settings/core/browser/content_settings_origin_identifier_value_map.h"
 #include "components/content_settings/core/browser/content_settings_rule.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
+#include "components/content_settings/core/common/content_settings_utils.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 using content_settings::ConcatenationIterator;
 using content_settings::Rule;
 using content_settings::RuleIterator;
 using content_settings::OriginIdentifierValueMap;
 using content_settings::ResourceIdentifier;
-using content_settings::ValueToContentSetting;
 
 namespace extensions {
 
 namespace helpers = content_settings_helpers;
 namespace keys = content_settings_api_constants;
 
 struct ContentSettingsStore::ExtensionEntry {
   // Extension id.
   std::string id;
   // Installation time.
@@ skipping 198 matching lines @@
       return;
     }
     notify = !map->empty();
     map->clear();
   }
   if (notify) {
     NotifyOfContentSettingChanged(ext_id, scope != kExtensionPrefsScopeRegular);
   }
 }
 
 std::unique_ptr<base::ListValue> ContentSettingsStore::GetSettingsForExtension(

[lazyboy, 2017/06/30 18:11:40]

Since this touches persistent extension preference, I'd carefully check if
extension's content settings preferences stored before the CL can be correctly
retrieved by this function after the CL.

From the look of it, it (extension preference) doesn't seem to have changed at
all though.

[tbansal1, 2017/06/30 18:32:31]

Correct, this CL should not affect any consumers. This CL is not changing what
is stored on the disk. The only change is in an intermediate data structure that
is populated from the contents stored on the disk.

     const std::string& extension_id,
     ExtensionPrefsScope scope) const {
   base::AutoLock lock(lock_);
   const OriginIdentifierValueMap* map = GetValueMap(extension_id, scope);
   if (!map)
     return nullptr;
 
   auto settings = base::MakeUnique<base::ListValue>();
   for (const auto& it : *map) {
     const auto& key = it.first;
     std::unique_ptr<RuleIterator> rule_iterator(
         map->GetRuleIterator(key.content_type, key.resource_identifier,
                              nullptr));  // We already hold the lock.
     if (!rule_iterator)
       continue;
 
     while (rule_iterator->HasNext()) {
       const Rule& rule = rule_iterator->Next();
       std::unique_ptr<base::DictionaryValue> setting_dict(
           new base::DictionaryValue());
       setting_dict->SetString(keys::kPrimaryPatternKey,
                               rule.primary_pattern.ToString());
       setting_dict->SetString(keys::kSecondaryPatternKey,
                               rule.secondary_pattern.ToString());
       setting_dict->SetString(
           keys::kContentSettingsTypeKey,
           helpers::ContentSettingsTypeToString(key.content_type));
       setting_dict->SetString(keys::kResourceIdentifierKey,
                               key.resource_identifier);
-      ContentSetting content_setting = ValueToContentSetting(rule.value.get());
+      ContentSetting content_setting =
+          content_settings::ValueToContentSetting(rule.value.get());
       DCHECK_NE(CONTENT_SETTING_DEFAULT, content_setting);
 
       std::string setting_string =
           content_settings::ContentSettingToString(content_setting);
       DCHECK(!setting_string.empty());
 
       setting_dict->SetString(keys::kContentSettingKey, setting_string);
       settings->Append(std::move(setting_dict));
     }
   }
@@ skipping 94 matching lines @@
 
 ContentSettingsStore::ExtensionEntries::iterator
 ContentSettingsStore::FindIterator(const std::string& ext_id) {
   return std::find_if(entries_.begin(), entries_.end(),
                       [ext_id](const std::unique_ptr<ExtensionEntry>& entry) {
                         return entry->id == ext_id;
                       });
 }
 
 }  // namespace extensions