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