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