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