chrome/browser/browser_process_impl.cc

   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/browser_process_impl.h"
   6
   7 #include <algorithm>
   8 #include <map>
   9 #include <vector>
  10
  11 #include "base/atomic_ref_count.h"
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/command_line.h"
  15 #include "base/debug/alias.h"
  16 #include "base/debug/leak_annotations.h"
  17 #include "base/files/file_path.h"
  18 #include "base/metrics/field_trial.h"
  19 #include "base/metrics/histogram_macros.h"
  20 #include "base/path_service.h"
  21 #include "base/prefs/json_pref_store.h"
  22 #include "base/prefs/pref_registry_simple.h"
  23 #include "base/prefs/pref_service.h"
  24 #include "base/synchronization/waitable_event.h"
  25 #include "base/threading/thread.h"
  26 #include "base/threading/thread_restrictions.h"
  27 #include "base/time/default_tick_clock.h"
  28 #include "base/trace_event/trace_event.h"
  29 #include "chrome/browser/chrome_browser_main.h"
  30 #include "chrome/browser/chrome_content_browser_client.h"
  31 #include "chrome/browser/chrome_notification_types.h"
  32 #include "chrome/browser/component_updater/chrome_component_updater_configurator.h"
  33 #include "chrome/browser/component_updater/supervised_user_whitelist_installer.h"
  34 #include "chrome/browser/defaults.h"
  35 #include "chrome/browser/devtools/remote_debugging_server.h"
  36 #include "chrome/browser/download/download_request_limiter.h"
  37 #include "chrome/browser/download/download_status_updater.h"
  38 #include "chrome/browser/first_run/upgrade_util.h"
  39 #include "chrome/browser/gpu/gl_string_manager.h"
  40 #include "chrome/browser/gpu/gpu_mode_manager.h"
  41 #include "chrome/browser/icon_manager.h"
  42 #include "chrome/browser/intranet_redirect_detector.h"
  43 #include "chrome/browser/io_thread.h"
  44 #include "chrome/browser/lifetime/application_lifetime.h"
  45 #include "chrome/browser/metrics/metrics_services_manager.h"
  46 #include "chrome/browser/metrics/thread_watcher.h"
  47 #include "chrome/browser/net/chrome_net_log.h"
  48 #include "chrome/browser/net/crl_set_fetcher.h"
  49 #include "chrome/browser/notifications/notification_ui_manager.h"
  50 #include "chrome/browser/plugins/chrome_plugin_service_filter.h"
  51 #include "chrome/browser/plugins/plugin_finder.h"
  52 #include "chrome/browser/prefs/browser_prefs.h"
  53 #include "chrome/browser/prefs/chrome_pref_service_factory.h"
  54 #include "chrome/browser/prerender/prerender_tracker.h"
  55 #include "chrome/browser/printing/background_printing_manager.h"
  56 #include "chrome/browser/printing/print_job_manager.h"
  57 #include "chrome/browser/printing/print_preview_dialog_controller.h"
  58 #include "chrome/browser/profiles/profile_manager.h"
  59 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
  60 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  61 #include "chrome/browser/shell_integration.h"
  62 #include "chrome/browser/status_icons/status_tray.h"
  63 #include "chrome/browser/ui/browser_dialogs.h"
  64 #include "chrome/browser/ui/browser_finder.h"
  65 #include "chrome/browser/ui/user_manager.h"
  66 #include "chrome/browser/update_client/chrome_update_query_params_delegate.h"
  67 #include "chrome/browser/web_resource/promo_resource_service.h"
  68 #include "chrome/common/chrome_constants.h"
  69 #include "chrome/common/chrome_paths.h"
  70 #include "chrome/common/chrome_switches.h"
  71 #include "chrome/common/extensions/chrome_extensions_client.h"
  72 #include "chrome/common/pref_names.h"
  73 #include "chrome/common/switch_utils.h"
  74 #include "chrome/common/url_constants.h"
  75 #include "chrome/installer/util/google_update_constants.h"
  76 #include "chrome/installer/util/google_update_settings.h"
  77 #include "components/component_updater/component_updater_service.h"
  78 #include "components/gcm_driver/gcm_driver.h"
  79 #include "components/metrics/metrics_service.h"
  80 #include "components/network_time/network_time_tracker.h"
  81 #include "components/policy/core/common/policy_service.h"
  82 #include "components/signin/core/common/profile_management_switches.h"
  83 #include "components/translate/core/browser/translate_download_manager.h"
  84 #include "components/update_client/update_query_params.h"
  85 #include "components/web_resource/web_resource_pref_names.h"
  86 #include "content/public/browser/browser_thread.h"
  87 #include "content/public/browser/child_process_security_policy.h"
  88 #include "content/public/browser/notification_details.h"
  89 #include "content/public/browser/plugin_service.h"
  90 #include "content/public/browser/render_process_host.h"
  91 #include "content/public/browser/resource_dispatcher_host.h"
  92 #include "content/public/browser/service_worker_context.h"
  93 #include "content/public/browser/storage_partition.h"
  94 #include "extensions/common/constants.h"
  95 #include "net/socket/client_socket_pool_manager.h"
  96 #include "net/url_request/url_request_context_getter.h"
  97 #include "ui/base/idle/idle.h"
  98 #include "ui/base/l10n/l10n_util.h"
  99 #include "ui/message_center/message_center.h"
 100
 101 #if defined(OS_WIN)
 102 #include "base/win/windows_version.h"
 103 #include "ui/views/focus/view_storage.h"
 104 #elif defined(OS_MACOSX)
 105 #include "chrome/browser/chrome_browser_main_mac.h"
 106 #endif
 107
 108 #if !defined(OS_ANDROID)
 109 #include "chrome/browser/chrome_device_client.h"
 110 #include "chrome/browser/services/gcm/gcm_desktop_utils.h"
 111 #include "components/gcm_driver/gcm_client_factory.h"
 112 #endif
 113
 114 #if defined(USE_AURA)
 115 #include "ui/aura/env.h"
 116 #endif
 117
 118 #if defined(ENABLE_BACKGROUND)
 119 #include "chrome/browser/background/background_mode_manager.h"
 120 #endif
 121
 122 #if defined(ENABLE_CONFIGURATION_POLICY)
 123 #include "components/policy/core/browser/browser_policy_connector.h"
 124 #else
 125 #include "components/policy/core/common/policy_service_stub.h"
 126 #endif  // defined(ENABLE_CONFIGURATION_POLICY)
 127
 128 #if defined(ENABLE_EXTENSIONS)
 129 #include "chrome/browser/extensions/chrome_extensions_browser_client.h"
 130 #include "chrome/browser/extensions/event_router_forwarder.h"
 131 #include "chrome/browser/extensions/extension_renderer_state.h"
 132 #include "chrome/browser/media_galleries/media_file_system_registry.h"
 133 #include "chrome/browser/ui/apps/chrome_app_window_client.h"
 134 #include "components/storage_monitor/storage_monitor.h"
 135 #include "extensions/common/extension_l10n_util.h"
 136 #endif
 137
 138 #if !defined(DISABLE_NACL)
 139 #include "chrome/browser/component_updater/pnacl/pnacl_component_installer.h"
 140 #endif
 141
 142 #if defined(ENABLE_PLUGIN_INSTALLATION)
 143 #include "chrome/browser/plugins/plugins_resource_service.h"
 144 #endif
 145
 146 #if defined(ENABLE_WEBRTC)
 147 #include "chrome/browser/media/webrtc_log_uploader.h"
 148 #endif
 149
 150 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
 151 // How often to check if the persistent instance of Chrome needs to restart
 152 // to install an update.
 153 static const int kUpdateCheckIntervalHours = 6;
 154 #endif
 155
 156 #if defined(USE_X11) || defined(OS_WIN)
 157 // How long to wait for the File thread to complete during EndSession, on Linux
 158 // and Windows. We have a timeout here because we're unable to run the UI
 159 // messageloop and there's some deadlock risk. Our only option is to exit
 160 // anyway.
 161 static const int kEndSessionTimeoutSeconds = 10;
 162 #endif
 163
 164 using content::BrowserThread;
 165 using content::ChildProcessSecurityPolicy;
 166 using content::PluginService;
 167 using content::ResourceDispatcherHost;
 168
 169 BrowserProcessImpl::BrowserProcessImpl(
 170     base::SequencedTaskRunner* local_state_task_runner,
 171     const base::CommandLine& command_line)
 172     : created_watchdog_thread_(false),
 173       created_browser_policy_connector_(false),
 174       created_profile_manager_(false),
 175       created_local_state_(false),
 176       created_icon_manager_(false),
 177       created_notification_ui_manager_(false),
 178       created_safe_browsing_service_(false),
 179       module_ref_count_(0),
 180       did_start_(false),
 181       download_status_updater_(new DownloadStatusUpdater),
 182       local_state_task_runner_(local_state_task_runner) {
 183   g_browser_process = this;
 184   platform_part_.reset(new BrowserProcessPlatformPart());
 185
 186 #if defined(ENABLE_PRINTING)
 187   // Must be created after the NotificationService.
 188   print_job_manager_.reset(new printing::PrintJobManager);
 189 #endif
 190
 191   net_log_.reset(new ChromeNetLog);
 192
 193   ChildProcessSecurityPolicy::GetInstance()->RegisterWebSafeScheme(
 194       extensions::kExtensionScheme);
 195   ChildProcessSecurityPolicy::GetInstance()->RegisterWebSafeScheme(
 196       extensions::kExtensionResourceScheme);
 197   ChildProcessSecurityPolicy::GetInstance()->RegisterWebSafeScheme(
 198       chrome::kChromeSearchScheme);
 199
 200 #if defined(OS_MACOSX)
 201   ui::InitIdleMonitor();
 202 #endif
 203
 204 #if !defined(OS_ANDROID)
 205   device_client_.reset(new ChromeDeviceClient);
 206 #endif
 207
 208 #if defined(ENABLE_EXTENSIONS)
 209   // Athena sets its own instance during Athena's init process.
 210   extensions::AppWindowClient::Set(ChromeAppWindowClient::GetInstance());
 211
 212   extension_event_router_forwarder_ = new extensions::EventRouterForwarder;
 213   ExtensionRendererState::GetInstance()->Init();
 214
 215   extensions::ExtensionsClient::Set(
 216       extensions::ChromeExtensionsClient::GetInstance());
 217
 218   extensions_browser_client_.reset(
 219       new extensions::ChromeExtensionsBrowserClient);
 220   extensions::ExtensionsBrowserClient::Set(extensions_browser_client_.get());
 221 #endif
 222
 223   message_center::MessageCenter::Initialize();
 224
 225   update_client::UpdateQueryParams::SetDelegate(
 226       ChromeUpdateQueryParamsDelegate::GetInstance());
 227 }
 228
 229 BrowserProcessImpl::~BrowserProcessImpl() {
 230   tracked_objects::ThreadData::EnsureCleanupWasCalled(4);
 231
 232   g_browser_process = NULL;
 233 }
 234
 235 void BrowserProcessImpl::StartTearDown() {
 236     TRACE_EVENT0("shutdown", "BrowserProcessImpl::StartTearDown");
 237   // We need to destroy the MetricsServicesManager, IntranetRedirectDetector,
 238   // PromoResourceService, and SafeBrowsing ClientSideDetectionService (owned by
 239   // the SafeBrowsingService) before the io_thread_ gets destroyed, since their
 240   // destructors can call the URLFetcher destructor, which does a
 241   // PostDelayedTask operation on the IO thread. (The IO thread will handle that
 242   // URLFetcher operation before going away.)
 243   metrics_services_manager_.reset();
 244   intranet_redirect_detector_.reset();
 245 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
 246   if (safe_browsing_service_.get())
 247     safe_browsing_service()->ShutDown();
 248 #endif
 249   promo_resource_service_.reset();
 250 #if defined(ENABLE_PLUGIN_INSTALLATION)
 251   plugins_resource_service_.reset();
 252 #endif
 253
 254   // Need to clear the desktop notification balloons before the io_thread_ and
 255   // before the profiles, since if there are any still showing we will access
 256   // those things during teardown.
 257   notification_ui_manager_.reset();
 258
 259   // The SupervisedUserWhitelistInstaller observes the ProfileInfoCache, so it
 260   // needs to be shut down before the ProfileManager.
 261   supervised_user_whitelist_installer_.reset();
 262
 263   // Need to clear profiles (download managers) before the io_thread_.
 264   {
 265     TRACE_EVENT0("shutdown",
 266                  "BrowserProcessImpl::StartTearDown:ProfileManager");
 267     // The desktop User Manager needs to be closed before the guest profile
 268     // can be destroyed.
 269     if (switches::IsNewAvatarMenu())
 270       UserManager::Hide();
 271     profile_manager_.reset();
 272   }
 273
 274 #if !defined(OS_ANDROID)
 275   // Debugger must be cleaned up before IO thread and NotificationService.
 276   remote_debugging_server_.reset();
 277 #endif
 278
 279 #if defined(ENABLE_EXTENSIONS)
 280   ExtensionRendererState::GetInstance()->Shutdown();
 281
 282   media_file_system_registry_.reset();
 283   // Remove the global instance of the Storage Monitor now. Otherwise the
 284   // FILE thread would be gone when we try to release it in the dtor and
 285   // Valgrind would report a leak on almost every single browser_test.
 286   // TODO(gbillock): Make this unnecessary.
 287   storage_monitor::StorageMonitor::Destroy();
 288 #endif
 289
 290   message_center::MessageCenter::Shutdown();
 291
 292 #if defined(ENABLE_CONFIGURATION_POLICY)
 293   // The policy providers managed by |browser_policy_connector_| need to shut
 294   // down while the IO and FILE threads are still alive.
 295   if (browser_policy_connector_)
 296     browser_policy_connector_->Shutdown();
 297 #endif
 298
 299   // The |gcm_driver_| must shut down while the IO thread is still alive.
 300   if (gcm_driver_)
 301     gcm_driver_->Shutdown();
 302
 303   // Stop the watchdog thread before stopping other threads.
 304   watchdog_thread_.reset();
 305
 306 #if defined(USE_AURA)
 307   // Delete aura after the metrics service has been deleted as it accesses
 308   // monitor information.
 309   aura::Env::DeleteInstance();
 310 #endif
 311
 312   platform_part()->StartTearDown();
 313
 314 #if defined(ENABLE_WEBRTC)
 315   // Cancel any uploads to release the system url request context references.
 316   if (webrtc_log_uploader_)
 317     webrtc_log_uploader_->StartShutdown();
 318 #endif
 319
 320   if (local_state())
 321     local_state()->CommitPendingWrite();
 322 }
 323
 324 void BrowserProcessImpl::PostDestroyThreads() {
 325   // With the file_thread_ flushed, we can release any icon resources.
 326   icon_manager_.reset();
 327
 328 #if defined(ENABLE_WEBRTC)
 329   // Must outlive the file thread.
 330   webrtc_log_uploader_.reset();
 331 #endif
 332
 333   // Reset associated state right after actual thread is stopped,
 334   // as io_thread_.global_ cleanup happens in CleanUp on the IO
 335   // thread, i.e. as the thread exits its message loop.
 336   //
 337   // This is important also because in various places, the
 338   // IOThread object being NULL is considered synonymous with the
 339   // IO thread having stopped.
 340   io_thread_.reset();
 341 }
 342
 343 unsigned int BrowserProcessImpl::AddRefModule() {
 344   DCHECK(CalledOnValidThread());
 345
 346   // CHECK(!IsShuttingDown());
 347   if (IsShuttingDown()) {
 348     // Copy the stacktrace which released the final reference onto our stack so
 349     // it will be available in the crash report for inspection.
 350     base::debug::StackTrace callstack = release_last_reference_callstack_;
 351     base::debug::Alias(&callstack);
 352     CHECK(false);
 353   }
 354
 355   did_start_ = true;
 356   module_ref_count_++;
 357   return module_ref_count_;
 358 }
 359
 360 unsigned int BrowserProcessImpl::ReleaseModule() {
 361   DCHECK(CalledOnValidThread());
 362   DCHECK_NE(0u, module_ref_count_);
 363   module_ref_count_--;
 364   if (0 == module_ref_count_) {
 365     release_last_reference_callstack_ = base::debug::StackTrace();
 366
 367 #if defined(ENABLE_PRINTING)
 368     // Wait for the pending print jobs to finish. Don't do this later, since
 369     // this might cause a nested message loop to run, and we don't want pending
 370     // tasks to run once teardown has started.
 371     print_job_manager_->Shutdown();
 372 #endif
 373
 374 #if defined(LEAK_SANITIZER)
 375     // Check for memory leaks now, before we start shutting down threads. Doing
 376     // this early means we won't report any shutdown-only leaks (as they have
 377     // not yet happened at this point).
 378     // If leaks are found, this will make the process exit immediately.
 379     __lsan_do_leak_check();
 380 #endif
 381
 382     CHECK(base::MessageLoop::current()->is_running());
 383
 384 #if defined(OS_MACOSX)
 385     base::MessageLoop::current()->PostTask(
 386         FROM_HERE,
 387         base::Bind(ChromeBrowserMainPartsMac::DidEndMainMessageLoop));
 388 #endif
 389     base::MessageLoop::current()->Quit();
 390   }
 391   return module_ref_count_;
 392 }
 393
 394 namespace {
 395
 396 // Used at the end of session to block the UI thread for completion of sentinel
 397 // tasks on the set of threads used to persist profile data and local state.
 398 // This is done to ensure that the data has been persisted to disk before
 399 // continuing.
 400 class RundownTaskCounter :
 401     public base::RefCountedThreadSafe<RundownTaskCounter> {
 402  public:
 403   RundownTaskCounter();
 404
 405   // Posts a rundown task to |task_runner|, can be invoked an arbitrary number
 406   // of times before calling TimedWait.
 407   void Post(base::SequencedTaskRunner* task_runner);
 408
 409   // Waits until the count is zero or |max_time| has passed.
 410   // This can only be called once per instance.
 411   bool TimedWait(const base::TimeDelta& max_time);
 412
 413  private:
 414   friend class base::RefCountedThreadSafe<RundownTaskCounter>;
 415   ~RundownTaskCounter() {}
 416
 417   // Decrements the counter and releases the waitable event on transition to
 418   // zero.
 419   void Decrement();
 420
 421   // The count starts at one to defer the possibility of one->zero transitions
 422   // until TimedWait is called.
 423   base::AtomicRefCount count_;
 424   base::WaitableEvent waitable_event_;
 425
 426   DISALLOW_COPY_AND_ASSIGN(RundownTaskCounter);
 427 };
 428
 429 RundownTaskCounter::RundownTaskCounter()
 430     : count_(1), waitable_event_(true, false) {
 431 }
 432
 433 void RundownTaskCounter::Post(base::SequencedTaskRunner* task_runner) {
 434   // As the count starts off at one, it should never get to zero unless
 435   // TimedWait has been called.
 436   DCHECK(!base::AtomicRefCountIsZero(&count_));
 437
 438   base::AtomicRefCountInc(&count_);
 439
 440   // The task must be non-nestable to guarantee that it runs after all tasks
 441   // currently scheduled on |task_runner| have completed.
 442   task_runner->PostNonNestableTask(FROM_HERE,
 443       base::Bind(&RundownTaskCounter::Decrement, this));
 444 }
 445
 446 void RundownTaskCounter::Decrement() {
 447   if (!base::AtomicRefCountDec(&count_))
 448     waitable_event_.Signal();
 449 }
 450
 451 bool RundownTaskCounter::TimedWait(const base::TimeDelta& max_time) {
 452   // Decrement the excess count from the constructor.
 453   Decrement();
 454
 455   return waitable_event_.TimedWait(max_time);
 456 }
 457
 458 }  // namespace
 459
 460 void BrowserProcessImpl::EndSession() {
 461   // Mark all the profiles as clean.
 462   ProfileManager* pm = profile_manager();
 463   std::vector<Profile*> profiles(pm->GetLoadedProfiles());
 464   scoped_refptr<RundownTaskCounter> rundown_counter(new RundownTaskCounter());
 465   for (size_t i = 0; i < profiles.size(); ++i) {
 466     Profile* profile = profiles[i];
 467     profile->SetExitType(Profile::EXIT_SESSION_ENDED);
 468
 469     rundown_counter->Post(profile->GetIOTaskRunner().get());
 470   }
 471
 472   // Tell the metrics service it was cleanly shutdown.
 473   metrics::MetricsService* metrics = g_browser_process->metrics_service();
 474   if (metrics && local_state()) {
 475     metrics->RecordStartOfSessionEnd();
 476 #if !defined(OS_CHROMEOS)
 477     // MetricsService lazily writes to prefs, force it to write now.
 478     // On ChromeOS, chrome gets killed when hangs, so no need to
 479     // commit metrics::prefs::kStabilitySessionEndCompleted change immediately.
 480     local_state()->CommitPendingWrite();
 481
 482     rundown_counter->Post(local_state_task_runner_.get());
 483 #endif
 484   }
 485
 486   // http://crbug.com/125207
 487   base::ThreadRestrictions::ScopedAllowWait allow_wait;
 488
 489   // We must write that the profile and metrics service shutdown cleanly,
 490   // otherwise on startup we'll think we crashed. So we block until done and
 491   // then proceed with normal shutdown.
 492   //
 493   // If you change the condition here, be sure to also change
 494   // ProfileBrowserTests to match.
 495 #if defined(USE_X11) || defined(OS_WIN)
 496   // Do a best-effort wait on the successful countdown of rundown tasks. Note
 497   // that if we don't complete "quickly enough", Windows will terminate our
 498   // process.
 499   //
 500   // On Windows, we previously posted a message to FILE and then ran a nested
 501   // message loop, waiting for that message to be processed until quitting.
 502   // However, doing so means that other messages will also be processed. In
 503   // particular, if the GPU process host notices that the GPU has been killed
 504   // during shutdown, it races exiting the nested loop with the process host
 505   // blocking the message loop attempting to re-establish a connection to the
 506   // GPU process synchronously. Because the system may not be allowing
 507   // processes to launch, this can result in a hang. See
 508   // http://crbug.com/318527.
 509   rundown_counter->TimedWait(
 510       base::TimeDelta::FromSeconds(kEndSessionTimeoutSeconds));
 511 #else
 512   NOTIMPLEMENTED();
 513 #endif
 514 }
 515
 516 MetricsServicesManager* BrowserProcessImpl::GetMetricsServicesManager() {
 517   DCHECK(CalledOnValidThread());
 518   if (!metrics_services_manager_)
 519     metrics_services_manager_.reset(new MetricsServicesManager(local_state()));
 520   return metrics_services_manager_.get();
 521 }
 522
 523 metrics::MetricsService* BrowserProcessImpl::metrics_service() {
 524   DCHECK(CalledOnValidThread());
 525   return GetMetricsServicesManager()->GetMetricsService();
 526 }
 527
 528 rappor::RapporService* BrowserProcessImpl::rappor_service() {
 529   DCHECK(CalledOnValidThread());
 530   return GetMetricsServicesManager()->GetRapporService();
 531 }
 532
 533 IOThread* BrowserProcessImpl::io_thread() {
 534   DCHECK(CalledOnValidThread());
 535   DCHECK(io_thread_.get());
 536   return io_thread_.get();
 537 }
 538
 539 WatchDogThread* BrowserProcessImpl::watchdog_thread() {
 540   DCHECK(CalledOnValidThread());
 541   if (!created_watchdog_thread_)
 542     CreateWatchdogThread();
 543   DCHECK(watchdog_thread_.get() != NULL);
 544   return watchdog_thread_.get();
 545 }
 546
 547 ProfileManager* BrowserProcessImpl::profile_manager() {
 548   DCHECK(CalledOnValidThread());
 549   if (!created_profile_manager_)
 550     CreateProfileManager();
 551   return profile_manager_.get();
 552 }
 553
 554 PrefService* BrowserProcessImpl::local_state() {
 555   DCHECK(CalledOnValidThread());
 556   if (!created_local_state_)
 557     CreateLocalState();
 558   return local_state_.get();
 559 }
 560
 561 net::URLRequestContextGetter* BrowserProcessImpl::system_request_context() {
 562   DCHECK(CalledOnValidThread());
 563   return io_thread()->system_url_request_context_getter();
 564 }
 565
 566 chrome_variations::VariationsService* BrowserProcessImpl::variations_service() {
 567   DCHECK(CalledOnValidThread());
 568   return GetMetricsServicesManager()->GetVariationsService();
 569 }
 570
 571 BrowserProcessPlatformPart* BrowserProcessImpl::platform_part() {
 572   return platform_part_.get();
 573 }
 574
 575 extensions::EventRouterForwarder*
 576 BrowserProcessImpl::extension_event_router_forwarder() {
 577 #if defined(ENABLE_EXTENSIONS)
 578   return extension_event_router_forwarder_.get();
 579 #else
 580   return NULL;
 581 #endif
 582 }
 583
 584 NotificationUIManager* BrowserProcessImpl::notification_ui_manager() {
 585   DCHECK(CalledOnValidThread());
 586   if (!created_notification_ui_manager_)
 587     CreateNotificationUIManager();
 588   return notification_ui_manager_.get();
 589 }
 590
 591 message_center::MessageCenter* BrowserProcessImpl::message_center() {
 592   DCHECK(CalledOnValidThread());
 593   return message_center::MessageCenter::Get();
 594 }
 595
 596 policy::BrowserPolicyConnector* BrowserProcessImpl::browser_policy_connector() {
 597   DCHECK(CalledOnValidThread());
 598 #if defined(ENABLE_CONFIGURATION_POLICY)
 599   if (!created_browser_policy_connector_) {
 600     DCHECK(!browser_policy_connector_);
 601     browser_policy_connector_ = platform_part_->CreateBrowserPolicyConnector();
 602     created_browser_policy_connector_ = true;
 603   }
 604   return browser_policy_connector_.get();
 605 #else
 606   return NULL;
 607 #endif
 608 }
 609
 610 policy::PolicyService* BrowserProcessImpl::policy_service() {
 611 #if defined(ENABLE_CONFIGURATION_POLICY)
 612   return browser_policy_connector()->GetPolicyService();
 613 #else
 614   if (!policy_service_.get())
 615     policy_service_.reset(new policy::PolicyServiceStub());
 616   return policy_service_.get();
 617 #endif
 618 }
 619
 620 IconManager* BrowserProcessImpl::icon_manager() {
 621   DCHECK(CalledOnValidThread());
 622   if (!created_icon_manager_)
 623     CreateIconManager();
 624   return icon_manager_.get();
 625 }
 626
 627 GLStringManager* BrowserProcessImpl::gl_string_manager() {
 628   DCHECK(CalledOnValidThread());
 629   if (!gl_string_manager_.get())
 630     gl_string_manager_.reset(new GLStringManager());
 631   return gl_string_manager_.get();
 632 }
 633
 634 GpuModeManager* BrowserProcessImpl::gpu_mode_manager() {
 635   DCHECK(CalledOnValidThread());
 636   if (!gpu_mode_manager_.get())
 637     gpu_mode_manager_.reset(new GpuModeManager());
 638   return gpu_mode_manager_.get();
 639 }
 640
 641 void BrowserProcessImpl::CreateDevToolsHttpProtocolHandler(
 642     chrome::HostDesktopType host_desktop_type,
 643     const std::string& ip,
 644     uint16 port) {
 645   DCHECK(CalledOnValidThread());
 646 #if !defined(OS_ANDROID)
 647   // StartupBrowserCreator::LaunchBrowser can be run multiple times when browser
 648   // is started with several profiles or existing browser process is reused.
 649   if (!remote_debugging_server_.get()) {
 650     remote_debugging_server_.reset(
 651         new RemoteDebuggingServer(host_desktop_type, ip, port));
 652   }
 653 #endif
 654 }
 655
 656 bool BrowserProcessImpl::IsShuttingDown() {
 657   DCHECK(CalledOnValidThread());
 658   return did_start_ && 0 == module_ref_count_;
 659 }
 660
 661 printing::PrintJobManager* BrowserProcessImpl::print_job_manager() {
 662   DCHECK(CalledOnValidThread());
 663   return print_job_manager_.get();
 664 }
 665
 666 printing::PrintPreviewDialogController*
 667     BrowserProcessImpl::print_preview_dialog_controller() {
 668 #if defined(ENABLE_PRINT_PREVIEW)
 669   DCHECK(CalledOnValidThread());
 670   if (!print_preview_dialog_controller_.get())
 671     CreatePrintPreviewDialogController();
 672   return print_preview_dialog_controller_.get();
 673 #else
 674   NOTIMPLEMENTED();
 675   return NULL;
 676 #endif
 677 }
 678
 679 printing::BackgroundPrintingManager*
 680     BrowserProcessImpl::background_printing_manager() {
 681 #if defined(ENABLE_PRINT_PREVIEW)
 682   DCHECK(CalledOnValidThread());
 683   if (!background_printing_manager_.get())
 684     CreateBackgroundPrintingManager();
 685   return background_printing_manager_.get();
 686 #else
 687   NOTIMPLEMENTED();
 688   return NULL;
 689 #endif
 690 }
 691
 692 IntranetRedirectDetector* BrowserProcessImpl::intranet_redirect_detector() {
 693   DCHECK(CalledOnValidThread());
 694   if (!intranet_redirect_detector_.get())
 695     CreateIntranetRedirectDetector();
 696   return intranet_redirect_detector_.get();
 697 }
 698
 699 const std::string& BrowserProcessImpl::GetApplicationLocale() {
 700   DCHECK(!locale_.empty());
 701   return locale_;
 702 }
 703
 704 void BrowserProcessImpl::SetApplicationLocale(const std::string& locale) {
 705   locale_ = locale;
 706 #if defined(ENABLE_EXTENSIONS)
 707   extension_l10n_util::SetProcessLocale(locale);
 708 #endif
 709   chrome::ChromeContentBrowserClient::SetApplicationLocale(locale);
 710   translate::TranslateDownloadManager::GetInstance()->set_application_locale(
 711       locale);
 712 }
 713
 714 DownloadStatusUpdater* BrowserProcessImpl::download_status_updater() {
 715   return download_status_updater_.get();
 716 }
 717
 718 MediaFileSystemRegistry* BrowserProcessImpl::media_file_system_registry() {
 719 #if defined(ENABLE_EXTENSIONS)
 720   if (!media_file_system_registry_)
 721     media_file_system_registry_.reset(new MediaFileSystemRegistry());
 722   return media_file_system_registry_.get();
 723 #else
 724   return NULL;
 725 #endif
 726 }
 727
 728 bool BrowserProcessImpl::created_local_state() const {
 729   return created_local_state_;
 730 }
 731
 732 #if defined(ENABLE_WEBRTC)
 733 WebRtcLogUploader* BrowserProcessImpl::webrtc_log_uploader() {
 734   if (!webrtc_log_uploader_.get())
 735     webrtc_log_uploader_.reset(new WebRtcLogUploader());
 736   return webrtc_log_uploader_.get();
 737 }
 738 #endif
 739
 740 network_time::NetworkTimeTracker* BrowserProcessImpl::network_time_tracker() {
 741   if (!network_time_tracker_) {
 742     network_time_tracker_.reset(new network_time::NetworkTimeTracker(
 743         scoped_ptr<base::TickClock>(new base::DefaultTickClock()),
 744         local_state()));
 745   }
 746   return network_time_tracker_.get();
 747 }
 748
 749 gcm::GCMDriver* BrowserProcessImpl::gcm_driver() {
 750   DCHECK(CalledOnValidThread());
 751   if (!gcm_driver_)
 752     CreateGCMDriver();
 753   return gcm_driver_.get();
 754 }
 755
 756 // static
 757 void BrowserProcessImpl::RegisterPrefs(PrefRegistrySimple* registry) {
 758   registry->RegisterBooleanPref(prefs::kDefaultBrowserSettingEnabled,
 759                                 false);
 760   // This policy needs to be defined before the net subsystem is initialized,
 761   // so we do it here.
 762   registry->RegisterIntegerPref(prefs::kMaxConnectionsPerProxy,
 763                                 net::kDefaultMaxSocketsPerProxyServer);
 764
 765   registry->RegisterBooleanPref(prefs::kAllowCrossOriginAuthPrompt, false);
 766
 767 #if defined(OS_CHROMEOS) || defined(OS_ANDROID) || defined(OS_IOS)
 768   registry->RegisterBooleanPref(prefs::kEulaAccepted, false);
 769 #endif  // defined(OS_CHROMEOS) || defined(OS_ANDROID) || defined(OS_IOS)
 770 #if defined(OS_WIN)
 771   if (base::win::GetVersion() >= base::win::VERSION_WIN7) {
 772     registry->RegisterStringPref(prefs::kRelaunchMode,
 773                                  upgrade_util::kRelaunchModeDefault);
 774   }
 775 #endif
 776
 777   // TODO(brettw,*): this comment about ResourceBundle was here since
 778   // initial commit.  This comment seems unrelated, bit-rotten and
 779   // a candidate for removal.
 780   // Initialize ResourceBundle which handles files loaded from external
 781   // sources. This has to be done before uninstall code path and before prefs
 782   // are registered.
 783   registry->RegisterStringPref(prefs::kApplicationLocale, std::string());
 784 #if defined(OS_CHROMEOS)
 785   registry->RegisterStringPref(prefs::kOwnerLocale, std::string());
 786   registry->RegisterStringPref(prefs::kHardwareKeyboardLayout,
 787                                std::string());
 788 #endif  // defined(OS_CHROMEOS)
 789 #if !defined(OS_CHROMEOS)
 790   registry->RegisterBooleanPref(
 791       prefs::kMetricsReportingEnabled,
 792       GoogleUpdateSettings::GetCollectStatsConsent());
 793 #endif  // !defined(OS_CHROMEOS)
 794
 795 #if defined(OS_ANDROID)
 796   registry->RegisterBooleanPref(
 797       prefs::kCrashReportingEnabled, false);
 798 #endif  // defined(OS_ANDROID)
 799 }
 800
 801 DownloadRequestLimiter* BrowserProcessImpl::download_request_limiter() {
 802   DCHECK(CalledOnValidThread());
 803   if (!download_request_limiter_.get())
 804     download_request_limiter_ = new DownloadRequestLimiter();
 805   return download_request_limiter_.get();
 806 }
 807
 808 BackgroundModeManager* BrowserProcessImpl::background_mode_manager() {
 809   DCHECK(CalledOnValidThread());
 810 #if defined(ENABLE_BACKGROUND)
 811   if (!background_mode_manager_.get())
 812     CreateBackgroundModeManager();
 813   return background_mode_manager_.get();
 814 #else
 815   NOTIMPLEMENTED();
 816   return NULL;
 817 #endif
 818 }
 819
 820 void BrowserProcessImpl::set_background_mode_manager_for_test(
 821     scoped_ptr<BackgroundModeManager> manager) {
 822 #if defined(ENABLE_BACKGROUND)
 823   background_mode_manager_ = manager.Pass();
 824 #endif
 825 }
 826
 827 StatusTray* BrowserProcessImpl::status_tray() {
 828   DCHECK(CalledOnValidThread());
 829   if (!status_tray_.get())
 830     CreateStatusTray();
 831   return status_tray_.get();
 832 }
 833
 834
 835 SafeBrowsingService* BrowserProcessImpl::safe_browsing_service() {
 836   DCHECK(CalledOnValidThread());
 837   if (!created_safe_browsing_service_)
 838     CreateSafeBrowsingService();
 839   return safe_browsing_service_.get();
 840 }
 841
 842 safe_browsing::ClientSideDetectionService*
 843     BrowserProcessImpl::safe_browsing_detection_service() {
 844   DCHECK(CalledOnValidThread());
 845   if (safe_browsing_service())
 846     return safe_browsing_service()->safe_browsing_detection_service();
 847   return NULL;
 848 }
 849
 850 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
 851 void BrowserProcessImpl::StartAutoupdateTimer() {
 852   autoupdate_timer_.Start(FROM_HERE,
 853       base::TimeDelta::FromHours(kUpdateCheckIntervalHours),
 854       this,
 855       &BrowserProcessImpl::OnAutoupdateTimer);
 856 }
 857 #endif
 858
 859 ChromeNetLog* BrowserProcessImpl::net_log() {
 860   return net_log_.get();
 861 }
 862
 863 prerender::PrerenderTracker* BrowserProcessImpl::prerender_tracker() {
 864   if (!prerender_tracker_.get())
 865     prerender_tracker_.reset(new prerender::PrerenderTracker);
 866
 867   return prerender_tracker_.get();
 868 }
 869
 870 component_updater::ComponentUpdateService*
 871 BrowserProcessImpl::component_updater() {
 872   if (!component_updater_.get()) {
 873     if (!BrowserThread::CurrentlyOn(BrowserThread::UI))
 874       return NULL;
 875     update_client::Configurator* configurator =
 876         component_updater::MakeChromeComponentUpdaterConfigurator(
 877             base::CommandLine::ForCurrentProcess(),
 878             io_thread()->system_url_request_context_getter());
 879     // Creating the component updater does not do anything, components
 880     // need to be registered and Start() needs to be called.
 881     component_updater_.reset(
 882         component_updater::ComponentUpdateServiceFactory(configurator));
 883   }
 884   return component_updater_.get();
 885 }
 886
 887 CRLSetFetcher* BrowserProcessImpl::crl_set_fetcher() {
 888   if (!crl_set_fetcher_)
 889     crl_set_fetcher_ = new CRLSetFetcher();
 890   return crl_set_fetcher_.get();
 891 }
 892
 893 component_updater::PnaclComponentInstaller*
 894 BrowserProcessImpl::pnacl_component_installer() {
 895 #if !defined(DISABLE_NACL)
 896   if (!pnacl_component_installer_) {
 897     pnacl_component_installer_ =
 898         new component_updater::PnaclComponentInstaller();
 899   }
 900   return pnacl_component_installer_.get();
 901 #else
 902   return nullptr;
 903 #endif
 904 }
 905
 906 component_updater::SupervisedUserWhitelistInstaller*
 907 BrowserProcessImpl::supervised_user_whitelist_installer() {
 908   if (!supervised_user_whitelist_installer_) {
 909     supervised_user_whitelist_installer_ =
 910         component_updater::SupervisedUserWhitelistInstaller::Create(
 911             component_updater(), &profile_manager()->GetProfileInfoCache(),
 912             local_state());
 913   }
 914   return supervised_user_whitelist_installer_.get();
 915 }
 916
 917 void BrowserProcessImpl::ResourceDispatcherHostCreated() {
 918   resource_dispatcher_host_delegate_.reset(
 919       new ChromeResourceDispatcherHostDelegate(prerender_tracker()));
 920   ResourceDispatcherHost::Get()->SetDelegate(
 921       resource_dispatcher_host_delegate_.get());
 922
 923   pref_change_registrar_.Add(
 924       prefs::kAllowCrossOriginAuthPrompt,
 925       base::Bind(&BrowserProcessImpl::ApplyAllowCrossOriginAuthPromptPolicy,
 926                  base::Unretained(this)));
 927   ApplyAllowCrossOriginAuthPromptPolicy();
 928 }
 929
 930 void BrowserProcessImpl::CreateWatchdogThread() {
 931   DCHECK(!created_watchdog_thread_ && watchdog_thread_.get() == NULL);
 932   created_watchdog_thread_ = true;
 933
 934   scoped_ptr<WatchDogThread> thread(new WatchDogThread());
 935   base::Thread::Options options;
 936   options.timer_slack = base::TIMER_SLACK_MAXIMUM;
 937   if (!thread->StartWithOptions(options))
 938     return;
 939   watchdog_thread_.swap(thread);
 940 }
 941
 942 void BrowserProcessImpl::CreateProfileManager() {
 943   DCHECK(!created_profile_manager_ && profile_manager_.get() == NULL);
 944   created_profile_manager_ = true;
 945
 946   base::FilePath user_data_dir;
 947   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 948   profile_manager_.reset(new ProfileManager(user_data_dir));
 949 }
 950
 951 void BrowserProcessImpl::CreateLocalState() {
 952   DCHECK(!created_local_state_ && local_state_.get() == NULL);
 953   created_local_state_ = true;
 954
 955   base::FilePath local_state_path;
 956   CHECK(PathService::Get(chrome::FILE_LOCAL_STATE, &local_state_path));
 957   scoped_refptr<PrefRegistrySimple> pref_registry = new PrefRegistrySimple;
 958
 959   // Register local state preferences.
 960   chrome::RegisterLocalState(pref_registry.get());
 961
 962   local_state_ =
 963       chrome_prefs::CreateLocalState(local_state_path,
 964                                      local_state_task_runner_.get(),
 965                                      policy_service(),
 966                                      pref_registry,
 967                                      false).Pass();
 968
 969   pref_change_registrar_.Init(local_state_.get());
 970
 971   // Initialize the notification for the default browser setting policy.
 972   pref_change_registrar_.Add(
 973       prefs::kDefaultBrowserSettingEnabled,
 974       base::Bind(&BrowserProcessImpl::ApplyDefaultBrowserPolicy,
 975                  base::Unretained(this)));
 976
 977   // This preference must be kept in sync with external values; update them
 978   // whenever the preference or its controlling policy changes.
 979 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID) && !defined(OS_IOS)
 980   pref_change_registrar_.Add(
 981       prefs::kMetricsReportingEnabled,
 982       base::Bind(&BrowserProcessImpl::ApplyMetricsReportingPolicy,
 983                  base::Unretained(this)));
 984 #endif
 985
 986   int max_per_proxy = local_state_->GetInteger(prefs::kMaxConnectionsPerProxy);
 987   net::ClientSocketPoolManager::set_max_sockets_per_proxy_server(
 988       net::HttpNetworkSession::NORMAL_SOCKET_POOL,
 989       std::max(std::min(max_per_proxy, 99),
 990                net::ClientSocketPoolManager::max_sockets_per_group(
 991                    net::HttpNetworkSession::NORMAL_SOCKET_POOL)));
 992 }
 993
 994 void BrowserProcessImpl::PreCreateThreads() {
 995   io_thread_.reset(
 996       new IOThread(local_state(), policy_service(), net_log_.get(),
 997                    extension_event_router_forwarder()));
 998 }
 999
1000 void BrowserProcessImpl::PreMainMessageLoopRun() {
1001   TRACE_EVENT0("startup", "BrowserProcessImpl::PreMainMessageLoopRun");
1002   SCOPED_UMA_HISTOGRAM_TIMER(
1003       "Startup.BrowserProcessImpl_PreMainMessageLoopRunTime");
1004
1005 #if defined(ENABLE_CONFIGURATION_POLICY)
1006   // browser_policy_connector() is created very early because local_state()
1007   // needs policy to be initialized with the managed preference values.
1008   // However, policy fetches from the network and loading of disk caches
1009   // requires that threads are running; this Init() call lets the connector
1010   // resume its initialization now that the loops are spinning and the
1011   // system request context is available for the fetchers.
1012   browser_policy_connector()->Init(local_state(), system_request_context());
1013 #endif
1014
1015   if (local_state_->IsManagedPreference(prefs::kDefaultBrowserSettingEnabled))
1016     ApplyDefaultBrowserPolicy();
1017
1018 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID) && !defined(OS_IOS)
1019   ApplyMetricsReportingPolicy();
1020 #endif
1021
1022 #if defined(ENABLE_PLUGINS)
1023   PluginService* plugin_service = PluginService::GetInstance();
1024   plugin_service->SetFilter(ChromePluginServiceFilter::GetInstance());
1025   plugin_service->StartWatchingPlugins();
1026
1027 #if defined(OS_POSIX)
1028   // Also find plugins in a user-specific plugins dir,
1029   // e.g. ~/.config/chromium/Plugins.
1030   const base::CommandLine& cmd_line = *base::CommandLine::ForCurrentProcess();
1031   if (!cmd_line.HasSwitch(switches::kDisablePluginsDiscovery)) {
1032     base::FilePath user_data_dir;
1033     if (PathService::Get(chrome::DIR_USER_DATA, &user_data_dir))
1034       plugin_service->AddExtraPluginDir(user_data_dir.Append("Plugins"));
1035   }
1036 #endif
1037
1038   // Triggers initialization of the singleton instance on UI thread.
1039   PluginFinder::GetInstance()->Init();
1040
1041 #if defined(ENABLE_PLUGIN_INSTALLATION)
1042   DCHECK(!plugins_resource_service_.get());
1043   plugins_resource_service_.reset(new PluginsResourceService(local_state()));
1044   plugins_resource_service_->Init();
1045 #endif
1046 #endif  // defined(ENABLE_PLUGINS)
1047
1048   const base::CommandLine& command_line =
1049       *base::CommandLine::ForCurrentProcess();
1050   if (!command_line.HasSwitch(switches::kDisableWebResources)) {
1051     DCHECK(!promo_resource_service_.get());
1052     promo_resource_service_.reset(new PromoResourceService);
1053     promo_resource_service_->StartAfterDelay();
1054   }
1055
1056 #if !defined(OS_ANDROID) && !defined(OS_IOS)
1057   storage_monitor::StorageMonitor::Create();
1058 #endif
1059
1060   platform_part_->PreMainMessageLoopRun();
1061 }
1062
1063 void BrowserProcessImpl::CreateIconManager() {
1064   DCHECK(!created_icon_manager_ && icon_manager_.get() == NULL);
1065   created_icon_manager_ = true;
1066   icon_manager_.reset(new IconManager);
1067 }
1068
1069 void BrowserProcessImpl::CreateIntranetRedirectDetector() {
1070   DCHECK(intranet_redirect_detector_.get() == NULL);
1071   scoped_ptr<IntranetRedirectDetector> intranet_redirect_detector(
1072       new IntranetRedirectDetector);
1073   intranet_redirect_detector_.swap(intranet_redirect_detector);
1074 }
1075
1076 void BrowserProcessImpl::CreateNotificationUIManager() {
1077 #if defined(ENABLE_NOTIFICATIONS)
1078   DCHECK(notification_ui_manager_.get() == NULL);
1079   notification_ui_manager_.reset(NotificationUIManager::Create(local_state()));
1080   created_notification_ui_manager_ = true;
1081 #endif
1082 }
1083
1084 void BrowserProcessImpl::CreateBackgroundModeManager() {
1085 #if defined(ENABLE_BACKGROUND)
1086   DCHECK(background_mode_manager_.get() == NULL);
1087   background_mode_manager_.reset(
1088       new BackgroundModeManager(*base::CommandLine::ForCurrentProcess(),
1089                                 &profile_manager()->GetProfileInfoCache()));
1090 #endif
1091 }
1092
1093 void BrowserProcessImpl::CreateStatusTray() {
1094   DCHECK(status_tray_.get() == NULL);
1095   status_tray_.reset(StatusTray::Create());
1096 }
1097
1098 void BrowserProcessImpl::CreatePrintPreviewDialogController() {
1099 #if defined(ENABLE_PRINT_PREVIEW)
1100   DCHECK(print_preview_dialog_controller_.get() == NULL);
1101   print_preview_dialog_controller_ =
1102       new printing::PrintPreviewDialogController();
1103 #else
1104   NOTIMPLEMENTED();
1105 #endif
1106 }
1107
1108 void BrowserProcessImpl::CreateBackgroundPrintingManager() {
1109 #if defined(ENABLE_PRINT_PREVIEW)
1110   DCHECK(background_printing_manager_.get() == NULL);
1111   background_printing_manager_.reset(new printing::BackgroundPrintingManager());
1112 #else
1113   NOTIMPLEMENTED();
1114 #endif
1115 }
1116
1117 void BrowserProcessImpl::CreateSafeBrowsingService() {
1118   DCHECK(safe_browsing_service_.get() == NULL);
1119   // Set this flag to true so that we don't retry indefinitely to
1120   // create the service class if there was an error.
1121   created_safe_browsing_service_ = true;
1122 #if defined(FULL_SAFE_BROWSING) || defined(MOBILE_SAFE_BROWSING)
1123   safe_browsing_service_ = SafeBrowsingService::CreateSafeBrowsingService();
1124   safe_browsing_service_->Initialize();
1125 #endif
1126 }
1127
1128 void BrowserProcessImpl::CreateGCMDriver() {
1129   DCHECK(!gcm_driver_);
1130
1131 #if defined(OS_ANDROID)
1132   // Android's GCMDriver currently makes the assumption that it's a singleton.
1133   // Until this gets fixed, instantiating multiple Java GCMDrivers will throw
1134   // an exception, but because they're only initialized on demand these crashes
1135   // would be very difficult to triage. See http://crbug.com/437827.
1136   NOTREACHED();
1137 #else
1138   base::FilePath store_path;
1139   CHECK(PathService::Get(chrome::DIR_GLOBAL_GCM_STORE, &store_path));
1140   gcm_driver_ = gcm::CreateGCMDriverDesktop(
1141       make_scoped_ptr(new gcm::GCMClientFactory),
1142       local_state(),
1143       store_path,
1144       system_request_context());
1145 #endif  // defined(OS_ANDROID)
1146 }
1147
1148 void BrowserProcessImpl::ApplyDefaultBrowserPolicy() {
1149   if (local_state()->GetBoolean(prefs::kDefaultBrowserSettingEnabled)) {
1150     scoped_refptr<ShellIntegration::DefaultWebClientWorker>
1151         set_browser_worker = new ShellIntegration::DefaultBrowserWorker(NULL);
1152     set_browser_worker->StartSetAsDefault();
1153   }
1154 }
1155
1156 void BrowserProcessImpl::ApplyAllowCrossOriginAuthPromptPolicy() {
1157   bool value = local_state()->GetBoolean(prefs::kAllowCrossOriginAuthPrompt);
1158   ResourceDispatcherHost::Get()->SetAllowCrossOriginAuthPrompt(value);
1159 }
1160
1161 void BrowserProcessImpl::ApplyMetricsReportingPolicy() {
1162 #if !defined(OS_CHROMEOS) && !defined(OS_ANDROID) && !defined(OS_IOS)
1163   CHECK(BrowserThread::PostTask(
1164       BrowserThread::FILE, FROM_HERE,
1165       base::Bind(
1166           base::IgnoreResult(&GoogleUpdateSettings::SetCollectStatsConsent),
1167           local_state()->GetBoolean(prefs::kMetricsReportingEnabled))));
1168 #endif
1169 }
1170
1171 // Mac is currently not supported.
1172 #if (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)
1173
1174 bool BrowserProcessImpl::CanAutorestartForUpdate() const {
1175   // Check if browser is in the background and if it needs to be restarted to
1176   // apply a pending update.
1177   return chrome::GetTotalBrowserCount() == 0 && chrome::WillKeepAlive() &&
1178          upgrade_util::IsUpdatePendingRestart();
1179 }
1180
1181 // Switches to add when auto-restarting Chrome.
1182 const char* const kSwitchesToAddOnAutorestart[] = {
1183   switches::kNoStartupWindow
1184 };
1185
1186 void BrowserProcessImpl::RestartBackgroundInstance() {
1187   base::CommandLine* old_cl = base::CommandLine::ForCurrentProcess();
1188   scoped_ptr<base::CommandLine> new_cl(
1189       new base::CommandLine(old_cl->GetProgram()));
1190
1191   std::map<std::string, base::CommandLine::StringType> switches =
1192       old_cl->GetSwitches();
1193
1194   switches::RemoveSwitchesForAutostart(&switches);
1195
1196   // Append the rest of the switches (along with their values, if any)
1197   // to the new command line
1198   for (std::map<std::string, base::CommandLine::StringType>::const_iterator i =
1199            switches.begin();
1200        i != switches.end(); ++i) {
1201     base::CommandLine::StringType switch_value = i->second;
1202       if (switch_value.length() > 0) {
1203         new_cl->AppendSwitchNative(i->first, i->second);
1204       } else {
1205         new_cl->AppendSwitch(i->first);
1206       }
1207   }
1208
1209   // Ensure that our desired switches are set on the new process.
1210   for (size_t i = 0; i < arraysize(kSwitchesToAddOnAutorestart); ++i) {
1211     if (!new_cl->HasSwitch(kSwitchesToAddOnAutorestart[i]))
1212       new_cl->AppendSwitch(kSwitchesToAddOnAutorestart[i]);
1213   }
1214
1215   DLOG(WARNING) << "Shutting down current instance of the browser.";
1216   chrome::AttemptExit();
1217
1218   // Transfer ownership to Upgrade.
1219   upgrade_util::SetNewCommandLine(new_cl.release());
1220 }
1221
1222 void BrowserProcessImpl::OnAutoupdateTimer() {
1223   if (CanAutorestartForUpdate()) {
1224     DLOG(WARNING) << "Detected update.  Restarting browser.";
1225     RestartBackgroundInstance();
1226   }
1227 }
1228
1229 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)