shell_extensions_browser_client.cc revision 1320f92c476a1ad9d19dba2a48c72b75566198e9 
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
25using content::BrowserContext;
26using content::BrowserThread;
27
28namespace extensions {
29namespace {
30
31// See chrome::RegisterProfilePrefs() in chrome/browser/prefs/browser_prefs.cc
32void RegisterPrefs(user_prefs::PrefRegistrySyncable* registry) {
33  ExtensionPrefs::RegisterProfilePrefs(registry);
34}
35
36}  // namespace
37
38ShellExtensionsBrowserClient::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
56ShellExtensionsBrowserClient::~ShellExtensionsBrowserClient() {
57}
58
59bool ShellExtensionsBrowserClient::IsShuttingDown() {
60  return false;
61}
62
63bool ShellExtensionsBrowserClient::AreExtensionsDisabled(
64    const base::CommandLine& command_line,
65    BrowserContext* context) {
66  return false;
67}
68
69bool ShellExtensionsBrowserClient::IsValidContext(BrowserContext* context) {
70  return context == browser_context_;
71}
72
73bool ShellExtensionsBrowserClient::IsSameContext(BrowserContext* first,
74                                                 BrowserContext* second) {
75  return first == second;
76}
77
78bool ShellExtensionsBrowserClient::HasOffTheRecordContext(
79    BrowserContext* context) {
80  return false;
81}
82
83BrowserContext* ShellExtensionsBrowserClient::GetOffTheRecordContext(
84    BrowserContext* context) {
85  // app_shell only supports a single context.
86  return NULL;
87}
88
89BrowserContext* ShellExtensionsBrowserClient::GetOriginalContext(
90    BrowserContext* context) {
91  return context;
92}
93
94bool ShellExtensionsBrowserClient::IsGuestSession(
95    BrowserContext* context) const {
96  return false;
97}
98
99bool ShellExtensionsBrowserClient::IsExtensionIncognitoEnabled(
100    const std::string& extension_id,
101    content::BrowserContext* context) const {
102  return false;
103}
104
105bool ShellExtensionsBrowserClient::CanExtensionCrossIncognito(
106    const Extension* extension,
107    content::BrowserContext* context) const {
108  return false;
109}
110
111net::URLRequestJob*
112ShellExtensionsBrowserClient::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
121bool 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
136PrefService* ShellExtensionsBrowserClient::GetPrefServiceForContext(
137    BrowserContext* context) {
138  return prefs_.get();
139}
140
141void ShellExtensionsBrowserClient::GetEarlyExtensionPrefsObservers(
142    content::BrowserContext* context,
143    std::vector<ExtensionPrefsObserver*>* observers) const {
144}
145
146ProcessManagerDelegate*
147ShellExtensionsBrowserClient::GetProcessManagerDelegate() const {
148  return NULL;
149}
150
151scoped_ptr<ExtensionHostDelegate>
152ShellExtensionsBrowserClient::CreateExtensionHostDelegate() {
153  return scoped_ptr<ExtensionHostDelegate>(new ShellExtensionHostDelegate);
154}
155
156bool ShellExtensionsBrowserClient::DidVersionUpdate(BrowserContext* context) {
157  // TODO(jamescook): We might want to tell extensions when app_shell updates.
158  return false;
159}
160
161void ShellExtensionsBrowserClient::PermitExternalProtocolHandler() {
162}
163
164scoped_ptr<AppSorting> ShellExtensionsBrowserClient::CreateAppSorting() {
165  return scoped_ptr<AppSorting>(new NullAppSorting);
166}
167
168bool ShellExtensionsBrowserClient::IsRunningInForcedAppMode() {
169  return false;
170}
171
172ApiActivityMonitor* ShellExtensionsBrowserClient::GetApiActivityMonitor(
173    BrowserContext* context) {
174  // app_shell doesn't monitor API function calls or events.
175  return NULL;
176}
177
178ExtensionSystemProvider*
179ShellExtensionsBrowserClient::GetExtensionSystemFactory() {
180  return ShellExtensionSystemFactory::GetInstance();
181}
182
183void ShellExtensionsBrowserClient::RegisterExtensionFunctions(
184    ExtensionFunctionRegistry* registry) const {
185  // Register core extension-system APIs.
186  core_api::GeneratedFunctionRegistry::RegisterAll(registry);
187}
188
189scoped_ptr<RuntimeAPIDelegate>
190ShellExtensionsBrowserClient::CreateRuntimeAPIDelegate(
191    content::BrowserContext* context) const {
192  return scoped_ptr<RuntimeAPIDelegate>(new ShellRuntimeAPIDelegate());
193}
194
195ComponentExtensionResourceManager*
196ShellExtensionsBrowserClient::GetComponentExtensionResourceManager() {
197  return NULL;
198}
199
200void 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
218net::NetLog* ShellExtensionsBrowserClient::GetNetLog() {
219  return NULL;
220}
221
222}  // namespace extensions
223