localStorage: Aggressively flush to disk for Android WebView.

content/browser/dom_storage/dom_storage_area.cc

 // Copyright 2013 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 "content/browser/dom_storage/dom_storage_area.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 24 matching lines @@
 // of other values being set, so changes are batched.
 const int kCommitDefaultDelaySecs = 5;
 
 // To avoid excessive IO we apply limits to the amount of data being written
 // and the frequency of writes. The specific values used are somewhat arbitrary.
 const int kMaxBytesPerDay = kPerStorageAreaQuota * 2;
 const int kMaxCommitsPerHour = 6;
 
 }  // namespace
 
+bool DOMStorageArea::s_aggressive_flushing_enabled_ = false;
+
 DOMStorageArea::RateLimiter::RateLimiter(size_t desired_rate,
                                          base::TimeDelta time_quantum)
     : rate_(desired_rate), samples_(0), time_quantum_(time_quantum) {
   DCHECK_GT(desired_rate, 0ul);
 }
 
 base::TimeDelta DOMStorageArea::RateLimiter::ComputeTimeNeeded() const {
   return time_quantum_ * (samples_ / rate_);
 }
 
@@ skipping 28 matching lines @@
 }
 
 // static
 GURL DOMStorageArea::OriginFromDatabaseFileName(const base::FilePath& name) {
   DCHECK(name.MatchesExtension(kDatabaseFileExtension));
   std::string origin_id =
       name.BaseName().RemoveExtension().MaybeAsASCII();
   return storage::GetOriginFromIdentifier(origin_id);
 }
 
+// Commence aggressive flushing. This should be called early in the startup -
+// before any localStorage writing. Currently scheduled writes will not be
+// rescheduled and will be flushed at the scheduled time after which aggressive
+// flushing will commence.

[michaeln, 2015/05/07 23:19:03]

maybe put the comment in the .h file

[cmumford, 2015/05/08 16:02:48]

Done.

+void DOMStorageArea::EnableAggressiveCommitDelay() {
+  s_aggressive_flushing_enabled_ = true;
+}
+
 DOMStorageArea::DOMStorageArea(const GURL& origin,
                                const base::FilePath& directory,
                                DOMStorageTaskRunner* task_runner)
     : namespace_id_(kLocalStorageNamespaceId),
       origin_(origin),
       directory_(directory),
       task_runner_(task_runner),
       map_(new DOMStorageMap(kPerStorageAreaQuota +
                              kPerStorageAreaOverQuotaAllowance)),
       is_initial_import_done_(true),
@@ skipping 278 matching lines @@
   // started after the commits have happened.
   if (commit_batches_in_flight_)
     return;
 
   task_runner_->PostDelayedTask(
       FROM_HERE, base::Bind(&DOMStorageArea::OnCommitTimer, this),
       ComputeCommitDelay());
 }
 
 base::TimeDelta DOMStorageArea::ComputeCommitDelay() const {
-  base::TimeDelta elapsed_time = base::TimeTicks::Now() - start_time_;
-  base::TimeDelta delay = std::max(
-      base::TimeDelta::FromSeconds(kCommitDefaultDelaySecs),
-      std::max(commit_rate_limiter_.ComputeDelayNeeded(elapsed_time),
-               data_rate_limiter_.ComputeDelayNeeded(elapsed_time)));
-  UMA_HISTOGRAM_LONG_TIMES("LocalStorage.CommitDelay", delay);
+  base::TimeDelta delay;
+  if (s_aggressive_flushing_enabled_) {
+    // Calculate very short delay to flush unwritten data soon. Used for
+    // Chromium hosts that do not write data during shutdown (Android WebView).
+    // More info at http://crbug.com/479767

[michaeln, 2015/05/07 23:19:03]

nit: Given the nicely named methods and members, much of the comment isn't
really needed and we generally prefer early returns to else where possible. In
the spirit of less is more...

if (s_aggressive_flushing_enabled_)
  return base::TimeDelta::FromSeconds(1);

[cmumford, 2015/05/08 16:02:48]

Done.

+    delay = base::TimeDelta::FromSeconds(1);
+  } else {
+    base::TimeDelta elapsed_time = base::TimeTicks::Now() - start_time_;
+    delay =
+        std::max(base::TimeDelta::FromSeconds(kCommitDefaultDelaySecs),
+                 std::max(commit_rate_limiter_.ComputeDelayNeeded(elapsed_time),
+                          data_rate_limiter_.ComputeDelayNeeded(elapsed_time)));
+    UMA_HISTOGRAM_LONG_TIMES("LocalStorage.CommitDelay", delay);
+  }
   return delay;
 }
 
 void DOMStorageArea::OnCommitTimer() {
   if (is_shutdown_)
     return;
 
   // It's possible that there is nothing to commit if an immediate
   // commit occured after the timer was scheduled but before it fired.
   if (!commit_batch_)
@@ skipping 59 matching lines @@
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   backing_.reset();
   session_storage_backing_ = NULL;
 }
 
 }  // namespace content