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