[Extensions] Remove mechanism for non-generated schemas

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>
 #include <utility>
 #include <vector>
 
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extensions_client.h"
 #include "extensions/common/features/feature.h"
 #include "extensions/common/features/feature_provider.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/permissions/permission_set.h"
 #include "extensions/common/permissions/permissions_data.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 const char* kChildKinds[] = {
   "functions",
   "events"
 };
 
-base::StringPiece ReadFromResource(int resource_id) {
-  return ResourceBundle::GetSharedInstance().GetRawDataResource(
-      resource_id);
-}
-
 std::unique_ptr<base::ListValue> LoadSchemaList(
     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));
 
@@ skipping 164 matching lines @@
     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));
     PrefixWithNamespace(schema_namespace, schema.get());
     schemas_[schema_namespace] = std::move(schema);
-    if (!extensions_client->IsAPISchemaGenerated(schema_namespace))
-      CHECK_EQ(1u, unloaded_schemas_.erase(schema_namespace));
   }
 }
 
 ExtensionAPI::ExtensionAPI() : default_configuration_initialized_(false) {
 }
 
 ExtensionAPI::~ExtensionAPI() {
 }
 
 void ExtensionAPI::InitDefaultConfiguration() {
   const char* names[] = {"api", "manifest", "permission"};
   for (size_t i = 0; i < arraysize(names); ++i)
     RegisterDependencyProvider(names[i], FeatureProvider::GetByName(names[i]));
 
-  ExtensionsClient::Get()->RegisterAPISchemaResources(this);
   default_configuration_initialized_ = true;
 }
 
-void ExtensionAPI::RegisterSchemaResource(const std::string& name,
-                                          int resource_id) {
-  unloaded_schemas_[name] = resource_id;
-}
-
 void ExtensionAPI::RegisterDependencyProvider(const std::string& name,
                                               const FeatureProvider* provider) {
   dependency_providers_[name] = provider;
 }
 
 bool ExtensionAPI::IsAnyFeatureAvailableToContext(const Feature& api,
                                                   const Extension* extension,
                                                   Feature::Context context,
                                                   const GURL& url) {
   FeatureProviderMap::iterator provider = dependency_providers_.find("api");
@@ skipping 35 matching lines @@
     const std::string& full_name) {
   std::string child_name;
   std::string api_name = GetAPINameFromFullName(full_name, &child_name);
 
   const base::DictionaryValue* result = NULL;
   SchemaMap::iterator maybe_schema = schemas_.find(api_name);
   if (maybe_schema != schemas_.end()) {
     result = maybe_schema->second.get();
   } else {
     // Might not have loaded yet; or might just not exist.
-    UnloadedSchemaMap::iterator maybe_schema_resource =
-        unloaded_schemas_.find(api_name);
     extensions::ExtensionsClient* extensions_client =
         extensions::ExtensionsClient::Get();
     DCHECK(extensions_client);
-    if (maybe_schema_resource != unloaded_schemas_.end()) {
-      LoadSchema(maybe_schema_resource->first,
-                 ReadFromResource(maybe_schema_resource->second));
-    } else if (default_configuration_initialized_ &&
-               extensions_client->IsAPISchemaGenerated(api_name)) {
+    if (default_configuration_initialized_ &&
+        extensions_client->IsAPISchemaGenerated(api_name)) {
       LoadSchema(api_name, extensions_client->GetAPISchema(api_name));
     } else {
-      return NULL;
+      return nullptr;
     }
 
     maybe_schema = schemas_.find(api_name);
     CHECK(schemas_.end() != maybe_schema);
     result = maybe_schema->second.get();
   }
 
   if (!child_name.empty())
     result = GetSchemaChild(result, child_name);
 
@@ skipping 16 matching lines @@
     std::string child_name;
     feature = provider->second->GetFeature(
         GetAPINameFromFullName(feature_name, &child_name));
   }
   return feature;
 }
 
 std::string ExtensionAPI::GetAPINameFromFullName(const std::string& full_name,
                                                  std::string* child_name) {
   std::string api_name_candidate = full_name;
-  extensions::ExtensionsClient* extensions_client =
-      extensions::ExtensionsClient::Get();
+  ExtensionsClient* extensions_client = ExtensionsClient::Get();
   DCHECK(extensions_client);
   while (true) {
-    if (schemas_.find(api_name_candidate) != schemas_.end() ||
-        extensions_client->IsAPISchemaGenerated(api_name_candidate) ||
-        unloaded_schemas_.find(api_name_candidate) != unloaded_schemas_.end()) {
-      std::string result = api_name_candidate;
-
+    if (IsKnownAPI(api_name_candidate, extensions_client)) {
       if (child_name) {
-        if (result.length() < full_name.length())
-          *child_name = full_name.substr(result.length() + 1);
+        if (api_name_candidate.length() < full_name.length())
+          *child_name = full_name.substr(api_name_candidate.length() + 1);
         else
           *child_name = "";
       }
-
-      return result;
+      return api_name_candidate;
     }
 
     size_t last_dot_index = api_name_candidate.rfind('.');
     if (last_dot_index == std::string::npos)
       break;
 
     api_name_candidate = api_name_candidate.substr(0, last_dot_index);
   }
 
   *child_name = "";
   return std::string();
 }
 
+bool ExtensionAPI::IsKnownAPI(const std::string& name,
+                              ExtensionsClient* client) {
+  return schemas_.find(name) != schemas_.end() ||
+         client->IsAPISchemaGenerated(name);
+}
+
 }  // namespace extensions