extensions/shell/browser/shell_extensions_browser_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/browser/shell_extensions_browser_client.h"
   6
   7 #include "content/public/browser/browser_context.h"
   8 #include "content/public/browser/browser_thread.h"
   9 #include "content/public/browser/render_frame_host.h"
  10 #include "extensions/browser/api/extensions_api_client.h"
  11 #include "extensions/browser/api/generated_api_registration.h"
  12 #include "extensions/browser/app_sorting.h"
  13 #include "extensions/browser/event_router.h"
  14 #include "extensions/browser/extension_function_registry.h"
  15 #include "extensions/browser/mojo/service_registration.h"
  16 #include "extensions/browser/null_app_sorting.h"
  17 #include "extensions/browser/updater/null_extension_cache.h"
  18 #include "extensions/browser/url_request_util.h"
  19 #include "extensions/shell/browser/api/generated_api_registration.h"
  20 #include "extensions/shell/browser/shell_extension_host_delegate.h"
  21 #include "extensions/shell/browser/shell_extension_system_factory.h"
  22 #include "extensions/shell/browser/shell_extensions_api_client.h"
  23 #include "extensions/shell/browser/shell_runtime_api_delegate.h"
  24
  25 #if defined(OS_CHROMEOS)
  26 #include "chromeos/login/login_state.h"
  27 #endif
  28
  29 using content::BrowserContext;
  30 using content::BrowserThread;
  31
  32 namespace extensions {
  33
  34 ShellExtensionsBrowserClient::ShellExtensionsBrowserClient(
  35     BrowserContext* context,
  36     PrefService* pref_service)
  37     : browser_context_(context),
  38       pref_service_(pref_service),
  39       api_client_(new ShellExtensionsAPIClient),
  40       extension_cache_(new NullExtensionCache()) {
  41 }
  42
  43 ShellExtensionsBrowserClient::~ShellExtensionsBrowserClient() {
  44 }
  45
  46 bool ShellExtensionsBrowserClient::IsShuttingDown() {
  47   return false;
  48 }
  49
  50 bool ShellExtensionsBrowserClient::AreExtensionsDisabled(
  51     const base::CommandLine& command_line,
  52     BrowserContext* context) {
  53   return false;
  54 }
  55
  56 bool ShellExtensionsBrowserClient::IsValidContext(BrowserContext* context) {
  57   return context == browser_context_;
  58 }
  59
  60 bool ShellExtensionsBrowserClient::IsSameContext(BrowserContext* first,
  61                                                  BrowserContext* second) {
  62   return first == second;
  63 }
  64
  65 bool ShellExtensionsBrowserClient::HasOffTheRecordContext(
  66     BrowserContext* context) {
  67   return false;
  68 }
  69
  70 BrowserContext* ShellExtensionsBrowserClient::GetOffTheRecordContext(
  71     BrowserContext* context) {
  72   // app_shell only supports a single context.
  73   return NULL;
  74 }
  75
  76 BrowserContext* ShellExtensionsBrowserClient::GetOriginalContext(
  77     BrowserContext* context) {
  78   return context;
  79 }
  80
  81 #if defined(OS_CHROMEOS)
  82 std::string ShellExtensionsBrowserClient::GetUserIdHashFromContext(
  83     content::BrowserContext* context) {
  84   return chromeos::LoginState::Get()->primary_user_hash();;
  85 }
  86 #endif
  87
  88 bool ShellExtensionsBrowserClient::IsGuestSession(
  89     BrowserContext* context) const {
  90   return false;
  91 }
  92
  93 bool ShellExtensionsBrowserClient::IsExtensionIncognitoEnabled(
  94     const std::string& extension_id,
  95     content::BrowserContext* context) const {
  96   return false;
  97 }
  98
  99 bool ShellExtensionsBrowserClient::CanExtensionCrossIncognito(
 100     const Extension* extension,
 101     content::BrowserContext* context) const {
 102   return false;
 103 }
 104
 105 net::URLRequestJob*
 106 ShellExtensionsBrowserClient::MaybeCreateResourceBundleRequestJob(
 107     net::URLRequest* request,
 108     net::NetworkDelegate* network_delegate,
 109     const base::FilePath& directory_path,
 110     const std::string& content_security_policy,
 111     bool send_cors_header) {
 112   return NULL;
 113 }
 114
 115 bool ShellExtensionsBrowserClient::AllowCrossRendererResourceLoad(
 116     net::URLRequest* request,
 117     bool is_incognito,
 118     const Extension* extension,
 119     InfoMap* extension_info_map) {
 120   bool allowed = false;
 121   if (url_request_util::AllowCrossRendererResourceLoad(
 122           request, is_incognito, extension, extension_info_map, &allowed)) {
 123     return allowed;
 124   }
 125
 126   // Couldn't determine if resource is allowed. Block the load.
 127   return false;
 128 }
 129
 130 PrefService* ShellExtensionsBrowserClient::GetPrefServiceForContext(
 131     BrowserContext* context) {
 132   return pref_service_;
 133 }
 134
 135 void ShellExtensionsBrowserClient::GetEarlyExtensionPrefsObservers(
 136     content::BrowserContext* context,
 137     std::vector<ExtensionPrefsObserver*>* observers) const {
 138 }
 139
 140 ProcessManagerDelegate*
 141 ShellExtensionsBrowserClient::GetProcessManagerDelegate() const {
 142   return NULL;
 143 }
 144
 145 scoped_ptr<ExtensionHostDelegate>
 146 ShellExtensionsBrowserClient::CreateExtensionHostDelegate() {
 147   return scoped_ptr<ExtensionHostDelegate>(new ShellExtensionHostDelegate);
 148 }
 149
 150 bool ShellExtensionsBrowserClient::DidVersionUpdate(BrowserContext* context) {
 151   // TODO(jamescook): We might want to tell extensions when app_shell updates.
 152   return false;
 153 }
 154
 155 void ShellExtensionsBrowserClient::PermitExternalProtocolHandler() {
 156 }
 157
 158 scoped_ptr<AppSorting> ShellExtensionsBrowserClient::CreateAppSorting() {
 159   return scoped_ptr<AppSorting>(new NullAppSorting);
 160 }
 161
 162 bool ShellExtensionsBrowserClient::IsRunningInForcedAppMode() {
 163   return false;
 164 }
 165
 166 ApiActivityMonitor* ShellExtensionsBrowserClient::GetApiActivityMonitor(
 167     BrowserContext* context) {
 168   // app_shell doesn't monitor API function calls or events.
 169   return NULL;
 170 }
 171
 172 ExtensionSystemProvider*
 173 ShellExtensionsBrowserClient::GetExtensionSystemFactory() {
 174   return ShellExtensionSystemFactory::GetInstance();
 175 }
 176
 177 void ShellExtensionsBrowserClient::RegisterExtensionFunctions(
 178     ExtensionFunctionRegistry* registry) const {
 179   // Register core extension-system APIs.
 180   core_api::GeneratedFunctionRegistry::RegisterAll(registry);
 181
 182   // app_shell-only APIs.
 183   shell::api::GeneratedFunctionRegistry::RegisterAll(registry);
 184 }
 185
 186 void ShellExtensionsBrowserClient::RegisterMojoServices(
 187     content::RenderFrameHost* render_frame_host,
 188     const Extension* extension) const {
 189   RegisterServicesForFrame(render_frame_host, extension);
 190 }
 191
 192 scoped_ptr<RuntimeAPIDelegate>
 193 ShellExtensionsBrowserClient::CreateRuntimeAPIDelegate(
 194     content::BrowserContext* context) const {
 195   return scoped_ptr<RuntimeAPIDelegate>(new ShellRuntimeAPIDelegate());
 196 }
 197
 198 const ComponentExtensionResourceManager*
 199 ShellExtensionsBrowserClient::GetComponentExtensionResourceManager() {
 200   return NULL;
 201 }
 202
 203 void ShellExtensionsBrowserClient::BroadcastEventToRenderers(
 204     const std::string& event_name,
 205     scoped_ptr<base::ListValue> args) {
 206   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
 207     BrowserThread::PostTask(
 208         BrowserThread::UI,
 209         FROM_HERE,
 210         base::Bind(&ShellExtensionsBrowserClient::BroadcastEventToRenderers,
 211                    base::Unretained(this),
 212                    event_name,
 213                    base::Passed(&args)));
 214     return;
 215   }
 216
 217   scoped_ptr<Event> event(new Event(event_name, args.Pass()));
 218   EventRouter::Get(browser_context_)->BroadcastEvent(event.Pass());
 219 }
 220
 221 net::NetLog* ShellExtensionsBrowserClient::GetNetLog() {
 222   return NULL;
 223 }
 224
 225 ExtensionCache* ShellExtensionsBrowserClient::GetExtensionCache() {
 226   return extension_cache_.get();
 227 }
 228
 229 bool ShellExtensionsBrowserClient::IsBackgroundUpdateAllowed() {
 230   return true;
 231 }
 232
 233 bool ShellExtensionsBrowserClient::IsMinBrowserVersionSupported(
 234     const std::string& min_version) {
 235   return true;
 236 }
 237
 238 void ShellExtensionsBrowserClient::SetAPIClientForTest(
 239     ExtensionsAPIClient* api_client) {
 240   api_client_.reset(api_client);
 241 }
 242
 243 }  // namespace extensions