Tweak DOMStorageArea rate limit

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 15 matching lines @@
 #include "storage/common/fileapi/file_system_util.h"
 
 using storage::DatabaseUtil;
 
 namespace content {
 
 namespace {
 
 // Delay for a moment after a value is set in anticipation
 // of other values being set, so changes are batched.
-const int kCommitDefaultDelaySecs = 5;
+const int kCommitDefaultDelaySecs = 10;

[michaeln, 2015/05/14 01:33:48]

Please don't hastily remove the commit rate limiter. You asked about Local State
and Preference files compared to DomStorage areas, one  difference is the number
of files involved. There can be a large number of areas constantly running
commit timers.

 
 // 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;
+const int kMaxBytesPerMinute = kPerStorageAreaQuota;

[michaeln, 2015/05/14 01:33:48]

Adjusting the values is ok, but this adjustment goes too far.

This translates to 14Gbytes per day, 7 bad behaving apps could make for a
terabyte per week. Actually more because the limits are applied to the size of
the values provided, but due to sqlite journaling the amt of writes to disk is
about dbl.

 
 }  // 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);
 }
@@ skipping 50 matching lines @@
     : namespace_id_(kLocalStorageNamespaceId),
       origin_(origin),
       directory_(directory),
       task_runner_(task_runner),
       map_(new DOMStorageMap(kPerStorageAreaQuota +
                              kPerStorageAreaOverQuotaAllowance)),
       is_initial_import_done_(true),
       is_shutdown_(false),
       commit_batches_in_flight_(0),
       start_time_(base::TimeTicks::Now()),
-      data_rate_limiter_(kMaxBytesPerDay, base::TimeDelta::FromHours(24)),
-      commit_rate_limiter_(kMaxCommitsPerHour, base::TimeDelta::FromHours(1)) {
+      data_rate_limiter_(kMaxBytesPerMinute, base::TimeDelta::FromMinutes(1)) {
   if (!directory.empty()) {
     base::FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_));
     backing_.reset(new LocalStorageDatabaseAdapter(path));
     is_initial_import_done_ = false;
   }
 }
 
 DOMStorageArea::DOMStorageArea(int64 namespace_id,
                                const std::string& persistent_namespace_id,
                                const GURL& origin,
                                SessionStorageDatabase* session_storage_backing,
                                DOMStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
       persistent_namespace_id_(persistent_namespace_id),
       origin_(origin),
       task_runner_(task_runner),
       map_(new DOMStorageMap(kPerStorageAreaQuota +
                              kPerStorageAreaOverQuotaAllowance)),
       session_storage_backing_(session_storage_backing),
       is_initial_import_done_(true),
       is_shutdown_(false),
       commit_batches_in_flight_(0),
       start_time_(base::TimeTicks::Now()),
-      data_rate_limiter_(kMaxBytesPerDay, base::TimeDelta::FromHours(24)),
-      commit_rate_limiter_(kMaxCommitsPerHour, base::TimeDelta::FromHours(1)) {
+      data_rate_limiter_(kMaxBytesPerMinute, base::TimeDelta::FromMinutes(1)) {
   DCHECK(namespace_id != kLocalStorageNamespaceId);
   if (session_storage_backing) {
     backing_.reset(new SessionStorageDatabaseAdapter(
         session_storage_backing, persistent_namespace_id, origin));
     is_initial_import_done_ = false;
   }
 }
 
 DOMStorageArea::~DOMStorageArea() {
 }
@@ skipping 244 matching lines @@
       ComputeCommitDelay());
 }
 
 base::TimeDelta DOMStorageArea::ComputeCommitDelay() const {
   if (s_aggressive_flushing_enabled_)
     return base::TimeDelta::FromSeconds(1);
 
   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)));
+      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_)
     return;
 
   PostCommitTask();
 }
 
 void DOMStorageArea::PostCommitTask() {
   if (is_shutdown_ || !commit_batch_)
     return;
 
   DCHECK(backing_.get());
 
-  commit_rate_limiter_.add_samples(1);
   data_rate_limiter_.add_samples(commit_batch_->GetDataSize());
 
   // This method executes on the primary sequence, we schedule
   // a task for immediate execution on the commit sequence.
   DCHECK(task_runner_->IsRunningOnPrimarySequence());
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DOMStorageTaskRunner::COMMIT_SEQUENCE,
       base::Bind(&DOMStorageArea::CommitChanges, this,
                  base::Owned(commit_batch_.release())));
@@ skipping 37 matching lines @@
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   backing_.reset();
   session_storage_backing_ = NULL;
 }
 
 }  // namespace content