Purge in-memory localStorage areas if the # of areas exceeds the limit

webkit/dom_storage/dom_storage_context.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 "webkit/dom_storage/dom_storage_context.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/time.h"
 #include "webkit/dom_storage/dom_storage_area.h"
 #include "webkit/dom_storage/dom_storage_database.h"
+#include "webkit/dom_storage/dom_storage_host.h"
 #include "webkit/dom_storage/dom_storage_namespace.h"
 #include "webkit/dom_storage/dom_storage_task_runner.h"
 #include "webkit/dom_storage/dom_storage_types.h"
 #include "webkit/dom_storage/session_storage_database.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using file_util::FileEnumerator;
 
 namespace dom_storage {
 
 static const int kSessionStoraceScavengingSeconds = 60;
 
 DomStorageContext::DomStorageContext(
     const base::FilePath& localstorage_directory,
     const base::FilePath& sessionstorage_directory,
     quota::SpecialStoragePolicy* special_storage_policy,
     DomStorageTaskRunner* task_runner)
     : localstorage_directory_(localstorage_directory),
       sessionstorage_directory_(sessionstorage_directory),
       task_runner_(task_runner),
       is_shutdown_(false),
       force_keep_session_state_(false),
       special_storage_policy_(special_storage_policy),
-      scavenging_started_(false) {
+      scavenging_started_(false),
+      total_area_size_(-1) {
   // AtomicSequenceNum starts at 0 but we want to start session
   // namespace ids at one since zero is reserved for the
   // kLocalStorageNamespaceId.
   session_id_sequence_.GetNext();
 }
 
 DomStorageContext::~DomStorageContext() {
   if (session_storage_database_.get()) {
     // SessionStorageDatabase shouldn't be deleted right away: deleting it will
     // potentially involve waiting in leveldb::DBImpl::~DBImpl, and waiting
@@ skipping 158 matching lines @@
 void DomStorageContext::RemoveEventObserver(EventObserver* observer) {
   event_observers_.RemoveObserver(observer);
 }
 
 void DomStorageContext::NotifyItemSet(
     const DomStorageArea* area,
     const string16& key,
     const string16& new_value,
     const NullableString16& old_value,
     const GURL& page_url) {
+  InvalidateInMemoryAreaSize();
   FOR_EACH_OBSERVER(
       EventObserver, event_observers_,
       OnDomStorageItemSet(area, key, new_value, old_value, page_url));
 }
 
 void DomStorageContext::NotifyItemRemoved(
     const DomStorageArea* area,
     const string16& key,
     const string16& old_value,
     const GURL& page_url) {
+  InvalidateInMemoryAreaSize();
   FOR_EACH_OBSERVER(
       EventObserver, event_observers_,
       OnDomStorageItemRemoved(area, key, old_value, page_url));
 }
 
 void DomStorageContext::NotifyAreaCleared(
     const DomStorageArea* area,
     const GURL& page_url) {
+  InvalidateInMemoryAreaSize();
   FOR_EACH_OBSERVER(
       EventObserver, event_observers_,
       OnDomStorageAreaCleared(area, page_url));
 }
 
 std::string DomStorageContext::AllocatePersistentSessionId() {
   std::string guid = base::GenerateGUID();
   std::replace(guid.begin(), guid.end(), '-', '_');
   return guid;
 }
@@ skipping 100 matching lines @@
 }
 
 void DomStorageContext::StartScavengingUnusedSessionStorage() {
   if (session_storage_database_.get()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&DomStorageContext::FindUnusedNamespaces, this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
+bool DomStorageContext::CanSetItem(
+    DomStorageHost* host,
+    int connection_id,
+    const string16& key,
+    const string16& value) {
+  DCHECK(host);
+  if (GetRemainingCacheSize() >= static_cast<int64>(kPerAreaQuota))
+    return true;
+  // Go through the slower check only if the memory is getting tight.
+  // TODO(kinuko,michaeln): Purge cache memory if we're caching too many areas.
+  NullableString16 old_value = host->GetAreaItem(connection_id, key);
+  int64 increase = value.size();
+  if (old_value.is_null())
+    increase += key.size();
+  else
+    increase -= old_value.string().size();
+  return static_cast<int64>(increase * sizeof(char16)) <=
+      GetRemainingCacheSize();
+}
+
 void DomStorageContext::FindUnusedNamespaces() {
   DCHECK(session_storage_database_.get());
   if (scavenging_started_)
     return;
   scavenging_started_ = true;
   std::set<std::string> namespace_ids_in_use;
   for (StorageNamespaceMap::const_iterator it = namespaces_.begin();
        it != namespaces_.end(); ++it)
     namespace_ids_in_use.insert(it->second->persistent_namespace_id());
   std::set<std::string> protected_persistent_session_ids;
@@ skipping 49 matching lines @@
   deletable_persistent_namespace_ids_.pop_back();
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DomStorageContext::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
+int64 DomStorageContext::GetRemainingCacheSize() {
+  if (total_area_size_ < 0) {

[Mike West, 2013/03/06 13:41:11]

I don't see where you're updating total_area_size_ after this initial call. Am I
blind?

Ah. Now I see. You invalidate the cached size on each write. Would it be
possible to adjust the running total rather than forcing a recalculation on
set/delete/clear? That seems like it would be a significant performance
improvement over this mechanism.

+    total_area_size_ = 0;
+    // Naively add-up the area size for each connection.
+    std::set<DomStorageArea*> visited_areas;
+    for (StorageNamespaceMap::const_iterator itr = namespaces_.begin();
+        itr != namespaces_.end(); ++itr) {
+      const DomStorageNamespace::AreaMap& map = itr->second->GetAreaMap();
+      for (DomStorageNamespace::AreaMap::const_iterator map_itr = map.begin();
+          map_itr != map.end(); ++map_itr) {
+        // We don't care open_count_ here, since we don't purge memory (yet).
+        DomStorageArea* area = map_itr->second.area_;
+        DCHECK(area);
+        if (visited_areas.insert(area).second)
+          total_area_size_ += area->GetMapSize();
+      }
+    }
+  }
+  return kMaxInMemoryAreaSize - total_area_size_;
+}
+
 }  // namespace dom_storage