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.
5 #include "chrome/browser/chrome_content_browser_client.h"
11 #include "base/bind.h"
12 #include "base/command_line.h"
13 #include "base/lazy_instance.h"
14 #include "base/path_service.h"
15 #include "base/prefs/pref_service.h"
16 #include "base/prefs/scoped_user_pref_update.h"
17 #include "base/strings/string_number_conversions.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "base/threading/sequenced_worker_pool.h"
20 #include "chrome/browser/browser_about_handler.h"
21 #include "chrome/browser/browser_process.h"
22 #include "chrome/browser/browser_shutdown.h"
23 #include "chrome/browser/browsing_data/browsing_data_helper.h"
24 #include "chrome/browser/browsing_data/browsing_data_remover.h"
25 #include "chrome/browser/character_encoding.h"
26 #include "chrome/browser/chrome_content_browser_client_parts.h"
27 #include "chrome/browser/chrome_net_benchmarking_message_filter.h"
28 #include "chrome/browser/chrome_quota_permission_context.h"
29 #include "chrome/browser/content_settings/content_settings_utils.h"
30 #include "chrome/browser/content_settings/cookie_settings.h"
31 #include "chrome/browser/content_settings/host_content_settings_map.h"
32 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
33 #include "chrome/browser/defaults.h"
34 #include "chrome/browser/download/download_prefs.h"
35 #include "chrome/browser/font_family_cache.h"
36 #include "chrome/browser/geolocation/chrome_access_token_store.h"
37 #include "chrome/browser/geolocation/geolocation_permission_context.h"
38 #include "chrome/browser/geolocation/geolocation_permission_context_factory.h"
39 #include "chrome/browser/media/cast_transport_host_filter.h"
40 #include "chrome/browser/media/media_capture_devices_dispatcher.h"
41 #include "chrome/browser/media/midi_permission_context.h"
42 #include "chrome/browser/media/midi_permission_context_factory.h"
43 #include "chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.h"
44 #include "chrome/browser/nacl_host/nacl_browser_delegate_impl.h"
45 #include "chrome/browser/net/chrome_net_log.h"
46 #include "chrome/browser/notifications/desktop_notification_service.h"
47 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
48 #include "chrome/browser/platform_util.h"
49 #include "chrome/browser/plugins/plugin_info_message_filter.h"
50 #include "chrome/browser/prerender/prerender_final_status.h"
51 #include "chrome/browser/prerender/prerender_manager.h"
52 #include "chrome/browser/prerender/prerender_manager_factory.h"
53 #include "chrome/browser/prerender/prerender_message_filter.h"
54 #include "chrome/browser/prerender/prerender_tracker.h"
55 #include "chrome/browser/printing/printing_message_filter.h"
56 #include "chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.h"
57 #include "chrome/browser/profiles/profile.h"
58 #include "chrome/browser/profiles/profile_io_data.h"
59 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
60 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
61 #include "chrome/browser/search/instant_service.h"
62 #include "chrome/browser/search/instant_service_factory.h"
63 #include "chrome/browser/search/search.h"
64 #include "chrome/browser/search_engines/search_provider_install_state_message_filter.h"
65 #include "chrome/browser/signin/principals_message_filter.h"
66 #include "chrome/browser/speech/chrome_speech_recognition_manager_delegate.h"
67 #include "chrome/browser/speech/tts_controller.h"
68 #include "chrome/browser/speech/tts_message_filter.h"
69 #include "chrome/browser/ssl/ssl_add_certificate.h"
70 #include "chrome/browser/ssl/ssl_blocking_page.h"
71 #include "chrome/browser/ssl/ssl_client_certificate_selector.h"
72 #include "chrome/browser/tab_contents/tab_util.h"
73 #include "chrome/browser/ui/blocked_content/blocked_window_params.h"
74 #include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h"
75 #include "chrome/browser/ui/chrome_select_file_policy.h"
76 #include "chrome/browser/ui/sync/sync_promo_ui.h"
77 #include "chrome/browser/ui/tab_contents/chrome_web_contents_view_delegate.h"
78 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
79 #include "chrome/common/chrome_constants.h"
80 #include "chrome/common/chrome_paths.h"
81 #include "chrome/common/chrome_switches.h"
82 #include "chrome/common/env_vars.h"
83 #include "chrome/common/logging_chrome.h"
84 #include "chrome/common/pepper_permission_util.h"
85 #include "chrome/common/pref_names.h"
86 #include "chrome/common/render_messages.h"
87 #include "chrome/common/url_constants.h"
88 #include "chrome/grit/generated_resources.h"
89 #include "chrome/installer/util/google_update_settings.h"
90 #include "chromeos/chromeos_constants.h"
91 #include "components/cdm/browser/cdm_message_filter_android.h"
92 #include "components/cloud_devices/common/cloud_devices_switches.h"
93 #include "components/content_settings/core/browser/content_settings_provider.h"
94 #include "components/content_settings/core/common/content_settings.h"
95 #include "components/content_settings/core/common/permission_request_id.h"
96 #include "components/dom_distiller/core/url_constants.h"
97 #include "components/google/core/browser/google_util.h"
98 #include "components/metrics/client_info.h"
99 #include "components/pref_registry/pref_registry_syncable.h"
100 #include "components/signin/core/common/profile_management_switches.h"
101 #include "components/translate/core/common/translate_switches.h"
102 #include "content/public/browser/browser_child_process_host.h"
103 #include "content/public/browser/browser_main_parts.h"
104 #include "content/public/browser/browser_ppapi_host.h"
105 #include "content/public/browser/browser_thread.h"
106 #include "content/public/browser/browser_url_handler.h"
107 #include "content/public/browser/child_process_data.h"
108 #include "content/public/browser/child_process_security_policy.h"
109 #include "content/public/browser/desktop_notification_delegate.h"
110 #include "content/public/browser/render_frame_host.h"
111 #include "content/public/browser/render_process_host.h"
112 #include "content/public/browser/render_view_host.h"
113 #include "content/public/browser/resource_context.h"
114 #include "content/public/browser/site_instance.h"
115 #include "content/public/browser/web_contents.h"
116 #include "content/public/common/child_process_host.h"
117 #include "content/public/common/content_descriptors.h"
118 #include "content/public/common/show_desktop_notification_params.h"
119 #include "content/public/common/url_utils.h"
120 #include "content/public/common/web_preferences.h"
121 #include "net/base/mime_util.h"
122 #include "net/cookies/canonical_cookie.h"
123 #include "net/cookies/cookie_options.h"
124 #include "net/ssl/ssl_cert_request_info.h"
125 #include "ppapi/host/ppapi_host.h"
126 #include "ppapi/shared_impl/ppapi_switches.h"
127 #include "storage/browser/fileapi/external_mount_points.h"
128 #include "ui/base/l10n/l10n_util.h"
129 #include "ui/base/resource/resource_bundle.h"
130 #include "ui/resources/grit/ui_resources.h"
133 #include "base/win/windows_version.h"
134 #include "chrome/browser/chrome_browser_main_win.h"
135 #include "sandbox/win/src/sandbox_policy.h"
136 #elif defined(OS_MACOSX)
137 #include "chrome/browser/chrome_browser_main_mac.h"
138 #include "chrome/browser/spellchecker/spellcheck_message_filter_mac.h"
139 #include "components/crash/app/breakpad_mac.h"
140 #elif defined(OS_CHROMEOS)
141 #include "chrome/browser/chromeos/chrome_browser_main_chromeos.h"
142 #include "chrome/browser/chromeos/drive/fileapi/file_system_backend_delegate.h"
143 #include "chrome/browser/chromeos/file_manager/app_id.h"
144 #include "chrome/browser/chromeos/file_system_provider/fileapi/backend_delegate.h"
145 #include "chrome/browser/chromeos/fileapi/file_system_backend.h"
146 #include "chrome/browser/chromeos/fileapi/mtp_file_system_backend_delegate.h"
147 #include "chrome/browser/chromeos/login/startup_utils.h"
148 #include "chrome/browser/chromeos/system/input_device_settings.h"
149 #include "chromeos/chromeos_switches.h"
150 #include "components/user_manager/user_manager.h"
151 #elif defined(OS_LINUX)
152 #include "chrome/browser/chrome_browser_main_linux.h"
153 #elif defined(OS_ANDROID)
154 #include "chrome/browser/android/new_tab_page_url_handler.h"
155 #include "chrome/browser/android/webapps/single_tab_mode_tab_helper.h"
156 #include "chrome/browser/chrome_browser_main_android.h"
157 #include "chrome/browser/media/protected_media_identifier_permission_context.h"
158 #include "chrome/browser/media/protected_media_identifier_permission_context_factory.h"
159 #include "chrome/common/descriptors_android.h"
160 #include "components/crash/browser/crash_dump_manager_android.h"
161 #elif defined(OS_POSIX)
162 #include "chrome/browser/chrome_browser_main_posix.h"
165 #if defined(OS_POSIX) && !defined(OS_MACOSX)
166 #include "base/debug/leak_annotations.h"
167 #include "components/crash/app/breakpad_linux.h"
168 #include "components/crash/browser/crash_handler_host_linux.h"
171 #if defined(OS_ANDROID)
172 #include "ui/base/ui_base_paths.h"
173 #include "ui/gfx/android/device_display_info.h"
176 #if defined(OS_ANDROID)
177 #include "chrome/browser/android/dev_tools_manager_delegate_android.h"
179 #include "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
182 #if !defined(OS_CHROMEOS)
183 #include "chrome/browser/signin/chrome_signin_client.h"
184 #include "chrome/browser/signin/chrome_signin_client_factory.h"
185 #include "chrome/browser/signin/signin_manager_factory.h"
186 #include "components/signin/core/browser/signin_manager.h"
189 #if defined(TOOLKIT_VIEWS)
190 #include "chrome/browser/ui/views/chrome_browser_main_extra_parts_views.h"
193 #if defined(USE_ATHENA)
194 #include "athena/content/public/web_contents_view_delegate_creator.h"
195 #include "chrome/browser/ui/views/athena/chrome_browser_main_extra_parts_athena.h"
196 #elif defined(USE_ASH)
197 #include "chrome/browser/ui/views/ash/chrome_browser_main_extra_parts_ash.h"
200 #if defined(USE_AURA)
201 #include "chrome/browser/ui/aura/chrome_browser_main_extra_parts_aura.h"
205 #include "chrome/browser/chrome_browser_main_extra_parts_x11.h"
208 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
209 #include "chrome/browser/captive_portal/captive_portal_tab_helper.h"
212 #if !defined(DISABLE_NACL)
213 #include "components/nacl/browser/nacl_browser.h"
214 #include "components/nacl/browser/nacl_host_message_filter.h"
215 #include "components/nacl/browser/nacl_process_host.h"
216 #include "components/nacl/common/nacl_process_type.h"
217 #include "components/nacl/common/nacl_switches.h"
220 #if defined(ENABLE_EXTENSIONS)
221 #include "chrome/browser/extensions/chrome_content_browser_client_extensions_part.h"
222 #include "chrome/browser/extensions/extension_service.h"
223 #include "chrome/browser/extensions/extension_util.h"
224 #include "chrome/browser/speech/extension_api/tts_engine_extension_api.h"
225 #include "extensions/browser/extension_system.h"
226 #include "extensions/browser/guest_view/guest_view_base.h"
227 #include "extensions/browser/guest_view/guest_view_manager.h"
228 #include "extensions/browser/guest_view/web_view/web_view_guest.h"
229 #include "extensions/browser/guest_view/web_view/web_view_permission_helper.h"
230 #include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
231 #include "extensions/browser/suggest_permission_util.h"
232 #include "extensions/common/constants.h"
233 #include "extensions/common/extension.h"
234 #include "extensions/common/extension_set.h"
235 #include "extensions/common/manifest_handlers/background_info.h"
236 #include "extensions/common/manifest_handlers/shared_module_info.h"
237 #include "extensions/common/permissions/permissions_data.h"
238 #include "extensions/common/permissions/socket_permission.h"
239 #include "extensions/common/switches.h"
242 #if defined(ENABLE_SPELLCHECK)
243 #include "chrome/browser/spellchecker/spellcheck_message_filter.h"
246 #if defined(ENABLE_WEBRTC)
247 #include "chrome/browser/media/webrtc_logging_handler_host.h"
250 using base::FileDescriptor;
251 using blink::WebWindowFeatures;
252 using content::AccessTokenStore;
253 using content::BrowserThread;
254 using content::BrowserURLHandler;
255 using content::ChildProcessSecurityPolicy;
256 using content::QuotaPermissionContext;
257 using content::RenderFrameHost;
258 using content::RenderViewHost;
259 using content::ResourceType;
260 using content::SiteInstance;
261 using content::WebContents;
262 using content::WebPreferences;
263 using message_center::NotifierId;
265 #if defined(OS_POSIX)
266 using content::FileDescriptorInfo;
269 #if defined(ENABLE_EXTENSIONS)
270 using extensions::APIPermission;
271 using extensions::ChromeContentBrowserClientExtensionsPart;
272 using extensions::Extension;
273 using extensions::InfoMap;
274 using extensions::Manifest;
279 // Cached version of the locale so we can return the locale on the I/O
281 base::LazyInstance<std::string> g_io_thread_application_locale;
283 #if defined(ENABLE_PLUGINS)
284 // TODO(teravest): Add renderer-side API-specific checking for these APIs so
285 // that blanket permission isn't granted to all dev channel APIs for these.
286 // http://crbug.com/386743
287 const char* const kPredefinedAllowedDevChannelOrigins[] = {
288 "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F", // see crbug.com/383937
289 "4EB74897CB187C7633357C2FE832E0AD6A44883A" // see crbug.com/383937
292 const char* const kPredefinedAllowedFileHandleOrigins[] = {
293 "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F", // see crbug.com/234789
294 "4EB74897CB187C7633357C2FE832E0AD6A44883A" // see crbug.com/234789
297 const char* const kPredefinedAllowedSocketOrigins[] = {
298 "okddffdblfhhnmhodogpojmfkjmhinfp", // Test SSH Client
299 "pnhechapfaindjhompbnflcldabbghjo", // HTerm App (SSH Client)
300 "bglhmjfplikpjnfoegeomebmfnkjomhe", // see crbug.com/122126
301 "gbchcmhmhahfdphkhkmpfmihenigjmpp", // Chrome Remote Desktop
302 "kgngmbheleoaphbjbaiobfdepmghbfah", // Pre-release Chrome Remote Desktop
303 "odkaodonbgfohohmklejpjiejmcipmib", // Dogfood Chrome Remote Desktop
304 "ojoimpklfciegopdfgeenehpalipignm", // Chromoting canary
305 "cbkkbcmdlboombapidmoeolnmdacpkch", // see crbug.com/129089
306 "hhnbmknkdabfoieppbbljkhkfjcmcbjh", // see crbug.com/134099
307 "mablfbjkhmhkmefkjjacnbaikjkipphg", // see crbug.com/134099
308 "pdeelgamlgannhelgoegilelnnojegoh", // see crbug.com/134099
309 "cabapfdbkniadpollkckdnedaanlciaj", // see crbug.com/134099
310 "mapljbgnjledlpdmlchihnmeclmefbba", // see crbug.com/134099
311 "ghbfeebgmiidnnmeobbbaiamklmpbpii", // see crbug.com/134099
312 "jdfhpkjeckflbbleddjlpimecpbjdeep", // see crbug.com/142514
313 "iabmpiboiopbgfabjmgeedhcmjenhbla", // see crbug.com/165080
314 "B7CF8A292249681AF81771650BA4CEEAF19A4560", // see crbug.com/165080
315 "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F", // see crbug.com/234789
316 "4EB74897CB187C7633357C2FE832E0AD6A44883A", // see crbug.com/234789
317 "7525AF4F66763A70A883C4700529F647B470E4D2", // see crbug.com/238084
318 "0B549507088E1564D672F7942EB87CA4DAD73972", // see crbug.com/238084
319 "864288364E239573E777D3E0E36864E590E95C74" // see crbug.com/238084
323 // Returns a copy of the given url with its host set to given host and path set
324 // to given path. Other parts of the url will be the same.
325 GURL ReplaceURLHostAndPath(const GURL& url,
326 const std::string& host,
327 const std::string& path) {
328 url::Replacements<char> replacements;
329 replacements.SetHost(host.c_str(), url::Component(0, host.length()));
330 replacements.SetPath(path.c_str(), url::Component(0, path.length()));
331 return url.ReplaceComponents(replacements);
334 // Maps "foo://bar/baz/" to "foo://chrome/bar/baz/".
335 GURL AddUberHost(const GURL& url) {
336 const std::string uber_host = chrome::kChromeUIUberHost;
337 const std::string new_path = url.host() + url.path();
339 return ReplaceURLHostAndPath(url, uber_host, new_path);
342 // If url->host() is "chrome" and url->path() has characters other than the
343 // first slash, changes the url from "foo://chrome/bar/" to "foo://bar/" and
344 // returns true. Otherwise returns false.
345 bool RemoveUberHost(GURL* url) {
346 if (url->host() != chrome::kChromeUIUberHost)
349 if (url->path().empty() || url->path() == "/")
352 const std::string old_path = url->path();
354 const std::string::size_type separator = old_path.find('/', 1);
355 std::string new_host;
356 std::string new_path;
357 if (separator == std::string::npos) {
358 new_host = old_path.substr(1);
360 new_host = old_path.substr(1, separator - 1);
361 new_path = old_path.substr(separator);
364 // Do not allow URLs with paths empty before the first slash since we can't
365 // have an empty host. (e.g "foo://chrome//")
366 if (new_host.empty())
369 *url = ReplaceURLHostAndPath(*url, new_host, new_path);
371 DCHECK(url->is_valid());
376 // Handles rewriting Web UI URLs.
377 bool HandleWebUI(GURL* url, content::BrowserContext* browser_context) {
378 // Do not handle special URLs such as "about:foo"
379 if (!url->host().empty()) {
380 const GURL chrome_url = AddUberHost(*url);
382 // Handle valid "chrome://chrome/foo" URLs so the reverse handler will
384 if (ChromeWebUIControllerFactory::GetInstance()->UseWebUIForURL(
385 browser_context, chrome_url))
389 if (!ChromeWebUIControllerFactory::GetInstance()->UseWebUIForURL(
390 browser_context, *url))
393 #if defined(OS_CHROMEOS)
394 // Special case : in ChromeOS in Guest mode bookmarks and history are
395 // disabled for security reasons. New tab page explains the reasons, so
396 // we redirect user to new tab page.
397 if (user_manager::UserManager::Get()->IsLoggedInAsGuest()) {
398 if (url->SchemeIs(content::kChromeUIScheme) &&
399 (url->DomainIs(chrome::kChromeUIBookmarksHost) ||
400 url->DomainIs(chrome::kChromeUIHistoryHost))) {
401 // Rewrite with new tab URL
402 *url = GURL(chrome::kChromeUINewTabURL);
410 // Reverse URL handler for Web UI. Maps "chrome://chrome/foo/" to
412 bool HandleWebUIReverse(GURL* url, content::BrowserContext* browser_context) {
413 if (!url->is_valid() || !url->SchemeIs(content::kChromeUIScheme))
416 return RemoveUberHost(url);
419 bool CertMatchesFilter(const net::X509Certificate& cert,
420 const base::DictionaryValue& filter) {
421 // TODO(markusheintz): This is the minimal required filter implementation.
422 // Implement a better matcher.
424 // An empty filter matches any client certificate since no requirements are
429 std::string common_name;
430 if (filter.GetString("ISSUER.CN", &common_name) &&
431 (cert.issuer().common_name == common_name)) {
437 #if defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
438 breakpad::CrashHandlerHostLinux* CreateCrashHandlerHost(
439 const std::string& process_type) {
440 base::FilePath dumps_path;
441 PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path);
443 ANNOTATE_SCOPED_MEMORY_LEAK;
444 bool upload = (getenv(env_vars::kHeadless) == NULL);
445 breakpad::CrashHandlerHostLinux* crash_handler =
446 new breakpad::CrashHandlerHostLinux(process_type, dumps_path, upload);
447 crash_handler->StartUploaderThread();
448 return crash_handler;
452 int GetCrashSignalFD(const CommandLine& command_line) {
453 // Extensions have the same process type as renderers.
454 if (command_line.HasSwitch(extensions::switches::kExtensionProcess)) {
455 static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
457 crash_handler = CreateCrashHandlerHost("extension");
458 return crash_handler->GetDeathSignalSocket();
461 std::string process_type =
462 command_line.GetSwitchValueASCII(switches::kProcessType);
464 if (process_type == switches::kRendererProcess) {
465 static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
467 crash_handler = CreateCrashHandlerHost(process_type);
468 return crash_handler->GetDeathSignalSocket();
471 if (process_type == switches::kPluginProcess) {
472 static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
474 crash_handler = CreateCrashHandlerHost(process_type);
475 return crash_handler->GetDeathSignalSocket();
478 if (process_type == switches::kPpapiPluginProcess) {
479 static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
481 crash_handler = CreateCrashHandlerHost(process_type);
482 return crash_handler->GetDeathSignalSocket();
485 if (process_type == switches::kGpuProcess) {
486 static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
488 crash_handler = CreateCrashHandlerHost(process_type);
489 return crash_handler->GetDeathSignalSocket();
494 #endif // defined(OS_POSIX) && !defined(OS_ANDROID) && !defined(OS_MACOSX)
496 #if !defined(OS_CHROMEOS)
497 GURL GetEffectiveURLForSignin(const GURL& url) {
498 CHECK(SigninManager::IsWebBasedSigninFlowURL(url));
500 GURL effective_url(SigninManager::kChromeSigninEffectiveSite);
501 // Copy the path because the argument to SetPathStr must outlive
502 // the Replacements object.
503 const std::string path_copy(url.path());
504 GURL::Replacements replacements;
505 replacements.SetPathStr(path_copy);
506 effective_url = effective_url.ReplaceComponents(replacements);
507 return effective_url;
511 void SetApplicationLocaleOnIOThread(const std::string& locale) {
512 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
513 g_io_thread_application_locale.Get() = locale;
516 void HandleBlockedPopupOnUIThread(const BlockedWindowParams& params) {
517 WebContents* tab = tab_util::GetWebContentsByID(params.render_process_id(),
522 prerender::PrerenderContents* prerender_contents =
523 prerender::PrerenderContents::FromWebContents(tab);
524 if (prerender_contents) {
525 prerender_contents->Destroy(prerender::FINAL_STATUS_CREATE_NEW_WINDOW);
529 PopupBlockerTabHelper* popup_helper =
530 PopupBlockerTabHelper::FromWebContents(tab);
533 popup_helper->AddBlockedPopup(params);
536 #if defined(OS_ANDROID)
538 void HandleSingleTabModeBlockOnUIThread(const BlockedWindowParams& params) {
539 WebContents* web_contents =
540 tab_util::GetWebContentsByID(params.render_process_id(),
545 SingleTabModeTabHelper::FromWebContents(web_contents)->HandleOpenUrl(params);
548 float GetDeviceScaleAdjustment() {
549 static const float kMinFSM = 1.05f;
550 static const int kWidthForMinFSM = 320;
551 static const float kMaxFSM = 1.3f;
552 static const int kWidthForMaxFSM = 800;
554 gfx::DeviceDisplayInfo info;
555 int minWidth = info.GetSmallestDIPWidth();
557 if (minWidth <= kWidthForMinFSM)
559 if (minWidth >= kWidthForMaxFSM)
562 // The font scale multiplier varies linearly between kMinFSM and kMaxFSM.
563 float ratio = static_cast<float>(minWidth - kWidthForMinFSM) /
564 (kWidthForMaxFSM - kWidthForMinFSM);
565 return ratio * (kMaxFSM - kMinFSM) + kMinFSM;
568 #endif // defined(OS_ANDROID)
570 #if defined(ENABLE_EXTENSIONS)
571 // By default, JavaScript and images are enabled in guest content.
572 void GetGuestViewDefaultContentSettingRules(
574 RendererContentSettingRules* rules) {
575 rules->image_rules.push_back(
576 ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
577 ContentSettingsPattern::Wildcard(),
578 CONTENT_SETTING_ALLOW,
582 rules->script_rules.push_back(
583 ContentSettingPatternSource(ContentSettingsPattern::Wildcard(),
584 ContentSettingsPattern::Wildcard(),
585 CONTENT_SETTING_ALLOW,
589 #endif // defined(ENALBE_EXTENSIONS)
595 ChromeContentBrowserClient::ChromeContentBrowserClient()
596 : prerender_tracker_(NULL),
597 weak_factory_(this) {
598 #if defined(ENABLE_PLUGINS)
599 for (size_t i = 0; i < arraysize(kPredefinedAllowedDevChannelOrigins); ++i)
600 allowed_dev_channel_origins_.insert(kPredefinedAllowedDevChannelOrigins[i]);
601 for (size_t i = 0; i < arraysize(kPredefinedAllowedFileHandleOrigins); ++i)
602 allowed_file_handle_origins_.insert(kPredefinedAllowedFileHandleOrigins[i]);
603 for (size_t i = 0; i < arraysize(kPredefinedAllowedSocketOrigins); ++i)
604 allowed_socket_origins_.insert(kPredefinedAllowedSocketOrigins[i]);
607 #if !defined(OS_ANDROID)
608 TtsExtensionEngine* tts_extension_engine = TtsExtensionEngine::GetInstance();
609 TtsController::GetInstance()->SetTtsEngineDelegate(tts_extension_engine);
612 #if defined(ENABLE_EXTENSIONS)
613 extra_parts_.push_back(new ChromeContentBrowserClientExtensionsPart);
617 ChromeContentBrowserClient::~ChromeContentBrowserClient() {
618 for (int i = static_cast<int>(extra_parts_.size()) - 1; i >= 0; --i)
619 delete extra_parts_[i];
620 extra_parts_.clear();
624 void ChromeContentBrowserClient::RegisterProfilePrefs(
625 user_prefs::PrefRegistrySyncable* registry) {
626 registry->RegisterBooleanPref(
627 prefs::kDisable3DAPIs,
629 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
630 registry->RegisterBooleanPref(
631 prefs::kEnableHyperlinkAuditing,
633 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
634 registry->RegisterListPref(
635 prefs::kEnableDeprecatedWebPlatformFeatures,
636 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
640 void ChromeContentBrowserClient::SetApplicationLocale(
641 const std::string& locale) {
642 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
644 // This object is guaranteed to outlive all threads so we don't have to
645 // worry about the lack of refcounting and can just post as Unretained.
647 // The common case is that this function is called early in Chrome startup
648 // before any threads are created (it will also be called later if the user
649 // changes the pref). In this case, there will be no threads created and
650 // posting will fail. When there are no threads, we can just set the string
651 // without worrying about threadsafety.
652 if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
653 base::Bind(&SetApplicationLocaleOnIOThread, locale))) {
654 g_io_thread_application_locale.Get() = locale;
658 content::BrowserMainParts* ChromeContentBrowserClient::CreateBrowserMainParts(
659 const content::MainFunctionParams& parameters) {
660 ChromeBrowserMainParts* main_parts;
661 // Construct the Main browser parts based on the OS type.
663 main_parts = new ChromeBrowserMainPartsWin(parameters);
664 #elif defined(OS_MACOSX)
665 main_parts = new ChromeBrowserMainPartsMac(parameters);
666 #elif defined(OS_CHROMEOS)
667 main_parts = new chromeos::ChromeBrowserMainPartsChromeos(parameters);
668 #elif defined(OS_LINUX)
669 main_parts = new ChromeBrowserMainPartsLinux(parameters);
670 #elif defined(OS_ANDROID)
671 main_parts = new ChromeBrowserMainPartsAndroid(parameters);
672 #elif defined(OS_POSIX)
673 main_parts = new ChromeBrowserMainPartsPosix(parameters);
676 main_parts = new ChromeBrowserMainParts(parameters);
679 chrome::AddProfilesExtraParts(main_parts);
681 // Construct additional browser parts. Stages are called in the order in
682 // which they are added.
683 #if defined(TOOLKIT_VIEWS)
684 main_parts->AddParts(new ChromeBrowserMainExtraPartsViews());
687 // TODO(oshima): Athena on chrome currently requires USE_ASH to build.
688 // We should reduce the dependency as much as possible.
689 #if defined(USE_ATHENA)
690 main_parts->AddParts(CreateChromeBrowserMainExtraPartsAthena());
691 #elif defined(USE_ASH)
692 main_parts->AddParts(new ChromeBrowserMainExtraPartsAsh());
695 #if defined(USE_AURA)
696 main_parts->AddParts(new ChromeBrowserMainExtraPartsAura());
700 main_parts->AddParts(new ChromeBrowserMainExtraPartsX11());
703 chrome::AddMetricsExtraParts(main_parts);
708 std::string ChromeContentBrowserClient::GetStoragePartitionIdForSite(
709 content::BrowserContext* browser_context,
711 std::string partition_id;
713 // The partition ID for webview guest processes is the string value of its
714 // SiteInstance URL - "chrome-guest://app_id/persist?partition".
715 if (site.SchemeIs(content::kGuestScheme)) {
716 partition_id = site.spec();
717 } else if (site.GetOrigin().spec() == kChromeUIChromeSigninURL) {
718 // Chrome signin page has an embedded iframe of extension and web content,
719 // thus it must be isolated from other webUI pages.
720 partition_id = site.GetOrigin().spec();
723 DCHECK(IsValidStoragePartitionId(browser_context, partition_id));
727 bool ChromeContentBrowserClient::IsValidStoragePartitionId(
728 content::BrowserContext* browser_context,
729 const std::string& partition_id) {
730 // The default ID is empty and is always valid.
731 if (partition_id.empty())
734 return GURL(partition_id).is_valid();
737 void ChromeContentBrowserClient::GetStoragePartitionConfigForSite(
738 content::BrowserContext* browser_context,
741 std::string* partition_domain,
742 std::string* partition_name,
744 // Default to the browser-wide storage partition and override based on |site|
746 partition_domain->clear();
747 partition_name->clear();
750 bool success = false;
751 #if defined(ENABLE_EXTENSIONS)
752 success = extensions::WebViewGuest::GetGuestPartitionConfigForSite(
753 site, partition_domain, partition_name, in_memory);
755 if (!success && site.SchemeIs(extensions::kExtensionScheme)) {
756 // If |can_be_default| is false, the caller is stating that the |site|
757 // should be parsed as if it had isolated storage. In particular it is
758 // important to NOT check ExtensionService for the is_storage_isolated()
759 // attribute because this code path is run during Extension uninstall
760 // to do cleanup after the Extension has already been unloaded from the
762 bool is_isolated = !can_be_default;
763 if (can_be_default) {
764 if (extensions::util::SiteHasIsolatedStorage(site, browser_context))
769 CHECK(site.has_host());
770 // For extensions with isolated storage, the the host of the |site| is
771 // the |partition_domain|. The |in_memory| and |partition_name| are only
772 // used in guest schemes so they are cleared here.
773 *partition_domain = site.host();
775 partition_name->clear();
781 if (!success && (site.GetOrigin().spec() == kChromeUIChromeSigninURL)) {
782 // Chrome signin page has an embedded iframe of extension and web content,
783 // thus it must be isolated from other webUI pages.
784 *partition_domain = chrome::kChromeUIChromeSigninHost;
787 // Assert that if |can_be_default| is false, the code above must have found a
788 // non-default partition. If this fails, the caller has a serious logic
789 // error about which StoragePartition they expect to be in and it is not
791 CHECK(can_be_default || !partition_domain->empty());
794 content::WebContentsViewDelegate*
795 ChromeContentBrowserClient::GetWebContentsViewDelegate(
796 content::WebContents* web_contents) {
797 #if defined(USE_ATHENA)
798 return athena::CreateWebContentsViewDelegate(web_contents);
800 return chrome::CreateWebContentsViewDelegate(web_contents);
804 void ChromeContentBrowserClient::RenderProcessWillLaunch(
805 content::RenderProcessHost* host) {
806 int id = host->GetID();
807 Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext());
808 net::URLRequestContextGetter* context =
809 profile->GetRequestContextForRenderProcess(id);
811 host->AddFilter(new ChromeRenderMessageFilter(id, profile));
812 #if defined(ENABLE_PLUGINS)
813 host->AddFilter(new PluginInfoMessageFilter(id, profile));
815 host->AddFilter(new cast::CastTransportHostFilter);
816 #if defined(ENABLE_PRINTING)
817 host->AddFilter(new printing::PrintingMessageFilter(id, profile));
819 host->AddFilter(new SearchProviderInstallStateMessageFilter(id, profile));
820 #if defined(ENABLE_SPELLCHECK)
821 host->AddFilter(new SpellCheckMessageFilter(id));
823 #if defined(OS_MACOSX)
824 host->AddFilter(new SpellCheckMessageFilterMac(id));
826 host->AddFilter(new ChromeNetBenchmarkingMessageFilter(profile, context));
827 host->AddFilter(new prerender::PrerenderMessageFilter(id, profile));
828 host->AddFilter(new TtsMessageFilter(id, host->GetBrowserContext()));
829 #if defined(ENABLE_WEBRTC)
830 WebRtcLoggingHandlerHost* webrtc_logging_handler_host =
831 new WebRtcLoggingHandlerHost(profile);
832 host->SetWebRtcLogMessageCallback(base::Bind(
833 &WebRtcLoggingHandlerHost::LogMessage, webrtc_logging_handler_host));
834 host->AddFilter(webrtc_logging_handler_host);
835 host->SetUserData(host, new base::UserDataAdapter<WebRtcLoggingHandlerHost>(
836 webrtc_logging_handler_host));
838 #if !defined(DISABLE_NACL)
839 host->AddFilter(new nacl::NaClHostMessageFilter(
840 id, profile->IsOffTheRecord(),
844 #if defined(OS_ANDROID)
845 host->AddFilter(new cdm::CdmMessageFilterAndroid());
847 if (switches::IsEnableAccountConsistency())
848 host->AddFilter(new PrincipalsMessageFilter(id));
850 host->Send(new ChromeViewMsg_SetIsIncognitoProcess(
851 profile->IsOffTheRecord()));
853 for (size_t i = 0; i < extra_parts_.size(); ++i)
854 extra_parts_[i]->RenderProcessWillLaunch(host);
856 RendererContentSettingRules rules;
857 if (host->IsIsolatedGuest()) {
858 #if defined(ENABLE_EXTENSIONS)
859 GetGuestViewDefaultContentSettingRules(profile->IsOffTheRecord(), &rules);
864 GetRendererContentSettingRules(
865 profile->GetHostContentSettingsMap(), &rules);
867 host->Send(new ChromeViewMsg_SetContentSettingRules(rules));
870 GURL ChromeContentBrowserClient::GetEffectiveURL(
871 content::BrowserContext* browser_context, const GURL& url) {
872 Profile* profile = Profile::FromBrowserContext(browser_context);
876 // If the input |url| should be assigned to the Instant renderer, make its
877 // effective URL distinct from other URLs on the search provider's domain.
878 if (chrome::ShouldAssignURLToInstantRenderer(url, profile))
879 return chrome::GetEffectiveURLForInstant(url, profile);
881 #if !defined(OS_CHROMEOS)
882 // If the input |url| should be assigned to the Signin renderer, make its
883 // effective URL distinct from other URLs on the signin service's domain.
884 // Note that the signin renderer will be allowed to sign the user in to
886 if (SigninManager::IsWebBasedSigninFlowURL(url))
887 return GetEffectiveURLForSignin(url);
890 #if defined(ENABLE_EXTENSIONS)
891 return ChromeContentBrowserClientExtensionsPart::GetEffectiveURL(
898 bool ChromeContentBrowserClient::ShouldUseProcessPerSite(
899 content::BrowserContext* browser_context, const GURL& effective_url) {
900 // Non-extension, non-Instant URLs should generally use
901 // process-per-site-instance. Because we expect to use the effective URL,
902 // URLs for hosted apps (apart from bookmark apps) should have an extension
905 Profile* profile = Profile::FromBrowserContext(browser_context);
909 if (chrome::ShouldUseProcessPerSiteForInstantURL(effective_url, profile))
912 #if !defined(OS_CHROMEOS)
913 if (SigninManager::IsWebBasedSigninFlowURL(effective_url))
917 #if defined(ENABLE_EXTENSIONS)
918 return ChromeContentBrowserClientExtensionsPart::ShouldUseProcessPerSite(
919 profile, effective_url);
925 // These are treated as WebUI schemes but do not get WebUI bindings. Also,
926 // view-source is allowed for these schemes.
927 void ChromeContentBrowserClient::GetAdditionalWebUISchemes(
928 std::vector<std::string>* additional_schemes) {
929 additional_schemes->push_back(chrome::kChromeSearchScheme);
930 additional_schemes->push_back(dom_distiller::kDomDistillerScheme);
933 void ChromeContentBrowserClient::GetAdditionalWebUIHostsToIgnoreParititionCheck(
934 std::vector<std::string>* hosts) {
935 hosts->push_back(chrome::kChromeUIExtensionIconHost);
936 hosts->push_back(chrome::kChromeUIFaviconHost);
937 hosts->push_back(chrome::kChromeUIThemeHost);
938 hosts->push_back(chrome::kChromeUIThumbnailHost);
939 hosts->push_back(chrome::kChromeUIThumbnailHost2);
940 hosts->push_back(chrome::kChromeUIThumbnailListHost);
943 net::URLRequestContextGetter*
944 ChromeContentBrowserClient::CreateRequestContext(
945 content::BrowserContext* browser_context,
946 content::ProtocolHandlerMap* protocol_handlers,
947 content::URLRequestInterceptorScopedVector request_interceptors) {
948 Profile* profile = Profile::FromBrowserContext(browser_context);
949 return profile->CreateRequestContext(protocol_handlers,
950 request_interceptors.Pass());
953 net::URLRequestContextGetter*
954 ChromeContentBrowserClient::CreateRequestContextForStoragePartition(
955 content::BrowserContext* browser_context,
956 const base::FilePath& partition_path,
958 content::ProtocolHandlerMap* protocol_handlers,
959 content::URLRequestInterceptorScopedVector request_interceptors) {
960 Profile* profile = Profile::FromBrowserContext(browser_context);
961 return profile->CreateRequestContextForStoragePartition(
965 request_interceptors.Pass());
968 bool ChromeContentBrowserClient::IsHandledURL(const GURL& url) {
969 return ProfileIOData::IsHandledURL(url);
972 bool ChromeContentBrowserClient::CanCommitURL(
973 content::RenderProcessHost* process_host,
975 #if defined(ENABLE_EXTENSIONS)
976 return ChromeContentBrowserClientExtensionsPart::CanCommitURL(
983 bool ChromeContentBrowserClient::ShouldAllowOpenURL(
984 content::SiteInstance* site_instance, const GURL& url) {
985 GURL from_url = site_instance->GetSiteURL();
987 #if defined(ENABLE_EXTENSIONS)
989 if (ChromeContentBrowserClientExtensionsPart::ShouldAllowOpenURL(
990 site_instance, from_url, url, &result))
994 // Do not allow chrome://chrome-signin navigate to other chrome:// URLs, since
995 // the signin page may host untrusted web content.
996 if (from_url.GetOrigin().spec() == chrome::kChromeUIChromeSigninURL &&
997 url.SchemeIs(content::kChromeUIScheme) &&
998 url.host() != chrome::kChromeUIChromeSigninHost) {
999 VLOG(1) << "Blocked navigation to " << url.spec() << " from "
1000 << chrome::kChromeUIChromeSigninURL;
1007 bool ChromeContentBrowserClient::IsSuitableHost(
1008 content::RenderProcessHost* process_host,
1009 const GURL& site_url) {
1011 Profile::FromBrowserContext(process_host->GetBrowserContext());
1012 // This may be NULL during tests. In that case, just assume any site can
1017 // Instant URLs should only be in the instant process and instant process
1018 // should only have Instant URLs.
1019 InstantService* instant_service =
1020 InstantServiceFactory::GetForProfile(profile);
1021 if (instant_service) {
1022 bool is_instant_process = instant_service->IsInstantProcess(
1023 process_host->GetID());
1024 bool should_be_in_instant_process =
1025 chrome::ShouldAssignURLToInstantRenderer(site_url, profile);
1026 if (is_instant_process || should_be_in_instant_process)
1027 return is_instant_process && should_be_in_instant_process;
1030 #if !defined(OS_CHROMEOS)
1031 SigninClient* signin_client =
1032 ChromeSigninClientFactory::GetForProfile(profile);
1033 if (signin_client && signin_client->IsSigninProcess(process_host->GetID()))
1034 return SigninManager::IsWebBasedSigninFlowURL(site_url);
1037 #if defined(ENABLE_EXTENSIONS)
1038 return ChromeContentBrowserClientExtensionsPart::IsSuitableHost(
1039 profile, process_host, site_url);
1045 bool ChromeContentBrowserClient::MayReuseHost(
1046 content::RenderProcessHost* process_host) {
1047 // If there is currently a prerender in progress for the host provided,
1048 // it may not be shared. We require prerenders to be by themselves in a
1049 // separate process, so that we can monitor their resource usage, and so that
1050 // we can track the cookies that they change.
1051 Profile* profile = Profile::FromBrowserContext(
1052 process_host->GetBrowserContext());
1053 prerender::PrerenderManager* prerender_manager =
1054 prerender::PrerenderManagerFactory::GetForProfile(profile);
1055 if (prerender_manager &&
1056 !prerender_manager->MayReuseProcessHost(process_host)) {
1063 bool ChromeContentBrowserClient::ShouldTryToUseExistingProcessHost(
1064 content::BrowserContext* browser_context, const GURL& url) {
1065 // It has to be a valid URL for us to check for an extension.
1066 if (!url.is_valid())
1069 #if defined(ENABLE_EXTENSIONS)
1070 Profile* profile = Profile::FromBrowserContext(browser_context);
1071 return ChromeContentBrowserClientExtensionsPart::
1072 ShouldTryToUseExistingProcessHost(
1079 void ChromeContentBrowserClient::SiteInstanceGotProcess(
1080 SiteInstance* site_instance) {
1081 CHECK(site_instance->HasProcess());
1083 Profile* profile = Profile::FromBrowserContext(
1084 site_instance->GetBrowserContext());
1088 // Remember the ID of the Instant process to signal the renderer process
1089 // on startup in |AppendExtraCommandLineSwitches| below.
1090 if (chrome::ShouldAssignURLToInstantRenderer(
1091 site_instance->GetSiteURL(), profile)) {
1092 InstantService* instant_service =
1093 InstantServiceFactory::GetForProfile(profile);
1094 if (instant_service)
1095 instant_service->AddInstantProcess(site_instance->GetProcess()->GetID());
1098 #if !defined(OS_CHROMEOS)
1099 // We only expect there to be one signin process as we use process-per-site
1100 // for signin URLs. The signin process will be cleared from SigninManager
1101 // when the renderer is destroyed.
1102 if (SigninManager::IsWebBasedSigninFlowURL(site_instance->GetSiteURL())) {
1103 SigninClient* signin_client =
1104 ChromeSigninClientFactory::GetForProfile(profile);
1106 signin_client->SetSigninProcess(site_instance->GetProcess()->GetID());
1107 #if defined(ENABLE_EXTENSIONS)
1108 ChromeContentBrowserClientExtensionsPart::SetSigninProcess(site_instance);
1113 for (size_t i = 0; i < extra_parts_.size(); ++i)
1114 extra_parts_[i]->SiteInstanceGotProcess(site_instance);
1117 void ChromeContentBrowserClient::SiteInstanceDeleting(
1118 SiteInstance* site_instance) {
1119 if (!site_instance->HasProcess())
1122 for (size_t i = 0; i < extra_parts_.size(); ++i)
1123 extra_parts_[i]->SiteInstanceDeleting(site_instance);
1126 bool ChromeContentBrowserClient::ShouldSwapBrowsingInstancesForNavigation(
1127 SiteInstance* site_instance,
1128 const GURL& current_url,
1129 const GURL& new_url) {
1130 #if defined(ENABLE_EXTENSIONS)
1131 return ChromeContentBrowserClientExtensionsPart::
1132 ShouldSwapBrowsingInstancesForNavigation(
1133 site_instance, current_url, new_url);
1139 bool ChromeContentBrowserClient::ShouldSwapProcessesForRedirect(
1140 content::ResourceContext* resource_context, const GURL& current_url,
1141 const GURL& new_url) {
1142 #if defined(ENABLE_EXTENSIONS)
1143 return ChromeContentBrowserClientExtensionsPart::
1144 ShouldSwapProcessesForRedirect(resource_context, current_url, new_url);
1150 bool ChromeContentBrowserClient::ShouldAssignSiteForURL(const GURL& url) {
1151 return !url.SchemeIs(chrome::kChromeNativeScheme);
1154 std::string ChromeContentBrowserClient::GetCanonicalEncodingNameByAliasName(
1155 const std::string& alias_name) {
1156 return CharacterEncoding::GetCanonicalEncodingNameByAliasName(alias_name);
1161 bool IsAutoReloadEnabled() {
1162 // Fetch the field trial, even though we don't use it. Calling FindFullName()
1163 // causes the field-trial mechanism to report which group we're in, which
1164 // might reflect a hard disable or hard enable via flag, both of which have
1165 // their own field trial groups. This lets us know what percentage of users
1166 // manually enable or disable auto-reload.
1167 std::string group = base::FieldTrialList::FindFullName(
1168 "AutoReloadExperiment");
1169 const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
1170 if (browser_command_line.HasSwitch(switches::kEnableOfflineAutoReload))
1172 if (browser_command_line.HasSwitch(switches::kDisableOfflineAutoReload))
1177 bool IsAutoReloadVisibleOnlyEnabled() {
1178 // See the block comment in IsAutoReloadEnabled().
1179 std::string group = base::FieldTrialList::FindFullName(
1180 "AutoReloadVisibleOnlyExperiment");
1181 const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
1182 if (browser_command_line.HasSwitch(
1183 switches::kEnableOfflineAutoReloadVisibleOnly)) {
1186 if (browser_command_line.HasSwitch(
1187 switches::kDisableOfflineAutoReloadVisibleOnly)) {
1195 void ChromeContentBrowserClient::AppendExtraCommandLineSwitches(
1196 CommandLine* command_line, int child_process_id) {
1197 #if defined(OS_POSIX)
1198 if (breakpad::IsCrashReporterEnabled()) {
1199 scoped_ptr<metrics::ClientInfo> client_info =
1200 GoogleUpdateSettings::LoadMetricsClientInfo();
1201 command_line->AppendSwitchASCII(switches::kEnableCrashReporter,
1202 client_info ? client_info->client_id
1205 #endif // defined(OS_POSIX)
1207 if (logging::DialogsAreSuppressed())
1208 command_line->AppendSwitch(switches::kNoErrorDialogs);
1210 std::string process_type =
1211 command_line->GetSwitchValueASCII(switches::kProcessType);
1212 const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess();
1214 static const char* const kCommonSwitchNames[] = {
1215 switches::kUserAgent,
1216 switches::kUserDataDir, // Make logs go to the right file.
1218 command_line->CopySwitchesFrom(browser_command_line, kCommonSwitchNames,
1219 arraysize(kCommonSwitchNames));
1221 #if defined(ENABLE_IPC_FUZZER)
1222 static const char* const kIpcFuzzerSwitches[] = {
1223 switches::kIpcFuzzerTestcase,
1225 command_line->CopySwitchesFrom(browser_command_line, kIpcFuzzerSwitches,
1226 arraysize(kIpcFuzzerSwitches));
1229 #if defined(OS_CHROMEOS)
1230 // On Chrome OS need to pass primary user homedir (in multi-profiles session).
1231 base::FilePath homedir;
1232 PathService::Get(base::DIR_HOME, &homedir);
1233 command_line->AppendSwitchASCII(chromeos::switches::kHomedir,
1234 homedir.value().c_str());
1237 if (process_type == switches::kRendererProcess) {
1238 content::RenderProcessHost* process =
1239 content::RenderProcessHost::FromID(child_process_id);
1241 process ? Profile::FromBrowserContext(process->GetBrowserContext())
1243 for (size_t i = 0; i < extra_parts_.size(); ++i) {
1244 extra_parts_[i]->AppendExtraRendererCommandLineSwitches(
1245 command_line, process, profile);
1248 #if defined(OS_CHROMEOS)
1249 const std::string& login_profile =
1250 browser_command_line.GetSwitchValueASCII(
1251 chromeos::switches::kLoginProfile);
1252 if (!login_profile.empty())
1253 command_line->AppendSwitchASCII(
1254 chromeos::switches::kLoginProfile, login_profile);
1257 #if defined(ENABLE_WEBRTC)
1258 MaybeCopyDisableWebRtcEncryptionSwitch(command_line,
1259 browser_command_line,
1260 VersionInfo::GetChannel());
1264 PrefService* prefs = profile->GetPrefs();
1265 // Currently this pref is only registered if applied via a policy.
1266 if (prefs->HasPrefPath(prefs::kDisable3DAPIs) &&
1267 prefs->GetBoolean(prefs::kDisable3DAPIs)) {
1268 // Turn this policy into a command line switch.
1269 command_line->AppendSwitch(switches::kDisable3DAPIs);
1272 const base::ListValue* switches =
1273 prefs->GetList(prefs::kEnableDeprecatedWebPlatformFeatures);
1275 // Enable any deprecated features that have been re-enabled by policy.
1276 for (base::ListValue::const_iterator it = switches->begin();
1277 it != switches->end(); ++it) {
1278 std::string switch_to_enable;
1279 if ((*it)->GetAsString(&switch_to_enable))
1280 command_line->AppendSwitch(switch_to_enable);
1284 // Disable client-side phishing detection in the renderer if it is
1285 // disabled in the Profile preferences or the browser process.
1286 if (!prefs->GetBoolean(prefs::kSafeBrowsingEnabled) ||
1287 !g_browser_process->safe_browsing_detection_service()) {
1288 command_line->AppendSwitch(
1289 switches::kDisableClientSidePhishingDetection);
1292 if (prefs->GetBoolean(prefs::kPrintPreviewDisabled))
1293 command_line->AppendSwitch(switches::kDisablePrintPreview);
1295 InstantService* instant_service =
1296 InstantServiceFactory::GetForProfile(profile);
1297 if (instant_service &&
1298 instant_service->IsInstantProcess(process->GetID()))
1299 command_line->AppendSwitch(switches::kInstantProcess);
1301 #if !defined(OS_CHROMEOS)
1302 SigninClient* signin_client =
1303 ChromeSigninClientFactory::GetForProfile(profile);
1304 if (signin_client && signin_client->IsSigninProcess(process->GetID()))
1305 command_line->AppendSwitch(switches::kSigninProcess);
1309 if (IsAutoReloadEnabled())
1310 command_line->AppendSwitch(switches::kEnableOfflineAutoReload);
1311 if (IsAutoReloadVisibleOnlyEnabled()) {
1312 command_line->AppendSwitch(
1313 switches::kEnableOfflineAutoReloadVisibleOnly);
1317 // Enable load stale cache if this session is in the field trial or
1318 // the user explicitly enabled it. Note that as far as the renderer
1319 // is concerned, the feature is enabled if-and-only-if the
1320 // kEnableOfflineLoadStaleCache flag is on the command line;
1321 // the yes/no/default behavior is only at the browser command line
1324 // Command line switches override
1325 if (browser_command_line.HasSwitch(
1326 switches::kEnableOfflineLoadStaleCache)) {
1327 command_line->AppendSwitch(switches::kEnableOfflineLoadStaleCache);
1328 } else if (!browser_command_line.HasSwitch(
1329 switches::kDisableOfflineLoadStaleCache)) {
1331 base::FieldTrialList::FindFullName("LoadStaleCacheExperiment");
1333 if (group == "Enabled")
1334 command_line->AppendSwitch(switches::kEnableOfflineLoadStaleCache);
1338 // Please keep this in alphabetical order.
1339 static const char* const kSwitchNames[] = {
1340 autofill::switches::kDisableIgnoreAutocompleteOff,
1341 autofill::switches::kDisablePasswordGeneration,
1342 autofill::switches::kEnablePasswordGeneration,
1343 autofill::switches::kLocalHeuristicsOnlyForPasswordGeneration,
1344 #if defined(ENABLE_EXTENSIONS)
1345 extensions::switches::kAllowHTTPBackgroundPage,
1346 extensions::switches::kAllowLegacyExtensionManifests,
1347 extensions::switches::kEnableAppView,
1348 extensions::switches::kEnableAppWindowControls,
1349 extensions::switches::kEnableEmbeddedExtensionOptions,
1350 extensions::switches::kEnableExperimentalExtensionApis,
1351 extensions::switches::kEnableScriptsRequireAction,
1352 extensions::switches::kExtensionsOnChromeURLs,
1353 extensions::switches::kWhitelistedExtensionID,
1355 switches::kAppsCheckoutURL,
1356 switches::kAppsGalleryURL,
1357 switches::kCloudPrintURL,
1358 switches::kCloudPrintXmppEndpoint,
1359 switches::kDisableBundledPpapiFlash,
1360 switches::kEnableBenchmarking,
1361 switches::kEnableNaCl,
1362 #if !defined(DISABLE_NACL)
1363 switches::kEnableNaClDebug,
1364 switches::kEnableNaClNonSfiMode,
1366 switches::kEnableNetBenchmarking,
1367 switches::kEnableShowModalDialog,
1368 switches::kEnableStreamlinedHostedApps,
1369 switches::kEnableWebBasedSignin,
1370 switches::kJavaScriptHarmony,
1371 switches::kMessageLoopHistogrammer,
1372 switches::kOutOfProcessPdf,
1373 switches::kPlaybackMode,
1374 switches::kPpapiFlashArgs,
1375 switches::kPpapiFlashPath,
1376 switches::kPpapiFlashVersion,
1377 switches::kProfilingAtStart,
1378 switches::kProfilingFile,
1379 switches::kProfilingFlush,
1380 switches::kRecordMode,
1381 translate::switches::kTranslateSecurityOrigin,
1384 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
1385 arraysize(kSwitchNames));
1386 } else if (process_type == switches::kUtilityProcess) {
1387 #if defined(ENABLE_EXTENSIONS)
1388 static const char* const kSwitchNames[] = {
1389 extensions::switches::kAllowHTTPBackgroundPage,
1390 extensions::switches::kEnableExperimentalExtensionApis,
1391 extensions::switches::kExtensionsOnChromeURLs,
1392 extensions::switches::kWhitelistedExtensionID,
1395 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
1396 arraysize(kSwitchNames));
1398 } else if (process_type == switches::kPluginProcess) {
1399 #if defined(OS_CHROMEOS)
1400 static const char* const kSwitchNames[] = {
1401 chromeos::switches::kLoginProfile,
1404 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
1405 arraysize(kSwitchNames));
1407 } else if (process_type == switches::kZygoteProcess) {
1408 static const char* const kSwitchNames[] = {
1409 // Load (in-process) Pepper plugins in-process in the zygote pre-sandbox.
1410 switches::kDisableBundledPpapiFlash,
1411 #if !defined(DISABLE_NACL)
1412 switches::kEnableNaClNonSfiMode,
1413 switches::kNaClDangerousNoSandboxNonSfi,
1415 switches::kPpapiFlashPath,
1416 switches::kPpapiFlashVersion,
1419 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames,
1420 arraysize(kSwitchNames));
1421 } else if (process_type == switches::kGpuProcess) {
1422 // If --ignore-gpu-blacklist is passed in, don't send in crash reports
1423 // because GPU is expected to be unreliable.
1424 if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) &&
1425 !command_line->HasSwitch(switches::kDisableBreakpad))
1426 command_line->AppendSwitch(switches::kDisableBreakpad);
1429 // The command line switch kEnableBenchmarking needs to be specified along
1430 // with the kEnableStatsTable switch to ensure that the stats table global
1431 // is initialized correctly.
1432 if (command_line->HasSwitch(switches::kEnableBenchmarking))
1433 DCHECK(command_line->HasSwitch(switches::kEnableStatsTable));
1436 std::string ChromeContentBrowserClient::GetApplicationLocale() {
1437 if (BrowserThread::CurrentlyOn(BrowserThread::IO))
1438 return g_io_thread_application_locale.Get();
1439 return g_browser_process->GetApplicationLocale();
1442 std::string ChromeContentBrowserClient::GetAcceptLangs(
1443 content::BrowserContext* context) {
1444 Profile* profile = Profile::FromBrowserContext(context);
1445 return profile->GetPrefs()->GetString(prefs::kAcceptLanguages);
1448 const gfx::ImageSkia* ChromeContentBrowserClient::GetDefaultFavicon() {
1449 ResourceBundle& rb = ResourceBundle::GetSharedInstance();
1450 return rb.GetNativeImageNamed(IDR_DEFAULT_FAVICON).ToImageSkia();
1453 bool ChromeContentBrowserClient::AllowAppCache(
1454 const GURL& manifest_url,
1455 const GURL& first_party,
1456 content::ResourceContext* context) {
1457 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1458 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1459 return io_data->GetCookieSettings()->
1460 IsSettingCookieAllowed(manifest_url, first_party);
1463 bool ChromeContentBrowserClient::AllowGetCookie(
1465 const GURL& first_party,
1466 const net::CookieList& cookie_list,
1467 content::ResourceContext* context,
1468 int render_process_id,
1469 int render_frame_id) {
1470 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1471 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1472 bool allow = io_data->GetCookieSettings()->
1473 IsReadingCookieAllowed(url, first_party);
1475 BrowserThread::PostTask(
1476 BrowserThread::UI, FROM_HERE,
1477 base::Bind(&TabSpecificContentSettings::CookiesRead, render_process_id,
1478 render_frame_id, url, first_party, cookie_list, !allow, true));
1482 bool ChromeContentBrowserClient::AllowSetCookie(
1484 const GURL& first_party,
1485 const std::string& cookie_line,
1486 content::ResourceContext* context,
1487 int render_process_id,
1488 int render_frame_id,
1489 net::CookieOptions* options) {
1490 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1491 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1492 CookieSettings* cookie_settings = io_data->GetCookieSettings();
1493 bool allow = cookie_settings->IsSettingCookieAllowed(url, first_party);
1495 if (prerender_tracker_) {
1496 prerender_tracker_->OnCookieChangedForURL(
1498 context->GetRequestContext()->cookie_store()->GetCookieMonster(),
1502 BrowserThread::PostTask(
1503 BrowserThread::UI, FROM_HERE,
1504 base::Bind(&TabSpecificContentSettings::CookieChanged, render_process_id,
1505 render_frame_id, url, first_party, cookie_line, *options,
1510 bool ChromeContentBrowserClient::AllowSaveLocalState(
1511 content::ResourceContext* context) {
1512 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1513 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1514 CookieSettings* cookie_settings = io_data->GetCookieSettings();
1515 ContentSetting setting = cookie_settings->GetDefaultCookieSetting(NULL);
1517 // TODO(bauerb): Should we also disallow local state if the default is BLOCK?
1518 // Could we even support per-origin settings?
1519 return setting != CONTENT_SETTING_SESSION_ONLY;
1522 bool ChromeContentBrowserClient::AllowWorkerDatabase(
1524 const base::string16& name,
1525 const base::string16& display_name,
1526 unsigned long estimated_size,
1527 content::ResourceContext* context,
1528 const std::vector<std::pair<int, int> >& render_frames) {
1529 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1530 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1531 CookieSettings* cookie_settings = io_data->GetCookieSettings();
1532 bool allow = cookie_settings->IsSettingCookieAllowed(url, url);
1534 // Record access to database for potential display in UI.
1535 std::vector<std::pair<int, int> >::const_iterator i;
1536 for (i = render_frames.begin(); i != render_frames.end(); ++i) {
1537 BrowserThread::PostTask(
1538 BrowserThread::UI, FROM_HERE,
1539 base::Bind(&TabSpecificContentSettings::WebDatabaseAccessed,
1540 i->first, i->second, url, name, display_name, !allow));
1546 void ChromeContentBrowserClient::AllowWorkerFileSystem(
1548 content::ResourceContext* context,
1549 const std::vector<std::pair<int, int> >& render_frames,
1550 base::Callback<void(bool)> callback) {
1551 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1552 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1553 CookieSettings* cookie_settings = io_data->GetCookieSettings();
1554 bool allow = cookie_settings->IsSettingCookieAllowed(url, url);
1556 #if defined(ENABLE_EXTENSIONS)
1557 GuestPermissionRequestHelper(url, render_frames, callback, allow);
1559 FileSystemAccessed(url, render_frames, callback, allow);
1563 #if defined(ENABLE_EXTENSIONS)
1564 void ChromeContentBrowserClient::GuestPermissionRequestHelper(
1566 const std::vector<std::pair<int, int> >& render_frames,
1567 base::Callback<void(bool)> callback,
1569 DCHECK(BrowserThread:: CurrentlyOn(BrowserThread::IO));
1570 std::vector<std::pair<int, int> >::const_iterator i;
1571 std::map<int, int> process_map;
1572 std::map<int, int>::const_iterator it;
1573 bool has_web_view_guest = false;
1574 // Record access to file system for potential display in UI.
1575 for (i = render_frames.begin(); i != render_frames.end(); ++i) {
1576 if (process_map.find(i->first) != process_map.end())
1579 process_map.insert(std::pair<int, int>(i->first, i->second));
1581 if (extensions::WebViewRendererState::GetInstance()->IsGuest(i->first))
1582 has_web_view_guest = true;
1584 if (!has_web_view_guest) {
1585 FileSystemAccessed(url, render_frames, callback, allow);
1588 DCHECK_EQ(1U, process_map.size());
1589 it = process_map.begin();
1590 BrowserThread::PostTask(
1593 base::Bind(&ChromeContentBrowserClient::
1594 RequestFileSystemPermissionOnUIThread,
1599 base::Bind(&ChromeContentBrowserClient::FileSystemAccessed,
1600 weak_factory_.GetWeakPtr(),
1606 void ChromeContentBrowserClient::RequestFileSystemPermissionOnUIThread(
1607 int render_process_id,
1608 int render_frame_id,
1610 bool allowed_by_default,
1611 const base::Callback<void(bool)>& callback) {
1612 DCHECK(BrowserThread:: CurrentlyOn(BrowserThread::UI));
1613 extensions::WebViewPermissionHelper* web_view_permission_helper =
1614 extensions::WebViewPermissionHelper::FromFrameID(
1615 render_process_id, render_frame_id);
1616 web_view_permission_helper->RequestFileSystemPermission(url,
1622 void ChromeContentBrowserClient::FileSystemAccessed(
1624 const std::vector<std::pair<int, int> >& render_frames,
1625 base::Callback<void(bool)> callback,
1627 // Record access to file system for potential display in UI.
1628 std::vector<std::pair<int, int> >::const_iterator i;
1629 for (i = render_frames.begin(); i != render_frames.end(); ++i) {
1630 BrowserThread::PostTask(
1633 base::Bind(&TabSpecificContentSettings::FileSystemAccessed,
1634 i->first, i->second, url, !allow));
1636 callback.Run(allow);
1639 bool ChromeContentBrowserClient::AllowWorkerIndexedDB(
1641 const base::string16& name,
1642 content::ResourceContext* context,
1643 const std::vector<std::pair<int, int> >& render_frames) {
1644 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1645 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1646 CookieSettings* cookie_settings = io_data->GetCookieSettings();
1647 bool allow = cookie_settings->IsSettingCookieAllowed(url, url);
1649 // Record access to IndexedDB for potential display in UI.
1650 std::vector<std::pair<int, int> >::const_iterator i;
1651 for (i = render_frames.begin(); i != render_frames.end(); ++i) {
1652 BrowserThread::PostTask(
1653 BrowserThread::UI, FROM_HERE,
1654 base::Bind(&TabSpecificContentSettings::IndexedDBAccessed,
1655 i->first, i->second, url, name, !allow));
1661 net::URLRequestContext*
1662 ChromeContentBrowserClient::OverrideRequestContextForURL(
1663 const GURL& url, content::ResourceContext* context) {
1664 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1665 #if defined(ENABLE_EXTENSIONS)
1666 if (url.SchemeIs(extensions::kExtensionScheme)) {
1667 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1668 return io_data->extensions_request_context();
1675 QuotaPermissionContext*
1676 ChromeContentBrowserClient::CreateQuotaPermissionContext() {
1677 return new ChromeQuotaPermissionContext();
1680 void ChromeContentBrowserClient::AllowCertificateError(
1681 int render_process_id,
1682 int render_frame_id,
1684 const net::SSLInfo& ssl_info,
1685 const GURL& request_url,
1686 ResourceType resource_type,
1688 bool strict_enforcement,
1689 bool expired_previous_decision,
1690 const base::Callback<void(bool)>& callback,
1691 content::CertificateRequestResultType* result) {
1692 if (resource_type != content::RESOURCE_TYPE_MAIN_FRAME) {
1693 // A sub-resource has a certificate error. The user doesn't really
1694 // have a context for making the right decision, so block the
1695 // request hard, without an info bar to allow showing the insecure
1697 *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY;
1701 // If the tab is being prerendered, cancel the prerender and the request.
1702 content::RenderFrameHost* render_frame_host =
1703 content::RenderFrameHost::FromID(render_process_id, render_frame_id);
1704 WebContents* tab = WebContents::FromRenderFrameHost(render_frame_host);
1710 prerender::PrerenderContents* prerender_contents =
1711 prerender::PrerenderContents::FromWebContents(tab);
1712 if (prerender_contents) {
1713 prerender_contents->Destroy(prerender::FINAL_STATUS_SSL_ERROR);
1714 *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL;
1718 #if defined(ENABLE_CAPTIVE_PORTAL_DETECTION)
1719 CaptivePortalTabHelper* captive_portal_tab_helper =
1720 CaptivePortalTabHelper::FromWebContents(tab);
1721 if (captive_portal_tab_helper)
1722 captive_portal_tab_helper->OnSSLCertError(ssl_info);
1725 // Otherwise, display an SSL blocking page. The interstitial page takes
1726 // ownership of ssl_blocking_page.
1727 int options_mask = 0;
1729 options_mask |= SSLBlockingPage::OVERRIDABLE;
1730 if (strict_enforcement)
1731 options_mask |= SSLBlockingPage::STRICT_ENFORCEMENT;
1732 if (expired_previous_decision)
1733 options_mask |= SSLBlockingPage::EXPIRED_BUT_PREVIOUSLY_ALLOWED;
1734 SSLBlockingPage* ssl_blocking_page = new SSLBlockingPage(
1735 tab, cert_error, ssl_info, request_url, options_mask, callback);
1736 ssl_blocking_page->Show();
1739 void ChromeContentBrowserClient::SelectClientCertificate(
1740 int render_process_id,
1741 int render_frame_id,
1742 const net::HttpNetworkSession* network_session,
1743 net::SSLCertRequestInfo* cert_request_info,
1744 const base::Callback<void(net::X509Certificate*)>& callback) {
1745 content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
1746 render_process_id, render_frame_id);
1747 WebContents* tab = WebContents::FromRenderFrameHost(rfh);
1753 prerender::PrerenderContents* prerender_contents =
1754 prerender::PrerenderContents::FromWebContents(tab);
1755 if (prerender_contents) {
1756 prerender_contents->Destroy(
1757 prerender::FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED);
1761 GURL requesting_url("https://" + cert_request_info->host_and_port.ToString());
1762 DCHECK(requesting_url.is_valid())
1763 << "Invalid URL string: https://"
1764 << cert_request_info->host_and_port.ToString();
1766 Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext());
1767 scoped_ptr<base::Value> filter =
1768 profile->GetHostContentSettingsMap()->GetWebsiteSetting(
1771 CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE,
1776 // Try to automatically select a client certificate.
1777 if (filter->IsType(base::Value::TYPE_DICTIONARY)) {
1778 base::DictionaryValue* filter_dict =
1779 static_cast<base::DictionaryValue*>(filter.get());
1781 const std::vector<scoped_refptr<net::X509Certificate> >&
1782 all_client_certs = cert_request_info->client_certs;
1783 for (size_t i = 0; i < all_client_certs.size(); ++i) {
1784 if (CertMatchesFilter(*all_client_certs[i].get(), *filter_dict)) {
1785 // Use the first certificate that is matched by the filter.
1786 callback.Run(all_client_certs[i].get());
1795 chrome::ShowSSLClientCertificateSelector(tab, network_session,
1796 cert_request_info, callback);
1799 void ChromeContentBrowserClient::AddCertificate(
1800 net::CertificateMimeType cert_type,
1801 const void* cert_data,
1803 int render_process_id,
1804 int render_frame_id) {
1805 chrome::SSLAddCertificate(cert_type, cert_data, cert_size,
1806 render_process_id, render_frame_id);
1809 content::MediaObserver* ChromeContentBrowserClient::GetMediaObserver() {
1810 return MediaCaptureDevicesDispatcher::GetInstance();
1813 void ChromeContentBrowserClient::RequestDesktopNotificationPermission(
1814 const GURL& source_origin,
1815 content::RenderFrameHost* render_frame_host,
1816 const base::Callback<void(blink::WebNotificationPermission)>& callback) {
1817 #if defined(ENABLE_NOTIFICATIONS)
1818 // Skip showing the infobar if the request comes from an extension, and that
1819 // extension has the 'notify' permission. (If the extension does not have the
1820 // permission, the user will still be prompted.)
1821 Profile* profile = Profile::FromBrowserContext(
1822 render_frame_host->GetSiteInstance()->GetBrowserContext());
1823 DesktopNotificationService* notification_service =
1824 DesktopNotificationServiceFactory::GetForProfile(profile);
1825 #if defined(ENABLE_EXTENSIONS)
1826 InfoMap* extension_info_map =
1827 extensions::ExtensionSystem::Get(profile)->info_map();
1828 const Extension* extension = NULL;
1829 if (extension_info_map) {
1830 extensions::ExtensionSet extensions;
1831 extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
1833 render_frame_host->GetProcess()->GetID(),
1834 extensions::APIPermission::kNotifications,
1836 for (extensions::ExtensionSet::const_iterator iter = extensions.begin();
1837 iter != extensions.end(); ++iter) {
1838 if (notification_service->IsNotifierEnabled(NotifierId(
1839 NotifierId::APPLICATION, (*iter)->id()))) {
1840 extension = iter->get();
1845 if (IsExtensionWithPermissionOrSuggestInConsole(
1846 APIPermission::kNotifications,
1848 render_frame_host->GetRenderViewHost())) {
1849 callback.Run(blink::WebNotificationPermissionAllowed);
1854 WebContents* web_contents = WebContents::FromRenderFrameHost(
1856 int render_process_id = render_frame_host->GetProcess()->GetID();
1857 const PermissionRequestID request_id(render_process_id,
1858 web_contents->GetRoutingID(),
1862 notification_service->RequestNotificationPermission(
1866 // TODO(peter): plumb user_gesture over IPC
1875 blink::WebNotificationPermission
1876 ChromeContentBrowserClient::CheckDesktopNotificationPermission(
1877 const GURL& source_origin,
1878 content::ResourceContext* context,
1879 int render_process_id) {
1880 #if defined(ENABLE_NOTIFICATIONS)
1881 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
1883 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
1884 #if defined(ENABLE_EXTENSIONS)
1885 InfoMap* extension_info_map = io_data->GetExtensionInfoMap();
1887 // We want to see if there is an extension that hasn't been manually disabled
1888 // that has the notifications permission and applies to this security origin.
1889 // First, get the list of extensions with permission for the origin.
1890 extensions::ExtensionSet extensions;
1891 extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin(
1894 extensions::APIPermission::kNotifications,
1896 for (extensions::ExtensionSet::const_iterator iter = extensions.begin();
1897 iter != extensions.end(); ++iter) {
1898 // Then, check to see if it's been disabled by the user.
1899 if (!extension_info_map->AreNotificationsDisabled((*iter)->id()))
1900 return blink::WebNotificationPermissionAllowed;
1904 // No enabled extensions exist, so check the normal host content settings.
1905 HostContentSettingsMap* host_content_settings_map =
1906 io_data->GetHostContentSettingsMap();
1907 ContentSetting setting = host_content_settings_map->GetContentSetting(
1910 CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
1911 NO_RESOURCE_IDENTIFIER);
1913 if (setting == CONTENT_SETTING_ALLOW)
1914 return blink::WebNotificationPermissionAllowed;
1915 if (setting == CONTENT_SETTING_BLOCK)
1916 return blink::WebNotificationPermissionDenied;
1917 return blink::WebNotificationPermissionDefault;
1919 return blink::WebNotificationPermissionAllowed;
1923 void ChromeContentBrowserClient::ShowDesktopNotification(
1924 const content::ShowDesktopNotificationHostMsgParams& params,
1925 RenderFrameHost* render_frame_host,
1926 scoped_ptr<content::DesktopNotificationDelegate> delegate,
1927 base::Closure* cancel_callback) {
1928 #if defined(ENABLE_NOTIFICATIONS)
1929 content::RenderProcessHost* process = render_frame_host->GetProcess();
1930 Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
1931 DesktopNotificationService* service =
1932 DesktopNotificationServiceFactory::GetForProfile(profile);
1933 service->ShowDesktopNotification(
1934 params, render_frame_host, delegate.Pass(), cancel_callback);
1936 profile->GetHostContentSettingsMap()->UpdateLastUsage(
1937 params.origin, params.origin, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
1943 void ChromeContentBrowserClient::RequestGeolocationPermission(
1944 content::WebContents* web_contents,
1946 const GURL& requesting_frame,
1948 base::Callback<void(bool)> result_callback,
1949 base::Closure* cancel_callback) {
1950 GeolocationPermissionContextFactory::GetForProfile(
1951 Profile::FromBrowserContext(web_contents->GetBrowserContext()))->
1952 RequestGeolocationPermission(web_contents, bridge_id,
1953 requesting_frame, user_gesture,
1954 result_callback, cancel_callback);
1957 void ChromeContentBrowserClient::RequestMidiSysExPermission(
1958 content::WebContents* web_contents,
1960 const GURL& requesting_frame,
1962 base::Callback<void(bool)> result_callback,
1963 base::Closure* cancel_callback) {
1964 MidiPermissionContext* context =
1965 MidiPermissionContextFactory::GetForProfile(
1966 Profile::FromBrowserContext(web_contents->GetBrowserContext()));
1967 int renderer_id = web_contents->GetRenderProcessHost()->GetID();
1968 int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
1969 const PermissionRequestID id(renderer_id, render_view_id, bridge_id, GURL());
1971 context->RequestPermission(web_contents, id, requesting_frame,
1972 user_gesture, result_callback);
1975 void ChromeContentBrowserClient::DidUseGeolocationPermission(
1976 content::WebContents* web_contents,
1977 const GURL& frame_url,
1978 const GURL& main_frame_url) {
1979 Profile::FromBrowserContext(web_contents->GetBrowserContext())
1980 ->GetHostContentSettingsMap()
1982 frame_url, main_frame_url, CONTENT_SETTINGS_TYPE_GEOLOCATION);
1985 void ChromeContentBrowserClient::RequestProtectedMediaIdentifierPermission(
1986 content::WebContents* web_contents,
1988 base::Callback<void(bool)> result_callback,
1989 base::Closure* cancel_callback) {
1990 #if defined(OS_ANDROID)
1991 ProtectedMediaIdentifierPermissionContext* context =
1992 ProtectedMediaIdentifierPermissionContextFactory::GetForProfile(
1993 Profile::FromBrowserContext(web_contents->GetBrowserContext()));
1994 context->RequestProtectedMediaIdentifierPermission(web_contents,
2000 result_callback.Run(false);
2001 #endif // defined(OS_ANDROID)
2004 bool ChromeContentBrowserClient::CanCreateWindow(
2005 const GURL& opener_url,
2006 const GURL& opener_top_level_frame_url,
2007 const GURL& source_origin,
2008 WindowContainerType container_type,
2009 const GURL& target_url,
2010 const content::Referrer& referrer,
2011 WindowOpenDisposition disposition,
2012 const WebWindowFeatures& features,
2014 bool opener_suppressed,
2015 content::ResourceContext* context,
2016 int render_process_id,
2018 bool* no_javascript_access) {
2019 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
2021 *no_javascript_access = false;
2023 // If the opener is trying to create a background window but doesn't have
2024 // the appropriate permission, fail the attempt.
2025 if (container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) {
2026 #if defined(ENABLE_EXTENSIONS)
2027 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context);
2028 InfoMap* map = io_data->GetExtensionInfoMap();
2029 if (!map->SecurityOriginHasAPIPermission(
2032 APIPermission::kBackground)) {
2036 // Note: this use of GetExtensionOrAppByURL is safe but imperfect. It may
2037 // return a recently installed Extension even if this CanCreateWindow call
2038 // was made by an old copy of the page in a normal web process. That's ok,
2039 // because the permission check above would have caused an early return
2040 // already. We must use the full URL to find hosted apps, though, and not
2042 const Extension* extension =
2043 map->extensions().GetExtensionOrAppByURL(opener_url);
2044 if (extension && !extensions::BackgroundInfo::AllowJSAccess(extension))
2045 *no_javascript_access = true;
2051 #if defined(ENABLE_EXTENSIONS)
2052 if (extensions::WebViewRendererState::GetInstance()->IsGuest(
2057 HostContentSettingsMap* content_settings =
2058 ProfileIOData::FromResourceContext(context)->GetHostContentSettingsMap();
2059 BlockedWindowParams blocked_params(target_url,
2068 if (!user_gesture && !CommandLine::ForCurrentProcess()->HasSwitch(
2069 switches::kDisablePopupBlocking)) {
2070 if (content_settings->GetContentSetting(opener_top_level_frame_url,
2071 opener_top_level_frame_url,
2072 CONTENT_SETTINGS_TYPE_POPUPS,
2074 CONTENT_SETTING_ALLOW) {
2075 BrowserThread::PostTask(BrowserThread::UI,
2077 base::Bind(&HandleBlockedPopupOnUIThread,
2083 #if defined(OS_ANDROID)
2084 if (SingleTabModeTabHelper::IsRegistered(render_process_id, opener_id)) {
2085 BrowserThread::PostTask(BrowserThread::UI,
2087 base::Bind(&HandleSingleTabModeBlockOnUIThread,
2096 void ChromeContentBrowserClient::ResourceDispatcherHostCreated() {
2097 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
2098 prerender_tracker_ = g_browser_process->prerender_tracker();
2099 return g_browser_process->ResourceDispatcherHostCreated();
2102 // TODO(tommi): Rename from Get to Create.
2103 content::SpeechRecognitionManagerDelegate*
2104 ChromeContentBrowserClient::GetSpeechRecognitionManagerDelegate() {
2105 return new speech::ChromeSpeechRecognitionManagerDelegate();
2108 net::NetLog* ChromeContentBrowserClient::GetNetLog() {
2109 return g_browser_process->net_log();
2112 AccessTokenStore* ChromeContentBrowserClient::CreateAccessTokenStore() {
2113 return new ChromeAccessTokenStore();
2116 bool ChromeContentBrowserClient::IsFastShutdownPossible() {
2120 void ChromeContentBrowserClient::OverrideWebkitPrefs(
2121 RenderViewHost* rvh, const GURL& url, WebPreferences* web_prefs) {
2122 Profile* profile = Profile::FromBrowserContext(
2123 rvh->GetProcess()->GetBrowserContext());
2124 PrefService* prefs = profile->GetPrefs();
2126 // Fill per-script font preferences. These are not registered on Android
2127 // - http://crbug.com/308033.
2128 #if !defined(OS_ANDROID)
2129 FontFamilyCache::FillFontFamilyMap(profile,
2130 prefs::kWebKitStandardFontFamilyMap,
2131 &web_prefs->standard_font_family_map);
2132 FontFamilyCache::FillFontFamilyMap(profile,
2133 prefs::kWebKitFixedFontFamilyMap,
2134 &web_prefs->fixed_font_family_map);
2135 FontFamilyCache::FillFontFamilyMap(profile,
2136 prefs::kWebKitSerifFontFamilyMap,
2137 &web_prefs->serif_font_family_map);
2138 FontFamilyCache::FillFontFamilyMap(profile,
2139 prefs::kWebKitSansSerifFontFamilyMap,
2140 &web_prefs->sans_serif_font_family_map);
2141 FontFamilyCache::FillFontFamilyMap(profile,
2142 prefs::kWebKitCursiveFontFamilyMap,
2143 &web_prefs->cursive_font_family_map);
2144 FontFamilyCache::FillFontFamilyMap(profile,
2145 prefs::kWebKitFantasyFontFamilyMap,
2146 &web_prefs->fantasy_font_family_map);
2147 FontFamilyCache::FillFontFamilyMap(profile,
2148 prefs::kWebKitPictographFontFamilyMap,
2149 &web_prefs->pictograph_font_family_map);
2152 web_prefs->default_font_size =
2153 prefs->GetInteger(prefs::kWebKitDefaultFontSize);
2154 web_prefs->default_fixed_font_size =
2155 prefs->GetInteger(prefs::kWebKitDefaultFixedFontSize);
2156 web_prefs->minimum_font_size =
2157 prefs->GetInteger(prefs::kWebKitMinimumFontSize);
2158 web_prefs->minimum_logical_font_size =
2159 prefs->GetInteger(prefs::kWebKitMinimumLogicalFontSize);
2161 web_prefs->default_encoding = prefs->GetString(prefs::kDefaultCharset);
2163 web_prefs->javascript_can_open_windows_automatically =
2164 prefs->GetBoolean(prefs::kWebKitJavascriptCanOpenWindowsAutomatically);
2165 web_prefs->dom_paste_enabled =
2166 prefs->GetBoolean(prefs::kWebKitDomPasteEnabled);
2167 web_prefs->shrinks_standalone_images_to_fit =
2168 prefs->GetBoolean(prefs::kWebKitShrinksStandaloneImagesToFit);
2169 web_prefs->tabs_to_links = prefs->GetBoolean(prefs::kWebkitTabsToLinks);
2171 if (!prefs->GetBoolean(prefs::kWebKitJavascriptEnabled))
2172 web_prefs->javascript_enabled = false;
2173 if (!prefs->GetBoolean(prefs::kWebKitWebSecurityEnabled))
2174 web_prefs->web_security_enabled = false;
2175 if (!prefs->GetBoolean(prefs::kWebKitPluginsEnabled))
2176 web_prefs->plugins_enabled = false;
2177 if (!prefs->GetBoolean(prefs::kWebKitJavaEnabled))
2178 web_prefs->java_enabled = false;
2179 web_prefs->loads_images_automatically =
2180 prefs->GetBoolean(prefs::kWebKitLoadsImagesAutomatically);
2182 if (prefs->GetBoolean(prefs::kDisable3DAPIs))
2183 web_prefs->experimental_webgl_enabled = false;
2185 web_prefs->allow_displaying_insecure_content =
2186 prefs->GetBoolean(prefs::kWebKitAllowDisplayingInsecureContent);
2187 web_prefs->allow_running_insecure_content =
2188 prefs->GetBoolean(prefs::kWebKitAllowRunningInsecureContent);
2189 #if defined(OS_ANDROID)
2190 web_prefs->font_scale_factor =
2191 static_cast<float>(prefs->GetDouble(prefs::kWebKitFontScaleFactor));
2192 web_prefs->device_scale_adjustment = GetDeviceScaleAdjustment();
2193 web_prefs->force_enable_zoom =
2194 prefs->GetBoolean(prefs::kWebKitForceEnableZoom);
2197 #if defined(OS_ANDROID)
2198 web_prefs->password_echo_enabled =
2199 prefs->GetBoolean(prefs::kWebKitPasswordEchoEnabled);
2201 web_prefs->password_echo_enabled = browser_defaults::kPasswordEchoEnabled;
2204 web_prefs->asynchronous_spell_checking_enabled = true;
2205 web_prefs->unified_textchecker_enabled = true;
2207 web_prefs->uses_universal_detector =
2208 prefs->GetBoolean(prefs::kWebKitUsesUniversalDetector);
2209 web_prefs->text_areas_are_resizable =
2210 prefs->GetBoolean(prefs::kWebKitTextAreasAreResizable);
2211 web_prefs->hyperlink_auditing_enabled =
2212 prefs->GetBoolean(prefs::kEnableHyperlinkAuditing);
2214 // Make sure we will set the default_encoding with canonical encoding name.
2215 web_prefs->default_encoding =
2216 CharacterEncoding::GetCanonicalEncodingNameByAliasName(
2217 web_prefs->default_encoding);
2218 if (web_prefs->default_encoding.empty()) {
2219 prefs->ClearPref(prefs::kDefaultCharset);
2220 web_prefs->default_encoding = prefs->GetString(prefs::kDefaultCharset);
2222 DCHECK(!web_prefs->default_encoding.empty());
2224 for (size_t i = 0; i < extra_parts_.size(); ++i)
2225 extra_parts_[i]->OverrideWebkitPrefs(rvh, url, web_prefs);
2228 void ChromeContentBrowserClient::BrowserURLHandlerCreated(
2229 BrowserURLHandler* handler) {
2230 for (size_t i = 0; i < extra_parts_.size(); ++i)
2231 extra_parts_[i]->BrowserURLHandlerCreated(handler);
2233 // about: handler. Must come before chrome: handler, since it will
2234 // rewrite about: urls to chrome: URLs and then expect chrome: to
2235 // actually handle them.
2236 handler->AddHandlerPair(&WillHandleBrowserAboutURL,
2237 BrowserURLHandler::null_handler());
2239 #if defined(OS_ANDROID)
2240 // Handler to rewrite chrome://newtab on Android.
2241 handler->AddHandlerPair(&chrome::android::HandleAndroidNewTabURL,
2242 BrowserURLHandler::null_handler());
2244 // Handler to rewrite chrome://newtab for InstantExtended.
2245 handler->AddHandlerPair(&chrome::HandleNewTabURLRewrite,
2246 &chrome::HandleNewTabURLReverseRewrite);
2249 // chrome: & friends.
2250 handler->AddHandlerPair(&HandleWebUI, &HandleWebUIReverse);
2253 void ChromeContentBrowserClient::ClearCache(RenderViewHost* rvh) {
2254 Profile* profile = Profile::FromBrowserContext(
2255 rvh->GetSiteInstance()->GetProcess()->GetBrowserContext());
2256 BrowsingDataRemover* remover =
2257 BrowsingDataRemover::CreateForUnboundedRange(profile);
2258 remover->Remove(BrowsingDataRemover::REMOVE_CACHE,
2259 BrowsingDataHelper::UNPROTECTED_WEB);
2260 // BrowsingDataRemover takes care of deleting itself when done.
2263 void ChromeContentBrowserClient::ClearCookies(RenderViewHost* rvh) {
2264 Profile* profile = Profile::FromBrowserContext(
2265 rvh->GetSiteInstance()->GetProcess()->GetBrowserContext());
2266 BrowsingDataRemover* remover =
2267 BrowsingDataRemover::CreateForUnboundedRange(profile);
2268 int remove_mask = BrowsingDataRemover::REMOVE_SITE_DATA;
2269 remover->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB);
2270 // BrowsingDataRemover takes care of deleting itself when done.
2273 base::FilePath ChromeContentBrowserClient::GetDefaultDownloadDirectory() {
2274 return DownloadPrefs::GetDefaultDownloadDirectory();
2277 std::string ChromeContentBrowserClient::GetDefaultDownloadName() {
2278 return l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME);
2281 void ChromeContentBrowserClient::DidCreatePpapiPlugin(
2282 content::BrowserPpapiHost* browser_host) {
2283 #if defined(ENABLE_PLUGINS)
2284 browser_host->GetPpapiHost()->AddHostFactoryFilter(
2285 scoped_ptr<ppapi::host::HostFactory>(
2286 new ChromeBrowserPepperHostFactory(browser_host)));
2290 content::BrowserPpapiHost*
2291 ChromeContentBrowserClient::GetExternalBrowserPpapiHost(
2292 int plugin_process_id) {
2293 #if !defined(DISABLE_NACL)
2294 content::BrowserChildProcessHostIterator iter(PROCESS_TYPE_NACL_LOADER);
2295 while (!iter.Done()) {
2296 nacl::NaClProcessHost* host = static_cast<nacl::NaClProcessHost*>(
2297 iter.GetDelegate());
2298 if (host->process() &&
2299 host->process()->GetData().id == plugin_process_id) {
2300 // Found the plugin.
2301 return host->browser_ppapi_host();
2309 bool ChromeContentBrowserClient::AllowPepperSocketAPI(
2310 content::BrowserContext* browser_context,
2313 const content::SocketPermissionRequest* params) {
2314 #if defined(ENABLE_EXTENSIONS)
2315 Profile* profile = Profile::FromBrowserContext(browser_context);
2316 const extensions::ExtensionSet* extension_set = NULL;
2318 const ExtensionService* ext_service =
2319 extensions::ExtensionSystem::Get(profile)->extension_service();
2321 extension_set = ext_service->extensions();
2326 // Access to private socket APIs is controlled by the whitelist.
2327 if (IsExtensionOrSharedModuleWhitelisted(url, extension_set,
2328 allowed_socket_origins_)) {
2332 // Access to public socket APIs is controlled by extension permissions.
2333 if (url.is_valid() && url.SchemeIs(extensions::kExtensionScheme) &&
2335 const Extension* extension = extension_set->GetByID(url.host());
2337 const extensions::PermissionsData* permissions_data =
2338 extension->permissions_data();
2340 extensions::SocketPermission::CheckParam check_params(
2341 params->type, params->host, params->port);
2342 if (permissions_data->CheckAPIPermissionWithParam(
2343 extensions::APIPermission::kSocket, &check_params)) {
2346 } else if (permissions_data->HasAPIPermission(
2347 extensions::APIPermission::kSocket)) {
2354 // Allow both public and private APIs if the command line says so.
2355 return IsHostAllowedByCommandLine(url, extension_set,
2356 switches::kAllowNaClSocketAPI);
2362 ui::SelectFilePolicy* ChromeContentBrowserClient::CreateSelectFilePolicy(
2363 WebContents* web_contents) {
2364 return new ChromeSelectFilePolicy(web_contents);
2367 void ChromeContentBrowserClient::GetAdditionalAllowedSchemesForFileSystem(
2368 std::vector<std::string>* additional_allowed_schemes) {
2369 ContentBrowserClient::GetAdditionalAllowedSchemesForFileSystem(
2370 additional_allowed_schemes);
2371 additional_allowed_schemes->push_back(content::kChromeDevToolsScheme);
2372 additional_allowed_schemes->push_back(content::kChromeUIScheme);
2373 for (size_t i = 0; i < extra_parts_.size(); ++i) {
2374 extra_parts_[i]->GetAdditionalAllowedSchemesForFileSystem(
2375 additional_allowed_schemes);
2379 void ChromeContentBrowserClient::GetURLRequestAutoMountHandlers(
2380 std::vector<storage::URLRequestAutoMountHandler>* handlers) {
2381 for (size_t i = 0; i < extra_parts_.size(); ++i)
2382 extra_parts_[i]->GetURLRequestAutoMountHandlers(handlers);
2385 void ChromeContentBrowserClient::GetAdditionalFileSystemBackends(
2386 content::BrowserContext* browser_context,
2387 const base::FilePath& storage_partition_path,
2388 ScopedVector<storage::FileSystemBackend>* additional_backends) {
2389 #if defined(OS_CHROMEOS)
2390 storage::ExternalMountPoints* external_mount_points =
2391 content::BrowserContext::GetMountPoints(browser_context);
2392 DCHECK(external_mount_points);
2393 chromeos::FileSystemBackend* backend = new chromeos::FileSystemBackend(
2394 new drive::FileSystemBackendDelegate,
2395 new chromeos::file_system_provider::BackendDelegate,
2396 new chromeos::MTPFileSystemBackendDelegate(storage_partition_path),
2397 browser_context->GetSpecialStoragePolicy(),
2398 external_mount_points,
2399 storage::ExternalMountPoints::GetSystemInstance());
2400 backend->AddSystemMountPoints();
2401 DCHECK(backend->CanHandleType(storage::kFileSystemTypeExternal));
2402 additional_backends->push_back(backend);
2405 for (size_t i = 0; i < extra_parts_.size(); ++i) {
2406 extra_parts_[i]->GetAdditionalFileSystemBackends(
2407 browser_context, storage_partition_path, additional_backends);
2411 #if defined(OS_POSIX) && !defined(OS_MACOSX)
2412 void ChromeContentBrowserClient::GetAdditionalMappedFilesForChildProcess(
2413 const CommandLine& command_line,
2414 int child_process_id,
2415 std::vector<FileDescriptorInfo>* mappings) {
2416 #if defined(OS_ANDROID)
2417 base::FilePath data_path;
2418 PathService::Get(ui::DIR_RESOURCE_PAKS_ANDROID, &data_path);
2419 DCHECK(!data_path.empty());
2421 int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
2422 base::FilePath chrome_resources_pak =
2423 data_path.AppendASCII("chrome_100_percent.pak");
2424 base::File file(chrome_resources_pak, flags);
2425 DCHECK(file.IsValid());
2426 mappings->push_back(FileDescriptorInfo(kAndroidChrome100PercentPakDescriptor,
2427 FileDescriptor(file.Pass())));
2429 const std::string locale = GetApplicationLocale();
2430 base::FilePath locale_pak = ResourceBundle::GetSharedInstance().
2431 GetLocaleFilePath(locale, false);
2432 file.Initialize(locale_pak, flags);
2433 DCHECK(file.IsValid());
2434 mappings->push_back(FileDescriptorInfo(kAndroidLocalePakDescriptor,
2435 FileDescriptor(file.Pass())));
2437 base::FilePath resources_pack_path;
2438 PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path);
2439 file.Initialize(resources_pack_path, flags);
2440 DCHECK(file.IsValid());
2441 mappings->push_back(FileDescriptorInfo(kAndroidUIResourcesPakDescriptor,
2442 FileDescriptor(file.Pass())));
2444 if (breakpad::IsCrashReporterEnabled()) {
2445 file = breakpad::CrashDumpManager::GetInstance()->CreateMinidumpFile(
2447 if (file.IsValid()) {
2448 mappings->push_back(FileDescriptorInfo(kAndroidMinidumpDescriptor,
2449 FileDescriptor(file.Pass())));
2451 LOG(ERROR) << "Failed to create file for minidump, crash reporting will "
2452 "be disabled for this process.";
2456 base::FilePath app_data_path;
2457 PathService::Get(base::DIR_ANDROID_APP_DATA, &app_data_path);
2458 DCHECK(!app_data_path.empty());
2460 flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
2461 base::FilePath icudata_path =
2462 app_data_path.AppendASCII("icudtl.dat");
2463 base::File icudata_file(icudata_path, flags);
2464 DCHECK(icudata_file.IsValid());
2465 mappings->push_back(FileDescriptorInfo(kAndroidICUDataDescriptor,
2466 FileDescriptor(icudata_file.Pass())));
2469 int crash_signal_fd = GetCrashSignalFD(command_line);
2470 if (crash_signal_fd >= 0) {
2471 mappings->push_back(FileDescriptorInfo(kCrashDumpSignal,
2472 FileDescriptor(crash_signal_fd,
2475 #endif // defined(OS_ANDROID)
2477 #endif // defined(OS_POSIX) && !defined(OS_MACOSX)
2480 const wchar_t* ChromeContentBrowserClient::GetResourceDllName() {
2481 return chrome::kBrowserResourcesDll;
2484 void ChromeContentBrowserClient::PreSpawnRenderer(
2485 sandbox::TargetPolicy* policy,
2487 // This code is duplicated in nacl_exe_win_64.cc.
2488 // Allow the server side of a pipe restricted to the "chrome.nacl."
2489 // namespace so that it cannot impersonate other system or other chrome
2491 sandbox::ResultCode result = policy->AddRule(
2492 sandbox::TargetPolicy::SUBSYS_NAMED_PIPES,
2493 sandbox::TargetPolicy::NAMEDPIPES_ALLOW_ANY,
2494 L"\\\\.\\pipe\\chrome.nacl.*");
2495 if (result != sandbox::SBOX_ALL_OK) {
2500 // Renderers need to send named pipe handles and shared memory
2501 // segment handles to NaCl loader processes.
2502 result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_HANDLES,
2503 sandbox::TargetPolicy::HANDLES_DUP_ANY,
2505 if (result != sandbox::SBOX_ALL_OK) {
2512 bool ChromeContentBrowserClient::CheckMediaAccessPermission(
2513 content::BrowserContext* browser_context,
2514 const GURL& security_origin,
2515 content::MediaStreamType type) {
2516 return MediaCaptureDevicesDispatcher::GetInstance()
2517 ->CheckMediaAccessPermission(
2518 browser_context, security_origin, type);
2521 content::DevToolsManagerDelegate*
2522 ChromeContentBrowserClient::GetDevToolsManagerDelegate() {
2523 #if defined(OS_ANDROID)
2524 return new DevToolsManagerDelegateAndroid();
2526 return new ChromeDevToolsManagerDelegate();
2530 bool ChromeContentBrowserClient::IsPluginAllowedToCallRequestOSFileHandle(
2531 content::BrowserContext* browser_context,
2533 #if defined(ENABLE_EXTENSIONS)
2534 Profile* profile = Profile::FromBrowserContext(browser_context);
2535 const extensions::ExtensionSet* extension_set = NULL;
2537 const ExtensionService* ext_service =
2538 extensions::ExtensionSystem::Get(profile)->extension_service();
2540 extension_set = ext_service->extensions();
2543 return IsExtensionOrSharedModuleWhitelisted(url, extension_set,
2544 allowed_file_handle_origins_) ||
2545 IsHostAllowedByCommandLine(url, extension_set,
2546 switches::kAllowNaClFileHandleAPI);
2552 bool ChromeContentBrowserClient::IsPluginAllowedToUseDevChannelAPIs(
2553 content::BrowserContext* browser_context,
2555 #if defined(ENABLE_EXTENSIONS)
2556 // Allow access for tests.
2557 if (CommandLine::ForCurrentProcess()->HasSwitch(
2558 switches::kEnablePepperTesting)) {
2562 Profile* profile = Profile::FromBrowserContext(browser_context);
2563 const extensions::ExtensionSet* extension_set = NULL;
2565 const ExtensionService* ext_service =
2566 extensions::ExtensionSystem::Get(profile)->extension_service();
2568 extension_set = ext_service->extensions();
2572 // Allow access for whitelisted applications.
2573 if (IsExtensionOrSharedModuleWhitelisted(url,
2575 allowed_dev_channel_origins_)) {
2579 chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
2580 // Allow dev channel APIs to be used on "Canary", "Dev", and "Unknown"
2581 // releases of Chrome. Permitting "Unknown" allows these APIs to be used on
2582 // Chromium builds as well.
2583 return channel <= chrome::VersionInfo::CHANNEL_DEV;
2590 ChromeContentBrowserClient::OverrideCookieStoreForRenderProcess(
2591 int render_process_id) {
2592 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
2593 if (!prerender_tracker_)
2595 return prerender_tracker_->GetPrerenderCookieStoreForRenderProcess(
2596 render_process_id).get();
2599 #if defined(ENABLE_WEBRTC)
2600 void ChromeContentBrowserClient::MaybeCopyDisableWebRtcEncryptionSwitch(
2601 CommandLine* to_command_line,
2602 const CommandLine& from_command_line,
2603 VersionInfo::Channel channel) {
2604 #if defined(OS_ANDROID)
2605 const VersionInfo::Channel kMaxDisableEncryptionChannel =
2606 VersionInfo::CHANNEL_BETA;
2608 const VersionInfo::Channel kMaxDisableEncryptionChannel =
2609 VersionInfo::CHANNEL_DEV;
2611 if (channel <= kMaxDisableEncryptionChannel) {
2612 static const char* const kWebRtcDevSwitchNames[] = {
2613 switches::kDisableWebRtcEncryption,
2615 to_command_line->CopySwitchesFrom(from_command_line,
2616 kWebRtcDevSwitchNames,
2617 arraysize(kWebRtcDevSwitchNames));
2620 #endif // defined(ENABLE_WEBRTC)
2622 } // namespace chrome