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