content_browser_client.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
1// Copyright (c) 2012 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 "content/public/browser/content_browser_client.h"
6
7#include "base/files/file_path.h"
8#include "ui/gfx/image/image_skia.h"
9#include "url/gurl.h"
10
11namespace content {
12
13BrowserMainParts* ContentBrowserClient::CreateBrowserMainParts(
14    const MainFunctionParams& parameters) {
15  return NULL;
16}
17
18WebContentsViewDelegate* ContentBrowserClient::GetWebContentsViewDelegate(
19    WebContents* web_contents) {
20  return NULL;
21}
22
23GURL ContentBrowserClient::GetEffectiveURL(BrowserContext* browser_context,
24                                           const GURL& url) {
25  return url;
26}
27
28bool ContentBrowserClient::ShouldUseProcessPerSite(
29    BrowserContext* browser_context, const GURL& effective_url) {
30  return false;
31}
32
33net::URLRequestContextGetter* ContentBrowserClient::CreateRequestContext(
34    BrowserContext* browser_context,
35    ProtocolHandlerMap* protocol_handlers,
36    URLRequestInterceptorScopedVector request_interceptors) {
37  return NULL;
38}
39
40net::URLRequestContextGetter*
41ContentBrowserClient::CreateRequestContextForStoragePartition(
42    BrowserContext* browser_context,
43    const base::FilePath& partition_path,
44    bool in_memory,
45    ProtocolHandlerMap* protocol_handlers,
46    URLRequestInterceptorScopedVector request_interceptors) {
47  return NULL;
48}
49
50bool ContentBrowserClient::IsHandledURL(const GURL& url) {
51  return false;
52}
53
54bool ContentBrowserClient::CanCommitURL(RenderProcessHost* process_host,
55                                        const GURL& site_url) {
56  return true;
57}
58
59bool ContentBrowserClient::ShouldAllowOpenURL(SiteInstance* site_instance,
60                                              const GURL& url) {
61  return true;
62}
63
64bool ContentBrowserClient::IsSuitableHost(RenderProcessHost* process_host,
65                                          const GURL& site_url) {
66  return true;
67}
68
69bool ContentBrowserClient::MayReuseHost(RenderProcessHost* process_host) {
70  return true;
71}
72
73bool ContentBrowserClient::ShouldTryToUseExistingProcessHost(
74      BrowserContext* browser_context, const GURL& url) {
75  return false;
76}
77
78bool ContentBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
79    SiteInstance* site_instance,
80    const GURL& current_url,
81    const GURL& new_url) {
82  return false;
83}
84
85bool ContentBrowserClient::ShouldSwapProcessesForRedirect(
86    ResourceContext* resource_context, const GURL& current_url,
87    const GURL& new_url) {
88  return false;
89}
90
91bool ContentBrowserClient::ShouldAssignSiteForURL(const GURL& url) {
92  return true;
93}
94
95std::string ContentBrowserClient::GetCanonicalEncodingNameByAliasName(
96    const std::string& alias_name) {
97  return std::string();
98}
99
100std::string ContentBrowserClient::GetApplicationLocale() {
101  return "en-US";
102}
103
104std::string ContentBrowserClient::GetAcceptLangs(BrowserContext* context) {
105  return std::string();
106}
107
108const gfx::ImageSkia* ContentBrowserClient::GetDefaultFavicon() {
109  static gfx::ImageSkia* empty = new gfx::ImageSkia();
110  return empty;
111}
112
113bool ContentBrowserClient::AllowAppCache(const GURL& manifest_url,
114                                         const GURL& first_party,
115                                         ResourceContext* context) {
116  return true;
117}
118
119bool ContentBrowserClient::AllowGetCookie(const GURL& url,
120                                          const GURL& first_party,
121                                          const net::CookieList& cookie_list,
122                                          ResourceContext* context,
123                                          int render_process_id,
124                                          int render_frame_id) {
125  return true;
126}
127
128bool ContentBrowserClient::AllowSetCookie(const GURL& url,
129                                          const GURL& first_party,
130                                          const std::string& cookie_line,
131                                          ResourceContext* context,
132                                          int render_process_id,
133                                          int render_frame_id,
134                                          net::CookieOptions* options) {
135  return true;
136}
137
138bool ContentBrowserClient::AllowSaveLocalState(ResourceContext* context) {
139  return true;
140}
141
142bool ContentBrowserClient::AllowWorkerDatabase(
143    const GURL& url,
144    const base::string16& name,
145    const base::string16& display_name,
146    unsigned long estimated_size,
147    ResourceContext* context,
148    const std::vector<std::pair<int, int> >& render_frames) {
149  return true;
150}
151
152void ContentBrowserClient::AllowWorkerFileSystem(
153    const GURL& url,
154    ResourceContext* context,
155    const std::vector<std::pair<int, int> >& render_frames,
156    base::Callback<void(bool)> callback) {
157  callback.Run(true);
158}
159
160bool ContentBrowserClient::AllowWorkerIndexedDB(
161    const GURL& url,
162    const base::string16& name,
163    ResourceContext* context,
164    const std::vector<std::pair<int, int> >& render_frames) {
165  return true;
166}
167
168QuotaPermissionContext* ContentBrowserClient::CreateQuotaPermissionContext() {
169  return NULL;
170}
171
172net::URLRequestContext* ContentBrowserClient::OverrideRequestContextForURL(
173    const GURL& url, ResourceContext* context) {
174  return NULL;
175}
176
177std::string ContentBrowserClient::GetStoragePartitionIdForSite(
178    BrowserContext* browser_context,
179    const GURL& site) {
180  return std::string();
181}
182
183bool ContentBrowserClient::IsValidStoragePartitionId(
184    BrowserContext* browser_context,
185    const std::string& partition_id) {
186  // Since the GetStoragePartitionIdForChildProcess() only generates empty
187  // strings, we should only ever see empty strings coming back.
188  return partition_id.empty();
189}
190
191void ContentBrowserClient::GetStoragePartitionConfigForSite(
192    BrowserContext* browser_context,
193    const GURL& site,
194    bool can_be_default,
195    std::string* partition_domain,
196    std::string* partition_name,
197    bool* in_memory) {
198  partition_domain->clear();
199  partition_name->clear();
200  *in_memory = false;
201}
202
203MediaObserver* ContentBrowserClient::GetMediaObserver() {
204  return NULL;
205}
206
207blink::WebNotificationPresenter::Permission
208    ContentBrowserClient::CheckDesktopNotificationPermission(
209        const GURL& source_origin,
210        ResourceContext* context,
211        int render_process_id) {
212  return blink::WebNotificationPresenter::PermissionAllowed;
213}
214
215void ContentBrowserClient::RequestGeolocationPermission(
216    WebContents* web_contents,
217    int bridge_id,
218    const GURL& requesting_frame,
219    bool user_gesture,
220    base::Callback<void(bool)> result_callback,
221    base::Closure* cancel_callback) {
222  result_callback.Run(true);
223}
224
225void ContentBrowserClient::RequestMidiSysExPermission(
226    WebContents* web_contents,
227    int bridge_id,
228    const GURL& requesting_frame,
229    bool user_gesture,
230    base::Callback<void(bool)> result_callback,
231    base::Closure* cancel_callback) {
232  result_callback.Run(true);
233}
234
235void ContentBrowserClient::RequestProtectedMediaIdentifierPermission(
236    WebContents* web_contents,
237    const GURL& origin,
238    base::Callback<void(bool)> result_callback,
239    base::Closure* cancel_callback) {
240  result_callback.Run(true);
241}
242
243bool ContentBrowserClient::CanCreateWindow(
244    const GURL& opener_url,
245    const GURL& opener_top_level_frame_url,
246    const GURL& source_origin,
247    WindowContainerType container_type,
248    const GURL& target_url,
249    const Referrer& referrer,
250    WindowOpenDisposition disposition,
251    const blink::WebWindowFeatures& features,
252    bool user_gesture,
253    bool opener_suppressed,
254    ResourceContext* context,
255    int render_process_id,
256    int opener_id,
257    bool* no_javascript_access) {
258  *no_javascript_access = false;
259  return true;
260}
261
262std::string ContentBrowserClient::GetWorkerProcessTitle(
263    const GURL& url, ResourceContext* context) {
264  return std::string();
265}
266
267SpeechRecognitionManagerDelegate*
268    ContentBrowserClient::GetSpeechRecognitionManagerDelegate() {
269  return NULL;
270}
271
272net::NetLog* ContentBrowserClient::GetNetLog() {
273  return NULL;
274}
275
276AccessTokenStore* ContentBrowserClient::CreateAccessTokenStore() {
277  return NULL;
278}
279
280bool ContentBrowserClient::IsFastShutdownPossible() {
281  return true;
282}
283
284base::FilePath ContentBrowserClient::GetDefaultDownloadDirectory() {
285  return base::FilePath();
286}
287
288std::string ContentBrowserClient::GetDefaultDownloadName() {
289  return std::string();
290}
291
292BrowserPpapiHost*
293    ContentBrowserClient::GetExternalBrowserPpapiHost(int plugin_process_id) {
294  return NULL;
295}
296
297bool ContentBrowserClient::AllowPepperSocketAPI(
298    BrowserContext* browser_context,
299    const GURL& url,
300    bool private_api,
301    const SocketPermissionRequest* params) {
302  return false;
303}
304
305ui::SelectFilePolicy* ContentBrowserClient::CreateSelectFilePolicy(
306    WebContents* web_contents) {
307  return NULL;
308}
309
310LocationProvider* ContentBrowserClient::OverrideSystemLocationProvider() {
311  return NULL;
312}
313
314VibrationProvider* ContentBrowserClient::OverrideVibrationProvider() {
315  return NULL;
316}
317
318DevToolsManagerDelegate* ContentBrowserClient::GetDevToolsManagerDelegate() {
319  return NULL;
320}
321
322bool ContentBrowserClient::IsPluginAllowedToCallRequestOSFileHandle(
323    BrowserContext* browser_context,
324    const GURL& url) {
325  return false;
326}
327
328bool ContentBrowserClient::IsPluginAllowedToUseDevChannelAPIs(
329    BrowserContext* browser_context,
330    const GURL& url) {
331  return false;
332}
333
334net::CookieStore* ContentBrowserClient::OverrideCookieStoreForRenderProcess(
335    int render_process_id) {
336  return NULL;
337}
338
339#if defined(OS_WIN)
340const wchar_t* ContentBrowserClient::GetResourceDllName() {
341  return NULL;
342}
343#endif
344
345#if defined(VIDEO_HOLE)
346ExternalVideoSurfaceContainer*
347ContentBrowserClient::OverrideCreateExternalVideoSurfaceContainer(
348    WebContents* web_contents) {
349  return NULL;
350}
351#endif
352
353}  // namespace content
354