Correct const accessors in base/values.(h|cc), Part II (ListValue)

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 38 matching lines @@
 
 // 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) {
   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;
+      const 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();
          it.Advance()) {
       const DictionaryValue* item = NULL;
       CHECK(it.value().GetAsDictionary(&item));
       if (IsUnprivileged(item))
@@ skipping 24 matching lines @@
   base::snprintf(buf, arraysize(buf), "%s: (%d) '%s'",
       name.c_str(),
       result.get() ? result->GetType() : -1,
       error_message.c_str());
 
   CHECK(result.get()) << error_message << " for schema " << schema;
   CHECK(result->IsType(Value::TYPE_LIST)) << " for schema " << schema;
   return scoped_ptr<ListValue>(static_cast<ListValue*>(result.release()));
 }
 
-DictionaryValue* FindListItem(const ListValue* list,
-                              const std::string& property_name,
-                              const std::string& property_value) {
+const DictionaryValue* FindListItem(const ListValue* list,
+                                    const std::string& property_name,
+                                    const std::string& property_value) {
   for (size_t i = 0; i < list->GetSize(); ++i) {
-    DictionaryValue* item = NULL;
+    const DictionaryValue* item = NULL;
     CHECK(list->GetDictionary(i, &item))
         << property_value << "/" << property_name;
     std::string value;
     if (item->GetString(property_name, &value) && value == property_value)
       return item;
   }
 
   return NULL;
 }
 
 const DictionaryValue* GetSchemaChild(const DictionaryValue* schema_node,
                                       const std::string& child_name) {
-  DictionaryValue* child_node = NULL;
+  const DictionaryValue* child_node = NULL;
   for (size_t i = 0; i < arraysize(kChildKinds); ++i) {
     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 711 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