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

chrome/browser/policy/policy_loader_win.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/policy/policy_loader_win.h"
 
 #include <string>
 
 #include <string.h>
 
@@ skipping 244 matching lines @@
 }
 
 // Returns the default type for registry entries of |reg_type|, when there is
 // no schema defined type for a policy.
 base::Value::Type GetDefaultFor(DWORD reg_type) {
   return reg_type == REG_DWORD ? base::Value::TYPE_INTEGER :
                                  base::Value::TYPE_STRING;
 }
 
 // Returns the entry with key |name| in |dictionary| (can be NULL), or NULL.
-base::DictionaryValue* GetEntry(const base::DictionaryValue* dictionary,
+const base::DictionaryValue* GetEntry(const base::DictionaryValue* dictionary,
                                 const std::string& name) {
   if (!dictionary)
     return NULL;
-  base::DictionaryValue* entry = NULL;
+  const base::DictionaryValue* entry = NULL;
   dictionary->GetDictionary(name, &entry);
   return entry;
 }
 
 // Returns the schema for property |name| given the |schema| of an object.
 // Returns the "additionalProperties" schema if no specific schema for
 // |name| is present. Returns NULL if no schema is found.
-base::DictionaryValue* GetSchemaFor(const base::DictionaryValue* schema,
+const base::DictionaryValue* GetSchemaFor(const base::DictionaryValue* schema,
                                     const std::string& name) {
-  base::DictionaryValue* properties = GetEntry(schema, kProperties);
-  base::DictionaryValue* sub_schema = GetEntry(properties, name);
+  const base::DictionaryValue* properties = GetEntry(schema, kProperties);
+  const base::DictionaryValue* sub_schema = GetEntry(properties, name);
   if (sub_schema)
     return sub_schema;
   // "additionalProperties" can be a boolean, but that case is ignored.
   return GetEntry(schema, kAdditionalProperties);
 }
 
 // Converts string |value| to another |type|, if possible.
 base::Value* ConvertComponentStringValue(const string16& value,
                                          base::Value::Type type) {
   switch (type) {
@@ skipping 171 matching lines @@
 
   for (RegistryKeyIterator it(hive, path.c_str()); it.Valid(); ++it) {
     string16 name16(it.Name());
     std::string name(UTF16ToUTF8(name16));
     if (dict->HasKey(name)) {
       DLOG(WARNING) << "Ignoring registry key because a value exists with the "
                        "same name: " << path << kPathSep << name;
       continue;
     }
 
-    base::DictionaryValue* sub_schema = GetSchemaFor(schema, name);
+    const base::DictionaryValue* sub_schema = GetSchemaFor(schema, name);
     base::Value::Type type = GetType(sub_schema, base::Value::TYPE_DICTIONARY);
     base::Value* value = NULL;
     const string16 sub_path = path + kPathSep + name16;
     if (type == base::Value::TYPE_DICTIONARY) {
       value = ReadComponentDictionaryValue(hive, sub_path, sub_schema);
     } else if (type == base::Value::TYPE_LIST) {
       value = ReadComponentListValue(hive, sub_path, sub_schema);
     } else {
       DLOG(WARNING) << "Can't read a simple type in registry key at " << path;
     }
@@ skipping 197 matching lines @@
 
 void PolicyLoaderWin::OnObjectSignaled(HANDLE object) {
   DCHECK(object == user_policy_changed_event_.handle() ||
          object == machine_policy_changed_event_.handle())
       << "unexpected object signaled policy reload, obj = "
       << std::showbase << std::hex << object;
   Reload(false);
 }
 
 }  // namespace policy