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