chrome_content_browser_client.cc revision effb81e5f8246d0db0270817048dc992db66e9fb
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/browser/chrome_content_browser_client.h" 6 7#include <set> 8#include <utility> 9#include <vector> 10 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/app_mode/app_mode_utils.h" 21#include "chrome/browser/browser_about_handler.h" 22#include "chrome/browser/browser_process.h" 23#include "chrome/browser/browser_shutdown.h" 24#include "chrome/browser/browsing_data/browsing_data_helper.h" 25#include "chrome/browser/browsing_data/browsing_data_remover.h" 26#include "chrome/browser/character_encoding.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/extensions/api/web_request/web_request_api.h" 36#include "chrome/browser/extensions/browser_permissions_policy_delegate.h" 37#include "chrome/browser/extensions/extension_service.h" 38#include "chrome/browser/extensions/extension_util.h" 39#include "chrome/browser/extensions/extension_web_ui.h" 40#include "chrome/browser/extensions/extension_webkit_preferences.h" 41#include "chrome/browser/extensions/suggest_permission_util.h" 42#include "chrome/browser/geolocation/chrome_access_token_store.h" 43#include "chrome/browser/google/google_util.h" 44#include "chrome/browser/guestview/adview/adview_guest.h" 45#include "chrome/browser/guestview/guestview.h" 46#include "chrome/browser/guestview/guestview_constants.h" 47#include "chrome/browser/guestview/webview/webview_guest.h" 48#include "chrome/browser/local_discovery/storage/privet_filesystem_backend.h" 49#include "chrome/browser/media/cast_transport_host_filter.h" 50#include "chrome/browser/media/media_capture_devices_dispatcher.h" 51#include "chrome/browser/metrics/chrome_browser_main_extra_parts_metrics.h" 52#include "chrome/browser/nacl_host/nacl_browser_delegate_impl.h" 53#include "chrome/browser/net/chrome_net_log.h" 54#include "chrome/browser/notifications/desktop_notification_service.h" 55#include "chrome/browser/notifications/desktop_notification_service_factory.h" 56#include "chrome/browser/platform_util.h" 57#include "chrome/browser/plugins/plugin_info_message_filter.h" 58#include "chrome/browser/prerender/prerender_final_status.h" 59#include "chrome/browser/prerender/prerender_manager.h" 60#include "chrome/browser/prerender/prerender_manager_factory.h" 61#include "chrome/browser/prerender/prerender_message_filter.h" 62#include "chrome/browser/prerender/prerender_tracker.h" 63#include "chrome/browser/printing/printing_message_filter.h" 64#include "chrome/browser/profiles/chrome_browser_main_extra_parts_profiles.h" 65#include "chrome/browser/profiles/profile.h" 66#include "chrome/browser/profiles/profile_io_data.h" 67#include "chrome/browser/profiles/profile_manager.h" 68#include "chrome/browser/renderer_host/chrome_render_message_filter.h" 69#include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h" 70#include "chrome/browser/search/instant_service.h" 71#include "chrome/browser/search/instant_service_factory.h" 72#include "chrome/browser/search/search.h" 73#include "chrome/browser/search_engines/search_provider_install_state_message_filter.h" 74#include "chrome/browser/signin/principals_message_filter.h" 75#include "chrome/browser/speech/chrome_speech_recognition_manager_delegate.h" 76#include "chrome/browser/speech/tts_message_filter.h" 77#include "chrome/browser/ssl/ssl_add_certificate.h" 78#include "chrome/browser/ssl/ssl_blocking_page.h" 79#include "chrome/browser/ssl/ssl_tab_helper.h" 80#include "chrome/browser/sync_file_system/local/sync_file_system_backend.h" 81#include "chrome/browser/tab_contents/tab_util.h" 82#include "chrome/browser/ui/blocked_content/blocked_window_params.h" 83#include "chrome/browser/ui/blocked_content/popup_blocker_tab_helper.h" 84#include "chrome/browser/ui/chrome_select_file_policy.h" 85#include "chrome/browser/ui/sync/sync_promo_ui.h" 86#include "chrome/browser/ui/tab_contents/chrome_web_contents_view_delegate.h" 87#include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h" 88#include "chrome/common/chrome_constants.h" 89#include "chrome/common/chrome_paths.h" 90#include "chrome/common/chrome_switches.h" 91#include "chrome/common/env_vars.h" 92#include "chrome/common/extensions/extension_process_policy.h" 93#include "chrome/common/extensions/manifest_handlers/app_isolation_info.h" 94#include "chrome/common/logging_chrome.h" 95#include "chrome/common/pepper_permission_util.h" 96#include "chrome/common/pref_names.h" 97#include "chrome/common/profile_management_switches.h" 98#include "chrome/common/render_messages.h" 99#include "chrome/common/url_constants.h" 100#include "chrome/installer/util/google_update_settings.h" 101#include "chromeos/chromeos_constants.h" 102#include "components/nacl/browser/nacl_browser.h" 103#include "components/nacl/browser/nacl_host_message_filter.h" 104#include "components/nacl/browser/nacl_process_host.h" 105#include "components/nacl/common/nacl_process_type.h" 106#include "components/nacl/common/nacl_switches.h" 107#include "components/translate/core/common/translate_switches.h" 108#include "components/user_prefs/pref_registry_syncable.h" 109#include "content/public/browser/browser_child_process_host.h" 110#include "content/public/browser/browser_main_parts.h" 111#include "content/public/browser/browser_ppapi_host.h" 112#include "content/public/browser/browser_thread.h" 113#include "content/public/browser/browser_url_handler.h" 114#include "content/public/browser/child_process_data.h" 115#include "content/public/browser/child_process_security_policy.h" 116#include "content/public/browser/render_frame_host.h" 117#include "content/public/browser/render_process_host.h" 118#include "content/public/browser/render_view_host.h" 119#include "content/public/browser/resource_context.h" 120#include "content/public/browser/site_instance.h" 121#include "content/public/browser/web_contents.h" 122#include "content/public/browser/web_contents_view.h" 123#include "content/public/common/child_process_host.h" 124#include "content/public/common/content_descriptors.h" 125#include "content/public/common/url_utils.h" 126#include "extensions/browser/extension_host.h" 127#include "extensions/browser/extension_message_filter.h" 128#include "extensions/browser/extension_registry.h" 129#include "extensions/browser/extension_system.h" 130#include "extensions/browser/info_map.h" 131#include "extensions/browser/process_manager.h" 132#include "extensions/browser/process_map.h" 133#include "extensions/browser/view_type_utils.h" 134#include "extensions/common/constants.h" 135#include "extensions/common/extension.h" 136#include "extensions/common/extension_set.h" 137#include "extensions/common/manifest_handlers/background_info.h" 138#include "extensions/common/manifest_handlers/shared_module_info.h" 139#include "extensions/common/manifest_handlers/web_accessible_resources_info.h" 140#include "extensions/common/permissions/permissions_data.h" 141#include "extensions/common/permissions/socket_permission.h" 142#include "extensions/common/switches.h" 143#include "grit/generated_resources.h" 144#include "grit/ui_resources.h" 145#include "net/base/mime_util.h" 146#include "net/cookies/canonical_cookie.h" 147#include "net/cookies/cookie_options.h" 148#include "net/ssl/ssl_cert_request_info.h" 149#include "ppapi/host/ppapi_host.h" 150#include "ppapi/shared_impl/ppapi_switches.h" 151#include "ui/base/l10n/l10n_util.h" 152#include "ui/base/resource/resource_bundle.h" 153#include "ui/message_center/message_center_util.h" 154#include "webkit/browser/fileapi/external_mount_points.h" 155#include "webkit/common/webpreferences.h" 156 157#if defined(OS_WIN) 158#include "base/win/windows_version.h" 159#include "chrome/browser/chrome_browser_main_win.h" 160#include "sandbox/win/src/sandbox_policy.h" 161#elif defined(OS_MACOSX) 162#include "chrome/browser/chrome_browser_main_mac.h" 163#include "chrome/browser/spellchecker/spellcheck_message_filter_mac.h" 164#include "components/breakpad/app/breakpad_mac.h" 165#elif defined(OS_CHROMEOS) 166#include "chrome/browser/chromeos/chrome_browser_main_chromeos.h" 167#include "chrome/browser/chromeos/drive/fileapi/file_system_backend_delegate.h" 168#include "chrome/browser/chromeos/fileapi/file_system_backend.h" 169#include "chrome/browser/chromeos/login/startup_utils.h" 170#include "chrome/browser/chromeos/login/user_manager.h" 171#include "chrome/browser/chromeos/system/input_device_settings.h" 172#include "chromeos/chromeos_switches.h" 173#elif defined(OS_LINUX) 174#include "chrome/browser/chrome_browser_main_linux.h" 175#elif defined(OS_ANDROID) 176#include "chrome/browser/android/new_tab_page_url_handler.h" 177#include "chrome/browser/android/webapps/single_tab_mode_tab_helper.h" 178#include "chrome/browser/chrome_browser_main_android.h" 179#include "chrome/browser/media/encrypted_media_message_filter_android.h" 180#include "chrome/common/descriptors_android.h" 181#include "components/breakpad/browser/crash_dump_manager_android.h" 182#elif defined(OS_POSIX) 183#include "chrome/browser/chrome_browser_main_posix.h" 184#endif 185 186#if defined(OS_POSIX) && !defined(OS_MACOSX) 187#include "base/debug/leak_annotations.h" 188#include "base/linux_util.h" 189#include "components/breakpad/app/breakpad_linux.h" 190#include "components/breakpad/browser/crash_handler_host_linux.h" 191#endif 192 193#if defined(ENABLE_CAPTIVE_PORTAL_DETECTION) 194#include "chrome/browser/captive_portal/captive_portal_tab_helper.h" 195#endif 196 197#if defined(OS_ANDROID) 198#include "ui/base/ui_base_paths.h" 199#include "ui/gfx/android/device_display_info.h" 200#endif 201 202#if !defined(OS_CHROMEOS) 203#include "chrome/browser/signin/chrome_signin_client.h" 204#include "chrome/browser/signin/chrome_signin_client_factory.h" 205#include "chrome/browser/signin/signin_manager.h" 206#include "chrome/browser/signin/signin_manager_factory.h" 207#endif 208 209#if !defined(OS_ANDROID) 210#include "chrome/browser/media_galleries/fileapi/media_file_system_backend.h" 211#endif 212 213#if defined(ENABLE_WEBRTC) 214#include "chrome/browser/media/webrtc_logging_handler_host.h" 215#endif 216 217#if defined(ENABLE_INPUT_SPEECH) 218#include "chrome/browser/speech/chrome_speech_recognition_manager_delegate_bubble_ui.h" 219#endif 220 221#if defined(OS_CHROMEOS) 222#include "chrome/browser/chromeos/file_manager/app_id.h" 223#endif 224 225#if defined(TOOLKIT_GTK) 226#include "chrome/browser/ui/gtk/chrome_browser_main_extra_parts_gtk.h" 227#endif 228 229#if defined(TOOLKIT_VIEWS) 230#include "chrome/browser/ui/views/chrome_browser_main_extra_parts_views.h" 231#endif 232 233#if defined(USE_ASH) 234#include "chrome/browser/ui/views/ash/chrome_browser_main_extra_parts_ash.h" 235#endif 236 237#if defined(USE_AURA) 238#include "chrome/browser/ui/aura/chrome_browser_main_extra_parts_aura.h" 239#endif 240 241#if defined(USE_X11) 242#include "chrome/browser/chrome_browser_main_extra_parts_x11.h" 243#endif 244 245#if defined(ENABLE_SPELLCHECK) 246#include "chrome/browser/spellchecker/spellcheck_message_filter.h" 247#endif 248 249#if defined(ENABLE_SERVICE_DISCOVERY) 250#include "chrome/browser/local_discovery/storage/privet_filesystem_backend.h" 251#endif 252 253using blink::WebWindowFeatures; 254using base::FileDescriptor; 255using content::AccessTokenStore; 256using content::BrowserChildProcessHostIterator; 257using content::BrowserThread; 258using content::BrowserURLHandler; 259using content::ChildProcessSecurityPolicy; 260using content::QuotaPermissionContext; 261using content::RenderViewHost; 262using content::SiteInstance; 263using content::WebContents; 264using extensions::APIPermission; 265using extensions::Extension; 266using extensions::InfoMap; 267using extensions::Manifest; 268using message_center::NotifierId; 269 270#if defined(OS_POSIX) 271using content::FileDescriptorInfo; 272#endif 273 274namespace { 275 276// Cached version of the locale so we can return the locale on the I/O 277// thread. 278base::LazyInstance<std::string> g_io_thread_application_locale; 279 280#if defined(ENABLE_PLUGINS) 281const char* kPredefinedAllowedFileHandleOrigins[] = { 282 "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F", // see crbug.com/234789 283 "4EB74897CB187C7633357C2FE832E0AD6A44883A" // see crbug.com/234789 284}; 285 286const char* kPredefinedAllowedSocketOrigins[] = { 287 "okddffdblfhhnmhodogpojmfkjmhinfp", // Test SSH Client 288 "pnhechapfaindjhompbnflcldabbghjo", // HTerm App (SSH Client) 289 "bglhmjfplikpjnfoegeomebmfnkjomhe", // see crbug.com/122126 290 "gbchcmhmhahfdphkhkmpfmihenigjmpp", // Chrome Remote Desktop 291 "kgngmbheleoaphbjbaiobfdepmghbfah", // Pre-release Chrome Remote Desktop 292 "odkaodonbgfohohmklejpjiejmcipmib", // Dogfood Chrome Remote Desktop 293 "ojoimpklfciegopdfgeenehpalipignm", // Chromoting canary 294 "cbkkbcmdlboombapidmoeolnmdacpkch", // see crbug.com/129089 295 "hhnbmknkdabfoieppbbljkhkfjcmcbjh", // see crbug.com/134099 296 "mablfbjkhmhkmefkjjacnbaikjkipphg", // see crbug.com/134099 297 "pdeelgamlgannhelgoegilelnnojegoh", // see crbug.com/134099 298 "cabapfdbkniadpollkckdnedaanlciaj", // see crbug.com/134099 299 "mapljbgnjledlpdmlchihnmeclmefbba", // see crbug.com/134099 300 "ghbfeebgmiidnnmeobbbaiamklmpbpii", // see crbug.com/134099 301 "jdfhpkjeckflbbleddjlpimecpbjdeep", // see crbug.com/142514 302 "iabmpiboiopbgfabjmgeedhcmjenhbla", // see crbug.com/165080 303 "B7CF8A292249681AF81771650BA4CEEAF19A4560", // see crbug.com/165080 304 "6EAED1924DB611B6EEF2A664BD077BE7EAD33B8F", // see crbug.com/234789 305 "4EB74897CB187C7633357C2FE832E0AD6A44883A", // see crbug.com/234789 306 "7525AF4F66763A70A883C4700529F647B470E4D2", // see crbug.com/238084 307 "0B549507088E1564D672F7942EB87CA4DAD73972", // see crbug.com/238084 308 "864288364E239573E777D3E0E36864E590E95C74" // see crbug.com/238084 309}; 310#endif 311 312// Returns a copy of the given url with its host set to given host and path set 313// to given path. Other parts of the url will be the same. 314GURL ReplaceURLHostAndPath(const GURL& url, 315 const std::string& host, 316 const std::string& path) { 317 url_canon::Replacements<char> replacements; 318 replacements.SetHost(host.c_str(), 319 url_parse::Component(0, host.length())); 320 replacements.SetPath(path.c_str(), 321 url_parse::Component(0, path.length())); 322 return url.ReplaceComponents(replacements); 323} 324 325// Maps "foo://bar/baz/" to "foo://chrome/bar/baz/". 326GURL AddUberHost(const GURL& url) { 327 const std::string uber_host = chrome::kChromeUIUberHost; 328 const std::string new_path = url.host() + url.path(); 329 330 return ReplaceURLHostAndPath(url, uber_host, new_path); 331} 332 333// If url->host() is "chrome" and url->path() has characters other than the 334// first slash, changes the url from "foo://chrome/bar/" to "foo://bar/" and 335// returns true. Otherwise returns false. 336bool RemoveUberHost(GURL* url) { 337 if (url->host() != chrome::kChromeUIUberHost) 338 return false; 339 340 if (url->path().empty() || url->path() == "/") 341 return false; 342 343 const std::string old_path = url->path(); 344 345 const std::string::size_type separator = old_path.find('/', 1); 346 std::string new_host; 347 std::string new_path; 348 if (separator == std::string::npos) { 349 new_host = old_path.substr(1); 350 } else { 351 new_host = old_path.substr(1, separator - 1); 352 new_path = old_path.substr(separator); 353 } 354 355 // Do not allow URLs with paths empty before the first slash since we can't 356 // have an empty host. (e.g "foo://chrome//") 357 if (new_host.empty()) 358 return false; 359 360 *url = ReplaceURLHostAndPath(*url, new_host, new_path); 361 362 DCHECK(url->is_valid()); 363 364 return true; 365} 366 367// Handles rewriting Web UI URLs. 368bool HandleWebUI(GURL* url, content::BrowserContext* browser_context) { 369 // Do not handle special URLs such as "about:foo" 370 if (!url->host().empty()) { 371 const GURL chrome_url = AddUberHost(*url); 372 373 // Handle valid "chrome://chrome/foo" URLs so the reverse handler will 374 // be called. 375 if (ChromeWebUIControllerFactory::GetInstance()->UseWebUIForURL( 376 browser_context, chrome_url)) 377 return true; 378 } 379 380 if (!ChromeWebUIControllerFactory::GetInstance()->UseWebUIForURL( 381 browser_context, *url)) 382 return false; 383 384#if defined(OS_CHROMEOS) 385 // Special case : in ChromeOS in Guest mode bookmarks and history are 386 // disabled for security reasons. New tab page explains the reasons, so 387 // we redirect user to new tab page. 388 if (chromeos::UserManager::Get()->IsLoggedInAsGuest()) { 389 if (url->SchemeIs(content::kChromeUIScheme) && 390 (url->DomainIs(chrome::kChromeUIBookmarksHost) || 391 url->DomainIs(chrome::kChromeUIHistoryHost))) { 392 // Rewrite with new tab URL 393 *url = GURL(chrome::kChromeUINewTabURL); 394 } 395 } 396#endif 397 398 return true; 399} 400 401// Reverse URL handler for Web UI. Maps "chrome://chrome/foo/" to 402// "chrome://foo/". 403bool HandleWebUIReverse(GURL* url, content::BrowserContext* browser_context) { 404 if (!url->is_valid() || !url->SchemeIs(content::kChromeUIScheme)) 405 return false; 406 407 return RemoveUberHost(url); 408} 409 410// Used by the GetPrivilegeRequiredByUrl() and GetProcessPrivilege() functions 411// below. Extension, and isolated apps require different privileges to be 412// granted to their RenderProcessHosts. This classification allows us to make 413// sure URLs are served by hosts with the right set of privileges. 414enum RenderProcessHostPrivilege { 415 PRIV_NORMAL, 416 PRIV_HOSTED, 417 PRIV_ISOLATED, 418 PRIV_EXTENSION, 419}; 420 421RenderProcessHostPrivilege GetPrivilegeRequiredByUrl( 422 const GURL& url, 423 ExtensionService* service) { 424 // Default to a normal renderer cause it is lower privileged. This should only 425 // occur if the URL on a site instance is either malformed, or uninitialized. 426 // If it is malformed, then there is no need for better privileges anyways. 427 // If it is uninitialized, but eventually settles on being an a scheme other 428 // than normal webrenderer, the navigation logic will correct us out of band 429 // anyways. 430 if (!url.is_valid()) 431 return PRIV_NORMAL; 432 433 if (url.SchemeIs(extensions::kExtensionScheme)) { 434 const Extension* extension = 435 service->extensions()->GetByID(url.host()); 436 if (extension && 437 extensions::AppIsolationInfo::HasIsolatedStorage(extension)) 438 return PRIV_ISOLATED; 439 if (extension && extension->is_hosted_app()) 440 return PRIV_HOSTED; 441 442 return PRIV_EXTENSION; 443 } 444 445 return PRIV_NORMAL; 446} 447 448RenderProcessHostPrivilege GetProcessPrivilege( 449 content::RenderProcessHost* process_host, 450 extensions::ProcessMap* process_map, 451 ExtensionService* service) { 452 std::set<std::string> extension_ids = 453 process_map->GetExtensionsInProcess(process_host->GetID()); 454 if (extension_ids.empty()) 455 return PRIV_NORMAL; 456 457 for (std::set<std::string>::iterator iter = extension_ids.begin(); 458 iter != extension_ids.end(); ++iter) { 459 const Extension* extension = service->GetExtensionById(*iter, false); 460 if (extension && 461 extensions::AppIsolationInfo::HasIsolatedStorage(extension)) 462 return PRIV_ISOLATED; 463 if (extension && extension->is_hosted_app()) 464 return PRIV_HOSTED; 465 } 466 467 return PRIV_EXTENSION; 468} 469 470bool CertMatchesFilter(const net::X509Certificate& cert, 471 const base::DictionaryValue& filter) { 472 // TODO(markusheintz): This is the minimal required filter implementation. 473 // Implement a better matcher. 474 475 // An empty filter matches any client certificate since no requirements are 476 // specified at all. 477 if (filter.empty()) 478 return true; 479 480 std::string common_name; 481 if (filter.GetString("ISSUER.CN", &common_name) && 482 (cert.issuer().common_name == common_name)) { 483 return true; 484 } 485 return false; 486} 487 488#if !defined(OS_ANDROID) 489// Fills |map| with the per-script font prefs under path |map_name|. 490void FillFontFamilyMap(const PrefService* prefs, 491 const char* map_name, 492 webkit_glue::ScriptFontFamilyMap* map) { 493 // TODO: Get rid of the brute-force scan over possible (font family / script) 494 // combinations - see http://crbug.com/308095. 495 for (size_t i = 0; i < prefs::kWebKitScriptsForFontFamilyMapsLength; ++i) { 496 const char* script = prefs::kWebKitScriptsForFontFamilyMaps[i]; 497 std::string pref_name = base::StringPrintf("%s.%s", map_name, script); 498 std::string font_family = prefs->GetString(pref_name.c_str()); 499 if (!font_family.empty()) 500 (*map)[script] = base::UTF8ToUTF16(font_family); 501 } 502} 503 504#if defined(OS_POSIX) && !defined(OS_MACOSX) 505breakpad::CrashHandlerHostLinux* CreateCrashHandlerHost( 506 const std::string& process_type) { 507 base::FilePath dumps_path; 508 PathService::Get(chrome::DIR_CRASH_DUMPS, &dumps_path); 509 { 510 ANNOTATE_SCOPED_MEMORY_LEAK; 511 breakpad::CrashHandlerHostLinux* crash_handler = 512 new breakpad::CrashHandlerHostLinux( 513 process_type, dumps_path, getenv(env_vars::kHeadless) == NULL); 514 crash_handler->StartUploaderThread(); 515 return crash_handler; 516 } 517} 518 519int GetCrashSignalFD(const CommandLine& command_line) { 520 if (command_line.HasSwitch(extensions::switches::kExtensionProcess)) { 521 static breakpad::CrashHandlerHostLinux* crash_handler = NULL; 522 if (!crash_handler) 523 crash_handler = CreateCrashHandlerHost("extension"); 524 return crash_handler->GetDeathSignalSocket(); 525 } 526 527 std::string process_type = 528 command_line.GetSwitchValueASCII(switches::kProcessType); 529 530 if (process_type == switches::kRendererProcess) { 531 static breakpad::CrashHandlerHostLinux* crash_handler = NULL; 532 if (!crash_handler) 533 crash_handler = CreateCrashHandlerHost(process_type); 534 return crash_handler->GetDeathSignalSocket(); 535 } 536 537 if (process_type == switches::kPluginProcess) { 538 static breakpad::CrashHandlerHostLinux* crash_handler = NULL; 539 if (!crash_handler) 540 crash_handler = CreateCrashHandlerHost(process_type); 541 return crash_handler->GetDeathSignalSocket(); 542 } 543 544 if (process_type == switches::kPpapiPluginProcess) { 545 static breakpad::CrashHandlerHostLinux* crash_handler = NULL; 546 if (!crash_handler) 547 crash_handler = CreateCrashHandlerHost(process_type); 548 return crash_handler->GetDeathSignalSocket(); 549 } 550 551 if (process_type == switches::kGpuProcess) { 552 static breakpad::CrashHandlerHostLinux* crash_handler = NULL; 553 if (!crash_handler) 554 crash_handler = CreateCrashHandlerHost(process_type); 555 return crash_handler->GetDeathSignalSocket(); 556 } 557 558 return -1; 559} 560#endif // defined(OS_POSIX) && !defined(OS_MACOSX) 561#endif // !defined(OS_ANDROID) 562 563#if !defined(OS_CHROMEOS) 564GURL GetEffectiveURLForSignin(const GURL& url) { 565 CHECK(SigninManager::IsWebBasedSigninFlowURL(url)); 566 567 GURL effective_url(SigninManager::kChromeSigninEffectiveSite); 568 // Copy the path because the argument to SetPathStr must outlive 569 // the Replacements object. 570 const std::string path_copy(url.path()); 571 GURL::Replacements replacements; 572 replacements.SetPathStr(path_copy); 573 effective_url = effective_url.ReplaceComponents(replacements); 574 return effective_url; 575} 576#endif 577 578void SetApplicationLocaleOnIOThread(const std::string& locale) { 579 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 580 g_io_thread_application_locale.Get() = locale; 581} 582 583void HandleBlockedPopupOnUIThread(const BlockedWindowParams& params) { 584 WebContents* tab = tab_util::GetWebContentsByID(params.render_process_id(), 585 params.opener_id()); 586 if (!tab) 587 return; 588 589 prerender::PrerenderContents* prerender_contents = 590 prerender::PrerenderContents::FromWebContents(tab); 591 if (prerender_contents) { 592 prerender_contents->Destroy(prerender::FINAL_STATUS_CREATE_NEW_WINDOW); 593 return; 594 } 595 596 PopupBlockerTabHelper* popup_helper = 597 PopupBlockerTabHelper::FromWebContents(tab); 598 if (!popup_helper) 599 return; 600 popup_helper->AddBlockedPopup(params); 601} 602 603#if defined(OS_ANDROID) 604 605void HandleSingleTabModeBlockOnUIThread(const BlockedWindowParams& params) { 606 WebContents* web_contents = 607 tab_util::GetWebContentsByID(params.render_process_id(), 608 params.opener_id()); 609 if (!web_contents) 610 return; 611 612 SingleTabModeTabHelper::FromWebContents(web_contents)->HandleOpenUrl(params); 613} 614 615float GetDeviceScaleAdjustment() { 616 static const float kMinFSM = 1.05f; 617 static const int kWidthForMinFSM = 320; 618 static const float kMaxFSM = 1.3f; 619 static const int kWidthForMaxFSM = 800; 620 621 gfx::DeviceDisplayInfo info; 622 int minWidth = info.GetSmallestDIPWidth(); 623 624 if (minWidth <= kWidthForMinFSM) 625 return kMinFSM; 626 if (minWidth >= kWidthForMaxFSM) 627 return kMaxFSM; 628 629 // The font scale multiplier varies linearly between kMinFSM and kMaxFSM. 630 float ratio = static_cast<float>(minWidth - kWidthForMinFSM) / 631 (kWidthForMaxFSM - kWidthForMinFSM); 632 return ratio * (kMaxFSM - kMinFSM) + kMinFSM; 633} 634 635#endif // defined(OS_ANDROID) 636 637} // namespace 638 639namespace chrome { 640 641ChromeContentBrowserClient::ChromeContentBrowserClient() { 642#if defined(ENABLE_PLUGINS) 643 for (size_t i = 0; i < arraysize(kPredefinedAllowedFileHandleOrigins); ++i) 644 allowed_file_handle_origins_.insert(kPredefinedAllowedFileHandleOrigins[i]); 645 for (size_t i = 0; i < arraysize(kPredefinedAllowedSocketOrigins); ++i) 646 allowed_socket_origins_.insert(kPredefinedAllowedSocketOrigins[i]); 647#endif 648 649 permissions_policy_delegate_.reset( 650 new extensions::BrowserPermissionsPolicyDelegate()); 651} 652 653ChromeContentBrowserClient::~ChromeContentBrowserClient() { 654} 655 656// static 657void ChromeContentBrowserClient::RegisterProfilePrefs( 658 user_prefs::PrefRegistrySyncable* registry) { 659 registry->RegisterBooleanPref( 660 prefs::kDisable3DAPIs, 661 false, 662 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 663 registry->RegisterBooleanPref( 664 prefs::kEnableHyperlinkAuditing, 665 true, 666 user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF); 667} 668 669// static 670void ChromeContentBrowserClient::SetApplicationLocale( 671 const std::string& locale) { 672 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 673 674 // This object is guaranteed to outlive all threads so we don't have to 675 // worry about the lack of refcounting and can just post as Unretained. 676 // 677 // The common case is that this function is called early in Chrome startup 678 // before any threads are created (it will also be called later if the user 679 // changes the pref). In this case, there will be no threads created and 680 // posting will fail. When there are no threads, we can just set the string 681 // without worrying about threadsafety. 682 if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, 683 base::Bind(&SetApplicationLocaleOnIOThread, locale))) { 684 g_io_thread_application_locale.Get() = locale; 685 } 686} 687 688content::BrowserMainParts* ChromeContentBrowserClient::CreateBrowserMainParts( 689 const content::MainFunctionParams& parameters) { 690 ChromeBrowserMainParts* main_parts; 691 // Construct the Main browser parts based on the OS type. 692#if defined(OS_WIN) 693 main_parts = new ChromeBrowserMainPartsWin(parameters); 694#elif defined(OS_MACOSX) 695 main_parts = new ChromeBrowserMainPartsMac(parameters); 696#elif defined(OS_CHROMEOS) 697 main_parts = new chromeos::ChromeBrowserMainPartsChromeos(parameters); 698#elif defined(OS_LINUX) 699 main_parts = new ChromeBrowserMainPartsLinux(parameters); 700#elif defined(OS_ANDROID) 701 main_parts = new ChromeBrowserMainPartsAndroid(parameters); 702#elif defined(OS_POSIX) 703 main_parts = new ChromeBrowserMainPartsPosix(parameters); 704#else 705 NOTREACHED(); 706 main_parts = new ChromeBrowserMainParts(parameters); 707#endif 708 709 chrome::AddProfilesExtraParts(main_parts); 710 711 // Construct additional browser parts. Stages are called in the order in 712 // which they are added. 713#if defined(TOOLKIT_GTK) 714 main_parts->AddParts(new ChromeBrowserMainExtraPartsGtk()); 715#endif 716 717#if defined(TOOLKIT_VIEWS) 718 main_parts->AddParts(new ChromeBrowserMainExtraPartsViews()); 719#endif 720 721#if defined(USE_ASH) 722 main_parts->AddParts(new ChromeBrowserMainExtraPartsAsh()); 723#endif 724 725#if defined(USE_AURA) 726 main_parts->AddParts(new ChromeBrowserMainExtraPartsAura()); 727#endif 728 729#if defined(USE_X11) 730 main_parts->AddParts(new ChromeBrowserMainExtraPartsX11()); 731#endif 732 733 chrome::AddMetricsExtraParts(main_parts); 734 735 return main_parts; 736} 737 738std::string ChromeContentBrowserClient::GetStoragePartitionIdForSite( 739 content::BrowserContext* browser_context, 740 const GURL& site) { 741 std::string partition_id; 742 743 // The partition ID for webview guest processes is the string value of its 744 // SiteInstance URL - "chrome-guest://app_id/persist?partition". 745 if (site.SchemeIs(content::kGuestScheme)) { 746 partition_id = site.spec(); 747 } else if (site.GetOrigin().spec() == kChromeUIChromeSigninURL) { 748 // Chrome signin page has an embedded iframe of extension and web content, 749 // thus it must be isolated from other webUI pages. 750 partition_id = site.GetOrigin().spec(); 751 } 752 753 DCHECK(IsValidStoragePartitionId(browser_context, partition_id)); 754 return partition_id; 755} 756 757bool ChromeContentBrowserClient::IsValidStoragePartitionId( 758 content::BrowserContext* browser_context, 759 const std::string& partition_id) { 760 // The default ID is empty and is always valid. 761 if (partition_id.empty()) 762 return true; 763 764 return GURL(partition_id).is_valid(); 765} 766 767void ChromeContentBrowserClient::GetStoragePartitionConfigForSite( 768 content::BrowserContext* browser_context, 769 const GURL& site, 770 bool can_be_default, 771 std::string* partition_domain, 772 std::string* partition_name, 773 bool* in_memory) { 774 // Default to the browser-wide storage partition and override based on |site| 775 // below. 776 partition_domain->clear(); 777 partition_name->clear(); 778 *in_memory = false; 779 780 bool success = GuestView::GetGuestPartitionConfigForSite( 781 site, partition_domain, partition_name, in_memory); 782 783 if (!success && site.SchemeIs(extensions::kExtensionScheme)) { 784 // If |can_be_default| is false, the caller is stating that the |site| 785 // should be parsed as if it had isolated storage. In particular it is 786 // important to NOT check ExtensionService for the is_storage_isolated() 787 // attribute because this code path is run during Extension uninstall 788 // to do cleanup after the Extension has already been unloaded from the 789 // ExtensionService. 790 bool is_isolated = !can_be_default; 791 if (can_be_default) { 792 if (extensions::util::SiteHasIsolatedStorage(site, browser_context)) 793 is_isolated = true; 794 } 795 796 if (is_isolated) { 797 CHECK(site.has_host()); 798 // For extensions with isolated storage, the the host of the |site| is 799 // the |partition_domain|. The |in_memory| and |partition_name| are only 800 // used in guest schemes so they are cleared here. 801 *partition_domain = site.host(); 802 *in_memory = false; 803 partition_name->clear(); 804 } 805 } else if (site.GetOrigin().spec() == kChromeUIChromeSigninURL) { 806 // Chrome signin page has an embedded iframe of extension and web content, 807 // thus it must be isolated from other webUI pages. 808 *partition_domain = chrome::kChromeUIChromeSigninHost; 809 } 810 811 // Assert that if |can_be_default| is false, the code above must have found a 812 // non-default partition. If this fails, the caller has a serious logic 813 // error about which StoragePartition they expect to be in and it is not 814 // safe to continue. 815 CHECK(can_be_default || !partition_domain->empty()); 816} 817 818content::WebContentsViewDelegate* 819 ChromeContentBrowserClient::GetWebContentsViewDelegate( 820 content::WebContents* web_contents) { 821 return chrome::CreateWebContentsViewDelegate(web_contents); 822} 823 824void ChromeContentBrowserClient::GuestWebContentsCreated( 825 SiteInstance* guest_site_instance, 826 WebContents* guest_web_contents, 827 WebContents* opener_web_contents, 828 content::BrowserPluginGuestDelegate** guest_delegate, 829 scoped_ptr<base::DictionaryValue> extra_params) { 830 if (!guest_site_instance) { 831 NOTREACHED(); 832 return; 833 } 834 GURL guest_site_url = guest_site_instance->GetSiteURL(); 835 const std::string& extension_id = guest_site_url.host(); 836 837 Profile* profile = Profile::FromBrowserContext( 838 guest_web_contents->GetBrowserContext()); 839 ExtensionService* service = 840 extensions::ExtensionSystem::Get(profile)->extension_service(); 841 if (!service) { 842 NOTREACHED(); 843 return; 844 } 845 846 /// TODO(fsamuel): In the future, certain types of GuestViews won't require 847 // extension bindings. At that point, we should clear |extension_id| instead 848 // of exiting early. 849 if (!service->GetExtensionById(extension_id, false) && 850 !CommandLine::ForCurrentProcess()->HasSwitch( 851 switches::kEnableBrowserPluginForAllViewTypes)) { 852 NOTREACHED(); 853 return; 854 } 855 856 if (opener_web_contents) { 857 GuestView* guest = GuestView::FromWebContents(opener_web_contents); 858 if (!guest) { 859 NOTREACHED(); 860 return; 861 } 862 863 // Create a new GuestView of the same type as the opener. 864 *guest_delegate = 865 GuestView::Create(guest_web_contents, 866 extension_id, 867 guest->GetViewType()); 868 return; 869 } 870 871 if (!extra_params) { 872 NOTREACHED(); 873 return; 874 } 875 std::string api_type; 876 extra_params->GetString(guestview::kParameterApi, &api_type); 877 878 if (api_type.empty()) 879 return; 880 881 *guest_delegate = 882 GuestView::Create(guest_web_contents, 883 extension_id, 884 GuestView::GetViewTypeFromString(api_type)); 885} 886 887void ChromeContentBrowserClient::GuestWebContentsAttached( 888 WebContents* guest_web_contents, 889 WebContents* embedder_web_contents, 890 const base::DictionaryValue& extra_params) { 891 892 GuestView* guest = GuestView::FromWebContents(guest_web_contents); 893 if (!guest) { 894 // It's ok to return here, since we could be running a browser plugin 895 // outside an extension, and don't need to attach a 896 // BrowserPluginGuestDelegate in that case; 897 // e.g. running with flag --enable-browser-plugin-for-all-view-types. 898 return; 899 } 900 guest->Attach(embedder_web_contents, extra_params); 901} 902 903void ChromeContentBrowserClient::RenderProcessWillLaunch( 904 content::RenderProcessHost* host) { 905 int id = host->GetID(); 906 Profile* profile = Profile::FromBrowserContext(host->GetBrowserContext()); 907 net::URLRequestContextGetter* context = 908 profile->GetRequestContextForRenderProcess(id); 909 910 host->AddFilter(new ChromeRenderMessageFilter(id, profile, context)); 911 host->AddFilter(new extensions::ExtensionMessageFilter(id, profile)); 912#if defined(ENABLE_PLUGINS) 913 host->AddFilter(new PluginInfoMessageFilter(id, profile)); 914#endif 915 host->AddFilter(new cast::CastTransportHostFilter); 916#if defined(ENABLE_PRINTING) 917 host->AddFilter(new PrintingMessageFilter(id, profile)); 918#endif 919 host->AddFilter(new SearchProviderInstallStateMessageFilter(id, profile)); 920#if defined(ENABLE_SPELLCHECK) 921 host->AddFilter(new SpellCheckMessageFilter(id)); 922#endif 923#if defined(OS_MACOSX) 924 host->AddFilter(new SpellCheckMessageFilterMac(id)); 925#endif 926 host->AddFilter(new ChromeNetBenchmarkingMessageFilter(profile, context)); 927 host->AddFilter(new prerender::PrerenderMessageFilter(id, profile)); 928 host->AddFilter(new TtsMessageFilter(id, profile)); 929#if defined(ENABLE_WEBRTC) 930 WebRtcLoggingHandlerHost* webrtc_logging_handler_host = 931 new WebRtcLoggingHandlerHost(profile); 932 host->SetWebRtcLogMessageCallback(base::Bind( 933 &WebRtcLoggingHandlerHost::LogMessage, webrtc_logging_handler_host)); 934 host->AddFilter(webrtc_logging_handler_host); 935 host->SetUserData(host, new base::UserDataAdapter<WebRtcLoggingHandlerHost>( 936 webrtc_logging_handler_host)); 937#endif 938#if !defined(DISABLE_NACL) 939 host->AddFilter(new nacl::NaClHostMessageFilter( 940 id, profile->IsOffTheRecord(), 941 profile->GetPath(), 942 context)); 943#endif 944#if defined(OS_ANDROID) 945 host->AddFilter(new EncryptedMediaMessageFilterAndroid()); 946#endif 947 if (switches::IsNewProfileManagement()) 948 host->AddFilter(new PrincipalsMessageFilter(id)); 949 950 host->Send(new ChromeViewMsg_SetIsIncognitoProcess( 951 profile->IsOffTheRecord())); 952 953 SendExtensionWebRequestStatusToHost(host); 954 955 RendererContentSettingRules rules; 956 if (host->IsGuest()) { 957 GuestView::GetDefaultContentSettingRules(&rules, profile->IsOffTheRecord()); 958 } else { 959 GetRendererContentSettingRules( 960 profile->GetHostContentSettingsMap(), &rules); 961 } 962 host->Send(new ChromeViewMsg_SetContentSettingRules(rules)); 963} 964 965GURL ChromeContentBrowserClient::GetEffectiveURL( 966 content::BrowserContext* browser_context, const GURL& url) { 967 Profile* profile = Profile::FromBrowserContext(browser_context); 968 if (!profile) 969 return url; 970 971 // If the input |url| should be assigned to the Instant renderer, make its 972 // effective URL distinct from other URLs on the search provider's domain. 973 if (chrome::ShouldAssignURLToInstantRenderer(url, profile)) 974 return chrome::GetEffectiveURLForInstant(url, profile); 975 976#if !defined(OS_CHROMEOS) 977 // If the input |url| should be assigned to the Signin renderer, make its 978 // effective URL distinct from other URLs on the signin service's domain. 979 // Note that the signin renderer will be allowed to sign the user in to 980 // Chrome. 981 if (SigninManager::IsWebBasedSigninFlowURL(url)) 982 return GetEffectiveURLForSignin(url); 983#endif 984 985 // If the input |url| is part of an installed app, the effective URL is an 986 // extension URL with the ID of that extension as the host. This has the 987 // effect of grouping apps together in a common SiteInstance. 988 ExtensionService* extension_service = 989 extensions::ExtensionSystem::Get(profile)->extension_service(); 990 if (!extension_service) 991 return url; 992 993 const Extension* extension = extension_service->extensions()-> 994 GetHostedAppByURL(url); 995 if (!extension) 996 return url; 997 998 // Bookmark apps do not use the hosted app process model, and should be 999 // treated as normal URLs. 1000 if (extension->from_bookmark()) 1001 return url; 1002 1003 // If the URL is part of an extension's web extent, convert it to an 1004 // extension URL. 1005 return extension->GetResourceURL(url.path()); 1006} 1007 1008bool ChromeContentBrowserClient::ShouldUseProcessPerSite( 1009 content::BrowserContext* browser_context, const GURL& effective_url) { 1010 // Non-extension, non-Instant URLs should generally use 1011 // process-per-site-instance. Because we expect to use the effective URL, 1012 // URLs for hosted apps (apart from bookmark apps) should have an extension 1013 // scheme by now. 1014 1015 Profile* profile = Profile::FromBrowserContext(browser_context); 1016 if (!profile) 1017 return false; 1018 1019 if (chrome::ShouldUseProcessPerSiteForInstantURL(effective_url, profile)) 1020 return true; 1021 1022#if !defined(OS_CHROMEOS) 1023 if (SigninManager::IsWebBasedSigninFlowURL(effective_url)) 1024 return true; 1025#endif 1026 1027 if (!effective_url.SchemeIs(extensions::kExtensionScheme)) 1028 return false; 1029 1030 ExtensionService* extension_service = 1031 extensions::ExtensionSystem::Get(profile)->extension_service(); 1032 if (!extension_service) 1033 return false; 1034 1035 const Extension* extension = 1036 extension_service->extensions()->GetExtensionOrAppByURL(effective_url); 1037 if (!extension) 1038 return false; 1039 1040 // If the URL is part of a hosted app that does not have the background 1041 // permission, or that does not allow JavaScript access to the background 1042 // page, we want to give each instance its own process to improve 1043 // responsiveness. 1044 if (extension->GetType() == Manifest::TYPE_HOSTED_APP) { 1045 if (!extension->HasAPIPermission(APIPermission::kBackground) || 1046 !extensions::BackgroundInfo::AllowJSAccess(extension)) { 1047 return false; 1048 } 1049 } 1050 1051 // Hosted apps that have script access to their background page must use 1052 // process per site, since all instances can make synchronous calls to the 1053 // background window. Other extensions should use process per site as well. 1054 return true; 1055} 1056 1057// These are treated as WebUI schemes but do not get WebUI bindings. Also, 1058// view-source is allowed for these schemes. 1059void ChromeContentBrowserClient::GetAdditionalWebUISchemes( 1060 std::vector<std::string>* additional_schemes) { 1061 additional_schemes->push_back(chrome::kChromeSearchScheme); 1062 additional_schemes->push_back(chrome::kDomDistillerScheme); 1063} 1064 1065void ChromeContentBrowserClient::GetAdditionalWebUIHostsToIgnoreParititionCheck( 1066 std::vector<std::string>* hosts) { 1067 hosts->push_back(chrome::kChromeUIExtensionIconHost); 1068 hosts->push_back(chrome::kChromeUIFaviconHost); 1069 hosts->push_back(chrome::kChromeUIThemeHost); 1070 hosts->push_back(chrome::kChromeUIThumbnailHost); 1071 hosts->push_back(chrome::kChromeUIThumbnailHost2); 1072 hosts->push_back(chrome::kChromeUIThumbnailListHost); 1073} 1074 1075net::URLRequestContextGetter* 1076ChromeContentBrowserClient::CreateRequestContext( 1077 content::BrowserContext* browser_context, 1078 content::ProtocolHandlerMap* protocol_handlers, 1079 content::ProtocolHandlerScopedVector protocol_interceptors) { 1080 Profile* profile = Profile::FromBrowserContext(browser_context); 1081 return profile->CreateRequestContext(protocol_handlers, 1082 protocol_interceptors.Pass()); 1083} 1084 1085net::URLRequestContextGetter* 1086ChromeContentBrowserClient::CreateRequestContextForStoragePartition( 1087 content::BrowserContext* browser_context, 1088 const base::FilePath& partition_path, 1089 bool in_memory, 1090 content::ProtocolHandlerMap* protocol_handlers, 1091 content::ProtocolHandlerScopedVector protocol_interceptors) { 1092 Profile* profile = Profile::FromBrowserContext(browser_context); 1093 return profile->CreateRequestContextForStoragePartition( 1094 partition_path, 1095 in_memory, 1096 protocol_handlers, 1097 protocol_interceptors.Pass()); 1098} 1099 1100bool ChromeContentBrowserClient::IsHandledURL(const GURL& url) { 1101 return ProfileIOData::IsHandledURL(url); 1102} 1103 1104bool ChromeContentBrowserClient::CanCommitURL( 1105 content::RenderProcessHost* process_host, 1106 const GURL& url) { 1107 // We need to let most extension URLs commit in any process, since this can 1108 // be allowed due to web_accessible_resources. Most hosted app URLs may also 1109 // load in any process (e.g., in an iframe). However, the Chrome Web Store 1110 // cannot be loaded in iframes and should never be requested outside its 1111 // process. 1112 Profile* profile = 1113 Profile::FromBrowserContext(process_host->GetBrowserContext()); 1114 ExtensionService* service = 1115 extensions::ExtensionSystem::Get(profile)->extension_service(); 1116 if (!service) 1117 return true; 1118 const Extension* new_extension = 1119 service->extensions()->GetExtensionOrAppByURL(url); 1120 if (new_extension && 1121 new_extension->is_hosted_app() && 1122 new_extension->id() == extension_misc::kWebStoreAppId && 1123 !extensions::ProcessMap::Get(profile)-> 1124 Contains(new_extension->id(), process_host->GetID())) { 1125 return false; 1126 } 1127 1128 return true; 1129} 1130 1131bool ChromeContentBrowserClient::ShouldAllowOpenURL( 1132 content::SiteInstance* site_instance, const GURL& url) { 1133 GURL from_url = site_instance->GetSiteURL(); 1134 // Do not allow pages from the web or other extensions navigate to 1135 // non-web-accessible extension resources. 1136 if (url.SchemeIs(extensions::kExtensionScheme) && 1137 (from_url.SchemeIsHTTPOrHTTPS() || 1138 from_url.SchemeIs(extensions::kExtensionScheme))) { 1139 Profile* profile = Profile::FromBrowserContext( 1140 site_instance->GetProcess()->GetBrowserContext()); 1141 ExtensionService* service = 1142 extensions::ExtensionSystem::Get(profile)->extension_service(); 1143 if (!service) 1144 return true; 1145 const Extension* extension = 1146 service->extensions()->GetExtensionOrAppByURL(url); 1147 if (!extension) 1148 return true; 1149 const Extension* from_extension = 1150 service->extensions()->GetExtensionOrAppByURL( 1151 site_instance->GetSiteURL()); 1152 if (from_extension && from_extension->id() == extension->id()) 1153 return true; 1154 1155 if (!extensions::WebAccessibleResourcesInfo::IsResourceWebAccessible( 1156 extension, url.path())) 1157 return false; 1158 } 1159 return true; 1160} 1161 1162bool ChromeContentBrowserClient::IsSuitableHost( 1163 content::RenderProcessHost* process_host, 1164 const GURL& site_url) { 1165 Profile* profile = 1166 Profile::FromBrowserContext(process_host->GetBrowserContext()); 1167 // This may be NULL during tests. In that case, just assume any site can 1168 // share any host. 1169 if (!profile) 1170 return true; 1171 1172 // Instant URLs should only be in the instant process and instant process 1173 // should only have Instant URLs. 1174 InstantService* instant_service = 1175 InstantServiceFactory::GetForProfile(profile); 1176 if (instant_service) { 1177 bool is_instant_process = instant_service->IsInstantProcess( 1178 process_host->GetID()); 1179 bool should_be_in_instant_process = 1180 chrome::ShouldAssignURLToInstantRenderer(site_url, profile); 1181 if (is_instant_process || should_be_in_instant_process) 1182 return is_instant_process && should_be_in_instant_process; 1183 } 1184 1185#if !defined(OS_CHROMEOS) 1186 ChromeSigninClient* signin_client = 1187 ChromeSigninClientFactory::GetForProfile(profile); 1188 if (signin_client && signin_client->IsSigninProcess(process_host->GetID())) 1189 return SigninManager::IsWebBasedSigninFlowURL(site_url); 1190#endif 1191 1192 ExtensionService* service = 1193 extensions::ExtensionSystem::Get(profile)->extension_service(); 1194 extensions::ProcessMap* process_map = extensions::ProcessMap::Get(profile); 1195 1196 // Don't allow the Task Manager to share a process with anything else. 1197 // Otherwise it can affect the renderers it is observing. 1198 // Note: we could create another RenderProcessHostPrivilege bucket for 1199 // this to allow multiple chrome://tasks instances to share, but that's 1200 // a very unlikely case without serious consequences. 1201 if (site_url.GetOrigin() == GURL(chrome::kChromeUITaskManagerURL).GetOrigin()) 1202 return false; 1203 1204 // These may be NULL during tests. In that case, just assume any site can 1205 // share any host. 1206 if (!service || !process_map) 1207 return true; 1208 1209 // Otherwise, just make sure the process privilege matches the privilege 1210 // required by the site. 1211 RenderProcessHostPrivilege privilege_required = 1212 GetPrivilegeRequiredByUrl(site_url, service); 1213 return GetProcessPrivilege(process_host, process_map, service) == 1214 privilege_required; 1215} 1216 1217// This function is trying to limit the amount of processes used by extensions 1218// with background pages. It uses a globally set percentage of processes to 1219// run such extensions and if the limit is exceeded, it returns true, to 1220// indicate to the content module to group extensions together. 1221bool ChromeContentBrowserClient::ShouldTryToUseExistingProcessHost( 1222 content::BrowserContext* browser_context, const GURL& url) { 1223 // It has to be a valid URL for us to check for an extension. 1224 if (!url.is_valid()) 1225 return false; 1226 1227 Profile* profile = Profile::FromBrowserContext(browser_context); 1228 ExtensionService* service = !profile ? NULL : 1229 extensions::ExtensionSystem::Get(profile)->extension_service(); 1230 if (!service) 1231 return false; 1232 1233 // We have to have a valid extension with background page to proceed. 1234 const Extension* extension = 1235 service->extensions()->GetExtensionOrAppByURL(url); 1236 if (!extension) 1237 return false; 1238 if (!extensions::BackgroundInfo::HasBackgroundPage(extension)) 1239 return false; 1240 1241 std::set<int> process_ids; 1242 size_t max_process_count = 1243 content::RenderProcessHost::GetMaxRendererProcessCount(); 1244 1245 // Go through all profiles to ensure we have total count of extension 1246 // processes containing background pages, otherwise one profile can 1247 // starve the other. 1248 std::vector<Profile*> profiles = g_browser_process->profile_manager()-> 1249 GetLoadedProfiles(); 1250 for (size_t i = 0; i < profiles.size(); ++i) { 1251 extensions::ProcessManager* epm = 1252 extensions::ExtensionSystem::Get(profiles[i])->process_manager(); 1253 for (extensions::ProcessManager::const_iterator iter = 1254 epm->background_hosts().begin(); 1255 iter != epm->background_hosts().end(); ++iter) { 1256 const extensions::ExtensionHost* host = *iter; 1257 process_ids.insert(host->render_process_host()->GetID()); 1258 } 1259 } 1260 1261 if (process_ids.size() > 1262 (max_process_count * chrome::kMaxShareOfExtensionProcesses)) { 1263 return true; 1264 } 1265 1266 return false; 1267} 1268 1269void ChromeContentBrowserClient::SiteInstanceGotProcess( 1270 SiteInstance* site_instance) { 1271 CHECK(site_instance->HasProcess()); 1272 1273 Profile* profile = Profile::FromBrowserContext( 1274 site_instance->GetBrowserContext()); 1275 if (!profile) 1276 return; 1277 1278 // Remember the ID of the Instant process to signal the renderer process 1279 // on startup in |AppendExtraCommandLineSwitches| below. 1280 if (chrome::ShouldAssignURLToInstantRenderer( 1281 site_instance->GetSiteURL(), profile)) { 1282 InstantService* instant_service = 1283 InstantServiceFactory::GetForProfile(profile); 1284 if (instant_service) 1285 instant_service->AddInstantProcess(site_instance->GetProcess()->GetID()); 1286 } 1287 1288#if !defined(OS_CHROMEOS) 1289 // We only expect there to be one signin process as we use process-per-site 1290 // for signin URLs. The signin process will be cleared from SigninManager 1291 // when the renderer is destroyed. 1292 if (SigninManager::IsWebBasedSigninFlowURL(site_instance->GetSiteURL())) { 1293 ChromeSigninClient* signin_client = 1294 ChromeSigninClientFactory::GetForProfile(profile); 1295 if (signin_client) 1296 signin_client->SetSigninProcess(site_instance->GetProcess()->GetID()); 1297 BrowserThread::PostTask( 1298 BrowserThread::IO, 1299 FROM_HERE, 1300 base::Bind(&InfoMap::SetSigninProcess, 1301 extensions::ExtensionSystem::Get(profile)->info_map(), 1302 site_instance->GetProcess()->GetID())); 1303 } 1304#endif 1305 1306 ExtensionService* service = 1307 extensions::ExtensionSystem::Get(profile)->extension_service(); 1308 if (!service) 1309 return; 1310 1311 const Extension* extension = service->extensions()->GetExtensionOrAppByURL( 1312 site_instance->GetSiteURL()); 1313 if (!extension) 1314 return; 1315 1316 extensions::ProcessMap::Get(profile) 1317 ->Insert(extension->id(), 1318 site_instance->GetProcess()->GetID(), 1319 site_instance->GetId()); 1320 1321 BrowserThread::PostTask( 1322 BrowserThread::IO, 1323 FROM_HERE, 1324 base::Bind(&InfoMap::RegisterExtensionProcess, 1325 extensions::ExtensionSystem::Get(profile)->info_map(), 1326 extension->id(), 1327 site_instance->GetProcess()->GetID(), 1328 site_instance->GetId())); 1329} 1330 1331void ChromeContentBrowserClient::SiteInstanceDeleting( 1332 SiteInstance* site_instance) { 1333 if (!site_instance->HasProcess()) 1334 return; 1335 1336 Profile* profile = Profile::FromBrowserContext( 1337 site_instance->GetBrowserContext()); 1338 ExtensionService* service = 1339 extensions::ExtensionSystem::Get(profile)->extension_service(); 1340 if (!service) 1341 return; 1342 1343 const Extension* extension = service->extensions()->GetExtensionOrAppByURL( 1344 site_instance->GetSiteURL()); 1345 if (!extension) 1346 return; 1347 1348 extensions::ProcessMap::Get(profile) 1349 ->Remove(extension->id(), 1350 site_instance->GetProcess()->GetID(), 1351 site_instance->GetId()); 1352 1353 BrowserThread::PostTask( 1354 BrowserThread::IO, 1355 FROM_HERE, 1356 base::Bind(&InfoMap::UnregisterExtensionProcess, 1357 extensions::ExtensionSystem::Get(profile)->info_map(), 1358 extension->id(), 1359 site_instance->GetProcess()->GetID(), 1360 site_instance->GetId())); 1361} 1362 1363void ChromeContentBrowserClient::WorkerProcessCreated( 1364 SiteInstance* site_instance, 1365 int worker_process_id) { 1366 extensions::ExtensionRegistry* extension_registry = 1367 extensions::ExtensionRegistry::Get(site_instance->GetBrowserContext()); 1368 if (!extension_registry) 1369 return; 1370 const Extension* extension = 1371 extension_registry->enabled_extensions().GetExtensionOrAppByURL( 1372 site_instance->GetSiteURL()); 1373 if (!extension) 1374 return; 1375 extensions::ExtensionSystem* extension_system = 1376 extensions::ExtensionSystem::Get(site_instance->GetBrowserContext()); 1377 extension_system->info_map()->RegisterExtensionWorkerProcess( 1378 extension->id(), 1379 worker_process_id, 1380 site_instance->GetId()); 1381} 1382 1383void ChromeContentBrowserClient::WorkerProcessTerminated( 1384 SiteInstance* site_instance, 1385 int worker_process_id) { 1386 extensions::ExtensionSystem* extension_system = 1387 extensions::ExtensionSystem::Get(site_instance->GetBrowserContext()); 1388 extension_system->info_map()->UnregisterExtensionWorkerProcess( 1389 worker_process_id); 1390} 1391 1392bool ChromeContentBrowserClient::ShouldSwapBrowsingInstancesForNavigation( 1393 SiteInstance* site_instance, 1394 const GURL& current_url, 1395 const GURL& new_url) { 1396 // If we don't have an ExtensionService, then rely on the SiteInstance logic 1397 // in RenderFrameHostManager to decide when to swap. 1398 Profile* profile = 1399 Profile::FromBrowserContext(site_instance->GetBrowserContext()); 1400 ExtensionService* service = 1401 extensions::ExtensionSystem::Get(profile)->extension_service(); 1402 if (!service) 1403 return false; 1404 1405 // We must use a new BrowsingInstance (forcing a process swap and disabling 1406 // scripting by existing tabs) if one of the URLs is an extension and the 1407 // other is not the exact same extension. 1408 // 1409 // We ignore hosted apps here so that other tabs in their BrowsingInstance can 1410 // use postMessage with them. (The exception is the Chrome Web Store, which 1411 // is a hosted app that requires its own BrowsingInstance.) Navigations 1412 // to/from a hosted app will still trigger a SiteInstance swap in 1413 // RenderFrameHostManager. 1414 const Extension* current_extension = 1415 service->extensions()->GetExtensionOrAppByURL(current_url); 1416 if (current_extension && 1417 current_extension->is_hosted_app() && 1418 current_extension->id() != extension_misc::kWebStoreAppId) 1419 current_extension = NULL; 1420 1421 const Extension* new_extension = 1422 service->extensions()->GetExtensionOrAppByURL(new_url); 1423 if (new_extension && 1424 new_extension->is_hosted_app() && 1425 new_extension->id() != extension_misc::kWebStoreAppId) 1426 new_extension = NULL; 1427 1428 // First do a process check. We should force a BrowsingInstance swap if the 1429 // current process doesn't know about new_extension, even if current_extension 1430 // is somehow the same as new_extension. 1431 extensions::ProcessMap* process_map = extensions::ProcessMap::Get(profile); 1432 if (new_extension && 1433 site_instance->HasProcess() && 1434 !process_map->Contains( 1435 new_extension->id(), site_instance->GetProcess()->GetID())) 1436 return true; 1437 1438 // Otherwise, swap BrowsingInstances if current_extension and new_extension 1439 // differ. 1440 return current_extension != new_extension; 1441} 1442 1443bool ChromeContentBrowserClient::ShouldSwapProcessesForRedirect( 1444 content::ResourceContext* resource_context, const GURL& current_url, 1445 const GURL& new_url) { 1446 ProfileIOData* io_data = ProfileIOData::FromResourceContext(resource_context); 1447 return extensions::CrossesExtensionProcessBoundary( 1448 io_data->GetExtensionInfoMap()->extensions(), 1449 current_url, new_url, false); 1450} 1451 1452bool ChromeContentBrowserClient::ShouldAssignSiteForURL(const GURL& url) { 1453 return !url.SchemeIs(chrome::kChromeNativeScheme); 1454} 1455 1456std::string ChromeContentBrowserClient::GetCanonicalEncodingNameByAliasName( 1457 const std::string& alias_name) { 1458 return CharacterEncoding::GetCanonicalEncodingNameByAliasName(alias_name); 1459} 1460 1461void ChromeContentBrowserClient::AppendExtraCommandLineSwitches( 1462 CommandLine* command_line, int child_process_id) { 1463#if defined(OS_POSIX) 1464 if (breakpad::IsCrashReporterEnabled()) { 1465 std::string enable_crash_reporter; 1466 GoogleUpdateSettings::GetMetricsId(&enable_crash_reporter); 1467#if !defined(OS_MACOSX) 1468 enable_crash_reporter += "," + base::GetLinuxDistro(); 1469#endif 1470 command_line->AppendSwitchASCII(switches::kEnableCrashReporter, 1471 enable_crash_reporter); 1472 } 1473#endif // OS_POSIX 1474 1475 if (logging::DialogsAreSuppressed()) 1476 command_line->AppendSwitch(switches::kNoErrorDialogs); 1477 1478 std::string process_type = 1479 command_line->GetSwitchValueASCII(switches::kProcessType); 1480 const CommandLine& browser_command_line = *CommandLine::ForCurrentProcess(); 1481 1482 static const char* const kCommonSwitchNames[] = { 1483 switches::kUserAgent, 1484 switches::kUserDataDir, // Make logs go to the right file. 1485 }; 1486 command_line->CopySwitchesFrom(browser_command_line, kCommonSwitchNames, 1487 arraysize(kCommonSwitchNames)); 1488 1489#if defined(ENABLE_IPC_FUZZER) 1490 static const char* const kIpcFuzzerSwitches[] = { 1491 switches::kIpcFuzzerTestcase, 1492 }; 1493 command_line->CopySwitchesFrom(browser_command_line, kIpcFuzzerSwitches, 1494 arraysize(kIpcFuzzerSwitches)); 1495#endif 1496 1497 if (process_type == switches::kRendererProcess) { 1498#if defined(OS_CHROMEOS) 1499 const std::string& login_profile = 1500 browser_command_line.GetSwitchValueASCII( 1501 chromeos::switches::kLoginProfile); 1502 if (!login_profile.empty()) 1503 command_line->AppendSwitchASCII( 1504 chromeos::switches::kLoginProfile, login_profile); 1505#endif 1506 1507#if defined(ENABLE_WEBRTC) 1508 MaybeCopyDisableWebRtcEncryptionSwitch(command_line, 1509 browser_command_line, 1510 VersionInfo::GetChannel()); 1511#endif 1512 1513 content::RenderProcessHost* process = 1514 content::RenderProcessHost::FromID(child_process_id); 1515 if (process) { 1516 Profile* profile = Profile::FromBrowserContext( 1517 process->GetBrowserContext()); 1518 1519 if (extensions::ProcessMap::Get(profile)->Contains(process->GetID())) 1520 command_line->AppendSwitch(extensions::switches::kExtensionProcess); 1521 1522 PrefService* prefs = profile->GetPrefs(); 1523 // Currently this pref is only registered if applied via a policy. 1524 if (prefs->HasPrefPath(prefs::kDisable3DAPIs) && 1525 prefs->GetBoolean(prefs::kDisable3DAPIs)) { 1526 // Turn this policy into a command line switch. 1527 command_line->AppendSwitch(switches::kDisable3DAPIs); 1528 } 1529 1530 // Disable client-side phishing detection in the renderer if it is 1531 // disabled in the Profile preferences or the browser process. 1532 if (!prefs->GetBoolean(prefs::kSafeBrowsingEnabled) || 1533 !g_browser_process->safe_browsing_detection_service()) { 1534 command_line->AppendSwitch( 1535 switches::kDisableClientSidePhishingDetection); 1536 } 1537 1538 if (!prefs->GetBoolean(prefs::kPrintPreviewDisabled)) 1539 command_line->AppendSwitch(switches::kRendererPrintPreview); 1540 1541 InstantService* instant_service = 1542 InstantServiceFactory::GetForProfile(profile); 1543 if (instant_service && 1544 instant_service->IsInstantProcess(process->GetID())) 1545 command_line->AppendSwitch(switches::kInstantProcess); 1546 1547#if !defined(OS_CHROMEOS) 1548 ChromeSigninClient* signin_client = 1549 ChromeSigninClientFactory::GetForProfile(profile); 1550 if (signin_client && signin_client->IsSigninProcess(process->GetID())) 1551 command_line->AppendSwitch(switches::kSigninProcess); 1552#endif 1553 } 1554 1555 { 1556 // Enable auto-reload if this session is in the field trial or the user 1557 // explicitly enabled it. 1558 std::string group = 1559 base::FieldTrialList::FindFullName("AutoReloadExperiment"); 1560 if (group == "Enabled" || 1561 browser_command_line.HasSwitch(switches::kEnableOfflineAutoReload)) { 1562 command_line->AppendSwitch(switches::kEnableOfflineAutoReload); 1563 } 1564 } 1565 1566 // Please keep this in alphabetical order. 1567 static const char* const kSwitchNames[] = { 1568 autofill::switches::kDisableIgnoreAutocompleteOff, 1569 autofill::switches::kDisableInteractiveAutocomplete, 1570 autofill::switches::kDisablePasswordGeneration, 1571 autofill::switches::kEnableInteractiveAutocomplete, 1572 autofill::switches::kEnablePasswordGeneration, 1573 autofill::switches::kLocalHeuristicsOnlyForPasswordGeneration, 1574 extensions::switches::kAllowHTTPBackgroundPage, 1575 extensions::switches::kAllowLegacyExtensionManifests, 1576 extensions::switches::kEnableExperimentalExtensionApis, 1577 extensions::switches::kExtensionsOnChromeURLs, 1578 // TODO(victorhsieh): remove the following flag once we move PPAPI FileIO 1579 // to browser. 1580 switches::kAllowNaClFileHandleAPI, 1581 switches::kAppsCheckoutURL, 1582 switches::kAppsGalleryURL, 1583 switches::kCloudPrintServiceURL, 1584 switches::kDisableBundledPpapiFlash, 1585 switches::kDisableExtensionsResourceWhitelist, 1586 switches::kDisablePnacl, 1587 switches::kDisableScriptedPrintThrottling, 1588 switches::kEnableAdview, 1589 switches::kEnableAppWindowControls, 1590 switches::kEnableBenchmarking, 1591 switches::kEnableNaCl, 1592 switches::kEnableNaClDebug, 1593 switches::kEnableNaClNonSfiMode, 1594 switches::kEnableNetBenchmarking, 1595 switches::kEnableStreamlinedHostedApps, 1596 switches::kEnableWatchdog, 1597 switches::kMemoryProfiling, 1598 switches::kMessageLoopHistogrammer, 1599 switches::kNoJsRandomness, 1600 switches::kOutOfProcessPdf, 1601 switches::kPlaybackMode, 1602 switches::kPpapiFlashArgs, 1603 switches::kPpapiFlashPath, 1604 switches::kPpapiFlashVersion, 1605 switches::kProfilingAtStart, 1606 switches::kProfilingFile, 1607 switches::kProfilingFlush, 1608 switches::kRecordMode, 1609 switches::kSilentDumpOnDCHECK, 1610 switches::kWhitelistedExtensionID, 1611 translate::switches::kTranslateSecurityOrigin, 1612 }; 1613 1614 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames, 1615 arraysize(kSwitchNames)); 1616 } else if (process_type == switches::kUtilityProcess) { 1617 static const char* const kSwitchNames[] = { 1618 extensions::switches::kAllowHTTPBackgroundPage, 1619 extensions::switches::kEnableExperimentalExtensionApis, 1620 extensions::switches::kExtensionsOnChromeURLs, 1621 switches::kWhitelistedExtensionID, 1622 }; 1623 1624 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames, 1625 arraysize(kSwitchNames)); 1626 } else if (process_type == switches::kPluginProcess) { 1627 static const char* const kSwitchNames[] = { 1628#if defined(OS_CHROMEOS) 1629 chromeos::switches::kLoginProfile, 1630#endif 1631 switches::kMemoryProfiling, 1632 switches::kSilentDumpOnDCHECK, 1633 }; 1634 1635 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames, 1636 arraysize(kSwitchNames)); 1637 } else if (process_type == switches::kZygoteProcess) { 1638 static const char* const kSwitchNames[] = { 1639 // Load (in-process) Pepper plugins in-process in the zygote pre-sandbox. 1640 switches::kDisableBundledPpapiFlash, 1641 switches::kPpapiFlashPath, 1642 switches::kPpapiFlashVersion, 1643 }; 1644 1645 command_line->CopySwitchesFrom(browser_command_line, kSwitchNames, 1646 arraysize(kSwitchNames)); 1647 } else if (process_type == switches::kGpuProcess) { 1648 // If --ignore-gpu-blacklist is passed in, don't send in crash reports 1649 // because GPU is expected to be unreliable. 1650 if (browser_command_line.HasSwitch(switches::kIgnoreGpuBlacklist) && 1651 !command_line->HasSwitch(switches::kDisableBreakpad)) 1652 command_line->AppendSwitch(switches::kDisableBreakpad); 1653 } 1654 1655 // The command line switch kEnableBenchmarking needs to be specified along 1656 // with the kEnableStatsTable switch to ensure that the stats table global 1657 // is initialized correctly. 1658 if (command_line->HasSwitch(switches::kEnableBenchmarking)) 1659 DCHECK(command_line->HasSwitch(switches::kEnableStatsTable)); 1660} 1661 1662std::string ChromeContentBrowserClient::GetApplicationLocale() { 1663 if (BrowserThread::CurrentlyOn(BrowserThread::IO)) 1664 return g_io_thread_application_locale.Get(); 1665 return g_browser_process->GetApplicationLocale(); 1666} 1667 1668std::string ChromeContentBrowserClient::GetAcceptLangs( 1669 content::BrowserContext* context) { 1670 Profile* profile = Profile::FromBrowserContext(context); 1671 return profile->GetPrefs()->GetString(prefs::kAcceptLanguages); 1672} 1673 1674gfx::ImageSkia* ChromeContentBrowserClient::GetDefaultFavicon() { 1675 ResourceBundle& rb = ResourceBundle::GetSharedInstance(); 1676 return rb.GetImageSkiaNamed(IDR_DEFAULT_FAVICON); 1677} 1678 1679bool ChromeContentBrowserClient::AllowAppCache( 1680 const GURL& manifest_url, 1681 const GURL& first_party, 1682 content::ResourceContext* context) { 1683 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1684 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1685 return io_data->GetCookieSettings()-> 1686 IsSettingCookieAllowed(manifest_url, first_party); 1687} 1688 1689bool ChromeContentBrowserClient::AllowGetCookie( 1690 const GURL& url, 1691 const GURL& first_party, 1692 const net::CookieList& cookie_list, 1693 content::ResourceContext* context, 1694 int render_process_id, 1695 int render_frame_id) { 1696 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1697 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1698 bool allow = io_data->GetCookieSettings()-> 1699 IsReadingCookieAllowed(url, first_party); 1700 1701 BrowserThread::PostTask( 1702 BrowserThread::UI, FROM_HERE, 1703 base::Bind(&TabSpecificContentSettings::CookiesRead, render_process_id, 1704 render_frame_id, url, first_party, cookie_list, !allow, true)); 1705 return allow; 1706} 1707 1708bool ChromeContentBrowserClient::AllowSetCookie( 1709 const GURL& url, 1710 const GURL& first_party, 1711 const std::string& cookie_line, 1712 content::ResourceContext* context, 1713 int render_process_id, 1714 int render_frame_id, 1715 net::CookieOptions* options) { 1716 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1717 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1718 CookieSettings* cookie_settings = io_data->GetCookieSettings(); 1719 bool allow = cookie_settings->IsSettingCookieAllowed(url, first_party); 1720 1721 BrowserThread::PostTask( 1722 BrowserThread::UI, FROM_HERE, 1723 base::Bind(&TabSpecificContentSettings::CookieChanged, render_process_id, 1724 render_frame_id, url, first_party, cookie_line, *options, 1725 !allow)); 1726 return allow; 1727} 1728 1729bool ChromeContentBrowserClient::AllowSaveLocalState( 1730 content::ResourceContext* context) { 1731 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1732 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1733 CookieSettings* cookie_settings = io_data->GetCookieSettings(); 1734 ContentSetting setting = cookie_settings->GetDefaultCookieSetting(NULL); 1735 1736 // TODO(bauerb): Should we also disallow local state if the default is BLOCK? 1737 // Could we even support per-origin settings? 1738 return setting != CONTENT_SETTING_SESSION_ONLY; 1739} 1740 1741bool ChromeContentBrowserClient::AllowWorkerDatabase( 1742 const GURL& url, 1743 const base::string16& name, 1744 const base::string16& display_name, 1745 unsigned long estimated_size, 1746 content::ResourceContext* context, 1747 const std::vector<std::pair<int, int> >& render_frames) { 1748 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1749 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1750 CookieSettings* cookie_settings = io_data->GetCookieSettings(); 1751 bool allow = cookie_settings->IsSettingCookieAllowed(url, url); 1752 1753 // Record access to database for potential display in UI. 1754 std::vector<std::pair<int, int> >::const_iterator i; 1755 for (i = render_frames.begin(); i != render_frames.end(); ++i) { 1756 BrowserThread::PostTask( 1757 BrowserThread::UI, FROM_HERE, 1758 base::Bind(&TabSpecificContentSettings::WebDatabaseAccessed, 1759 i->first, i->second, url, name, display_name, !allow)); 1760 } 1761 1762 return allow; 1763} 1764 1765bool ChromeContentBrowserClient::AllowWorkerFileSystem( 1766 const GURL& url, 1767 content::ResourceContext* context, 1768 const std::vector<std::pair<int, int> >& render_frames) { 1769 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1770 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1771 CookieSettings* cookie_settings = io_data->GetCookieSettings(); 1772 bool allow = cookie_settings->IsSettingCookieAllowed(url, url); 1773 1774 // Record access to file system for potential display in UI. 1775 std::vector<std::pair<int, int> >::const_iterator i; 1776 for (i = render_frames.begin(); i != render_frames.end(); ++i) { 1777 BrowserThread::PostTask( 1778 BrowserThread::UI, FROM_HERE, 1779 base::Bind(&TabSpecificContentSettings::FileSystemAccessed, 1780 i->first, i->second, url, !allow)); 1781 } 1782 1783 return allow; 1784} 1785 1786bool ChromeContentBrowserClient::AllowWorkerIndexedDB( 1787 const GURL& url, 1788 const base::string16& name, 1789 content::ResourceContext* context, 1790 const std::vector<std::pair<int, int> >& render_frames) { 1791 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1792 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1793 CookieSettings* cookie_settings = io_data->GetCookieSettings(); 1794 bool allow = cookie_settings->IsSettingCookieAllowed(url, url); 1795 1796 // Record access to IndexedDB for potential display in UI. 1797 std::vector<std::pair<int, int> >::const_iterator i; 1798 for (i = render_frames.begin(); i != render_frames.end(); ++i) { 1799 BrowserThread::PostTask( 1800 BrowserThread::UI, FROM_HERE, 1801 base::Bind(&TabSpecificContentSettings::IndexedDBAccessed, 1802 i->first, i->second, url, name, !allow)); 1803 } 1804 1805 return allow; 1806} 1807 1808net::URLRequestContext* 1809ChromeContentBrowserClient::OverrideRequestContextForURL( 1810 const GURL& url, content::ResourceContext* context) { 1811 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 1812 if (url.SchemeIs(extensions::kExtensionScheme)) { 1813 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 1814 return io_data->extensions_request_context(); 1815 } 1816 1817 return NULL; 1818} 1819 1820QuotaPermissionContext* 1821ChromeContentBrowserClient::CreateQuotaPermissionContext() { 1822 return new ChromeQuotaPermissionContext(); 1823} 1824 1825void ChromeContentBrowserClient::AllowCertificateError( 1826 int render_process_id, 1827 int render_frame_id, 1828 int cert_error, 1829 const net::SSLInfo& ssl_info, 1830 const GURL& request_url, 1831 ResourceType::Type resource_type, 1832 bool overridable, 1833 bool strict_enforcement, 1834 const base::Callback<void(bool)>& callback, 1835 content::CertificateRequestResultType* result) { 1836 if (resource_type != ResourceType::MAIN_FRAME) { 1837 // A sub-resource has a certificate error. The user doesn't really 1838 // have a context for making the right decision, so block the 1839 // request hard, without an info bar to allow showing the insecure 1840 // content. 1841 *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY; 1842 return; 1843 } 1844 1845 // If the tab is being prerendered, cancel the prerender and the request. 1846 content::RenderFrameHost* render_frame_host = 1847 content::RenderFrameHost::FromID(render_process_id, render_frame_id); 1848 WebContents* tab = WebContents::FromRenderFrameHost(render_frame_host); 1849 if (!tab) { 1850 NOTREACHED(); 1851 return; 1852 } 1853 1854 prerender::PrerenderContents* prerender_contents = 1855 prerender::PrerenderContents::FromWebContents(tab); 1856 if (prerender_contents) { 1857 prerender_contents->Destroy(prerender::FINAL_STATUS_SSL_ERROR); 1858 *result = content::CERTIFICATE_REQUEST_RESULT_TYPE_CANCEL; 1859 return; 1860 } 1861 1862#if defined(ENABLE_CAPTIVE_PORTAL_DETECTION) 1863 captive_portal::CaptivePortalTabHelper* captive_portal_tab_helper = 1864 captive_portal::CaptivePortalTabHelper::FromWebContents(tab); 1865 if (captive_portal_tab_helper) 1866 captive_portal_tab_helper->OnSSLCertError(ssl_info); 1867#endif 1868 1869 // Otherwise, display an SSL blocking page. 1870 new SSLBlockingPage(tab, cert_error, ssl_info, request_url, overridable, 1871 strict_enforcement, callback); 1872} 1873 1874void ChromeContentBrowserClient::SelectClientCertificate( 1875 int render_process_id, 1876 int render_frame_id, 1877 const net::HttpNetworkSession* network_session, 1878 net::SSLCertRequestInfo* cert_request_info, 1879 const base::Callback<void(net::X509Certificate*)>& callback) { 1880 content::RenderFrameHost* rfh = content::RenderFrameHost::FromID( 1881 render_process_id, render_frame_id); 1882 WebContents* tab = WebContents::FromRenderFrameHost(rfh); 1883 if (!tab) { 1884 NOTREACHED(); 1885 return; 1886 } 1887 1888 prerender::PrerenderContents* prerender_contents = 1889 prerender::PrerenderContents::FromWebContents(tab); 1890 if (prerender_contents) { 1891 prerender_contents->Destroy( 1892 prerender::FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED); 1893 return; 1894 } 1895 1896 GURL requesting_url("https://" + cert_request_info->host_and_port.ToString()); 1897 DCHECK(requesting_url.is_valid()) 1898 << "Invalid URL string: https://" 1899 << cert_request_info->host_and_port.ToString(); 1900 1901 Profile* profile = Profile::FromBrowserContext(tab->GetBrowserContext()); 1902 scoped_ptr<base::Value> filter( 1903 profile->GetHostContentSettingsMap()->GetWebsiteSetting( 1904 requesting_url, 1905 requesting_url, 1906 CONTENT_SETTINGS_TYPE_AUTO_SELECT_CERTIFICATE, 1907 std::string(), NULL)); 1908 1909 if (filter.get()) { 1910 // Try to automatically select a client certificate. 1911 if (filter->IsType(base::Value::TYPE_DICTIONARY)) { 1912 base::DictionaryValue* filter_dict = 1913 static_cast<base::DictionaryValue*>(filter.get()); 1914 1915 const std::vector<scoped_refptr<net::X509Certificate> >& 1916 all_client_certs = cert_request_info->client_certs; 1917 for (size_t i = 0; i < all_client_certs.size(); ++i) { 1918 if (CertMatchesFilter(*all_client_certs[i].get(), *filter_dict)) { 1919 // Use the first certificate that is matched by the filter. 1920 callback.Run(all_client_certs[i].get()); 1921 return; 1922 } 1923 } 1924 } else { 1925 NOTREACHED(); 1926 } 1927 } 1928 1929 SSLTabHelper* ssl_tab_helper = SSLTabHelper::FromWebContents(tab); 1930 if (!ssl_tab_helper) { 1931 // If there is no SSLTabHelper for the given WebContents then we can't 1932 // show the user a dialog to select a client certificate. So we simply 1933 // proceed with no client certificate. 1934 callback.Run(NULL); 1935 return; 1936 } 1937 ssl_tab_helper->ShowClientCertificateRequestDialog( 1938 network_session, cert_request_info, callback); 1939} 1940 1941void ChromeContentBrowserClient::AddCertificate( 1942 net::URLRequest* request, 1943 net::CertificateMimeType cert_type, 1944 const void* cert_data, 1945 size_t cert_size, 1946 int render_process_id, 1947 int render_view_id) { 1948 chrome::SSLAddCertificate(request, cert_type, cert_data, cert_size, 1949 render_process_id, render_view_id); 1950} 1951 1952content::MediaObserver* ChromeContentBrowserClient::GetMediaObserver() { 1953 return MediaCaptureDevicesDispatcher::GetInstance(); 1954} 1955 1956void ChromeContentBrowserClient::RequestDesktopNotificationPermission( 1957 const GURL& source_origin, 1958 int callback_context, 1959 int render_process_id, 1960 int render_view_id) { 1961#if defined(ENABLE_NOTIFICATIONS) 1962 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); 1963 WebContents* contents = 1964 tab_util::GetWebContentsByID(render_process_id, render_view_id); 1965 if (!contents) { 1966 NOTREACHED(); 1967 return; 1968 } 1969 1970 // Skip showing the infobar if the request comes from an extension, and that 1971 // extension has the 'notify' permission. (If the extension does not have the 1972 // permission, the user will still be prompted.) 1973 Profile* profile = Profile::FromBrowserContext(contents->GetBrowserContext()); 1974 InfoMap* extension_info_map = 1975 extensions::ExtensionSystem::Get(profile)->info_map(); 1976 DesktopNotificationService* notification_service = 1977 DesktopNotificationServiceFactory::GetForProfile(profile); 1978 const Extension* extension = NULL; 1979 if (extension_info_map) { 1980 extensions::ExtensionSet extensions; 1981 extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin( 1982 source_origin, render_process_id, 1983 extensions::APIPermission::kNotification, &extensions); 1984 for (extensions::ExtensionSet::const_iterator iter = extensions.begin(); 1985 iter != extensions.end(); ++iter) { 1986 if (notification_service->IsNotifierEnabled(NotifierId( 1987 NotifierId::APPLICATION, (*iter)->id()))) { 1988 extension = iter->get(); 1989 break; 1990 } 1991 } 1992 } 1993 RenderViewHost* rvh = 1994 RenderViewHost::FromID(render_process_id, render_view_id); 1995 if (IsExtensionWithPermissionOrSuggestInConsole( 1996 APIPermission::kNotification, extension, rvh)) { 1997 if (rvh) 1998 rvh->DesktopNotificationPermissionRequestDone(callback_context); 1999 return; 2000 } 2001 2002 notification_service->RequestPermission(source_origin, render_process_id, 2003 render_view_id, callback_context, contents); 2004#else 2005 NOTIMPLEMENTED(); 2006#endif 2007} 2008 2009blink::WebNotificationPresenter::Permission 2010 ChromeContentBrowserClient::CheckDesktopNotificationPermission( 2011 const GURL& source_origin, 2012 content::ResourceContext* context, 2013 int render_process_id) { 2014#if defined(ENABLE_NOTIFICATIONS) 2015 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 2016 2017 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 2018 InfoMap* extension_info_map = io_data->GetExtensionInfoMap(); 2019 2020 // We want to see if there is an extension that hasn't been manually disabled 2021 // that has the notifications permission and applies to this security origin. 2022 // First, get the list of extensions with permission for the origin. 2023 extensions::ExtensionSet extensions; 2024 extension_info_map->GetExtensionsWithAPIPermissionForSecurityOrigin( 2025 source_origin, render_process_id, 2026 extensions::APIPermission::kNotification, &extensions); 2027 for (extensions::ExtensionSet::const_iterator iter = extensions.begin(); 2028 iter != extensions.end(); ++iter) { 2029 // Then, check to see if it's been disabled by the user. 2030 if (!extension_info_map->AreNotificationsDisabled((*iter)->id())) 2031 return blink::WebNotificationPresenter::PermissionAllowed; 2032 } 2033 2034 // No enabled extensions exist, so check the normal host content settings. 2035 HostContentSettingsMap* host_content_settings_map = 2036 io_data->GetHostContentSettingsMap(); 2037 ContentSetting setting = host_content_settings_map->GetContentSetting( 2038 source_origin, 2039 source_origin, 2040 CONTENT_SETTINGS_TYPE_NOTIFICATIONS, 2041 NO_RESOURCE_IDENTIFIER); 2042 2043 if (setting == CONTENT_SETTING_ALLOW) 2044 return blink::WebNotificationPresenter::PermissionAllowed; 2045 if (setting == CONTENT_SETTING_BLOCK) 2046 return blink::WebNotificationPresenter::PermissionDenied; 2047 return blink::WebNotificationPresenter::PermissionNotAllowed; 2048#else 2049 return blink::WebNotificationPresenter::PermissionAllowed; 2050#endif 2051} 2052 2053void ChromeContentBrowserClient::ShowDesktopNotification( 2054 const content::ShowDesktopNotificationHostMsgParams& params, 2055 int render_process_id, 2056 int render_view_id, 2057 bool worker) { 2058#if defined(ENABLE_NOTIFICATIONS) 2059 RenderViewHost* rvh = RenderViewHost::FromID( 2060 render_process_id, render_view_id); 2061 if (!rvh) { 2062 NOTREACHED(); 2063 return; 2064 } 2065 2066 content::RenderProcessHost* process = rvh->GetProcess(); 2067 Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext()); 2068 DesktopNotificationService* service = 2069 DesktopNotificationServiceFactory::GetForProfile(profile); 2070 service->ShowDesktopNotification( 2071 params, render_process_id, render_view_id, 2072 worker ? DesktopNotificationService::WorkerNotification : 2073 DesktopNotificationService::PageNotification); 2074#else 2075 NOTIMPLEMENTED(); 2076#endif 2077} 2078 2079void ChromeContentBrowserClient::CancelDesktopNotification( 2080 int render_process_id, 2081 int render_view_id, 2082 int notification_id) { 2083#if defined(ENABLE_NOTIFICATIONS) 2084 RenderViewHost* rvh = RenderViewHost::FromID( 2085 render_process_id, render_view_id); 2086 if (!rvh) { 2087 NOTREACHED(); 2088 return; 2089 } 2090 2091 content::RenderProcessHost* process = rvh->GetProcess(); 2092 Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext()); 2093 DesktopNotificationService* service = 2094 DesktopNotificationServiceFactory::GetForProfile(profile); 2095 service->CancelDesktopNotification( 2096 render_process_id, render_view_id, notification_id); 2097#else 2098 NOTIMPLEMENTED(); 2099#endif 2100} 2101 2102bool ChromeContentBrowserClient::CanCreateWindow( 2103 const GURL& opener_url, 2104 const GURL& opener_top_level_frame_url, 2105 const GURL& source_origin, 2106 WindowContainerType container_type, 2107 const GURL& target_url, 2108 const content::Referrer& referrer, 2109 WindowOpenDisposition disposition, 2110 const WebWindowFeatures& features, 2111 bool user_gesture, 2112 bool opener_suppressed, 2113 content::ResourceContext* context, 2114 int render_process_id, 2115 bool is_guest, 2116 int opener_id, 2117 bool* no_javascript_access) { 2118 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 2119 2120 *no_javascript_access = false; 2121 2122 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 2123 InfoMap* map = io_data->GetExtensionInfoMap(); 2124 2125 // If the opener is trying to create a background window but doesn't have 2126 // the appropriate permission, fail the attempt. 2127 if (container_type == WINDOW_CONTAINER_TYPE_BACKGROUND) { 2128 if (!map->SecurityOriginHasAPIPermission( 2129 source_origin, 2130 render_process_id, 2131 APIPermission::kBackground)) { 2132 return false; 2133 } 2134 2135 // Note: this use of GetExtensionOrAppByURL is safe but imperfect. It may 2136 // return a recently installed Extension even if this CanCreateWindow call 2137 // was made by an old copy of the page in a normal web process. That's ok, 2138 // because the permission check above would have caused an early return 2139 // already. We must use the full URL to find hosted apps, though, and not 2140 // just the origin. 2141 const Extension* extension = 2142 map->extensions().GetExtensionOrAppByURL(opener_url); 2143 if (extension && !extensions::BackgroundInfo::AllowJSAccess(extension)) 2144 *no_javascript_access = true; 2145 2146 return true; 2147 } 2148 2149 // No new browser window (popup or tab) in app mode. 2150 if (container_type == WINDOW_CONTAINER_TYPE_NORMAL && 2151 chrome::IsRunningInForcedAppMode()) { 2152 return false; 2153 } 2154 2155 if (is_guest) 2156 return true; 2157 2158 HostContentSettingsMap* content_settings = 2159 ProfileIOData::FromResourceContext(context)->GetHostContentSettingsMap(); 2160 BlockedWindowParams blocked_params(target_url, 2161 referrer, 2162 disposition, 2163 features, 2164 user_gesture, 2165 opener_suppressed, 2166 render_process_id, 2167 opener_id); 2168 2169 if (!user_gesture && !CommandLine::ForCurrentProcess()->HasSwitch( 2170 switches::kDisablePopupBlocking)) { 2171 if (content_settings->GetContentSetting(opener_top_level_frame_url, 2172 opener_top_level_frame_url, 2173 CONTENT_SETTINGS_TYPE_POPUPS, 2174 std::string()) != 2175 CONTENT_SETTING_ALLOW) { 2176 BrowserThread::PostTask(BrowserThread::UI, 2177 FROM_HERE, 2178 base::Bind(&HandleBlockedPopupOnUIThread, 2179 blocked_params)); 2180 return false; 2181 } 2182 } 2183 2184#if defined(OS_ANDROID) 2185 if (SingleTabModeTabHelper::IsRegistered(render_process_id, opener_id)) { 2186 BrowserThread::PostTask(BrowserThread::UI, 2187 FROM_HERE, 2188 base::Bind(&HandleSingleTabModeBlockOnUIThread, 2189 blocked_params)); 2190 return false; 2191 } 2192#endif 2193 2194 return true; 2195} 2196 2197std::string ChromeContentBrowserClient::GetWorkerProcessTitle( 2198 const GURL& url, content::ResourceContext* context) { 2199 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); 2200 // Check if it's an extension-created worker, in which case we want to use 2201 // the name of the extension. 2202 ProfileIOData* io_data = ProfileIOData::FromResourceContext(context); 2203 const Extension* extension = 2204 io_data->GetExtensionInfoMap()->extensions().GetByID(url.host()); 2205 return extension ? extension->name() : std::string(); 2206} 2207 2208void ChromeContentBrowserClient::ResourceDispatcherHostCreated() { 2209 return g_browser_process->ResourceDispatcherHostCreated(); 2210} 2211 2212// TODO(tommi): Rename from Get to Create. 2213content::SpeechRecognitionManagerDelegate* 2214 ChromeContentBrowserClient::GetSpeechRecognitionManagerDelegate() { 2215#if defined(ENABLE_INPUT_SPEECH) 2216 return new speech::ChromeSpeechRecognitionManagerDelegateBubbleUI(); 2217#else 2218 // Platforms who don't implement x-webkit-speech (a.k.a INPUT_SPEECH) just 2219 // need the base delegate without the bubble UI. 2220 return new speech::ChromeSpeechRecognitionManagerDelegate(); 2221#endif 2222} 2223 2224net::NetLog* ChromeContentBrowserClient::GetNetLog() { 2225 return g_browser_process->net_log(); 2226} 2227 2228AccessTokenStore* ChromeContentBrowserClient::CreateAccessTokenStore() { 2229 return new ChromeAccessTokenStore(); 2230} 2231 2232bool ChromeContentBrowserClient::IsFastShutdownPossible() { 2233 return true; 2234} 2235 2236void ChromeContentBrowserClient::OverrideWebkitPrefs( 2237 RenderViewHost* rvh, const GURL& url, WebPreferences* web_prefs) { 2238 Profile* profile = Profile::FromBrowserContext( 2239 rvh->GetProcess()->GetBrowserContext()); 2240 PrefService* prefs = profile->GetPrefs(); 2241 2242 // Fill per-script font preferences. These are not registered on Android 2243 // - http://crbug.com/308033. 2244#if !defined(OS_ANDROID) 2245 FillFontFamilyMap(prefs, prefs::kWebKitStandardFontFamilyMap, 2246 &web_prefs->standard_font_family_map); 2247 FillFontFamilyMap(prefs, prefs::kWebKitFixedFontFamilyMap, 2248 &web_prefs->fixed_font_family_map); 2249 FillFontFamilyMap(prefs, prefs::kWebKitSerifFontFamilyMap, 2250 &web_prefs->serif_font_family_map); 2251 FillFontFamilyMap(prefs, prefs::kWebKitSansSerifFontFamilyMap, 2252 &web_prefs->sans_serif_font_family_map); 2253 FillFontFamilyMap(prefs, prefs::kWebKitCursiveFontFamilyMap, 2254 &web_prefs->cursive_font_family_map); 2255 FillFontFamilyMap(prefs, prefs::kWebKitFantasyFontFamilyMap, 2256 &web_prefs->fantasy_font_family_map); 2257 FillFontFamilyMap(prefs, prefs::kWebKitPictographFontFamilyMap, 2258 &web_prefs->pictograph_font_family_map); 2259#endif 2260 2261 web_prefs->default_font_size = 2262 prefs->GetInteger(prefs::kWebKitDefaultFontSize); 2263 web_prefs->default_fixed_font_size = 2264 prefs->GetInteger(prefs::kWebKitDefaultFixedFontSize); 2265 web_prefs->minimum_font_size = 2266 prefs->GetInteger(prefs::kWebKitMinimumFontSize); 2267 web_prefs->minimum_logical_font_size = 2268 prefs->GetInteger(prefs::kWebKitMinimumLogicalFontSize); 2269 2270 web_prefs->default_encoding = prefs->GetString(prefs::kDefaultCharset); 2271 2272 web_prefs->javascript_can_open_windows_automatically = 2273 prefs->GetBoolean(prefs::kWebKitJavascriptCanOpenWindowsAutomatically); 2274 web_prefs->dom_paste_enabled = 2275 prefs->GetBoolean(prefs::kWebKitDomPasteEnabled); 2276 web_prefs->shrinks_standalone_images_to_fit = 2277 prefs->GetBoolean(prefs::kWebKitShrinksStandaloneImagesToFit); 2278 const base::DictionaryValue* inspector_settings = 2279 prefs->GetDictionary(prefs::kWebKitInspectorSettings); 2280 if (inspector_settings) { 2281 for (base::DictionaryValue::Iterator iter(*inspector_settings); 2282 !iter.IsAtEnd(); 2283 iter.Advance()) { 2284 std::string value; 2285 if (iter.value().GetAsString(&value)) { 2286 web_prefs->inspector_settings.push_back( 2287 std::make_pair(iter.key(), value)); 2288 } 2289 } 2290 } 2291 web_prefs->tabs_to_links = prefs->GetBoolean(prefs::kWebkitTabsToLinks); 2292 2293 if (!prefs->GetBoolean(prefs::kWebKitJavascriptEnabled)) 2294 web_prefs->javascript_enabled = false; 2295 if (!prefs->GetBoolean(prefs::kWebKitWebSecurityEnabled)) 2296 web_prefs->web_security_enabled = false; 2297 if (!prefs->GetBoolean(prefs::kWebKitPluginsEnabled)) 2298 web_prefs->plugins_enabled = false; 2299 if (!prefs->GetBoolean(prefs::kWebKitJavaEnabled)) 2300 web_prefs->java_enabled = false; 2301 web_prefs->loads_images_automatically = 2302 prefs->GetBoolean(prefs::kWebKitLoadsImagesAutomatically); 2303 2304 if (prefs->GetBoolean(prefs::kDisable3DAPIs)) 2305 web_prefs->experimental_webgl_enabled = false; 2306 2307 web_prefs->allow_displaying_insecure_content = 2308 prefs->GetBoolean(prefs::kWebKitAllowDisplayingInsecureContent); 2309 web_prefs->allow_running_insecure_content = 2310 prefs->GetBoolean(prefs::kWebKitAllowRunningInsecureContent); 2311#if defined(OS_ANDROID) 2312 web_prefs->font_scale_factor = 2313 static_cast<float>(prefs->GetDouble(prefs::kWebKitFontScaleFactor)); 2314 web_prefs->device_scale_adjustment = GetDeviceScaleAdjustment(); 2315 web_prefs->force_enable_zoom = 2316 prefs->GetBoolean(prefs::kWebKitForceEnableZoom); 2317#endif 2318 2319#if defined(OS_ANDROID) 2320 web_prefs->password_echo_enabled = 2321 prefs->GetBoolean(prefs::kWebKitPasswordEchoEnabled); 2322#else 2323 web_prefs->password_echo_enabled = browser_defaults::kPasswordEchoEnabled; 2324#endif 2325 2326 web_prefs->asynchronous_spell_checking_enabled = true; 2327 web_prefs->unified_textchecker_enabled = true; 2328 2329 web_prefs->uses_universal_detector = 2330 prefs->GetBoolean(prefs::kWebKitUsesUniversalDetector); 2331 web_prefs->text_areas_are_resizable = 2332 prefs->GetBoolean(prefs::kWebKitTextAreasAreResizable); 2333 web_prefs->hyperlink_auditing_enabled = 2334 prefs->GetBoolean(prefs::kEnableHyperlinkAuditing); 2335 2336 // Make sure we will set the default_encoding with canonical encoding name. 2337 web_prefs->default_encoding = 2338 CharacterEncoding::GetCanonicalEncodingNameByAliasName( 2339 web_prefs->default_encoding); 2340 if (web_prefs->default_encoding.empty()) { 2341 prefs->ClearPref(prefs::kDefaultCharset); 2342 web_prefs->default_encoding = prefs->GetString(prefs::kDefaultCharset); 2343 } 2344 DCHECK(!web_prefs->default_encoding.empty()); 2345 2346 WebContents* web_contents = WebContents::FromRenderViewHost(rvh); 2347 extensions::ViewType view_type = extensions::GetViewType(web_contents); 2348 ExtensionService* service = 2349 extensions::ExtensionSystem::Get(profile)->extension_service(); 2350 if (service) { 2351 const GURL& site_url = rvh->GetSiteInstance()->GetSiteURL(); 2352 const Extension* extension = 2353 service->extensions()->GetByID(site_url.host()); 2354 // Ensure that we are only granting extension preferences to URLs with 2355 // the correct scheme. Without this check, chrome-guest:// schemes used by 2356 // webview tags as well as hosts that happen to match the id of an 2357 // installed extension would get the wrong preferences. 2358 if (site_url.SchemeIs(extensions::kExtensionScheme)) { 2359 extension_webkit_preferences::SetPreferences( 2360 extension, view_type, web_prefs); 2361 } 2362 } 2363 2364 if (view_type == extensions::VIEW_TYPE_NOTIFICATION) { 2365 web_prefs->allow_scripts_to_close_windows = true; 2366 } else if (view_type == extensions::VIEW_TYPE_BACKGROUND_CONTENTS) { 2367 // Disable all kinds of acceleration for background pages. 2368 // See http://crbug.com/96005 and http://crbug.com/96006 2369 web_prefs->force_compositing_mode = false; 2370 web_prefs->accelerated_compositing_enabled = false; 2371 } 2372 2373#if defined(OS_CHROMEOS) 2374 // Override the default of suppressing HW compositing for WebUI pages for the 2375 // file manager, which is implemented using WebUI but wants HW acceleration 2376 // for video decode & render. 2377 if (url.SchemeIs(extensions::kExtensionScheme) && 2378 url.host() == file_manager::kFileManagerAppId) { 2379 web_prefs->accelerated_compositing_enabled = true; 2380 web_prefs->accelerated_2d_canvas_enabled = true; 2381 } 2382#endif 2383} 2384 2385void ChromeContentBrowserClient::UpdateInspectorSetting( 2386 RenderViewHost* rvh, const std::string& key, const std::string& value) { 2387 content::BrowserContext* browser_context = 2388 rvh->GetProcess()->GetBrowserContext(); 2389 DictionaryPrefUpdate update( 2390 Profile::FromBrowserContext(browser_context)->GetPrefs(), 2391 prefs::kWebKitInspectorSettings); 2392 base::DictionaryValue* inspector_settings = update.Get(); 2393 inspector_settings->SetWithoutPathExpansion( 2394 key, base::Value::CreateStringValue(value)); 2395} 2396 2397void ChromeContentBrowserClient::BrowserURLHandlerCreated( 2398 BrowserURLHandler* handler) { 2399 // Add the default URL handlers. 2400 handler->AddHandlerPair(&ExtensionWebUI::HandleChromeURLOverride, 2401 BrowserURLHandler::null_handler()); 2402 handler->AddHandlerPair(BrowserURLHandler::null_handler(), 2403 &ExtensionWebUI::HandleChromeURLOverrideReverse); 2404 2405 // about: handler. Must come before chrome: handler, since it will 2406 // rewrite about: urls to chrome: URLs and then expect chrome: to 2407 // actually handle them. 2408 handler->AddHandlerPair(&WillHandleBrowserAboutURL, 2409 BrowserURLHandler::null_handler()); 2410 2411#if defined(OS_ANDROID) 2412 // Handler to rewrite chrome://newtab on Android. 2413 handler->AddHandlerPair(&chrome::android::HandleAndroidNewTabURL, 2414 BrowserURLHandler::null_handler()); 2415#else 2416 // Handler to rewrite chrome://newtab for InstantExtended. 2417 handler->AddHandlerPair(&chrome::HandleNewTabURLRewrite, 2418 &chrome::HandleNewTabURLReverseRewrite); 2419#endif 2420 2421 // chrome: & friends. 2422 handler->AddHandlerPair(&HandleWebUI, &HandleWebUIReverse); 2423} 2424 2425void ChromeContentBrowserClient::ClearCache(RenderViewHost* rvh) { 2426 Profile* profile = Profile::FromBrowserContext( 2427 rvh->GetSiteInstance()->GetProcess()->GetBrowserContext()); 2428 BrowsingDataRemover* remover = 2429 BrowsingDataRemover::CreateForUnboundedRange(profile); 2430 remover->Remove(BrowsingDataRemover::REMOVE_CACHE, 2431 BrowsingDataHelper::UNPROTECTED_WEB); 2432 // BrowsingDataRemover takes care of deleting itself when done. 2433} 2434 2435void ChromeContentBrowserClient::ClearCookies(RenderViewHost* rvh) { 2436 Profile* profile = Profile::FromBrowserContext( 2437 rvh->GetSiteInstance()->GetProcess()->GetBrowserContext()); 2438 BrowsingDataRemover* remover = 2439 BrowsingDataRemover::CreateForUnboundedRange(profile); 2440 int remove_mask = BrowsingDataRemover::REMOVE_SITE_DATA; 2441 remover->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB); 2442 // BrowsingDataRemover takes care of deleting itself when done. 2443} 2444 2445base::FilePath ChromeContentBrowserClient::GetDefaultDownloadDirectory() { 2446 return DownloadPrefs::GetDefaultDownloadDirectory(); 2447} 2448 2449std::string ChromeContentBrowserClient::GetDefaultDownloadName() { 2450 return l10n_util::GetStringUTF8(IDS_DEFAULT_DOWNLOAD_FILENAME); 2451} 2452 2453void ChromeContentBrowserClient::DidCreatePpapiPlugin( 2454 content::BrowserPpapiHost* browser_host) { 2455#if defined(ENABLE_PLUGINS) 2456 browser_host->GetPpapiHost()->AddHostFactoryFilter( 2457 scoped_ptr<ppapi::host::HostFactory>( 2458 new ChromeBrowserPepperHostFactory(browser_host))); 2459#endif 2460} 2461 2462content::BrowserPpapiHost* 2463 ChromeContentBrowserClient::GetExternalBrowserPpapiHost( 2464 int plugin_process_id) { 2465 BrowserChildProcessHostIterator iter(PROCESS_TYPE_NACL_LOADER); 2466 while (!iter.Done()) { 2467 nacl::NaClProcessHost* host = static_cast<nacl::NaClProcessHost*>( 2468 iter.GetDelegate()); 2469 if (host->process() && 2470 host->process()->GetData().id == plugin_process_id) { 2471 // Found the plugin. 2472 return host->browser_ppapi_host(); 2473 } 2474 ++iter; 2475 } 2476 return NULL; 2477} 2478 2479bool ChromeContentBrowserClient::SupportsBrowserPlugin( 2480 content::BrowserContext* browser_context, const GURL& site_url) { 2481 if (CommandLine::ForCurrentProcess()->HasSwitch( 2482 switches::kEnableBrowserPluginForAllViewTypes)) 2483 return true; 2484 2485 if (content::HasWebUIScheme(site_url)) 2486 return true; 2487 2488 Profile* profile = Profile::FromBrowserContext(browser_context); 2489 ExtensionService* service = 2490 extensions::ExtensionSystem::Get(profile)->extension_service(); 2491 if (!service) 2492 return false; 2493 2494 const Extension* extension = 2495 service->extensions()->GetExtensionOrAppByURL(site_url); 2496 if (!extension) 2497 return false; 2498 2499 return extension->HasAPIPermission(APIPermission::kWebView) || 2500 extension->HasAPIPermission(APIPermission::kAdView); 2501} 2502 2503bool ChromeContentBrowserClient::AllowPepperSocketAPI( 2504 content::BrowserContext* browser_context, 2505 const GURL& url, 2506 bool private_api, 2507 const content::SocketPermissionRequest* params) { 2508#if defined(ENABLE_PLUGINS) 2509 Profile* profile = Profile::FromBrowserContext(browser_context); 2510 const extensions::ExtensionSet* extension_set = NULL; 2511 if (profile) { 2512 extension_set = extensions::ExtensionSystem::Get(profile)-> 2513 extension_service()->extensions(); 2514 } 2515 2516 if (private_api) { 2517 // Access to private socket APIs is controlled by the whitelist. 2518 if (IsExtensionOrSharedModuleWhitelisted(url, extension_set, 2519 allowed_socket_origins_)) { 2520 return true; 2521 } 2522 } else { 2523 // Access to public socket APIs is controlled by extension permissions. 2524 if (url.is_valid() && url.SchemeIs(extensions::kExtensionScheme) && 2525 extension_set) { 2526 const Extension* extension = extension_set->GetByID(url.host()); 2527 if (extension) { 2528 if (params) { 2529 extensions::SocketPermission::CheckParam check_params( 2530 params->type, params->host, params->port); 2531 if (extensions::PermissionsData::CheckAPIPermissionWithParam( 2532 extension, extensions::APIPermission::kSocket, 2533 &check_params)) { 2534 return true; 2535 } 2536 } else { 2537 if (extensions::PermissionsData::HasAPIPermission( 2538 extension, extensions::APIPermission::kSocket)) { 2539 return true; 2540 } 2541 } 2542 } 2543 } 2544 } 2545 2546 // Allow both public and private APIs if the command line says so. 2547 return IsHostAllowedByCommandLine(url, extension_set, 2548 switches::kAllowNaClSocketAPI); 2549#else 2550 return false; 2551#endif 2552} 2553 2554ui::SelectFilePolicy* ChromeContentBrowserClient::CreateSelectFilePolicy( 2555 WebContents* web_contents) { 2556 return new ChromeSelectFilePolicy(web_contents); 2557} 2558 2559void ChromeContentBrowserClient::GetAdditionalAllowedSchemesForFileSystem( 2560 std::vector<std::string>* additional_allowed_schemes) { 2561 ContentBrowserClient::GetAdditionalAllowedSchemesForFileSystem( 2562 additional_allowed_schemes); 2563 additional_allowed_schemes->push_back(content::kChromeDevToolsScheme); 2564 additional_allowed_schemes->push_back(content::kChromeUIScheme); 2565 additional_allowed_schemes->push_back(extensions::kExtensionScheme); 2566} 2567 2568void ChromeContentBrowserClient::GetURLRequestAutoMountHandlers( 2569 std::vector<fileapi::URLRequestAutoMountHandler>* handlers) { 2570#if !defined(OS_ANDROID) 2571 handlers->push_back( 2572 base::Bind(MediaFileSystemBackend::AttemptAutoMountForURLRequest)); 2573#endif // OS_ANDROID 2574} 2575 2576void ChromeContentBrowserClient::GetAdditionalFileSystemBackends( 2577 content::BrowserContext* browser_context, 2578 const base::FilePath& storage_partition_path, 2579 ScopedVector<fileapi::FileSystemBackend>* additional_backends) { 2580#if !defined(OS_ANDROID) 2581 base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool(); 2582 additional_backends->push_back(new MediaFileSystemBackend( 2583 storage_partition_path, 2584 pool->GetSequencedTaskRunner(pool->GetNamedSequenceToken( 2585 MediaFileSystemBackend::kMediaTaskRunnerName)).get())); 2586#endif 2587#if defined(OS_CHROMEOS) 2588 fileapi::ExternalMountPoints* external_mount_points = 2589 content::BrowserContext::GetMountPoints(browser_context); 2590 DCHECK(external_mount_points); 2591 chromeos::FileSystemBackend* backend = 2592 new chromeos::FileSystemBackend( 2593 new drive::FileSystemBackendDelegate, 2594 browser_context->GetSpecialStoragePolicy(), 2595 external_mount_points, 2596 fileapi::ExternalMountPoints::GetSystemInstance()); 2597 backend->AddSystemMountPoints(); 2598 DCHECK(backend->CanHandleType(fileapi::kFileSystemTypeExternal)); 2599 additional_backends->push_back(backend); 2600#endif 2601 2602 additional_backends->push_back( 2603 new sync_file_system::SyncFileSystemBackend( 2604 Profile::FromBrowserContext(browser_context))); 2605 2606#if defined(ENABLE_SERVICE_DISCOVERY) 2607 if (CommandLine::ForCurrentProcess()->HasSwitch( 2608 switches::kEnablePrivetStorage)) { 2609 additional_backends->push_back( 2610 new local_discovery::PrivetFileSystemBackend( 2611 fileapi::ExternalMountPoints::GetSystemInstance(), 2612 browser_context)); 2613 } 2614#endif 2615} 2616 2617#if defined(OS_POSIX) && !defined(OS_MACOSX) 2618void ChromeContentBrowserClient::GetAdditionalMappedFilesForChildProcess( 2619 const CommandLine& command_line, 2620 int child_process_id, 2621 std::vector<FileDescriptorInfo>* mappings) { 2622#if defined(OS_ANDROID) 2623 base::FilePath data_path; 2624 PathService::Get(ui::DIR_RESOURCE_PAKS_ANDROID, &data_path); 2625 DCHECK(!data_path.empty()); 2626 2627 int flags = base::File::FLAG_OPEN | base::File::FLAG_READ; 2628 base::FilePath chrome_resources_pak = 2629 data_path.AppendASCII("chrome_100_percent.pak"); 2630 base::File file(chrome_resources_pak, flags); 2631 DCHECK(file.IsValid()); 2632 mappings->push_back(FileDescriptorInfo(kAndroidChrome100PercentPakDescriptor, 2633 FileDescriptor(file.Pass()))); 2634 2635 const std::string locale = GetApplicationLocale(); 2636 base::FilePath locale_pak = ResourceBundle::GetSharedInstance(). 2637 GetLocaleFilePath(locale, false); 2638 file.Initialize(locale_pak, flags); 2639 DCHECK(file.IsValid()); 2640 mappings->push_back(FileDescriptorInfo(kAndroidLocalePakDescriptor, 2641 FileDescriptor(file.Pass()))); 2642 2643 base::FilePath resources_pack_path; 2644 PathService::Get(chrome::FILE_RESOURCES_PACK, &resources_pack_path); 2645 file.Initialize(resources_pack_path, flags); 2646 DCHECK(file.IsValid()); 2647 mappings->push_back(FileDescriptorInfo(kAndroidUIResourcesPakDescriptor, 2648 FileDescriptor(file.Pass()))); 2649 2650 if (breakpad::IsCrashReporterEnabled()) { 2651 file = breakpad::CrashDumpManager::GetInstance()->CreateMinidumpFile( 2652 child_process_id); 2653 if (file.IsValid()) { 2654 mappings->push_back(FileDescriptorInfo(kAndroidMinidumpDescriptor, 2655 FileDescriptor(file.Pass()))); 2656 } else { 2657 LOG(ERROR) << "Failed to create file for minidump, crash reporting will " 2658 "be disabled for this process."; 2659 } 2660 } 2661 2662#else 2663 int crash_signal_fd = GetCrashSignalFD(command_line); 2664 if (crash_signal_fd >= 0) { 2665 mappings->push_back(FileDescriptorInfo(kCrashDumpSignal, 2666 FileDescriptor(crash_signal_fd, 2667 false))); 2668 } 2669#endif // defined(OS_ANDROID) 2670} 2671#endif // defined(OS_POSIX) && !defined(OS_MACOSX) 2672 2673#if defined(OS_WIN) 2674const wchar_t* ChromeContentBrowserClient::GetResourceDllName() { 2675 return chrome::kBrowserResourcesDll; 2676} 2677 2678void ChromeContentBrowserClient::PreSpawnRenderer( 2679 sandbox::TargetPolicy* policy, 2680 bool* success) { 2681 // This code is duplicated in nacl_exe_win_64.cc. 2682 // Allow the server side of a pipe restricted to the "chrome.nacl." 2683 // namespace so that it cannot impersonate other system or other chrome 2684 // service pipes. 2685 sandbox::ResultCode result = policy->AddRule( 2686 sandbox::TargetPolicy::SUBSYS_NAMED_PIPES, 2687 sandbox::TargetPolicy::NAMEDPIPES_ALLOW_ANY, 2688 L"\\\\.\\pipe\\chrome.nacl.*"); 2689 if (result != sandbox::SBOX_ALL_OK) { 2690 *success = false; 2691 return; 2692 } 2693 2694 // Renderers need to send named pipe handles and shared memory 2695 // segment handles to NaCl loader processes. 2696 result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_HANDLES, 2697 sandbox::TargetPolicy::HANDLES_DUP_ANY, 2698 L"File"); 2699 if (result != sandbox::SBOX_ALL_OK) { 2700 *success = false; 2701 return; 2702 } 2703} 2704#endif 2705 2706bool ChromeContentBrowserClient::IsPluginAllowedToCallRequestOSFileHandle( 2707 content::BrowserContext* browser_context, 2708 const GURL& url) { 2709#if defined(ENABLE_PLUGINS) 2710 Profile* profile = Profile::FromBrowserContext(browser_context); 2711 const extensions::ExtensionSet* extension_set = NULL; 2712 if (profile) { 2713 extension_set = extensions::ExtensionSystem::Get(profile)-> 2714 extension_service()->extensions(); 2715 } 2716 // TODO(teravest): Populate allowed_file_handle_origins_ when FileIO is moved 2717 // from the renderer to the browser. 2718 return IsExtensionOrSharedModuleWhitelisted(url, extension_set, 2719 allowed_file_handle_origins_) || 2720 IsHostAllowedByCommandLine(url, extension_set, 2721 switches::kAllowNaClFileHandleAPI); 2722#else 2723 return false; 2724#endif 2725} 2726 2727bool ChromeContentBrowserClient::IsPluginAllowedToUseDevChannelAPIs() { 2728#if defined(ENABLE_PLUGINS) 2729 // Allow access for tests. 2730 if (CommandLine::ForCurrentProcess()->HasSwitch( 2731 switches::kEnablePepperTesting)) { 2732 return true; 2733 } 2734 2735 chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel(); 2736 // Allow dev channel APIs to be used on "Canary", "Dev", and "Unknown" 2737 // releases of Chrome. Permitting "Unknown" allows these APIs to be used on 2738 // Chromium builds as well. 2739 return channel <= chrome::VersionInfo::CHANNEL_DEV; 2740#else 2741 return false; 2742#endif 2743} 2744 2745#if defined(ENABLE_WEBRTC) 2746void ChromeContentBrowserClient::MaybeCopyDisableWebRtcEncryptionSwitch( 2747 CommandLine* to_command_line, 2748 const CommandLine& from_command_line, 2749 VersionInfo::Channel channel) { 2750#if defined(OS_ANDROID) 2751 const VersionInfo::Channel kMaxDisableEncryptionChannel = 2752 VersionInfo::CHANNEL_BETA; 2753#else 2754 const VersionInfo::Channel kMaxDisableEncryptionChannel = 2755 VersionInfo::CHANNEL_DEV; 2756#endif 2757 if (channel <= kMaxDisableEncryptionChannel) { 2758 static const char* const kWebRtcDevSwitchNames[] = { 2759 switches::kDisableWebRtcEncryption, 2760 }; 2761 to_command_line->CopySwitchesFrom(from_command_line, 2762 kWebRtcDevSwitchNames, 2763 arraysize(kWebRtcDevSwitchNames)); 2764 } 2765} 2766#endif // defined(ENABLE_WEBRTC) 2767 2768} // namespace chrome 2769