Correct const accessors in base/values.(h|cc)

chrome/browser/extensions/extension_prefs.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/extension_prefs.h"
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/admin_policy.h"
@@ skipping 293 matching lines @@
 
 void ExtensionPrefs::MakePathsRelative() {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict || dict->empty())
     return;
 
   // Collect all extensions ids with absolute paths in |absolute_keys|.
   std::set<std::string> absolute_keys;
   for (DictionaryValue::key_iterator i = dict->begin_keys();
        i != dict->end_keys(); ++i) {
-    DictionaryValue* extension_dict = NULL;
+    const DictionaryValue* extension_dict = NULL;
     if (!dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict))
       continue;
     int location_value;
     if (extension_dict->GetInteger(kPrefLocation, &location_value) &&
         location_value == Extension::LOAD) {
       // Unpacked extensions can have absolute paths.
       continue;
     }
     FilePath::StringType path_string;
     if (!extension_dict->GetString(kPrefPath, &path_string))
       continue;
     FilePath path(path_string);
     if (path.IsAbsolute())
       absolute_keys.insert(*i);
   }
   if (absolute_keys.empty())
     return;
 
   // Fix these paths.
   DictionaryPrefUpdate update(prefs_, kExtensionsPref);
-  const DictionaryValue* update_dict = update.Get();
+  DictionaryValue* update_dict = update.Get();
   for (std::set<std::string>::iterator i = absolute_keys.begin();
        i != absolute_keys.end(); ++i) {
     DictionaryValue* extension_dict = NULL;
     if (!update_dict->GetDictionaryWithoutPathExpansion(*i, &extension_dict)) {
       NOTREACHED() << "Control should never reach here for extension " << *i;
       continue;
     }
     FilePath::StringType path_string;
     extension_dict->GetString(kPrefPath, &path_string);
     FilePath path(path_string);
@@ skipping 77 matching lines @@
     // No such extension yet.
     return false;
   }
   return ReadIntegerFromPref(ext, pref_key, out_value);
 }
 
 bool ExtensionPrefs::ReadExtensionPrefList(
     const std::string& extension_id, const std::string& pref_key,
     const ListValue** out_value) const {
   const DictionaryValue* ext = GetExtensionPref(extension_id);
-  ListValue* out = NULL;
+  const ListValue* out = NULL;
   if (!ext || !ext->GetList(pref_key, &out))
     return false;
   if (out_value)
     *out_value = out;
 
   return true;
 }
 
 bool ExtensionPrefs::ReadExtensionPrefString(
     const std::string& extension_id, const std::string& pref_key,
@@ skipping 89 matching lines @@
 
   // Set the scriptable host permissions.
   if (!new_value->scriptable_hosts().is_empty()) {
     SetExtensionPrefURLPatternSet(extension_id,
                                   JoinPrefs(pref_key, kPrefScriptableHosts),
                                   new_value->scriptable_hosts());
   }
 }
 
 // static
-bool ExtensionPrefs::IsBlacklistBitSet(DictionaryValue* ext) {
+bool ExtensionPrefs::IsBlacklistBitSet(const DictionaryValue* ext) {
   return ReadBooleanFromPref(ext, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionBlacklisted(const std::string& extension_id) {
   return ReadExtensionPrefBoolean(extension_id, kPrefBlacklist);
 }
 
 bool ExtensionPrefs::IsExtensionOrphaned(const std::string& extension_id) {
   // TODO(miket): we believe that this test will hinge on the number of
   // consecutive times that an update check has returned a certain response
@@ skipping 146 matching lines @@
 
 void ExtensionPrefs::UpdateBlacklist(
     const std::set<std::string>& blacklist_set) {
   std::vector<std::string> remove_pref_ids;
   std::set<std::string> used_id_set;
   const DictionaryValue* extensions = prefs_->GetDictionary(kExtensionsPref);
 
   if (extensions) {
     for (DictionaryValue::key_iterator extension_id = extensions->begin_keys();
          extension_id != extensions->end_keys(); ++extension_id) {
-      DictionaryValue* ext;
+      const DictionaryValue* ext;
       if (!extensions->GetDictionaryWithoutPathExpansion(*extension_id, &ext)) {
         NOTREACHED() << "Invalid pref for extension " << *extension_id;
         continue;
       }
       const std::string& id(*extension_id);
       if (blacklist_set.find(id) == blacklist_set.end()) {
         if (!IsBlacklistBitSet(ext)) {
           // This extension is not in blacklist. And it was not blacklisted
           // before.
           continue;
@@ skipping 120 matching lines @@
     const DictionaryValue* ext = GetExtensionPref(*ext_id);
     if (!ext || !ext->GetBoolean(kPrefOldGrantedFullAccess, &full_access))
       continue;
 
     // Remove the full access bit (empty list will get trimmed).
     UpdateExtensionPref(
         *ext_id, kPrefOldGrantedFullAccess, new ListValue());
 
     // Add the plugin permission if the full access bit was set.
     if (full_access) {
-      ListValue* apis = NULL;
+      const ListValue* apis = NULL;
       ListValue* new_apis = NULL;
 
       std::string granted_apis =
           JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
       if (ext->GetList(kPrefOldGrantedAPIs, &apis))
         new_apis = apis->DeepCopy();
       else
         new_apis = new ListValue();
 
       std::string plugin_name = info->GetByID(
           APIPermission::kPlugin)->name();
       new_apis->Append(Value::CreateStringValue(plugin_name));
       UpdateExtensionPref(*ext_id, granted_apis, new_apis);
     }
 
     // The granted permissions originally only held the effective hosts,
     // which are a combination of host and user script host permissions.
     // We now maintain these lists separately. For migration purposes, it
     // does not matter how we treat the old effective hosts as long as the
     // new effective hosts will be the same, so we move them to explicit
     // host permissions.
-    ListValue* hosts;
+    const ListValue* hosts;
     std::string explicit_hosts =
         JoinPrefs(kPrefGrantedPermissions, kPrefExplicitHosts);
     if (ext->GetList(kPrefOldGrantedHosts, &hosts)) {
       UpdateExtensionPref(
           *ext_id, explicit_hosts, hosts->DeepCopy());
 
       // We can get rid of the old one by setting it to an empty list.
       UpdateExtensionPref(*ext_id, kPrefOldGrantedHosts, new ListValue());
     }
   }
@@ skipping 54 matching lines @@
       extension_id, kPrefActivePermissions, permissions);
 }
 
 std::set<std::string> ExtensionPrefs::GetRegisteredEvents(
     const std::string& extension_id) {
   std::set<std::string> events;
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return events;
 
-  ListValue* value = NULL;
+  const ListValue* value = NULL;
   if (!extension->GetList(kRegisteredEvents, &value))
     return events;
 
   for (size_t i = 0; i < value->GetSize(); ++i) {
     std::string event;
     if (value->GetString(i, &event))
       events.insert(event);
   }
   return events;
 }
@@ skipping 38 matching lines @@
       break;
     }
   }
 }
 
 const DictionaryValue* ExtensionPrefs::GetFilteredEvents(
     const std::string& extension_id) const {
   const DictionaryValue* extension = GetExtensionPref(extension_id);
   if (!extension)
     return NULL;
-  DictionaryValue* result = NULL;
+  const DictionaryValue* result = NULL;
   if (!extension->GetDictionary(kFilteredEvents, &result))
     return NULL;
   return result;
 }
 
 void ExtensionPrefs::SetRegisteredEvents(
     const std::string& extension_id, const std::set<std::string>& events) {
   ListValue* value = new ListValue();
   for (std::set<std::string>::const_iterator it = events.begin();
        it != events.end(); ++it) {
     value->Append(new StringValue(*it));
   }
   UpdateExtensionPref(extension_id, kRegisteredEvents, value);
 }
 
 ExtensionOmniboxSuggestion
 ExtensionPrefs::GetOmniboxDefaultSuggestion(const std::string& extension_id) {
   ExtensionOmniboxSuggestion suggestion;
 
-  const base::DictionaryValue* extension = GetExtensionPref(extension_id);
-  base::DictionaryValue* dict = NULL;
+  const DictionaryValue* extension = GetExtensionPref(extension_id);
+  const DictionaryValue* dict = NULL;
   if (extension && extension->GetDictionary(kOmniboxDefaultSuggestion, &dict))
     suggestion.Populate(*dict, false);
 
   return suggestion;
 }
 
 void ExtensionPrefs::SetOmniboxDefaultSuggestion(
     const std::string& extension_id,
     const ExtensionOmniboxSuggestion& suggestion) {
   scoped_ptr<base::DictionaryValue> dict = suggestion.ToValue().Pass();
@@ skipping 290 matching lines @@
   }
 
   return version;
 }
 
 void ExtensionPrefs::UpdateManifest(const Extension* extension) {
   if (extension->location() != Extension::LOAD) {
     const DictionaryValue* extension_dict = GetExtensionPref(extension->id());
     if (!extension_dict)
       return;
-    DictionaryValue* old_manifest = NULL;
+    const DictionaryValue* old_manifest = NULL;
     bool update_required =
         !extension_dict->GetDictionary(kPrefManifest, &old_manifest) ||
         !extension->manifest()->value()->Equals(old_manifest);
     if (update_required) {
       UpdateExtensionPref(extension->id(), kPrefManifest,
                           extension->manifest()->value()->DeepCopy());
     }
   }
 }
 
@@ skipping 29 matching lines @@
   DictionaryPrefUpdate update(prefs_, kExtensionsPref);
   DictionaryValue* dict = update.Get();
   dict->Remove(extension_id, NULL);
 }
 
 const DictionaryValue* ExtensionPrefs::GetExtensionPref(
     const std::string& extension_id) const {
   const DictionaryValue* dict = prefs_->GetDictionary(kExtensionsPref);
   if (!dict)
     return NULL;
-  DictionaryValue* extension = NULL;
+  const DictionaryValue* extension = NULL;
   dict->GetDictionary(extension_id, &extension);
   return extension;
 }
 
 // Helper function for GetInstalledExtensionsInfo.
 static ExtensionInfo* GetInstalledExtensionInfoImpl(
     DictionaryValue* extension_data,
     DictionaryValue::key_iterator extension_id) {
   DictionaryValue* ext;
   if (!extension_data->GetDictionaryWithoutPathExpansion(*extension_id, &ext)) {
@@ skipping 111 matching lines @@
 bool ExtensionPrefs::GetIdleInstallInfo(const std::string& extension_id,
                                         FilePath* crx_path,
                                         std::string* version,
                                         base::Time* fetch_time) {
   const DictionaryValue* extension_prefs = GetExtensionPref(extension_id);
   if (!extension_prefs)
     return false;
 
   // Do all the reads from the prefs together, and don't do any assignment
   // to the out parameters unless all the reads succeed.
-  DictionaryValue* info = NULL;
+  const DictionaryValue* info = NULL;
   if (!extension_prefs->GetDictionary(kIdleInstallInfo, &info))
     return false;
 
   FilePath::StringType path_string;
   if (!info->GetString(kIdleInstallInfoCrxPath, &path_string))
     return false;
 
   std::string tmp_version;
   if (!info->GetString(kIdleInstallInfoVersion, &tmp_version))
     return false;
@@ skipping 144 matching lines @@
     out->push_back(info->extension_id);
   }
 }
 
 // static
 ExtensionPrefs::ExtensionIdSet ExtensionPrefs::GetExtensionsFrom(
     const base::DictionaryValue* extension_prefs) {
   ExtensionIdSet result;
   for (base::DictionaryValue::key_iterator it = extension_prefs->begin_keys();
        it != extension_prefs->end_keys(); ++it) {
-    DictionaryValue* ext;
+    const DictionaryValue* ext;
     if (!extension_prefs->GetDictionaryWithoutPathExpansion(*it, &ext)) {
       NOTREACHED() << "Invalid pref for extension " << *it;
       continue;
     }
     if (!IsBlacklistBitSet(ext))
       result.push_back(*it);
   }
   return result;
 }
 
@@ skipping 14 matching lines @@
   }
 }
 
 void ExtensionPrefs::LoadExtensionControlledPrefs(
     const std::string& extension_id,
     ExtensionPrefsScope scope) {
   std::string scope_string;
   bool success = ScopeToPrefKey(scope, &scope_string);
   DCHECK(success);
   std::string key = extension_id + "." + scope_string;
-  DictionaryValue* preferences = NULL;
+  const DictionaryValue* preferences = NULL;
   // First try the regular lookup.
   const DictionaryValue* source_dict = prefs_->GetDictionary(kExtensionsPref);
   if (!source_dict->GetDictionary(key, &preferences))
     return;
 
   for (DictionaryValue::Iterator i(*preferences); i.HasNext(); i.Advance()) {
     extension_pref_value_map_->SetExtensionPref(
         extension_id, i.key(), scope, i.value().DeepCopy());
   }
 }
@@ skipping 39 matching lines @@
     LoadExtensionControlledPrefs(*ext_id, kExtensionPrefsScopeRegular);
     // Set incognito extension controlled prefs.
     LoadExtensionControlledPrefs(*ext_id,
                                  kExtensionPrefsScopeIncognitoPersistent);
     // Set regular-only extension controlled prefs.
     LoadExtensionControlledPrefs(*ext_id, kExtensionPrefsScopeRegularOnly);
 
     // Set content settings.
     const DictionaryValue* extension_prefs = GetExtensionPref(*ext_id);
     DCHECK(extension_prefs);
-    ListValue* content_settings = NULL;
+    const ListValue* content_settings = NULL;
     if (extension_prefs->GetList(kPrefContentSettings,
                                  &content_settings)) {
       content_settings_store_->SetExtensionContentSettingFromList(
           *ext_id, content_settings,
           kExtensionPrefsScopeRegular);
     }
     if (extension_prefs->GetList(kPrefIncognitoContentSettings,
                                  &content_settings)) {
       content_settings_store_->SetExtensionContentSettingFromList(
           *ext_id, content_settings,
@@ skipping 142 matching lines @@
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterInt64Pref(prefs::kNextExtensionsUpdateCheck,
                            0,  // default value
                            PrefService::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kExtensionAllowedInstallSites,
                           PrefService::UNSYNCABLE_PREF);
 }
 
 }  // namespace extensions