[Extensions] Remove mechanism for non-generated schemas

chrome/common/extensions/api/common_extension_api_unittest.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 "extensions/common/extension_api.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 20 matching lines @@
 
 namespace extensions {
 
 namespace {
 
 const char* const kTestFeatures[] = {
     "test1", "test2", "test3",   "test4",   "test5",
     "test6", "test7", "parent1", "parent2", "parent3",
 };
 
-UnittestFeatureProvider api_feature_provider;
-}
+class TestExtensionAPI : public ExtensionAPI {
+ public:
+  TestExtensionAPI() {}
+  ~TestExtensionAPI() override {}
+
+  void add_fake_schema(const std::string& name) { fake_schemas_.insert(name); }
+
+ private:
+  bool IsKnownAPI(const std::string& name, ExtensionsClient* client) override {
+    return fake_schemas_.count(name) != 0;
+  }
+
+  std::set<std::string> fake_schemas_;
+  DISALLOW_COPY_AND_ASSIGN(TestExtensionAPI);
+};
+
+}  // namespace
 
 using test_util::BuildExtension;
 
 TEST(ExtensionAPITest, Creation) {
   ExtensionAPI* shared_instance = ExtensionAPI::GetSharedInstance();
   EXPECT_EQ(shared_instance, ExtensionAPI::GetSharedInstance());
 
   std::unique_ptr<ExtensionAPI> new_instance(
       ExtensionAPI::CreateWithDefaultConfiguration());
   EXPECT_NE(new_instance.get(),
@@ skipping 110 matching lines @@
     { "parent3.noparent.child", true, Feature::CONTENT_SCRIPT_CONTEXT, GURL() },
     { "parent3.noparent.child", true, Feature::BLESSED_EXTENSION_CONTEXT,
         GURL() },
     { "parent3.noparent.child", true, Feature::UNBLESSED_EXTENSION_CONTEXT,
         GURL() }
   };
 
   UnittestFeatureProvider api_feature_provider;
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
-    ExtensionAPI api;
+    TestExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (const auto& key : kTestFeatures)
-      api.RegisterSchemaResource(key, 0);
+      api.add_fake_schema(key);
     ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
     bool expected = test_data[i].expect_is_available;
     Feature::Availability availability =
         api.IsAvailable(test_data[i].api_full_name,
                         NULL,
                         test_data[i].context,
                         test_data[i].url);
     EXPECT_EQ(expected, availability.is_available())
         << base::StringPrintf("Test %d: Feature '%s' was %s: %s",
@@ skipping 54 matching lines @@
     { "test4.foo", true, Feature::CONTENT_SCRIPT_CONTEXT, NULL, GURL() },
     { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL,
         GURL("http://google.com") },
     { "test7", true, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://foo.com") },
     { "test7", false, Feature::WEB_PAGE_CONTEXT, NULL, GURL("http://bar.com") }
   };
 
   UnittestFeatureProvider api_feature_provider;
 
   for (size_t i = 0; i < arraysize(test_data); ++i) {
-    ExtensionAPI api;
+    TestExtensionAPI api;
     api.RegisterDependencyProvider("api", &api_feature_provider);
     for (const auto& key : kTestFeatures)
-      api.RegisterSchemaResource(key, 0);
+      api.add_fake_schema(key);
     ExtensionAPI::OverrideSharedInstanceForTest scope(&api);
 
     Feature* test_feature =
         api_feature_provider.GetFeature(test_data[i].api_full_name);
     ASSERT_TRUE(test_feature);
     EXPECT_EQ(test_data[i].expect_is_available,
               api.IsAnyFeatureAvailableToContext(*test_feature,
                                                  test_data[i].extension,
                                                  test_data[i].context,
                                                  test_data[i].url))
@@ skipping 396 matching lines @@
   base::FilePath manifest_path;
   PathService::Get(chrome::DIR_TEST_DATA, &manifest_path);
   manifest_path = manifest_path.AppendASCII("extensions")
       .AppendASCII("extension_api_unittest")
       .AppendASCII("types_have_namespace.json");
 
   std::string manifest_str;
   ASSERT_TRUE(base::ReadFileToString(manifest_path, &manifest_str))
       << "Failed to load: " << manifest_path.value();
 
-  ExtensionAPI api;
-  api.RegisterSchemaResource("test.foo", 0);
+  TestExtensionAPI api;
+  api.add_fake_schema("test.foo");
   api.LoadSchema("test.foo", manifest_str);
 
   const base::DictionaryValue* schema = api.GetSchema("test.foo");
 
   const base::DictionaryValue* dict;
   const base::DictionaryValue* sub_dict;
   std::string type;
 
   GetDictionaryFromList(schema, "types", 0, &dict);
   EXPECT_TRUE(dict->GetString("id", &type));
@@ skipping 112 matching lines @@
                                          extension.get(),
                                          Feature::BLESSED_EXTENSION_CONTEXT,
                                          GURL()).is_available());
   EXPECT_FALSE(extension_api->IsAvailable("pageAction",
                                           extension.get(),
                                           Feature::BLESSED_EXTENSION_CONTEXT,
                                           GURL()).is_available());
 }
 
 }  // namespace extensions