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