[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 47 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 33 matching lines @@
   // "<unknown-api>.monkey" -> ("", "")
   //
   // The |child_name| parameter can be be NULL if you don't need that part.
   std::string GetAPINameFromFullName(const std::string& full_name,
                                      std::string* child_name);
 
   // Gets a feature from any dependency provider registered with ExtensionAPI.
   // Returns NULL if the feature could not be found.
   Feature* GetFeatureDependency(const std::string& dependency_name);
 
+  // Adds a fake schema that the ExtensionAPI should know about.
+  void RegisterFakeSchemaForTesting(const std::string& schema);
+
  private:
   FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, DefaultConfigurationFeatures);
   FRIEND_TEST_ALL_PREFIXES(ExtensionAPITest, TypesHaveNamespace);
   friend struct base::DefaultSingletonTraits<ExtensionAPI>;
 
   void InitDefaultConfiguration();
 
   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_;
+  // A set of fake schema resources that we should treat as knowing for testing.
+  // TODO(devlin): This is rather silly.
+  std::set<std::string> fake_schemas_;

[Devlin, 2016/08/22 18:30:45]

I don't love this, but I also don't have a better idea that doesn't involve a
bunch of churn.  Open to suggestions. :)

[lazyboy, 2016/08/22 22:51:31]

I would put them in TestExtensionAPI (extending from ExtensionAPI) and use
instance of that class in unit test.

Then RegisterFakeSchemaForTesting method can go in that class.
We only ever need to read fake_schemas_ in
ExtensionAPI::GetAPINameFromFullName(),
so we can extract the "is known/valid api name" check into a virtual function,
e.g.
virtual bool ExtensionAPI::IsKnownAPI(const std::string& api_name) {
  return schemas_.find(api_name) != end ||
ExtensionsClient::Get()->IsAPISchemaGenerated(..);
}
bool TestExtensionAPI::IsKnownAPI(..string& name) override {
  return fake_schemas_.find != end;
}

Of course you'd need a test only class (more work), but keeps fake_schemas_ from
spreading out within the actual ExtensionAPI class.
WDYT?

[Devlin, 2016/08/23 00:13:08]

Works for me.  Still not my favorite, but I think this is probably one of those
"the perfect is the enemy of the good" type times.

Thanks for the idea :)

 
   // 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_