src/apps/shell/browser/shell_extensions_browser_client.cc

   1 // Copyright 2013 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 "apps/shell/browser/shell_extensions_browser_client.h"
   6
   7 #include "apps/shell/browser/shell_app_sorting.h"
   8 #include "apps/shell/browser/shell_extension_system_factory.h"
   9 #include "apps/shell/browser/shell_extension_web_contents_observer.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/prefs/pref_service_factory.h"
  12 #include "base/prefs/testing_pref_store.h"
  13 #include "chrome/common/extensions/api/generated_api.h"
  14 #include "components/user_prefs/pref_registry_syncable.h"
  15 #include "components/user_prefs/user_prefs.h"
  16 #include "extensions/browser/api/extensions_api_client.h"
  17 #include "extensions/browser/app_sorting.h"
  18 #include "extensions/browser/extension_host_delegate.h"
  19 #include "extensions/browser/extension_prefs.h"
  20 #include "extensions/common/api/generated_api.h"
  21
  22 using content::BrowserContext;
  23
  24 namespace extensions {
  25 namespace {
  26
  27 // See chrome::RegisterProfilePrefs() in chrome/browser/prefs/browser_prefs.cc
  28 void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry) {
  29   ExtensionPrefs::RegisterProfilePrefs(registry);
  30 }
  31
  32 // A minimal ExtensionHostDelegate.
  33 class ShellExtensionHostDelegate : public ExtensionHostDelegate {
  34  public:
  35   ShellExtensionHostDelegate() {}
  36   virtual ~ShellExtensionHostDelegate() {}
  37
  38   // ExtensionHostDelegate implementation.
  39   virtual void OnExtensionHostCreated(content::WebContents* web_contents)
  40       OVERRIDE;
  41
  42   virtual void OnRenderViewCreatedForBackgroundPage(ExtensionHost* host)
  43       OVERRIDE {}
  44
  45   virtual content::JavaScriptDialogManager* GetJavaScriptDialogManager()
  46       OVERRIDE {
  47     // TODO(jamescook): Create a JavaScriptDialogManager or reuse the one from
  48     // content_shell.
  49     NOTREACHED();
  50     return NULL;
  51   }
  52
  53   virtual void CreateTab(content::WebContents* web_contents,
  54                          const std::string& extension_id,
  55                          WindowOpenDisposition disposition,
  56                          const gfx::Rect& initial_pos,
  57                          bool user_gesture) OVERRIDE {
  58     // TODO(jamescook): Should app_shell support opening popup windows?
  59     NOTREACHED();
  60   }
  61
  62   virtual void ProcessMediaAccessRequest(
  63       content::WebContents* web_contents,
  64       const content::MediaStreamRequest& request,
  65       const content::MediaResponseCallback& callback,
  66       const Extension* extension) OVERRIDE {
  67     // app_shell does not support media capture.
  68     NOTREACHED();
  69   }
  70 };
  71
  72 void ShellExtensionHostDelegate::OnExtensionHostCreated(
  73     content::WebContents* web_contents) {
  74   ShellExtensionWebContentsObserver::CreateForWebContents(web_contents);
  75 }
  76
  77 }  // namespace
  78
  79 ShellExtensionsBrowserClient::ShellExtensionsBrowserClient(
  80     BrowserContext* context)
  81     : browser_context_(context), api_client_(new ExtensionsAPIClient) {
  82   // Set up the preferences service.
  83   base::PrefServiceFactory factory;
  84   factory.set_user_prefs(new TestingPrefStore);
  85   factory.set_extension_prefs(new TestingPrefStore);
  86   // app_shell should not require syncable preferences, but for now we need to
  87   // recycle some of the RegisterProfilePrefs() code in Chrome.
  88   // TODO(jamescook): Convert this to PrefRegistrySimple.
  89   user_prefs::PrefRegistrySyncable* pref_registry =
  90       new user_prefs::PrefRegistrySyncable;
  91   // Prefs should be registered before the PrefService is created.
  92   RegisterPrefs(pref_registry);
  93   prefs_ = factory.Create(pref_registry).Pass();
  94   user_prefs::UserPrefs::Set(browser_context_, prefs_.get());
  95 }
  96
  97 ShellExtensionsBrowserClient::~ShellExtensionsBrowserClient() {}
  98
  99 bool ShellExtensionsBrowserClient::IsShuttingDown() {
 100   return false;
 101 }
 102
 103 bool ShellExtensionsBrowserClient::AreExtensionsDisabled(
 104     const base::CommandLine& command_line,
 105     BrowserContext* context) {
 106   return false;
 107 }
 108
 109 bool ShellExtensionsBrowserClient::IsValidContext(BrowserContext* context) {
 110   return context == browser_context_;
 111 }
 112
 113 bool ShellExtensionsBrowserClient::IsSameContext(BrowserContext* first,
 114                                                  BrowserContext* second) {
 115   return first == second;
 116 }
 117
 118 bool ShellExtensionsBrowserClient::HasOffTheRecordContext(
 119     BrowserContext* context) {
 120   return false;
 121 }
 122
 123 BrowserContext* ShellExtensionsBrowserClient::GetOffTheRecordContext(
 124     BrowserContext* context) {
 125   // app_shell only supports a single context.
 126   return NULL;
 127 }
 128
 129 BrowserContext* ShellExtensionsBrowserClient::GetOriginalContext(
 130     BrowserContext* context) {
 131   return context;
 132 }
 133
 134 bool ShellExtensionsBrowserClient::IsGuestSession(
 135     BrowserContext* context) const {
 136   return false;
 137 }
 138
 139 bool ShellExtensionsBrowserClient::IsExtensionIncognitoEnabled(
 140     const std::string& extension_id,
 141     content::BrowserContext* context) const {
 142   return false;
 143 }
 144
 145 bool ShellExtensionsBrowserClient::CanExtensionCrossIncognito(
 146     const extensions::Extension* extension,
 147     content::BrowserContext* context) const {
 148   return false;
 149 }
 150
 151 PrefService* ShellExtensionsBrowserClient::GetPrefServiceForContext(
 152     BrowserContext* context) {
 153   return prefs_.get();
 154 }
 155
 156 bool ShellExtensionsBrowserClient::DeferLoadingBackgroundHosts(
 157     BrowserContext* context) const {
 158   return false;
 159 }
 160
 161 bool ShellExtensionsBrowserClient::IsBackgroundPageAllowed(
 162     BrowserContext* context) const {
 163   return true;
 164 }
 165
 166 scoped_ptr<ExtensionHostDelegate>
 167 ShellExtensionsBrowserClient::CreateExtensionHostDelegate() {
 168   return scoped_ptr<ExtensionHostDelegate>(new ShellExtensionHostDelegate);
 169 }
 170
 171 bool ShellExtensionsBrowserClient::DidVersionUpdate(BrowserContext* context) {
 172   // TODO(jamescook): We might want to tell extensions when app_shell updates.
 173   return false;
 174 }
 175
 176 void ShellExtensionsBrowserClient::PermitExternalProtocolHandler() {
 177 }
 178
 179 scoped_ptr<AppSorting> ShellExtensionsBrowserClient::CreateAppSorting() {
 180   return scoped_ptr<AppSorting>(new apps::ShellAppSorting);
 181 }
 182
 183 bool ShellExtensionsBrowserClient::IsRunningInForcedAppMode() {
 184   return false;
 185 }
 186
 187 ApiActivityMonitor* ShellExtensionsBrowserClient::GetApiActivityMonitor(
 188     BrowserContext* context) {
 189   // app_shell doesn't monitor API function calls or events.
 190   return NULL;
 191 }
 192
 193 ExtensionSystemProvider*
 194 ShellExtensionsBrowserClient::GetExtensionSystemFactory() {
 195   return ShellExtensionSystemFactory::GetInstance();
 196 }
 197
 198 void ShellExtensionsBrowserClient::RegisterExtensionFunctions(
 199     ExtensionFunctionRegistry* registry) const {
 200   extensions::core_api::GeneratedFunctionRegistry::RegisterAll(registry);
 201   // TODO(rockot): Remove dependency on src/chrome once we have some core APIs
 202   // moved out. See http://crbug.com/349042.
 203   extensions::api::GeneratedFunctionRegistry::RegisterAll(registry);
 204 }
 205
 206 }  // namespace extensions