[Extensions] Introduce an ExtensionsAPIProvider

Introduce an ExtensionsAPIProvider that contains knowledge of
generated APIs and extension features. The ExtensionsClient
contains multiple ExtensionsAPIProviders, and queries these
providers for features and generated API schemas. This allows the
registration of APIs from outside the extensions system, which will
be necessary for moving Chrome Apps API registration outside of
extensions code. This also more effectively wraps the logic relating
to the generated features within a single location, minimizing the
burden for consumers to add/check multiple generated sets.

Create an API Provider for each set of code that generates unique
features and APIs:
- Core Extension APIs (defined in //extensions)
- Chrome Extension APIs (defined in //chrome)
- Shell Extension APIs (defined in //extensions/shell)
- Cast Extension APIs (defined in //chromecast)

When the corresponding ExtensionsClient type is constructed, it
registers the appropriate providers.

Bug: 873937
Change-Id: I198e5e5cbd6ab53bff9e335ea1551bdcfe59f521
Reviewed-on: https://chromium-review.googlesource.com/1172000Reviewed-by: Dominick Ng <dominickn@chromium.org>
Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Reviewed-by: Istiaque Ahmed <lazyboy@chromium.org>
Commit-Queue: Devlin <rdevlin.cronin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#584571}

chrome/common/BUILD.gn

@@ -326,6 +326,8 @@ static_library("common") {
       "extensions/chrome_aliases.cc",
       "extensions/chrome_aliases.h",
       "extensions/chrome_extension_messages.h",
+      "extensions/chrome_extensions_api_provider.cc",
+      "extensions/chrome_extensions_api_provider.h",
       "extensions/chrome_extensions_client.cc",
       "extensions/chrome_extensions_client.h",
       "extensions/chrome_manifest_handlers.cc",
@@ -379,6 +381,7 @@ static_library("common") {
       "//device/usb",
       "//extensions:extensions_resources",
       "//extensions/common",
+      "//extensions/common:core_api_provider",
       "//extensions/common/api",
       "//extensions/strings",
       "//media/cast:net",

chrome/common/extensions/chrome_extensions_api_provider.cc

+// Copyright 2018 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 "chrome/common/extensions/chrome_extensions_api_provider.h"
+
+#include "chrome/common/extensions/api/api_features.h"
+#include "chrome/common/extensions/api/generated_schemas.h"
+#include "chrome/common/extensions/api/manifest_features.h"
+#include "chrome/common/extensions/api/permission_features.h"
+#include "chrome/grit/common_resources.h"
+#include "extensions/common/features/json_feature_provider_source.h"
+
+namespace extensions {
+
+ChromeExtensionsAPIProvider::ChromeExtensionsAPIProvider() = default;
+ChromeExtensionsAPIProvider::~ChromeExtensionsAPIProvider() = default;
+
+void ChromeExtensionsAPIProvider::AddAPIFeatures(FeatureProvider* provider) {
+  AddChromeAPIFeatures(provider);
+}
+
+void ChromeExtensionsAPIProvider::AddManifestFeatures(
+    FeatureProvider* provider) {
+  AddChromeManifestFeatures(provider);
+}
+
+void ChromeExtensionsAPIProvider::AddPermissionFeatures(
+    FeatureProvider* provider) {
+  AddChromePermissionFeatures(provider);
+}
+
+void ChromeExtensionsAPIProvider::AddBehaviorFeatures(
+    FeatureProvider* provider) {
+  // Note: No chrome-specific behavior features.
+}
+
+void ChromeExtensionsAPIProvider::AddAPIJSONSources(
+    JSONFeatureProviderSource* json_source) {
+  json_source->LoadJSON(IDR_CHROME_EXTENSION_API_FEATURES);
+}
+
+bool ChromeExtensionsAPIProvider::IsAPISchemaGenerated(
+    const std::string& name) {
+  return api::ChromeGeneratedSchemas::IsGenerated(name);
+}
+
+base::StringPiece ChromeExtensionsAPIProvider::GetAPISchema(
+    const std::string& name) {
+  return api::ChromeGeneratedSchemas::Get(name);
+}
+
+}  // namespace extensions

chrome/common/extensions/chrome_extensions_api_provider.h

+// Copyright 2018 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 CHROME_COMMON_EXTENSIONS_CHROME_EXTENSIONS_API_PROVIDER_H_
+#define CHROME_COMMON_EXTENSIONS_CHROME_EXTENSIONS_API_PROVIDER_H_
+
+#include "base/macros.h"
+#include "extensions/common/extensions_api_provider.h"
+
+namespace extensions {
+
+class ChromeExtensionsAPIProvider : public ExtensionsAPIProvider {
+ public:
+  ChromeExtensionsAPIProvider();
+  ~ChromeExtensionsAPIProvider() override;
+
+  // ExtensionsAPIProvider:
+  void AddAPIFeatures(FeatureProvider* provider) override;
+  void AddManifestFeatures(FeatureProvider* provider) override;
+  void AddPermissionFeatures(FeatureProvider* provider) override;
+  void AddBehaviorFeatures(FeatureProvider* provider) override;
+  void AddAPIJSONSources(JSONFeatureProviderSource* json_source) override;
+  bool IsAPISchemaGenerated(const std::string& name) override;
+  base::StringPiece GetAPISchema(const std::string& name) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ChromeExtensionsAPIProvider);
+};
+
+}  // namespace extensions
+
+#endif  // CHROME_COMMON_EXTENSIONS_CHROME_EXTENSIONS_API_PROVIDER_H_

chrome/common/extensions/chrome_extensions_client.cc

@@ -15,34 +15,24 @@
 #include "base/values.h"
 #include "chrome/common/chrome_content_client.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/extensions/api/api_features.h"
 #include "chrome/common/extensions/api/extension_action/action_info.h"
-#include "chrome/common/extensions/api/generated_schemas.h"
-#include "chrome/common/extensions/api/manifest_features.h"
-#include "chrome/common/extensions/api/permission_features.h"
 #include "chrome/common/extensions/chrome_aliases.h"
+#include "chrome/common/extensions/chrome_extensions_api_provider.h"
 #include "chrome/common/extensions/chrome_manifest_handlers.h"
 #include "chrome/common/extensions/manifest_handlers/theme_handler.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
-#include "chrome/grit/common_resources.h"
 #include "components/version_info/version_info.h"
 #include "content/public/common/url_constants.h"
-#include "extensions/common/api/api_features.h"
-#include "extensions/common/api/behavior_features.h"
-#include "extensions/common/api/generated_schemas.h"
-#include "extensions/common/api/manifest_features.h"
-#include "extensions/common/api/permission_features.h"
 #include "extensions/common/common_manifest_handlers.h"
 #include "extensions/common/constants.h"
+#include "extensions/common/core_extensions_api_provider.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_api.h"
 #include "extensions/common/extension_icon_set.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/extensions_aliases.h"
 #include "extensions/common/features/feature_channel.h"
-#include "extensions/common/features/feature_provider.h"
-#include "extensions/common/features/json_feature_provider_source.h"
 #include "extensions/common/manifest_constants.h"
 #include "extensions/common/manifest_handler.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
@@ -50,7 +40,6 @@
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
-#include "extensions/grit/extensions_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
@@ -96,7 +85,10 @@ ChromeChannelForHistogram GetChromeChannelForHistogram(
 
 }  // namespace
 
-ChromeExtensionsClient::ChromeExtensionsClient() {}
+ChromeExtensionsClient::ChromeExtensionsClient() {
+  AddAPIProvider(std::make_unique<ChromeExtensionsAPIProvider>());
+  AddAPIProvider(std::make_unique<CoreExtensionsAPIProvider>());
+}
 
 ChromeExtensionsClient::~ChromeExtensionsClient() {
 }
@@ -153,36 +145,6 @@ const std::string ChromeExtensionsClient::GetProductName() {
   return l10n_util::GetStringUTF8(IDS_PRODUCT_NAME);
 }
 
-std::unique_ptr<FeatureProvider> ChromeExtensionsClient::CreateFeatureProvider(
-    const std::string& name) const {
-  auto provider = std::make_unique<FeatureProvider>();
-  if (name == "api") {
-    AddCoreAPIFeatures(provider.get());
-    AddChromeAPIFeatures(provider.get());
-  } else if (name == "manifest") {
-    AddCoreManifestFeatures(provider.get());
-    AddChromeManifestFeatures(provider.get());
-  } else if (name == "permission") {
-    AddCorePermissionFeatures(provider.get());
-    AddChromePermissionFeatures(provider.get());
-  } else if (name == "behavior") {
-    // Note: There are no chrome-specific behavior features.
-    AddCoreBehaviorFeatures(provider.get());
-  } else {
-    NOTREACHED();
-  }
-  return provider;
-}
-
-std::unique_ptr<JSONFeatureProviderSource>
-ChromeExtensionsClient::CreateAPIFeatureSource() const {
-  std::unique_ptr<JSONFeatureProviderSource> source(
-      new JSONFeatureProviderSource("api"));
-  source->LoadJSON(IDR_EXTENSION_API_FEATURES);
-  source->LoadJSON(IDR_CHROME_EXTENSION_API_FEATURES);
-  return source;
-}
-
 void ChromeExtensionsClient::FilterHostPermissions(
     const URLPatternSet& hosts,
     URLPatternSet* new_hosts,
@@ -254,23 +216,6 @@ bool ChromeExtensionsClient::IsScriptableURL(
   return true;
 }
 
-bool ChromeExtensionsClient::IsAPISchemaGenerated(
-    const std::string& name) const {
-  // Test from most common to least common.
-  return api::ChromeGeneratedSchemas::IsGenerated(name) ||
-         api::GeneratedSchemas::IsGenerated(name);
-}
-
-base::StringPiece ChromeExtensionsClient::GetAPISchema(
-    const std::string& name) const {
-  // Test from most common to least common.
-  base::StringPiece chrome_schema = api::ChromeGeneratedSchemas::Get(name);
-  if (!chrome_schema.empty())
-    return chrome_schema;
-
-  return api::GeneratedSchemas::Get(name);
-}
-
 bool ChromeExtensionsClient::ShouldSuppressFatalErrors() const {
   // Suppress fatal everywhere until the cause of bugs like http://crbug/471599
   // are fixed. This would typically be:

chrome/common/extensions/chrome_extensions_client.h

@@ -31,10 +31,6 @@ class ChromeExtensionsClient : public ExtensionsClient {
   const PermissionMessageProvider& GetPermissionMessageProvider()
       const override;
   const std::string GetProductName() override;
-  std::unique_ptr<FeatureProvider> CreateFeatureProvider(
-      const std::string& name) const override;
-  std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource()
-      const override;
   void FilterHostPermissions(const URLPatternSet& hosts,
                              URLPatternSet* new_hosts,
                              PermissionIDSet* permissions) const override;
@@ -44,8 +40,6 @@ class ChromeExtensionsClient : public ExtensionsClient {
       const Extension* extension,
       const APIPermissionSet& api_permissions) const override;
   bool IsScriptableURL(const GURL& url, std::string* error) const override;
-  bool IsAPISchemaGenerated(const std::string& name) const override;
-  base::StringPiece GetAPISchema(const std::string& name) const override;
   bool ShouldSuppressFatalErrors() const override;
   void RecordDidSuppressFatalError() override;
   const GURL& GetWebstoreBaseURL() const override;

chromecast/common/BUILD.gn

@@ -28,6 +28,8 @@ cast_source_set("common") {
 
   if (enable_chromecast_extensions) {
     sources += [
+      "cast_extensions_api_provider.cc",
+      "cast_extensions_api_provider.h",
       "cast_extensions_client.cc",
       "cast_extensions_client.h",
       "cast_redirect_manifest_handler.cc",
@@ -46,6 +48,7 @@ cast_source_set("common") {
       "//components/version_info",
       "//extensions:extensions_resources_grd_grit",
       "//extensions/common",
+      "//extensions/common:core_api_provider",
       "//extensions/common/api",
       "//extensions/shell:resources",
       "//extensions/shell:resources_grit",

chromecast/common/cast_extensions_api_provider.cc

+// Copyright 2018 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 "chromecast/common/cast_extensions_api_provider.h"
+
+#include "chromecast/common/extensions_api/cast_api_features.h"
+#include "chromecast/common/extensions_api/cast_api_permissions.h"
+#include "chromecast/common/extensions_api/cast_manifest_features.h"
+#include "chromecast/common/extensions_api/cast_permission_features.h"
+#include "chromecast/common/extensions_api/generated_schemas.h"
+#include "extensions/common/features/json_feature_provider_source.h"
+#include "extensions/shell/grit/app_shell_resources.h"
+
+namespace extensions {
+
+CastExtensionsAPIProvider::CastExtensionsAPIProvider() = default;
+CastExtensionsAPIProvider::~CastExtensionsAPIProvider() = default;
+
+void CastExtensionsAPIProvider::AddAPIFeatures(FeatureProvider* provider) {
+  AddCastAPIFeatures(provider);
+}
+
+void CastExtensionsAPIProvider::AddManifestFeatures(FeatureProvider* provider) {
+  AddCastManifestFeatures(provider);
+}
+
+void CastExtensionsAPIProvider::AddPermissionFeatures(
+    FeatureProvider* provider) {
+  AddCastPermissionFeatures(provider);
+}
+
+void CastExtensionsAPIProvider::AddBehaviorFeatures(FeatureProvider* provider) {
+  // Note: No cast-specific behavior features.
+}
+
+void CastExtensionsAPIProvider::AddAPIJSONSources(
+    JSONFeatureProviderSource* json_source) {
+  json_source->LoadJSON(IDR_SHELL_EXTENSION_API_FEATURES);
+}
+
+bool CastExtensionsAPIProvider::IsAPISchemaGenerated(const std::string& name) {
+  return cast::api::CastGeneratedSchemas::IsGenerated(name);
+}
+
+base::StringPiece CastExtensionsAPIProvider::GetAPISchema(
+    const std::string& name) {
+  return cast::api::CastGeneratedSchemas::Get(name);
+}
+
+}  // namespace extensions

chromecast/common/cast_extensions_api_provider.h

+// Copyright 2018 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 CHROMECAST_COMMON_CAST_EXTENSIONS_API_PROVIDER_H_
+#define CHROMECAST_COMMON_CAST_EXTENSIONS_API_PROVIDER_H_
+
+#include "base/macros.h"
+#include "extensions/common/extensions_api_provider.h"
+
+namespace extensions {
+
+class CastExtensionsAPIProvider : public ExtensionsAPIProvider {
+ public:
+  CastExtensionsAPIProvider();
+  ~CastExtensionsAPIProvider() override;
+
+  // ExtensionsAPIProvider:
+  void AddAPIFeatures(FeatureProvider* provider) override;
+  void AddManifestFeatures(FeatureProvider* provider) override;
+  void AddPermissionFeatures(FeatureProvider* provider) override;
+  void AddBehaviorFeatures(FeatureProvider* provider) override;
+  void AddAPIJSONSources(JSONFeatureProviderSource* json_source) override;
+  bool IsAPISchemaGenerated(const std::string& name) override;
+  base::StringPiece GetAPISchema(const std::string& name) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CastExtensionsAPIProvider);
+};
+
+}  // namespace extensions
+
+#endif  // CHROMECAST_COMMON_CAST_EXTENSIONS_API_PROVIDER_H_

chromecast/common/cast_extensions_client.cc

@@ -10,13 +10,9 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/no_destructor.h"
+#include "chromecast/common/cast_extensions_api_provider.h"
 #include "chromecast/common/cast_redirect_manifest_handler.h"
 #include "chromecast/common/extensions_api/cast_aliases.h"
-#include "chromecast/common/extensions_api/cast_api_features.h"
-#include "chromecast/common/extensions_api/cast_api_permissions.h"
-#include "chromecast/common/extensions_api/cast_manifest_features.h"
-#include "chromecast/common/extensions_api/cast_permission_features.h"
-#include "chromecast/common/extensions_api/generated_schemas.h"
 #include "components/version_info/version_info.h"
 #include "content/public/common/user_agent.h"
 #include "extensions/common/api/api_features.h"
@@ -25,10 +21,10 @@
 #include "extensions/common/api/manifest_features.h"
 #include "extensions/common/api/permission_features.h"
 #include "extensions/common/common_manifest_handlers.h"
+#include "extensions/common/core_extensions_api_provider.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/extensions_aliases.h"
 #include "extensions/common/features/feature_provider.h"
-#include "extensions/common/features/json_feature_provider_source.h"
 #include "extensions/common/features/manifest_feature.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest_handler.h"
@@ -38,8 +34,6 @@
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/permissions/permissions_provider.h"
 #include "extensions/common/url_pattern_set.h"
-#include "extensions/grit/extensions_resources.h"
-#include "extensions/shell/grit/app_shell_resources.h"
 
 namespace extensions {
 
@@ -88,7 +82,10 @@ class ShellPermissionMessageProvider : public PermissionMessageProvider {
 CastExtensionsClient::CastExtensionsClient()
     : extensions_api_permissions_(ExtensionsAPIPermissions()),
       webstore_base_url_(extension_urls::kChromeWebstoreBaseURL),
-      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {}
+      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {
+  AddAPIProvider(std::make_unique<CoreExtensionsAPIProvider>());
+  AddAPIProvider(std::make_unique<CastExtensionsAPIProvider>());
+}
 
 CastExtensionsClient::~CastExtensionsClient() {}
 
@@ -119,36 +116,6 @@ const std::string CastExtensionsClient::GetProductName() {
   return "cast_shell";
 }
 
-std::unique_ptr<FeatureProvider> CastExtensionsClient::CreateFeatureProvider(
-    const std::string& name) const {
-  auto provider = std::make_unique<FeatureProvider>();
-  if (name == "api") {
-    AddCoreAPIFeatures(provider.get());
-    AddCastAPIFeatures(provider.get());
-  } else if (name == "manifest") {
-    AddCoreManifestFeatures(provider.get());
-    AddCastManifestFeatures(provider.get());
-  } else if (name == "permission") {
-    AddCorePermissionFeatures(provider.get());
-    AddCastPermissionFeatures(provider.get());
-  } else if (name == "behavior") {
-    // Note: There are no cast-specific behavior features.
-    AddCoreBehaviorFeatures(provider.get());
-  } else {
-    NOTREACHED();
-  }
-  return provider;
-}
-
-std::unique_ptr<JSONFeatureProviderSource>
-CastExtensionsClient::CreateAPIFeatureSource() const {
-  std::unique_ptr<JSONFeatureProviderSource> source(
-      new JSONFeatureProviderSource("api"));
-  source->LoadJSON(IDR_EXTENSION_API_FEATURES);
-  source->LoadJSON(IDR_SHELL_EXTENSION_API_FEATURES);
-  return source;
-}
-
 void CastExtensionsClient::FilterHostPermissions(
     const URLPatternSet& hosts,
     URLPatternSet* new_hosts,
@@ -180,21 +147,6 @@ bool CastExtensionsClient::IsScriptableURL(const GURL& url,
   return true;
 }
 
-bool CastExtensionsClient::IsAPISchemaGenerated(const std::string& name) const {
-  return api::GeneratedSchemas::IsGenerated(name) ||
-         cast::api::CastGeneratedSchemas::IsGenerated(name);
-}
-
-base::StringPiece CastExtensionsClient::GetAPISchema(
-    const std::string& name) const {
-  // Schema for cast_shell-only APIs.
-  if (cast::api::CastGeneratedSchemas::IsGenerated(name))
-    return cast::api::CastGeneratedSchemas::Get(name);
-
-  // Core extensions APIs.
-  return api::GeneratedSchemas::Get(name);
-}
-
 bool CastExtensionsClient::ShouldSuppressFatalErrors() const {
   return true;
 }

chromecast/common/cast_extensions_client.h

@@ -26,10 +26,6 @@ class CastExtensionsClient : public ExtensionsClient {
   const PermissionMessageProvider& GetPermissionMessageProvider()
       const override;
   const std::string GetProductName() override;
-  std::unique_ptr<FeatureProvider> CreateFeatureProvider(
-      const std::string& name) const override;
-  std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource()
-      const override;
   void FilterHostPermissions(const URLPatternSet& hosts,
                              URLPatternSet* new_hosts,
                              PermissionIDSet* permissions) const override;
@@ -39,8 +35,6 @@ class CastExtensionsClient : public ExtensionsClient {
       const Extension* extension,
       const APIPermissionSet& api_permissions) const override;
   bool IsScriptableURL(const GURL& url, std::string* error) const override;
-  bool IsAPISchemaGenerated(const std::string& name) const override;
-  base::StringPiece GetAPISchema(const std::string& name) const override;
   bool ShouldSuppressFatalErrors() const override;
   void RecordDidSuppressFatalError() override;
   const GURL& GetWebstoreBaseURL() const override;

extensions/BUILD.gn

@@ -145,6 +145,7 @@ jumbo_static_library("test_support") {
     "//extensions/browser:test_support",
     "//extensions/browser/api:api_registration",
     "//extensions/common",
+    "//extensions/common:core_api_provider",
     "//extensions/common/api",
     "//extensions/common/api:extensions_features",
     "//net:test_support",

extensions/common/BUILD.gn

@@ -356,6 +356,21 @@ if (enable_extensions) {
     }
   }
 
+  # NOTE: This is separate from ":common" because it depends on
+  # extensions/common/api:extensions_features, which in turn depends on
+  # :common.
+  source_set("core_api_provider") {
+    sources = [
+      "core_extensions_api_provider.cc",
+      "core_extensions_api_provider.h",
+    ]
+
+    deps = [
+      ":common",
+      "//extensions/common/api:extensions_features",
+    ]
+  }
+
   source_set("test_support") {
     testonly = true
 

extensions/common/core_extensions_api_provider.cc

+// Copyright 2018 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/core_extensions_api_provider.h"
+
+#include "extensions/common/api/api_features.h"
+#include "extensions/common/api/behavior_features.h"
+#include "extensions/common/api/generated_schemas.h"
+#include "extensions/common/api/manifest_features.h"
+#include "extensions/common/api/permission_features.h"
+#include "extensions/common/features/json_feature_provider_source.h"
+#include "extensions/grit/extensions_resources.h"
+
+namespace extensions {
+
+CoreExtensionsAPIProvider::CoreExtensionsAPIProvider() = default;
+CoreExtensionsAPIProvider::~CoreExtensionsAPIProvider() = default;
+
+void CoreExtensionsAPIProvider::AddAPIFeatures(FeatureProvider* provider) {
+  AddCoreAPIFeatures(provider);
+}
+
+void CoreExtensionsAPIProvider::AddManifestFeatures(FeatureProvider* provider) {
+  AddCoreManifestFeatures(provider);
+}
+
+void CoreExtensionsAPIProvider::AddPermissionFeatures(
+    FeatureProvider* provider) {
+  AddCorePermissionFeatures(provider);
+}
+
+void CoreExtensionsAPIProvider::AddBehaviorFeatures(FeatureProvider* provider) {
+  AddCoreBehaviorFeatures(provider);
+}
+
+void CoreExtensionsAPIProvider::AddAPIJSONSources(
+    JSONFeatureProviderSource* json_source) {
+  json_source->LoadJSON(IDR_EXTENSION_API_FEATURES);
+}
+
+bool CoreExtensionsAPIProvider::IsAPISchemaGenerated(const std::string& name) {
+  return api::GeneratedSchemas::IsGenerated(name);
+}
+
+base::StringPiece CoreExtensionsAPIProvider::GetAPISchema(
+    const std::string& name) {
+  return api::GeneratedSchemas::Get(name);
+}
+
+}  // namespace extensions

extensions/common/core_extensions_api_provider.h

+// Copyright 2018 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_CORE_EXTENSIONS_API_PROVIDER_H_
+#define EXTENSIONS_COMMON_CORE_EXTENSIONS_API_PROVIDER_H_
+
+#include "base/macros.h"
+#include "extensions/common/extensions_api_provider.h"
+
+namespace extensions {
+
+class CoreExtensionsAPIProvider : public ExtensionsAPIProvider {
+ public:
+  CoreExtensionsAPIProvider();
+  ~CoreExtensionsAPIProvider() override;
+
+  // ExtensionsAPIProvider:
+  void AddAPIFeatures(FeatureProvider* provider) override;
+  void AddManifestFeatures(FeatureProvider* provider) override;
+  void AddPermissionFeatures(FeatureProvider* provider) override;
+  void AddBehaviorFeatures(FeatureProvider* provider) override;
+  void AddAPIJSONSources(JSONFeatureProviderSource* json_source) override;
+  bool IsAPISchemaGenerated(const std::string& name) override;
+  base::StringPiece GetAPISchema(const std::string& name) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CoreExtensionsAPIProvider);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_COMMON_CORE_EXTENSIONS_API_PROVIDER_H_

extensions/common/extensions_api_provider.h

+// Copyright 2018 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_EXTENSIONS_API_PROVIDER_H_
+#define EXTENSIONS_COMMON_EXTENSIONS_API_PROVIDER_H_
+
+#include <string>
+
+#include "base/macros.h"
+#include "base/strings/string_piece_forward.h"
+
+namespace extensions {
+class FeatureProvider;
+class JSONFeatureProviderSource;
+
+// A class to provide API-specific bits and bobs to the extensions system.
+// This allows for composition of multiple providers, so that we can easily
+// selectively add features in different configurations.
+class ExtensionsAPIProvider {
+ public:
+  ExtensionsAPIProvider() {}
+  virtual ~ExtensionsAPIProvider() {}
+
+  // Adds feature definitions to the given |provider| of the specified type.
+  virtual void AddAPIFeatures(FeatureProvider* provider) = 0;
+  virtual void AddManifestFeatures(FeatureProvider* provider) = 0;
+  virtual void AddPermissionFeatures(FeatureProvider* provider) = 0;
+  virtual void AddBehaviorFeatures(FeatureProvider* provider) = 0;
+
+  // Adds resources containing the JSON API definitions.
+  virtual void AddAPIJSONSources(JSONFeatureProviderSource* json_source) = 0;
+
+  // Returns true if this provider knows about a generated schema for the given
+  // api |name|.
+  virtual bool IsAPISchemaGenerated(const std::string& name) = 0;
+
+  // Returns a the contents of the generated schema for the given api |name|,
+  // or an empty string if this provider doesn't know of the generated API.
+  virtual base::StringPiece GetAPISchema(const std::string& name) = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ExtensionsAPIProvider);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_COMMON_EXTENSIONS_API_PROVIDER_H_

extensions/common/extensions_client.cc

@@ -6,6 +6,9 @@
 
 #include "base/logging.h"
 #include "extensions/common/extension_icon_set.h"
+#include "extensions/common/extensions_api_provider.h"
+#include "extensions/common/features/feature_provider.h"
+#include "extensions/common/features/json_feature_provider_source.h"
 #include "extensions/common/manifest_handlers/icons_handler.h"
 
 namespace extensions {
@@ -21,10 +24,74 @@ ExtensionsClient* ExtensionsClient::Get() {
   return g_client;
 }
 
+void ExtensionsClient::Set(ExtensionsClient* client) {
+  // This can happen in unit tests, where the utility thread runs in-process.
+  if (g_client)
+    return;
+  g_client = client;
+  g_client->Initialize();
+}
+
+ExtensionsClient::ExtensionsClient() = default;
+ExtensionsClient::~ExtensionsClient() = default;
+
+std::unique_ptr<FeatureProvider> ExtensionsClient::CreateFeatureProvider(
+    const std::string& name) const {
+  auto feature_provider = std::make_unique<FeatureProvider>();
+  using ProviderMethod = void (ExtensionsAPIProvider::*)(FeatureProvider*);
+  ProviderMethod method = nullptr;
+  if (name == "api") {
+    method = &ExtensionsAPIProvider::AddAPIFeatures;
+  } else if (name == "manifest") {
+    method = &ExtensionsAPIProvider::AddManifestFeatures;
+  } else if (name == "permission") {
+    method = &ExtensionsAPIProvider::AddPermissionFeatures;
+  } else if (name == "behavior") {
+    method = &ExtensionsAPIProvider::AddBehaviorFeatures;
+  } else {
+    NOTREACHED();
+  }
+  for (const auto& api_provider : api_providers_)
+    ((*api_provider).*method)(feature_provider.get());
+
+  return feature_provider;
+}
+
+std::unique_ptr<JSONFeatureProviderSource>
+ExtensionsClient::CreateAPIFeatureSource() const {
+  auto source = std::make_unique<JSONFeatureProviderSource>("api");
+  for (const auto& api_provider : api_providers_)
+    api_provider->AddAPIJSONSources(source.get());
+  return source;
+}
+
+bool ExtensionsClient::IsAPISchemaGenerated(const std::string& name) const {
+  for (const auto& provider : api_providers_) {
+    if (provider->IsAPISchemaGenerated(name))
+      return true;
+  }
+  return false;
+}
+
+base::StringPiece ExtensionsClient::GetAPISchema(
+    const std::string& name) const {
+  for (const auto& provider : api_providers_) {
+    base::StringPiece api = provider->GetAPISchema(name);
+    if (!api.empty())
+      return api;
+  }
+  return base::StringPiece();
+}
+
+void ExtensionsClient::AddAPIProvider(
+    std::unique_ptr<ExtensionsAPIProvider> provider) {
+  api_providers_.push_back(std::move(provider));
+}
+
 std::set<base::FilePath> ExtensionsClient::GetBrowserImagePaths(
     const Extension* extension) {
   std::set<base::FilePath> paths;
-  extensions::IconsInfo::GetIcons(extension).GetPaths(&paths);
+  IconsInfo::GetIcons(extension).GetPaths(&paths);
   return paths;
 }
 
@@ -36,12 +103,4 @@ std::string ExtensionsClient::GetUserAgent() const {
   return std::string();
 }
 
-void ExtensionsClient::Set(ExtensionsClient* client) {
-  // This can happen in unit tests, where the utility thread runs in-process.
-  if (g_client)
-    return;
-  g_client = client;
-  g_client->Initialize();
-}
-
 }  // namespace extensions

extensions/common/extensions_client.h

@@ -24,6 +24,7 @@ namespace extensions {
 
 class APIPermissionSet;
 class Extension;
+class ExtensionsAPIProvider;
 class FeatureProvider;
 class JSONFeatureProviderSource;
 class PermissionMessageProvider;
@@ -35,7 +36,34 @@ class ExtensionsClient {
  public:
   typedef std::vector<std::string> ScriptingWhitelist;
 
-  virtual ~ExtensionsClient() {}
+  // Return the extensions client.
+  static ExtensionsClient* Get();
+
+  // Initialize the extensions system with this extensions client.
+  static void Set(ExtensionsClient* client);
+
+  ExtensionsClient();
+  virtual ~ExtensionsClient();
+
+  // Create a FeatureProvider for a specific feature type, e.g. "permission".
+  std::unique_ptr<FeatureProvider> CreateFeatureProvider(
+      const std::string& name) const;
+
+  // Returns the dictionary of the API features json file.
+  // TODO(devlin): We should find a way to remove this.
+  std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource() const;
+
+  // Returns true iff a schema named |name| is generated.
+  bool IsAPISchemaGenerated(const std::string& name) const;
+
+  // Gets the generated API schema named |name|.
+  base::StringPiece GetAPISchema(const std::string& name) const;
+
+  // Adds a new API provider.
+  void AddAPIProvider(std::unique_ptr<ExtensionsAPIProvider> provider);
+
+  //////////////////////////////////////////////////////////////////////////////
+  // Virtual Functions:
 
   // Initializes global state. Not done in the constructor because unit tests
   // can create additional ExtensionsClients because the utility thread runs
@@ -54,15 +82,6 @@ class ExtensionsClient {
   // Returns the application name. For example, "Chromium" or "app_shell".
   virtual const std::string GetProductName() = 0;
 
-  // Create a FeatureProvider for a specific feature type, e.g. "permission".
-  virtual std::unique_ptr<FeatureProvider> CreateFeatureProvider(
-      const std::string& name) const = 0;
-
-  // Returns the dictionary of the API features json file.
-  // TODO(devlin): We should find a way to remove this.
-  virtual std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource()
-      const = 0;
-
   // Takes the list of all hosts and filters out those with special
   // permission strings. Adds the regular hosts to |new_hosts|,
   // and adds any additional permissions to |permissions|.
@@ -89,12 +108,6 @@ class ExtensionsClient {
   // Returns false if content scripts are forbidden from running on |url|.
   virtual bool IsScriptableURL(const GURL& url, std::string* error) const = 0;
 
-  // Returns true iff a schema named |name| is generated.
-  virtual bool IsAPISchemaGenerated(const std::string& name) const = 0;
-
-  // Gets the generated API schema named |name|.
-  virtual base::StringPiece GetAPISchema(const std::string& name) const = 0;
-
   // Determines if certain fatal extensions errors should be surpressed
   // (i.e., only logged) or allowed (i.e., logged before crashing).
   virtual bool ShouldSuppressFatalErrors() const = 0;
@@ -137,11 +150,10 @@ class ExtensionsClient {
   // Returns the user agent used by the content module.
   virtual std::string GetUserAgent() const;
 
-  // Return the extensions client.
-  static ExtensionsClient* Get();
+ private:
+  std::vector<std::unique_ptr<ExtensionsAPIProvider>> api_providers_;
 
-  // Initialize the extensions system with this extensions client.
-  static void Set(ExtensionsClient* client);
+  DISALLOW_COPY_AND_ASSIGN(ExtensionsClient);
 };
 
 }  // namespace extensions

extensions/shell/BUILD.gn

@@ -61,6 +61,7 @@ source_set("app_shell_lib") {
     "//extensions/browser/api:api_registration",
     "//extensions/browser/kiosk",
     "//extensions/common",
+    "//extensions/common:core_api_provider",
     "//extensions/common/api",
     "//extensions/renderer",
     "//extensions/shell/browser/system_logs",
@@ -170,6 +171,8 @@ source_set("app_shell_lib") {
     "browser/shell_web_view_guest_delegate.h",
     "common/shell_content_client.cc",
     "common/shell_content_client.h",
+    "common/shell_extensions_api_provider.cc",
+    "common/shell_extensions_api_provider.h",
     "common/shell_extensions_client.cc",
     "common/shell_extensions_client.h",
     "common/switches.cc",

extensions/shell/common/shell_extensions_api_provider.cc

+// Copyright 2018 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/shell/common/shell_extensions_api_provider.h"
+
+#include "extensions/common/features/json_feature_provider_source.h"
+#include "extensions/shell/common/api/generated_schemas.h"
+#include "extensions/shell/common/api/shell_api_features.h"
+#include "extensions/shell/grit/app_shell_resources.h"
+
+namespace extensions {
+
+ShellExtensionsAPIProvider::ShellExtensionsAPIProvider() = default;
+ShellExtensionsAPIProvider::~ShellExtensionsAPIProvider() = default;
+
+void ShellExtensionsAPIProvider::AddAPIFeatures(FeatureProvider* provider) {
+  AddShellAPIFeatures(provider);
+}
+
+void ShellExtensionsAPIProvider::AddManifestFeatures(
+    FeatureProvider* provider) {
+  // No shell-specific manifest features.
+}
+
+void ShellExtensionsAPIProvider::AddPermissionFeatures(
+    FeatureProvider* provider) {
+  // No shell-specific permission features.
+}
+
+void ShellExtensionsAPIProvider::AddBehaviorFeatures(
+    FeatureProvider* provider) {
+  // No shell-specific behavior features.
+}
+
+void ShellExtensionsAPIProvider::AddAPIJSONSources(
+    JSONFeatureProviderSource* json_source) {
+  json_source->LoadJSON(IDR_SHELL_EXTENSION_API_FEATURES);
+}
+
+bool ShellExtensionsAPIProvider::IsAPISchemaGenerated(const std::string& name) {
+  return shell::api::ShellGeneratedSchemas::IsGenerated(name);
+}
+
+base::StringPiece ShellExtensionsAPIProvider::GetAPISchema(
+    const std::string& name) {
+  return shell::api::ShellGeneratedSchemas::Get(name);
+}
+
+}  // namespace extensions

extensions/shell/common/shell_extensions_api_provider.h

+// Copyright 2018 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_SHELL_COMMON_SHELL_EXTENSIONS_API_PROVIDER_H_
+#define EXTENSIONS_SHELL_COMMON_SHELL_EXTENSIONS_API_PROVIDER_H_
+
+#include "base/macros.h"
+#include "extensions/common/extensions_api_provider.h"
+
+namespace extensions {
+
+class ShellExtensionsAPIProvider : public ExtensionsAPIProvider {
+ public:
+  ShellExtensionsAPIProvider();
+  ~ShellExtensionsAPIProvider() override;
+
+  // ExtensionsAPIProvider:
+  void AddAPIFeatures(FeatureProvider* provider) override;
+  void AddManifestFeatures(FeatureProvider* provider) override;
+  void AddPermissionFeatures(FeatureProvider* provider) override;
+  void AddBehaviorFeatures(FeatureProvider* provider) override;
+  void AddAPIJSONSources(JSONFeatureProviderSource* json_source) override;
+  bool IsAPISchemaGenerated(const std::string& name) override;
+  base::StringPiece GetAPISchema(const std::string& name) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ShellExtensionsAPIProvider);
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_SHELL_COMMON_SHELL_EXTENSIONS_API_PROVIDER_H_

extensions/shell/common/shell_extensions_client.cc

@@ -12,26 +12,17 @@
 #include "base/macros.h"
 #include "components/version_info/version_info.h"
 #include "content/public/common/user_agent.h"
-#include "extensions/common/api/api_features.h"
-#include "extensions/common/api/behavior_features.h"
-#include "extensions/common/api/generated_schemas.h"
-#include "extensions/common/api/manifest_features.h"
-#include "extensions/common/api/permission_features.h"
 #include "extensions/common/common_manifest_handlers.h"
+#include "extensions/common/core_extensions_api_provider.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/extensions_aliases.h"
-#include "extensions/common/features/feature_provider.h"
-#include "extensions/common/features/json_feature_provider_source.h"
 #include "extensions/common/features/simple_feature.h"
 #include "extensions/common/manifest_handler.h"
 #include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permissions_info.h"
 #include "extensions/common/permissions/permissions_provider.h"
 #include "extensions/common/url_pattern_set.h"
-#include "extensions/grit/extensions_resources.h"
-#include "extensions/shell/common/api/generated_schemas.h"
-#include "extensions/shell/common/api/shell_api_features.h"
-#include "extensions/shell/grit/app_shell_resources.h"
+#include "extensions/shell/common/shell_extensions_api_provider.h"
 
 namespace extensions {
 
@@ -76,7 +67,10 @@ base::LazyInstance<ShellPermissionMessageProvider>::DestructorAtExit
 ShellExtensionsClient::ShellExtensionsClient()
     : extensions_api_permissions_(ExtensionsAPIPermissions()),
       webstore_base_url_(extension_urls::kChromeWebstoreBaseURL),
-      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {}
+      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {
+  AddAPIProvider(std::make_unique<CoreExtensionsAPIProvider>());
+  AddAPIProvider(std::make_unique<ShellExtensionsAPIProvider>());
+}
 
 ShellExtensionsClient::~ShellExtensionsClient() {
 }
@@ -103,33 +97,6 @@ const std::string ShellExtensionsClient::GetProductName() {
   return "app_shell";
 }
 
-std::unique_ptr<FeatureProvider> ShellExtensionsClient::CreateFeatureProvider(
-    const std::string& name) const {
-  auto provider = std::make_unique<FeatureProvider>();
-  if (name == "api") {
-    AddCoreAPIFeatures(provider.get());
-    AddShellAPIFeatures(provider.get());
-  } else if (name == "manifest") {
-    AddCoreManifestFeatures(provider.get());
-  } else if (name == "permission") {
-    AddCorePermissionFeatures(provider.get());
-  } else if (name == "behavior") {
-    AddCoreBehaviorFeatures(provider.get());
-  } else {
-    NOTREACHED();
-  }
-  return provider;
-}
-
-std::unique_ptr<JSONFeatureProviderSource>
-ShellExtensionsClient::CreateAPIFeatureSource() const {
-  std::unique_ptr<JSONFeatureProviderSource> source(
-      new JSONFeatureProviderSource("api"));
-  source->LoadJSON(IDR_EXTENSION_API_FEATURES);
-  source->LoadJSON(IDR_SHELL_EXTENSION_API_FEATURES);
-  return source;
-}
-
 void ShellExtensionsClient::FilterHostPermissions(
     const URLPatternSet& hosts,
     URLPatternSet* new_hosts,
@@ -161,22 +128,6 @@ bool ShellExtensionsClient::IsScriptableURL(const GURL& url,
   return true;
 }
 
-bool ShellExtensionsClient::IsAPISchemaGenerated(
-    const std::string& name) const {
-  return api::GeneratedSchemas::IsGenerated(name) ||
-         shell::api::ShellGeneratedSchemas::IsGenerated(name);
-}
-
-base::StringPiece ShellExtensionsClient::GetAPISchema(
-    const std::string& name) const {
-  // Schema for app_shell-only APIs.
-  if (shell::api::ShellGeneratedSchemas::IsGenerated(name))
-    return shell::api::ShellGeneratedSchemas::Get(name);
-
-  // Core extensions APIs.
-  return api::GeneratedSchemas::Get(name);
-}
-
 bool ShellExtensionsClient::ShouldSuppressFatalErrors() const {
   return true;
 }

extensions/shell/common/shell_extensions_client.h

@@ -25,10 +25,6 @@ class ShellExtensionsClient : public ExtensionsClient {
   const PermissionMessageProvider& GetPermissionMessageProvider()
       const override;
   const std::string GetProductName() override;
-  std::unique_ptr<FeatureProvider> CreateFeatureProvider(
-      const std::string& name) const override;
-  std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource()
-      const override;
   void FilterHostPermissions(const URLPatternSet& hosts,
                              URLPatternSet* new_hosts,
                              PermissionIDSet* permissions) const override;
@@ -38,8 +34,6 @@ class ShellExtensionsClient : public ExtensionsClient {
       const Extension* extension,
       const APIPermissionSet& api_permissions) const override;
   bool IsScriptableURL(const GURL& url, std::string* error) const override;
-  bool IsAPISchemaGenerated(const std::string& name) const override;
-  base::StringPiece GetAPISchema(const std::string& name) const override;
   bool ShouldSuppressFatalErrors() const override;
   void RecordDidSuppressFatalError() override;
   const GURL& GetWebstoreBaseURL() const override;

extensions/test/test_extensions_client.cc

@@ -11,16 +11,10 @@
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/stl_util.h"
-#include "extensions/common/api/api_features.h"
-#include "extensions/common/api/behavior_features.h"
-#include "extensions/common/api/generated_schemas.h"
-#include "extensions/common/api/manifest_features.h"
-#include "extensions/common/api/permission_features.h"
 #include "extensions/common/common_manifest_handlers.h"
+#include "extensions/common/core_extensions_api_provider.h"
 #include "extensions/common/extension_urls.h"
 #include "extensions/common/extensions_aliases.h"
-#include "extensions/common/features/feature_provider.h"
-#include "extensions/common/features/json_feature_provider_source.h"
 #include "extensions/common/manifest_handler.h"
 #include "extensions/common/permissions/extensions_api_permissions.h"
 #include "extensions/common/permissions/permissions_info.h"
@@ -32,7 +26,9 @@ namespace extensions {
 
 TestExtensionsClient::TestExtensionsClient()
     : webstore_base_url_(extension_urls::kChromeWebstoreBaseURL),
-      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {}
+      webstore_update_url_(extension_urls::kChromeWebstoreUpdateURL) {
+  AddAPIProvider(std::make_unique<CoreExtensionsAPIProvider>());
+}
 
 TestExtensionsClient::~TestExtensionsClient() {
 }
@@ -81,31 +77,6 @@ const std::string TestExtensionsClient::GetProductName() {
   return "extensions_test";
 }
 
-std::unique_ptr<FeatureProvider> TestExtensionsClient::CreateFeatureProvider(
-    const std::string& name) const {
-  auto provider = std::make_unique<FeatureProvider>();
-  if (name == "api") {
-    AddCoreAPIFeatures(provider.get());
-  } else if (name == "manifest") {
-    AddCoreManifestFeatures(provider.get());
-  } else if (name == "permission") {
-    AddCorePermissionFeatures(provider.get());
-  } else if (name == "behavior") {
-    AddCoreBehaviorFeatures(provider.get());
-  } else {
-    NOTREACHED();
-  }
-  return provider;
-}
-
-std::unique_ptr<JSONFeatureProviderSource>
-TestExtensionsClient::CreateAPIFeatureSource() const {
-  std::unique_ptr<JSONFeatureProviderSource> source(
-      new JSONFeatureProviderSource("api"));
-  source->LoadJSON(IDR_EXTENSION_API_FEATURES);
-  return source;
-}
-
 void TestExtensionsClient::FilterHostPermissions(
     const URLPatternSet& hosts,
     URLPatternSet* new_hosts,
@@ -134,16 +105,6 @@ bool TestExtensionsClient::IsScriptableURL(const GURL& url,
   return true;
 }
 
-bool TestExtensionsClient::IsAPISchemaGenerated(
-    const std::string& name) const {
-  return api::GeneratedSchemas::IsGenerated(name);
-}
-
-base::StringPiece TestExtensionsClient::GetAPISchema(
-    const std::string& name) const {
-  return api::GeneratedSchemas::Get(name);
-}
-
 bool TestExtensionsClient::ShouldSuppressFatalErrors() const {
   return true;
 }

extensions/test/test_extensions_client.h

@@ -33,10 +33,6 @@ class TestExtensionsClient : public ExtensionsClient {
   const PermissionMessageProvider& GetPermissionMessageProvider()
       const override;
   const std::string GetProductName() override;
-  std::unique_ptr<FeatureProvider> CreateFeatureProvider(
-      const std::string& name) const override;
-  std::unique_ptr<JSONFeatureProviderSource> CreateAPIFeatureSource()
-      const override;
   void FilterHostPermissions(const URLPatternSet& hosts,
                              URLPatternSet* new_hosts,
                              PermissionIDSet* permissions) const override;
@@ -46,8 +42,6 @@ class TestExtensionsClient : public ExtensionsClient {
       const Extension* extension,
       const APIPermissionSet& api_permissions) const override;
   bool IsScriptableURL(const GURL& url, std::string* error) const override;
-  bool IsAPISchemaGenerated(const std::string& name) const override;
-  base::StringPiece GetAPISchema(const std::string& name) const override;
   bool ShouldSuppressFatalErrors() const override;
   void RecordDidSuppressFatalError() override;
   const GURL& GetWebstoreBaseURL() const override;