[Extensions] Remove mechanism for non-generated schemas

extensions/common/extension_api.h

 // 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.
 
 #ifndef EXTENSIONS_COMMON_EXTENSION_API_H_
 #define EXTENSIONS_COMMON_EXTENSION_API_H_
 
 #include <map>
 #include <memory>
 #include <string>
@@ skipping 10 matching lines @@
 namespace base {
 class DictionaryValue;
 class Value;
 }
 
 class GURL;
 
 namespace extensions {
 
 class Extension;
+class ExtensionsClient;
 class Feature;
 
 // C++ Wrapper for the JSON API definitions in chrome/common/extensions/api/.
 //
 // WARNING: This class is accessed on multiple threads in the browser process
 // (see ExtensionFunctionDispatcher). No state should be modified after
 // construction.
 class ExtensionAPI {
  public:
   // Returns a single shared instance of this class. This is the typical use
@@ skipping 17 matching lines @@
 
   class OverrideSharedInstanceForTest {
    public:
     explicit OverrideSharedInstanceForTest(ExtensionAPI* testing_api);
     ~OverrideSharedInstanceForTest();
 
    private:
     ExtensionAPI* original_api_;
   };
 
-  // Creates a completely clean instance. Configure using RegisterSchema() and
+  // Creates a completely clean instance. Configure using
   // RegisterDependencyProvider before use.
   ExtensionAPI();
   virtual ~ExtensionAPI();
 
-  // Add a (non-generated) API schema resource.
-  void RegisterSchemaResource(const std::string& api_name, int resource_id);
-
   // Add a FeatureProvider for APIs. The features are used to specify
   // dependencies and constraints on the availability of APIs.
   void RegisterDependencyProvider(const std::string& name,
                                   const FeatureProvider* provider);
 
   // Returns true if the API item called |api_full_name| and all of its
   // dependencies are available in |context|.
   //
   // |api_full_name| can be either a namespace name (like "bookmarks") or a
   // member name (like "bookmarks.create").
@@ skipping 40 matching lines @@
   // Returns NULL if the feature could not be found.
   Feature* GetFeatureDependency(const std::string& dependency_name);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, DefaultConfigurationFeatures);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, TypesHaveNamespace);
   friend struct base::DefaultSingletonTraits<ExtensionAPI>;
 
   void InitDefaultConfiguration();
 
+  // Returns true if there exists an API with |name|. Declared virtual for
+  // testing purposes.
+  virtual bool IsKnownAPI(const std::string& name, ExtensionsClient* client);
+
   bool default_configuration_initialized_;
 
   // Loads a schema.
   void LoadSchema(const std::string& name, const base::StringPiece& schema);
 
-  // Map from each API that hasn't been loaded yet to the schema which defines
-  // it. Note that there may be multiple APIs per schema.
-  typedef std::map<std::string, int> UnloadedSchemaMap;
-  UnloadedSchemaMap unloaded_schemas_;
-
   // Schemas for each namespace.
   using SchemaMap =
       std::map<std::string, std::unique_ptr<const base::DictionaryValue>>;
   SchemaMap schemas_;
 
   // FeatureProviders used for resolving dependencies.
   typedef std::map<std::string, const FeatureProvider*> FeatureProviderMap;
   FeatureProviderMap dependency_providers_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionAPI);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_EXTENSION_API_H_