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