extensions/test/test_extensions_client.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/test/test_extensions_client.h"
   6
   7 #include "extensions/common/api/generated_schemas.h"
   8 #include "extensions/common/common_manifest_handlers.h"
   9 #include "extensions/common/extension_urls.h"
  10 #include "extensions/common/features/api_feature.h"
  11 #include "extensions/common/features/base_feature_provider.h"
  12 #include "extensions/common/features/behavior_feature.h"
  13 #include "extensions/common/features/feature_provider.h"
  14 #include "extensions/common/features/json_feature_provider_source.h"
  15 #include "extensions/common/features/manifest_feature.h"
  16 #include "extensions/common/features/permission_feature.h"
  17 #include "extensions/common/manifest_handler.h"
  18 #include "extensions/common/permissions/extensions_api_permissions.h"
  19 #include "extensions/common/permissions/permissions_info.h"
  20 #include "extensions/common/url_pattern_set.h"
  21 #include "extensions/test/test_permission_message_provider.h"
  22 #include "grit/extensions_resources.h"
  23
  24 namespace extensions {
  25
  26 namespace {
  27
  28 template <class FeatureClass>
  29 SimpleFeature* CreateFeature() {
  30   return new FeatureClass;
  31 }
  32
  33 }  // namespace
  34
  35 TestExtensionsClient::TestExtensionsClient() {
  36 }
  37
  38 TestExtensionsClient::~TestExtensionsClient() {
  39 }
  40
  41 void TestExtensionsClient::Initialize() {
  42   // Registration could already be finalized in unit tests, where the utility
  43   // thread runs in-process.
  44   if (!ManifestHandler::IsRegistrationFinalized()) {
  45     RegisterCommonManifestHandlers();
  46     ManifestHandler::FinalizeRegistration();
  47   }
  48
  49   // Allow the core API permissions.
  50   static ExtensionsAPIPermissions extensions_api_permissions;
  51   PermissionsInfo::GetInstance()->AddProvider(extensions_api_permissions);
  52 }
  53
  54 const PermissionMessageProvider&
  55 TestExtensionsClient::GetPermissionMessageProvider() const {
  56   static TestPermissionMessageProvider provider;
  57   return provider;
  58 }
  59
  60 const std::string TestExtensionsClient::GetProductName() {
  61   return "extensions_test";
  62 }
  63
  64 scoped_ptr<FeatureProvider> TestExtensionsClient::CreateFeatureProvider(
  65     const std::string& name) const {
  66   scoped_ptr<FeatureProvider> provider;
  67   scoped_ptr<JSONFeatureProviderSource> source(
  68       CreateFeatureProviderSource(name));
  69   if (name == "api") {
  70     provider.reset(new BaseFeatureProvider(source->dictionary(),
  71                                            CreateFeature<APIFeature>));
  72   } else if (name == "manifest") {
  73     provider.reset(new BaseFeatureProvider(source->dictionary(),
  74                                            CreateFeature<ManifestFeature>));
  75   } else if (name == "permission") {
  76     provider.reset(new BaseFeatureProvider(source->dictionary(),
  77                                            CreateFeature<PermissionFeature>));
  78   } else if (name == "behavior") {
  79     provider.reset(new BaseFeatureProvider(source->dictionary(),
  80                                            CreateFeature<BehaviorFeature>));
  81   } else {
  82     NOTREACHED();
  83   }
  84   return provider.Pass();
  85 }
  86
  87 scoped_ptr<JSONFeatureProviderSource>
  88 TestExtensionsClient::CreateFeatureProviderSource(
  89     const std::string& name) const {
  90   scoped_ptr<JSONFeatureProviderSource> source(
  91       new JSONFeatureProviderSource(name));
  92   if (name == "api") {
  93     source->LoadJSON(IDR_EXTENSION_API_FEATURES);
  94   } else if (name == "manifest") {
  95     source->LoadJSON(IDR_EXTENSION_MANIFEST_FEATURES);
  96   } else if (name == "permission") {
  97     source->LoadJSON(IDR_EXTENSION_PERMISSION_FEATURES);
  98   } else if (name == "behavior") {
  99     source->LoadJSON(IDR_EXTENSION_BEHAVIOR_FEATURES);
 100   } else {
 101     NOTREACHED();
 102     source.reset();
 103   }
 104   return source.Pass();
 105 }
 106
 107 void TestExtensionsClient::FilterHostPermissions(
 108     const URLPatternSet& hosts,
 109     URLPatternSet* new_hosts,
 110     std::set<PermissionMessage>* messages) const {
 111 }
 112
 113 void TestExtensionsClient::FilterHostPermissions(
 114     const URLPatternSet& hosts,
 115     URLPatternSet* new_hosts,
 116     PermissionIDSet* permissions) const {
 117 }
 118
 119 void TestExtensionsClient::SetScriptingWhitelist(
 120     const ExtensionsClient::ScriptingWhitelist& whitelist) {
 121   scripting_whitelist_ = whitelist;
 122 }
 123
 124 const ExtensionsClient::ScriptingWhitelist&
 125 TestExtensionsClient::GetScriptingWhitelist() const {
 126   return scripting_whitelist_;
 127 }
 128
 129 URLPatternSet TestExtensionsClient::GetPermittedChromeSchemeHosts(
 130     const Extension* extension,
 131     const APIPermissionSet& api_permissions) const {
 132   URLPatternSet hosts;
 133   return hosts;
 134 }
 135
 136 bool TestExtensionsClient::IsScriptableURL(const GURL& url,
 137                                            std::string* error) const {
 138   return true;
 139 }
 140
 141 bool TestExtensionsClient::IsAPISchemaGenerated(
 142     const std::string& name) const {
 143   return core_api::GeneratedSchemas::IsGenerated(name);
 144 }
 145
 146 base::StringPiece TestExtensionsClient::GetAPISchema(
 147     const std::string& name) const {
 148   return core_api::GeneratedSchemas::Get(name);
 149 }
 150
 151 void TestExtensionsClient::RegisterAPISchemaResources(ExtensionAPI* api) const {
 152 }
 153
 154 bool TestExtensionsClient::ShouldSuppressFatalErrors() const {
 155   return true;
 156 }
 157
 158 std::string TestExtensionsClient::GetWebstoreBaseURL() const {
 159   return extension_urls::kChromeWebstoreBaseURL;
 160 }
 161
 162 std::string TestExtensionsClient::GetWebstoreUpdateURL() const {
 163   return extension_urls::kChromeWebstoreUpdateURL;
 164 }
 165
 166 bool TestExtensionsClient::IsBlacklistUpdateURL(const GURL& url) const {
 167   return true;
 168 }
 169
 170 std::set<base::FilePath> TestExtensionsClient::GetBrowserImagePaths(
 171     const Extension* extension) {
 172   return std::set<base::FilePath>();
 173 }
 174
 175 }  // namespace extensions