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