extensions/shell/common/shell_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/shell/common/shell_extensions_client.h"
   6
   7 #include "base/lazy_instance.h"
   8 #include "base/logging.h"
   9 #include "extensions/common/api/generated_schemas.h"
  10 #include "extensions/common/api/sockets/sockets_manifest_handler.h"
  11 #include "extensions/common/common_manifest_handlers.h"
  12 #include "extensions/common/features/api_feature.h"
  13 #include "extensions/common/features/base_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/features/simple_feature.h"
  18 #include "extensions/common/manifest_handler.h"
  19 #include "extensions/common/permissions/permission_message_provider.h"
  20 #include "extensions/common/permissions/permissions_info.h"
  21 #include "extensions/common/permissions/permissions_provider.h"
  22 #include "extensions/common/url_pattern_set.h"
  23 #include "extensions/shell/common/api/generated_schemas.h"
  24 #include "grit/app_shell_resources.h"
  25 #include "grit/extensions_resources.h"
  26
  27 namespace extensions {
  28
  29 namespace {
  30
  31 template <class FeatureClass>
  32 SimpleFeature* CreateFeature() {
  33   return new FeatureClass;
  34 }
  35
  36 // TODO(jamescook): Refactor ChromePermissionsMessageProvider so we can share
  37 // code. For now, this implementation does nothing.
  38 class ShellPermissionMessageProvider : public PermissionMessageProvider {
  39  public:
  40   ShellPermissionMessageProvider() {}
  41   virtual ~ShellPermissionMessageProvider() {}
  42
  43   // PermissionMessageProvider implementation.
  44   virtual PermissionMessages GetPermissionMessages(
  45       const PermissionSet* permissions,
  46       Manifest::Type extension_type) const OVERRIDE {
  47     return PermissionMessages();
  48   }
  49
  50   virtual std::vector<base::string16> GetWarningMessages(
  51       const PermissionSet* permissions,
  52       Manifest::Type extension_type) const OVERRIDE {
  53     return std::vector<base::string16>();
  54   }
  55
  56   virtual std::vector<base::string16> GetWarningMessagesDetails(
  57       const PermissionSet* permissions,
  58       Manifest::Type extension_type) const OVERRIDE {
  59     return std::vector<base::string16>();
  60   }
  61
  62   virtual bool IsPrivilegeIncrease(
  63       const PermissionSet* old_permissions,
  64       const PermissionSet* new_permissions,
  65       Manifest::Type extension_type) const OVERRIDE {
  66     // Ensure we implement this before shipping.
  67     CHECK(false);
  68     return false;
  69   }
  70
  71  private:
  72   DISALLOW_COPY_AND_ASSIGN(ShellPermissionMessageProvider);
  73 };
  74
  75 base::LazyInstance<ShellPermissionMessageProvider>
  76     g_permission_message_provider = LAZY_INSTANCE_INITIALIZER;
  77
  78 }  // namespace
  79
  80 ShellExtensionsClient::ShellExtensionsClient()
  81     : extensions_api_permissions_(ExtensionsAPIPermissions()) {
  82 }
  83
  84 ShellExtensionsClient::~ShellExtensionsClient() {
  85 }
  86
  87 void ShellExtensionsClient::Initialize() {
  88   RegisterCommonManifestHandlers();
  89
  90   // TODO(rockot): API manifest handlers which move out to src/extensions
  91   // should either end up in RegisterCommonManifestHandlers or some new
  92   // initialization step specifically for API manifest handlers.
  93   (new SocketsManifestHandler)->Register();
  94
  95   ManifestHandler::FinalizeRegistration();
  96   // TODO(jamescook): Do we need to whitelist any extensions?
  97
  98   PermissionsInfo::GetInstance()->AddProvider(extensions_api_permissions_);
  99 }
 100
 101 const PermissionMessageProvider&
 102 ShellExtensionsClient::GetPermissionMessageProvider() const {
 103   NOTIMPLEMENTED();
 104   return g_permission_message_provider.Get();
 105 }
 106
 107 const std::string ShellExtensionsClient::GetProductName() {
 108   return "app_shell";
 109 }
 110
 111 scoped_ptr<FeatureProvider> ShellExtensionsClient::CreateFeatureProvider(
 112     const std::string& name) const {
 113   scoped_ptr<FeatureProvider> provider;
 114   scoped_ptr<JSONFeatureProviderSource> source(
 115       CreateFeatureProviderSource(name));
 116   if (name == "api") {
 117     provider.reset(new BaseFeatureProvider(source->dictionary(),
 118                                            CreateFeature<APIFeature>));
 119   } else if (name == "manifest") {
 120     provider.reset(new BaseFeatureProvider(source->dictionary(),
 121                                            CreateFeature<ManifestFeature>));
 122   } else if (name == "permission") {
 123     provider.reset(new BaseFeatureProvider(source->dictionary(),
 124                                            CreateFeature<PermissionFeature>));
 125   } else {
 126     NOTREACHED();
 127   }
 128   return provider.Pass();
 129 }
 130
 131 scoped_ptr<JSONFeatureProviderSource>
 132 ShellExtensionsClient::CreateFeatureProviderSource(
 133     const std::string& name) const {
 134   scoped_ptr<JSONFeatureProviderSource> source(
 135       new JSONFeatureProviderSource(name));
 136   if (name == "api") {
 137     source->LoadJSON(IDR_EXTENSION_API_FEATURES);
 138     source->LoadJSON(IDR_SHELL_EXTENSION_API_FEATURES);
 139   } else if (name == "manifest") {
 140     source->LoadJSON(IDR_EXTENSION_MANIFEST_FEATURES);
 141   } else if (name == "permission") {
 142     source->LoadJSON(IDR_EXTENSION_PERMISSION_FEATURES);
 143   } else {
 144     NOTREACHED();
 145     source.reset();
 146   }
 147   return source.Pass();
 148 }
 149
 150 void ShellExtensionsClient::FilterHostPermissions(
 151     const URLPatternSet& hosts,
 152     URLPatternSet* new_hosts,
 153     std::set<PermissionMessage>* messages) const {
 154   NOTIMPLEMENTED();
 155 }
 156
 157 void ShellExtensionsClient::SetScriptingWhitelist(
 158     const ScriptingWhitelist& whitelist) {
 159   scripting_whitelist_ = whitelist;
 160 }
 161
 162 const ExtensionsClient::ScriptingWhitelist&
 163 ShellExtensionsClient::GetScriptingWhitelist() const {
 164   // TODO(jamescook): Real whitelist.
 165   return scripting_whitelist_;
 166 }
 167
 168 URLPatternSet ShellExtensionsClient::GetPermittedChromeSchemeHosts(
 169     const Extension* extension,
 170     const APIPermissionSet& api_permissions) const {
 171   NOTIMPLEMENTED();
 172   return URLPatternSet();
 173 }
 174
 175 bool ShellExtensionsClient::IsScriptableURL(const GURL& url,
 176                                             std::string* error) const {
 177   NOTIMPLEMENTED();
 178   return true;
 179 }
 180
 181 bool ShellExtensionsClient::IsAPISchemaGenerated(
 182     const std::string& name) const {
 183   // TODO(rockot): Remove dependency on src/chrome once we have some core APIs
 184   // moved out. See http://crbug.com/349042.
 185   // Special-case our simplified app.runtime implementation because we don't
 186   // have the Chrome app APIs available.
 187   return core_api::GeneratedSchemas::IsGenerated(name) ||
 188          shell_api::GeneratedSchemas::IsGenerated(name);
 189 }
 190
 191 base::StringPiece ShellExtensionsClient::GetAPISchema(
 192     const std::string& name) const {
 193   // Schema for chrome.shell APIs.
 194   if (shell_api::GeneratedSchemas::IsGenerated(name))
 195     return shell_api::GeneratedSchemas::Get(name);
 196
 197   return core_api::GeneratedSchemas::Get(name);
 198 }
 199
 200 void ShellExtensionsClient::RegisterAPISchemaResources(
 201     ExtensionAPI* api) const {
 202 }
 203
 204 bool ShellExtensionsClient::ShouldSuppressFatalErrors() const {
 205   return true;
 206 }
 207
 208 }  // namespace extensions