Adjust LocalStorage commit rate limiting.

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 <algorithm>
 #include <map>
 #include <vector>
 
@@ skipping 389 matching lines @@
 
 namespace {
 
 // 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:
+  using TaskRunnerVector =
+      std::vector<scoped_refptr<base::SequencedTaskRunner>>;
+
   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(const TaskRunnerVector &runners);
+
   // Waits until the count is zero or |max_time| has passed.
   // This can only be called once per instance.
   bool TimedWait(const base::TimeDelta& max_time);
 
  private:
   friend class base::RefCountedThreadSafe<RundownTaskCounter>;
   ~RundownTaskCounter() {}
 
+  void RundownNextSerially(TaskRunnerVector::const_iterator it,
+                           scoped_ptr<TaskRunnerVector> runners_ptr);
+
   // Decrements the counter and releases the waitable event on transition to
   // zero.
   void Decrement();
 
   // 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_(true, false) {
 }
 
 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::Decrement() {
-  if (!base::AtomicRefCountDec(&count_))
-    waitable_event_.Signal();
+void RundownTaskCounter::PostSerially(const TaskRunnerVector& runners) {
+  DCHECK(!runners.empty());
+  base::AtomicRefCountInc(&count_);
+  scoped_ptr<TaskRunnerVector> runners_ptr(new TaskRunnerVector(runners));
+  TaskRunnerVector::const_iterator it = runners_ptr->begin();
+  (*it)->PostNonNestableTask(FROM_HERE,
+      base::Bind(&RundownTaskCounter::RundownNextSerially,
+                 this, it, base::Passed(runners_ptr.Pass())));
 }
 
 bool RundownTaskCounter::TimedWait(const base::TimeDelta& max_time) {
   // Decrement the excess count from the constructor.
   Decrement();
 
   return waitable_event_.TimedWait(max_time);
 }
 
+void RundownTaskCounter::Decrement() {
+  if (!base::AtomicRefCountDec(&count_))
+    waitable_event_.Signal();
+}
+
+void RundownTaskCounter::RundownNextSerially(
+    TaskRunnerVector::const_iterator it,
+    scoped_ptr<TaskRunnerVector> runners_ptr) {
+  TaskRunnerVector::const_iterator next = ++it;
+  if (next == runners_ptr->end()) {
+    Decrement();
+    return;
+  }
+  (*next)->PostNonNestableTask(FROM_HERE,
+      base::Bind(&RundownTaskCounter::RundownNextSerially,
+                 this, next, base::Passed(runners_ptr.Pass())));
+}
+
+void FlushStoragePartition(
+    RundownTaskCounter* rundown_counter,
+    content::StoragePartition* partition) {
+  partition->Flush();
+  //rundown_counter->PostSerially(partition->GetFlushTaskRunners());
+}
+
 }  // 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());
   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());
     }
+    content::BrowserContext::ForEachStoragePartition(
+        profile, base::Bind(FlushStoragePartition, rundown_counter));
   }
 
   // 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
     // commit metrics::prefs::kStabilitySessionEndCompleted change immediately.
@@ skipping 740 matching lines @@
 }
 
 void BrowserProcessImpl::OnAutoupdateTimer() {
   if (CanAutorestartForUpdate()) {
     DLOG(WARNING) << "Detected update.  Restarting browser.";
     RestartBackgroundInstance();
   }
 }
 
 #endif  // (defined(OS_WIN) || defined(OS_LINUX)) && !defined(OS_CHROMEOS)