Try to flush DOMStorage too when ending the browsing session.

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 <iterator>
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/atomic_ref_count.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/crash_logging.h"
 #include "base/debug/leak_annotations.h"
@@ skipping 371 matching lines @@
   //
   // This is important also because in various places, the
   // IOThread object being NULL is considered synonymous with the
   // IO thread having stopped.
   io_thread_.reset();
 }
 #endif  // !defined(OS_ANDROID)
 
 namespace {
 
+using TaskRunnerVector = std::vector<scoped_refptr<base::SequencedTaskRunner>>;
+
 // Used at the end of session to block the UI thread for completion of sentinel
 // tasks on the set of threads used to persist profile data and local state.
 // This is done to ensure that the data has been persisted to disk before
 // continuing.
 class RundownTaskCounter :
     public base::RefCountedThreadSafe<RundownTaskCounter> {
  public:
   RundownTaskCounter();
 
   // Posts a rundown task to |task_runner|, can be invoked an arbitrary number
   // of times before calling TimedWait.
   void Post(base::SequencedTaskRunner* task_runner);
 
+  // Posts a rundown task to each runner in |runners|, where the rundown task
+  // for runner[n+1] is posted during rundown task execution for runner[n].
+  void PostSerially(TaskRunnerVector runners);
+
   // Waits until the count is zero or |end_time| is reached.
   // This can only be called once per instance. Returns true if a count of zero
   // is reached or false if the |end_time| is reached. It is valid to pass an
   // |end_time| in the past.
   bool TimedWaitUntil(const base::TimeTicks& end_time);
 
  private:
   friend class base::RefCountedThreadSafe<RundownTaskCounter>;
   ~RundownTaskCounter() {}
 
   // Decrements the counter and releases the waitable event on transition to
   // zero.
   void Decrement();
 
+  void RundownSerially(TaskRunnerVector::const_iterator it,
+                       TaskRunnerVector runner);
+
   // The count starts at one to defer the possibility of one->zero transitions
   // until TimedWait is called.
   base::AtomicRefCount count_;
   base::WaitableEvent waitable_event_;
 
   DISALLOW_COPY_AND_ASSIGN(RundownTaskCounter);
 };
 
 RundownTaskCounter::RundownTaskCounter()
     : count_(1),
       waitable_event_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED) {}
 
 void RundownTaskCounter::Post(base::SequencedTaskRunner* task_runner) {
   // As the count starts off at one, it should never get to zero unless
   // TimedWait has been called.
   DCHECK(!base::AtomicRefCountIsZero(&count_));
 
   base::AtomicRefCountInc(&count_);
 
   // The task must be non-nestable to guarantee that it runs after all tasks
   // currently scheduled on |task_runner| have completed.
   task_runner->PostNonNestableTask(FROM_HERE,
       base::Bind(&RundownTaskCounter::Decrement, this));
 }
 
+void RundownTaskCounter::PostSerially(TaskRunnerVector runners) {
+  if (runners.empty())
+    return;
+  base::AtomicRefCountInc(&count_);
+  TaskRunnerVector::const_iterator it = runners.begin();
+  (*it)->PostNonNestableTask(
+      FROM_HERE, base::Bind(&RundownTaskCounter::RundownSerially, this, it + 1,
+                            base::Passed(&runners)));
+}
+
 void RundownTaskCounter::Decrement() {
   if (!base::AtomicRefCountDec(&count_))
     waitable_event_.Signal();
 }
 
 bool RundownTaskCounter::TimedWaitUntil(const base::TimeTicks& end_time) {
   // Decrement the excess count from the constructor.
   Decrement();
 
   return waitable_event_.TimedWaitUntil(end_time);
 }
 
+void RundownTaskCounter::RundownSerially(TaskRunnerVector::const_iterator it,
+                                         TaskRunnerVector runners) {
+  if (it == runners.end()) {
+    Decrement();
+    return;
+  }
+  (*it)->PostNonNestableTask(
+      FROM_HERE, base::Bind(&RundownTaskCounter::RundownSerially, this, it + 1,
+                            base::Passed(&runners)));
+}
+
 }  // 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 pref_service_enabled =
       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];
+  for (Profile* profile : profiles) {
     profile->SetExitType(Profile::EXIT_SESSION_ENDED);
     if (profile->GetPrefs()) {
       profile->GetPrefs()->CommitPendingWrite();
       if (pref_service_enabled) {
         rundown_counter->Post(content::BrowserThread::GetTaskRunnerForThread(
                                   content::BrowserThread::IO)
                                   .get());
         profile_writer_runners.push_back(profile->GetIOTaskRunner());
       } else {
         rundown_counter->Post(profile->GetIOTaskRunner().get());
@@ skipping 32 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.
   const base::TimeTicks end_time = base::TimeTicks::Now() + kEndSessionTimeout;
-  const bool timed_out = !rundown_counter->TimedWaitUntil(end_time);
-  if (timed_out || !pref_service_enabled)
+  if (!rundown_counter->TimedWaitUntil(end_time))
     return;
 
-  scoped_refptr<RundownTaskCounter> profile_write_rundown_counter(
+  if (pref_service_enabled) {
+    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());
+    if (!profile_write_rundown_counter->TimedWaitUntil(end_time))
+      return;
+  }
+
+  // Time permitting, give other storage systems a chance to flush caches.
+  auto flush_function = [](scoped_refptr<RundownTaskCounter> rundown_counter,
+                           content::StoragePartition* partition) {
+    rundown_counter->PostSerially(partition->Flush());
+  };
+  scoped_refptr<RundownTaskCounter> flush_storage_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->TimedWaitUntil(end_time);
+  for (Profile* profile : profiles) {
+    content::BrowserContext::ForEachStoragePartition(
+        profile,
+        base::BindRepeating(flush_function, flush_storage_rundown_counter));
+  }
+  flush_storage_rundown_counter->TimedWaitUntil(end_time);
 #else
   NOTIMPLEMENTED();
 #endif
 }
 
 metrics_services_manager::MetricsServicesManager*
 BrowserProcessImpl::GetMetricsServicesManager() {
   DCHECK(CalledOnValidThread());
   if (!metrics_services_manager_) {
     metrics_services_manager_.reset(
@@ skipping 886 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)