[Extensions] Don't generate a list for each generated schema

extensions/common/extension_api.cc

 // Copyright 2013 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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <string>
@@ skipping 20 matching lines @@
 
 namespace extensions {
 
 namespace {
 
 const char* kChildKinds[] = {
   "functions",
   "events"
 };
 
-std::unique_ptr<base::ListValue> LoadSchemaList(
+std::unique_ptr<base::DictionaryValue> LoadSchemaDictionary(
     const std::string& name,
     const base::StringPiece& schema) {
   std::string error_message;
   std::unique_ptr<base::Value> result(base::JSONReader::ReadAndReturnError(
       schema,
       base::JSON_PARSE_RFC | base::JSON_DETACHABLE_CHILDREN,  // options
       NULL,                                                   // error code
       &error_message));
 
   // Tracking down http://crbug.com/121424
   char buf[128];
   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(base::Value::TYPE_LIST)) << " for schema " << schema;
-  return base::ListValue::From(std::move(result));
+  CHECK(result->IsType(base::Value::TYPE_DICTIONARY)) << " for schema "
+                                                      << schema;
+  return base::DictionaryValue::From(std::move(result));
 }
 
 const base::DictionaryValue* FindListItem(const base::ListValue* list,
                                           const std::string& property_name,
                                           const std::string& property_value) {
   for (size_t i = 0; i < list->GetSize(); ++i) {
     const base::DictionaryValue* item = NULL;
     CHECK(list->GetDictionary(i, &item))
         << property_value << "/" << property_name;
     std::string value;
@@ skipping 68 matching lines @@
     : original_api_(g_shared_instance_for_test) {
   g_shared_instance_for_test = testing_api;
 }
 
 ExtensionAPI::OverrideSharedInstanceForTest::~OverrideSharedInstanceForTest() {
   g_shared_instance_for_test = original_api_;
 }
 
 void ExtensionAPI::LoadSchema(const std::string& name,
                               const base::StringPiece& schema) {
-  std::unique_ptr<base::ListValue> schema_list(LoadSchemaList(name, schema));
+  std::unique_ptr<base::DictionaryValue> schema_dict(
+      LoadSchemaDictionary(name, schema));
   std::string schema_namespace;
-  extensions::ExtensionsClient* extensions_client =
-      extensions::ExtensionsClient::Get();
-  DCHECK(extensions_client);
-  while (!schema_list->empty()) {
-    std::unique_ptr<base::DictionaryValue> schema;
-    {
-      std::unique_ptr<base::Value> val;
-      schema_list->Erase(schema_list->begin(), &val);
-      schema = base::DictionaryValue::From(std::move(val));
-      CHECK(schema);
-    }
-    CHECK(schema->GetString("namespace", &schema_namespace));
-    schemas_[schema_namespace] = std::move(schema);
-  }
+  CHECK(schema_dict->GetString("namespace", &schema_namespace));
+  schemas_[schema_namespace] = std::move(schema_dict);
 }
 
 ExtensionAPI::ExtensionAPI() : default_configuration_initialized_(false) {
 }
 
 ExtensionAPI::~ExtensionAPI() {
 }
 
 void ExtensionAPI::InitDefaultConfiguration() {
   const char* names[] = {"api", "manifest", "permission"};
@@ skipping 126 matching lines @@
   return std::string();
 }
 
 bool ExtensionAPI::IsKnownAPI(const std::string& name,
                               ExtensionsClient* client) {
   return schemas_.find(name) != schemas_.end() ||
          client->IsAPISchemaGenerated(name);
 }
 
 }  // namespace extensions