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

content/browser/dom_storage/dom_storage_message_filter.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 "content/browser/dom_storage/dom_storage_message_filter.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
+#include "base/stringprintf.h"
 #include "base/nullable_string16.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/common/dom_storage_messages.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/dom_storage/dom_storage_area.h"
 #include "webkit/dom_storage/dom_storage_host.h"
 #include "webkit/dom_storage/dom_storage_task_runner.h"
@@ skipping 69 matching lines @@
     IPC_MESSAGE_HANDLER(DOMStorageHostMsg_RemoveItem, OnRemoveItem)
     IPC_MESSAGE_HANDLER(DOMStorageHostMsg_Clear, OnClear)
     IPC_MESSAGE_HANDLER(DOMStorageHostMsg_FlushMessages, OnFlushMessages)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void DOMStorageMessageFilter::OnOpenStorageArea(int connection_id,
                                                 int64 namespace_id,
-                                                const GURL& origin) {
+                                                const GURL& origin,
+                                                int64* storage_size) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!host_->OpenStorageArea(connection_id, namespace_id, origin)) {
     RecordAction(UserMetricsAction("BadMessageTerminate_DSMF_1"));
     BadMessageReceived();
   }
+  *storage_size = context_->GetInMemoryStorageSize();
 }
 
 void DOMStorageMessageFilter::OnCloseStorageArea(int connection_id) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
   host_->CloseStorageArea(connection_id);
 }
 
 void DOMStorageMessageFilter::OnLoadStorageArea(int connection_id,
                                                 dom_storage::ValuesMap* map) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!host_->ExtractAreaValues(connection_id, map)) {
     RecordAction(UserMetricsAction("BadMessageTerminate_DSMF_2"));
     BadMessageReceived();
   }
   Send(new DOMStorageMsg_AsyncOperationComplete(true));
 }
 
 void DOMStorageMessageFilter::OnSetItem(
     int connection_id, const string16& key,
     const string16& value, const GURL& page_url) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(0, connection_dispatching_message_for_);

[michaeln, 2013/03/05 00:04:46]

Since there is an async code path for localstorage.set() to fail, not sure we
need to maintain the total mem usage in each renderer and introduce new sync
IPCs to do that.

if (using too much memory)
  Send(new DOMStorageMsg_AsyncOperationComplete(false));

We could probably define the 'using too much memory' condition out of existence
by purging individual areas from memory, no single area can be too large. Some
upper limit on the number of areas we held in memory might work w/o regard for
how large an area really is. Upon opening the <limit>+1, purge one of them. Say
100 areas max?

[kinuko, 2013/03/06 06:20:15]

Updated to use the async IPC.

   base::AutoReset<int> auto_reset(&connection_dispatching_message_for_,
                             connection_id);
   NullableString16 not_used;
   bool success = host_->SetAreaItem(connection_id, key, value,
                                     page_url, &not_used);
   Send(new DOMStorageMsg_AsyncOperationComplete(success));
 }
 
 void DOMStorageMessageFilter::OnRemoveItem(
     int connection_id, const string16& key,
@@ skipping 65 matching lines @@
   if (originated_in_process ||
       host_->HasAreaOpen(area->namespace_id(), area->origin())) {
     DOMStorageMsg_Event_Params params;
     params.origin = area->origin();
     params.page_url = page_url;
     params.connection_id = connection_dispatching_message_for_;
     params.key = key;
     params.new_value = new_value;
     params.old_value = old_value;
     params.namespace_id = area->namespace_id();
+    params.storage_size = context_->GetInMemoryStorageSize();
     Send(new DOMStorageMsg_Event(params));
   }
 }
 
 }  // namespace content