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/common_manifest_handlers.h" 11 #include "extensions/common/extension_urls.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 "grit/extensions_resources.h" 24 25 namespace extensions { 26 27 namespace { 28 29 template <class FeatureClass> 30 SimpleFeature* CreateFeature() { 31 return new FeatureClass; 32 } 33 34 // TODO(jamescook): Refactor ChromePermissionsMessageProvider so we can share 35 // code. For now, this implementation does nothing. 36 class ShellPermissionMessageProvider : public PermissionMessageProvider { 37 public: 38 ShellPermissionMessageProvider() {} 39 virtual ~ShellPermissionMessageProvider() {} 40 41 // PermissionMessageProvider implementation. 42 virtual PermissionMessages GetPermissionMessages( 43 const PermissionSet* permissions, 44 Manifest::Type extension_type) const OVERRIDE { 45 return PermissionMessages(); 46 } 47 48 virtual std::vector<base::string16> GetWarningMessages( 49 const PermissionSet* permissions, 50 Manifest::Type extension_type) const OVERRIDE { 51 return std::vector<base::string16>(); 52 } 53 54 virtual std::vector<base::string16> GetWarningMessagesDetails( 55 const PermissionSet* permissions, 56 Manifest::Type extension_type) const OVERRIDE { 57 return std::vector<base::string16>(); 58 } 59 60 virtual bool IsPrivilegeIncrease( 61 const PermissionSet* old_permissions, 62 const PermissionSet* new_permissions, 63 Manifest::Type extension_type) const OVERRIDE { 64 // Ensure we implement this before shipping. 65 CHECK(false); 66 return false; 67 } 68 69 private: 70 DISALLOW_COPY_AND_ASSIGN(ShellPermissionMessageProvider); 71 }; 72 73 base::LazyInstance<ShellPermissionMessageProvider> 74 g_permission_message_provider = LAZY_INSTANCE_INITIALIZER; 75 76 } // namespace 77 78 ShellExtensionsClient::ShellExtensionsClient() 79 : extensions_api_permissions_(ExtensionsAPIPermissions()) { 80 } 81 82 ShellExtensionsClient::~ShellExtensionsClient() { 83 } 84 85 void ShellExtensionsClient::Initialize() { 86 RegisterCommonManifestHandlers(); 87 ManifestHandler::FinalizeRegistration(); 88 // TODO(jamescook): Do we need to whitelist any extensions? 89 90 PermissionsInfo::GetInstance()->AddProvider(extensions_api_permissions_); 91 } 92 93 const PermissionMessageProvider& 94 ShellExtensionsClient::GetPermissionMessageProvider() const { 95 NOTIMPLEMENTED(); 96 return g_permission_message_provider.Get(); 97 } 98 99 const std::string ShellExtensionsClient::GetProductName() { 100 return "app_shell"; 101 } 102 103 scoped_ptr<FeatureProvider> ShellExtensionsClient::CreateFeatureProvider( 104 const std::string& name) const { 105 scoped_ptr<FeatureProvider> provider; 106 scoped_ptr<JSONFeatureProviderSource> source( 107 CreateFeatureProviderSource(name)); 108 if (name == "api") { 109 provider.reset(new BaseFeatureProvider(source->dictionary(), 110 CreateFeature<APIFeature>)); 111 } else if (name == "manifest") { 112 provider.reset(new BaseFeatureProvider(source->dictionary(), 113 CreateFeature<ManifestFeature>)); 114 } else if (name == "permission") { 115 provider.reset(new BaseFeatureProvider(source->dictionary(), 116 CreateFeature<PermissionFeature>)); 117 } else { 118 NOTREACHED(); 119 } 120 return provider.Pass(); 121 } 122 123 scoped_ptr<JSONFeatureProviderSource> 124 ShellExtensionsClient::CreateFeatureProviderSource( 125 const std::string& name) const { 126 scoped_ptr<JSONFeatureProviderSource> source( 127 new JSONFeatureProviderSource(name)); 128 if (name == "api") { 129 source->LoadJSON(IDR_EXTENSION_API_FEATURES); 130 } else if (name == "manifest") { 131 source->LoadJSON(IDR_EXTENSION_MANIFEST_FEATURES); 132 } else if (name == "permission") { 133 source->LoadJSON(IDR_EXTENSION_PERMISSION_FEATURES); 134 } else { 135 NOTREACHED(); 136 source.reset(); 137 } 138 return source.Pass(); 139 } 140 141 void ShellExtensionsClient::FilterHostPermissions( 142 const URLPatternSet& hosts, 143 URLPatternSet* new_hosts, 144 std::set<PermissionMessage>* messages) const { 145 NOTIMPLEMENTED(); 146 } 147 148 void ShellExtensionsClient::SetScriptingWhitelist( 149 const ScriptingWhitelist& whitelist) { 150 scripting_whitelist_ = whitelist; 151 } 152 153 const ExtensionsClient::ScriptingWhitelist& 154 ShellExtensionsClient::GetScriptingWhitelist() const { 155 // TODO(jamescook): Real whitelist. 156 return scripting_whitelist_; 157 } 158 159 URLPatternSet ShellExtensionsClient::GetPermittedChromeSchemeHosts( 160 const Extension* extension, 161 const APIPermissionSet& api_permissions) const { 162 NOTIMPLEMENTED(); 163 return URLPatternSet(); 164 } 165 166 bool ShellExtensionsClient::IsScriptableURL(const GURL& url, 167 std::string* error) const { 168 NOTIMPLEMENTED(); 169 return true; 170 } 171 172 bool ShellExtensionsClient::IsAPISchemaGenerated( 173 const std::string& name) const { 174 return core_api::GeneratedSchemas::IsGenerated(name); 175 } 176 177 base::StringPiece ShellExtensionsClient::GetAPISchema( 178 const std::string& name) const { 179 return core_api::GeneratedSchemas::Get(name); 180 } 181 182 void ShellExtensionsClient::RegisterAPISchemaResources( 183 ExtensionAPI* api) const { 184 } 185 186 bool ShellExtensionsClient::ShouldSuppressFatalErrors() const { 187 return true; 188 } 189 190 std::string ShellExtensionsClient::GetWebstoreBaseURL() const { 191 return extension_urls::kChromeWebstoreBaseURL; 192 } 193 194 std::string ShellExtensionsClient::GetWebstoreUpdateURL() const { 195 return extension_urls::kChromeWebstoreUpdateURL; 196 } 197 198 bool ShellExtensionsClient::IsBlacklistUpdateURL(const GURL& url) const { 199 // TODO(rockot): Maybe we want to do something else here. For now we accept 200 // any URL as a blacklist URL because we don't really care. 201 return true; 202 } 203 204 } // namespace extensions 205