Implement throttling behavior for LocalStorage mojo messages.

content/renderer/dom_storage/local_storage_cached_area.cc

 // Copyright 2016 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/renderer/dom_storage/local_storage_cached_area.h"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
@@ skipping 65 matching lines @@
 }
 
 LocalStorageCachedArea::LocalStorageCachedArea(
     const url::Origin& origin,
     mojom::StoragePartitionService* storage_partition_service,
     LocalStorageCachedAreas* cached_areas)
     : origin_(origin), binding_(this),
       cached_areas_(cached_areas), weak_factory_(this) {
   storage_partition_service->OpenLocalStorage(origin_,
                                               mojo::MakeRequest(&leveldb_));
+  leveldb_.set_process_async_during_sync(true);
   mojom::LevelDBObserverAssociatedPtrInfo ptr_info;
   binding_.Bind(&ptr_info, leveldb_.associated_group());
   leveldb_->AddObserver(std::move(ptr_info));
 }
 
 LocalStorageCachedArea::~LocalStorageCachedArea() {
   cached_areas_->CacheAreaClosed(this);
 }
 
 unsigned LocalStorageCachedArea::GetLength() {
@@ skipping 25 matching lines @@
   base::NullableString16 unused;
   if (!map_->SetItem(key, value, &unused))
     return false;
 
   // Ignore mutations to |key| until OnSetItemComplete.
   ignore_key_mutations_[key]++;
   leveldb_->Put(String16ToUint8Vector(key), String16ToUint8Vector(value),
                 PackSource(page_url, storage_area_id),
                 base::Bind(&LocalStorageCachedArea::OnSetItemComplete,
                            weak_factory_.GetWeakPtr(), key));
+  FlushIfNeeded();
+
   return true;
 }
 
 void LocalStorageCachedArea::RemoveItem(const base::string16& key,
                                         const GURL& page_url,
                                         const std::string& storage_area_id) {
   EnsureLoaded();
   base::string16 unused;
   if (!map_->RemoveItem(key, &unused))
     return;
 
   // Ignore mutations to |key| until OnRemoveItemComplete.
   ignore_key_mutations_[key]++;
   leveldb_->Delete(String16ToUint8Vector(key),
                    PackSource(page_url, storage_area_id),
                    base::Bind(&LocalStorageCachedArea::OnRemoveItemComplete,
                               weak_factory_.GetWeakPtr(), key));
+  FlushIfNeeded();
 }
 
 void LocalStorageCachedArea::Clear(const GURL& page_url,
                                    const std::string& storage_area_id) {
   // No need to prime the cache in this case.
-
   Reset();
   map_ = new DOMStorageMap(kPerStorageAreaQuota);
   ignore_all_mutations_ = true;
   leveldb_->DeleteAll(PackSource(page_url, storage_area_id),
                       base::Bind(&LocalStorageCachedArea::OnClearComplete,
                                   weak_factory_.GetWeakPtr()));
+  FlushIfNeeded();
 }
 
 void LocalStorageCachedArea::AreaCreated(LocalStorageArea* area) {
   areas_[area->id()] = area;
 }
 
 void LocalStorageCachedArea::AreaDestroyed(LocalStorageArea* area) {
   areas_.erase(area->id());
 }
 
@@ skipping 146 matching lines @@
                         time_to_prime);
   } else if (local_storage_size_kb < 1000) {
     UMA_HISTOGRAM_TIMES("LocalStorage.MojoTimeToPrimeFor100KBTo1MB",
                         time_to_prime);
   } else {
     UMA_HISTOGRAM_TIMES("LocalStorage.MojoTimeToPrimeFor1MBTo5MB",
                         time_to_prime);
   }
 }
 
+void LocalStorageCachedArea::FlushIfNeeded() {
+  if (leveldb_.pending_callback_count() > 1000) {
+    leveldb_->FlushPipe();
+    DCHECK_EQ(0u, leveldb_.pending_callback_count());
+  }
+}
+
 void LocalStorageCachedArea::OnSetItemComplete(const base::string16& key,
                                                bool success) {
   if (!success) {
     Reset();
     return;
   }
 
   auto found = ignore_key_mutations_.find(key);
   DCHECK(found != ignore_key_mutations_.end());
   if (--found->second == 0)
@@ skipping 25 matching lines @@
 }
 
 void LocalStorageCachedArea::Reset() {
   map_ = NULL;
   ignore_key_mutations_.clear();
   ignore_all_mutations_ = false;
   weak_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace content