Add a mojo bridge for PersistentPrefStore.

chrome/browser/browser_process_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/browser_process_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 58 matching lines @@
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/status_icons/status_tray.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/update_client/chrome_update_query_params_delegate.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/crash_keys.h"
 #include "chrome/common/extensions/chrome_extensions_client.h"
 #include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/switch_utils.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/installer/util/google_update_constants.h"
@@ skipping 43 matching lines @@
 #include "ui/message_center/message_center.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "ui/views/focus/view_storage.h"
 #elif defined(OS_MACOSX)
 #include "chrome/browser/chrome_browser_main_mac.h"
 #endif
 
 #if !defined(OS_ANDROID)
+#include "chrome/browser/features.h"
 #include "chrome/browser/gcm/gcm_product_util.h"
 #include "chrome/browser/lifetime/keep_alive_registry.h"
 #include "chrome/browser/ui/user_manager.h"
 #include "components/gcm_driver/gcm_client_factory.h"
 #include "components/gcm_driver/gcm_desktop_utils.h"
 #endif
 
 #if BUILDFLAG(ENABLE_BACKGROUND)
 #include "chrome/browser/background/background_mode_manager.h"
 #endif
@@ skipping 35 matching lines @@
 // How often to check if the persistent instance of Chrome needs to restart
 // to install an update.
 static const int kUpdateCheckIntervalHours = 6;
 #endif
 
 #if defined(USE_X11) || defined(OS_WIN) || defined(USE_OZONE)
 // How long to wait for the File thread to complete during EndSession, on Linux
 // and Windows. We have a timeout here because we're unable to run the UI
 // messageloop and there's some deadlock risk. Our only option is to exit
 // anyway.
-static const int kEndSessionTimeoutSeconds = 10;
+static constexpr base::TimeDelta kEndSessionTimeout =
+    base::TimeDelta::FromSeconds(10);
 #endif
 
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::PluginService;
 using content::ResourceDispatcherHost;
 
 rappor::RapporService* GetBrowserRapporService() {
   if (g_browser_process != nullptr)
     return g_browser_process->rappor_service();
@@ skipping 252 matching lines @@
   return waitable_event_.TimedWait(max_time);
 }
 
 }  // namespace
 
 void BrowserProcessImpl::EndSession() {
   // Mark all the profiles as clean.
   ProfileManager* pm = profile_manager();
   std::vector<Profile*> profiles(pm->GetLoadedProfiles());
   scoped_refptr<RundownTaskCounter> rundown_counter(new RundownTaskCounter());
+  const bool kEnablePrefService =
+      base::FeatureList::IsEnabled(features::kPrefService);
+  std::vector<scoped_refptr<base::SequencedTaskRunner>> profile_writer_runners;
   for (size_t i = 0; i < profiles.size(); ++i) {
     Profile* profile = profiles[i];
     profile->SetExitType(Profile::EXIT_SESSION_ENDED);
     if (profile->GetPrefs()) {
       profile->GetPrefs()->CommitPendingWrite();
-      rundown_counter->Post(profile->GetIOTaskRunner().get());
+      if (kEnablePrefService) {
+        rundown_counter->Post(content::BrowserThread::GetTaskRunnerForThread(
+                                  content::BrowserThread::IO)
+                                  .get());
+        profile_writer_runners.push_back(profile->GetIOTaskRunner());
+      } else {
+        rundown_counter->Post(profile->GetIOTaskRunner().get());
+      }
     }
   }
 
   // Tell the metrics service it was cleanly shutdown.
   metrics::MetricsService* metrics = g_browser_process->metrics_service();
   if (metrics && local_state()) {
     metrics->RecordStartOfSessionEnd();
 #if !defined(OS_CHROMEOS)
     // MetricsService lazily writes to prefs, force it to write now.
     // On ChromeOS, chrome gets killed when hangs, so no need to
@@ skipping 20 matching lines @@
   //
   // On Windows, we previously posted a message to FILE and then ran a nested
   // message loop, waiting for that message to be processed until quitting.
   // However, doing so means that other messages will also be processed. In
   // particular, if the GPU process host notices that the GPU has been killed
   // during shutdown, it races exiting the nested loop with the process host
   // blocking the message loop attempting to re-establish a connection to the
   // GPU process synchronously. Because the system may not be allowing
   // processes to launch, this can result in a hang. See
   // http://crbug.com/318527.
-  rundown_counter->TimedWait(
-      base::TimeDelta::FromSeconds(kEndSessionTimeoutSeconds));
+  base::Time start = base::Time::Now();
+  if (rundown_counter->TimedWait(kEndSessionTimeout) && kEnablePrefService) {
+    scoped_refptr<RundownTaskCounter> profile_write_rundown_counter(
+        new RundownTaskCounter());
+    for (auto& profile_writer_runner : profile_writer_runners) {
+      profile_write_rundown_counter->Post(profile_writer_runner.get());
+    }
+    profile_write_rundown_counter->TimedWait(kEndSessionTimeout -
+                                             (base::Time::Now() - start));
+  }
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 metrics_services_manager::MetricsServicesManager*
 BrowserProcessImpl::GetMetricsServicesManager() {
   DCHECK(CalledOnValidThread());
   if (!metrics_services_manager_) {
     metrics_services_manager_.reset(
@@ skipping 810 matching lines @@
 #if defined(LEAK_SANITIZER)
   // Check for memory leaks now, before we start shutting down threads. Doing
   // this early means we won't report any shutdown-only leaks (as they have
   // not yet happened at this point).
   // If leaks are found, this will make the process exit immediately.
   __lsan_do_leak_check();
 #endif
 
   CHECK(base::MessageLoop::current()->is_running());
 
+  if (base::FeatureList::IsEnabled(features::kPrefService)) {
+    bool fast_shutdown_enabled =
+#if !defined(OS_ANDROID)
+        base::FeatureList::IsEnabled(features::kDesktopFastShutdown);
+#else
+        false;
+#endif
+    for (auto* profile : profile_manager()->GetLoadedProfiles()) {
+      profile->SetExitType(fast_shutdown_enabled ? Profile::EXIT_SESSION_ENDED
+                                                 : Profile::EXIT_NORMAL);
+    }
+  }
+
 #if defined(OS_MACOSX)
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(ChromeBrowserMainPartsMac::DidEndMainMessageLoop));
 #endif
   base::MessageLoop::current()->QuitWhenIdle();
 
 #if !defined(OS_ANDROID)
   chrome::ShutdownIfNeeded();
 #endif  // !defined(OS_ANDROID)
 }
@@ skipping 55 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)