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

chrome/common/extensions/api/extension_api.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/common/extensions/api/extension_api.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 32 matching lines @@
 // Returns true if |dict| has an unprivileged "true" property.
 bool IsUnprivileged(const DictionaryValue* dict) {
   bool unprivileged = false;
   return dict->GetBoolean("unprivileged", &unprivileged) && unprivileged;
 }
 
 // Returns whether the list at |name_space_node|.|child_kind| contains any
 // children with an { "unprivileged": true } property.
 bool HasUnprivilegedChild(const DictionaryValue* name_space_node,
                           const std::string& child_kind) {
-  ListValue* child_list = NULL;
-  DictionaryValue* child_dict = NULL;
+  const ListValue* child_list = NULL;
+  const DictionaryValue* child_dict = NULL;
 
   if (name_space_node->GetList(child_kind, &child_list)) {
     for (size_t i = 0; i < child_list->GetSize(); ++i) {
       DictionaryValue* item = NULL;
       CHECK(child_list->GetDictionary(i, &item));
       if (IsUnprivileged(item))
         return true;
     }
   } else if (name_space_node->GetDictionary(child_kind, &child_dict)) {
     for (DictionaryValue::Iterator it(*child_dict); it.HasNext();
@@ skipping 47 matching lines @@
       return item;
   }
 
   return NULL;
 }
 
 const DictionaryValue* GetSchemaChild(const DictionaryValue* schema_node,
                                       const std::string& child_name) {
   DictionaryValue* child_node = NULL;
   for (size_t i = 0; i < arraysize(kChildKinds); ++i) {
-    ListValue* list_node = NULL;
+    const ListValue* list_node = NULL;
     if (!schema_node->GetList(kChildKinds[i], &list_node))
       continue;
     child_node = FindListItem(list_node, "name", child_name);
     if (child_node)
       return child_node;
   }
 
   return NULL;
 }
 
@@ skipping 656 matching lines @@
   std::string feature_name;
   SplitDependencyName(api_name, &feature_type, &feature_name);
 
   // Only API features can have dependencies for now.
   if (feature_type != "api")
     return;
 
   const DictionaryValue* schema = GetSchema(feature_name);
   CHECK(schema) << "Schema for " << feature_name << " not found";
 
-  ListValue* dependencies = NULL;
+  const ListValue* dependencies = NULL;
   if (!schema->GetList("dependencies", &dependencies))
     return;
 
   for (size_t i = 0; i < dependencies->GetSize(); ++i) {
     std::string dependency_name;
     if (dependencies->GetString(i, &dependency_name) &&
         !excluding.count(dependency_name)) {
       out->insert(dependency_name);
     }
   }
@@ skipping 30 matching lines @@
 
 void ExtensionAPI::LoadAllSchemas() {
   while (unloaded_schemas_.size()) {
     std::map<std::string, base::StringPiece>::iterator it =
         unloaded_schemas_.begin();
     LoadSchema(it->first, it->second);
   }
 }
 
 }  // namespace extensions