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