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

content/renderer/dom_storage/dom_storage_dispatcher.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/renderer/dom_storage/dom_storage_dispatcher.h"
 
 #include <list>
 #include <map>
 
 #include "base/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "content/common/dom_storage_messages.h"
 #include "content/renderer/dom_storage/webstoragearea_impl.h"
 #include "content/renderer/dom_storage/webstoragenamespace_impl.h"
 #include "content/renderer/render_thread_impl.h"
+#include "ipc/ipc_sync_message_filter.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebStorageEventDispatcher.h"
 #include "webkit/dom_storage/dom_storage_cached_area.h"
 #include "webkit/dom_storage/dom_storage_proxy.h"
 #include "webkit/dom_storage/dom_storage_types.h"
 
 using dom_storage::DomStorageCachedArea;
 using dom_storage::DomStorageProxy;
 using dom_storage::ValuesMap;
@@ skipping 70 matching lines @@
 // ProxyImpl -----------------------------------------------------
 // An implementation of the DomStorageProxy interface in terms of IPC.
 // This class also manages the collection of cached areas and pending
 // operations awaiting completion callbacks.
 class DomStorageDispatcher::ProxyImpl : public DomStorageProxy {
  public:
   explicit ProxyImpl(RenderThreadImpl* sender);
 
   // Methods for use by DomStorageDispatcher directly.
   DomStorageCachedArea* OpenCachedArea(
-      int64 namespace_id, const GURL& origin);
+      int64 namespace_id, const GURL& origin, int64 storage_size);
   void CloseCachedArea(DomStorageCachedArea* area);
   DomStorageCachedArea* LookupCachedArea(
       int64 namespace_id, const GURL& origin);
   void CompleteOnePendingCallback(bool success);
   void Shutdown();
 
   // DomStorageProxy interface for use by DomStorageCachedArea.
   virtual void LoadArea(int connection_id, ValuesMap* values,
                         const CompletionCallback& callback) OVERRIDE;
   virtual void SetItem(int connection_id, const string16& key,
@@ skipping 55 matching lines @@
   scoped_refptr<MessageThrottlingFilter> throttling_filter_;
 };
 
 DomStorageDispatcher::ProxyImpl::ProxyImpl(RenderThreadImpl* sender)
     : sender_(sender),
       throttling_filter_(new MessageThrottlingFilter(sender)) {
   sender_->AddFilter(throttling_filter_);
 }
 
 DomStorageCachedArea* DomStorageDispatcher::ProxyImpl::OpenCachedArea(
-    int64 namespace_id, const GURL& origin) {
+    int64 namespace_id, const GURL& origin, int64 storage_size) {
   std::string key = GetCachedAreaKey(namespace_id, origin);
   if (CachedAreaHolder* holder = GetAreaHolder(key)) {
     ++(holder->open_count_);
     return holder->area_;
   }
   scoped_refptr<DomStorageCachedArea> area =
-      new DomStorageCachedArea(namespace_id, origin, this);
+      new DomStorageCachedArea(namespace_id, origin, this, storage_size);
   cached_areas_[key] = CachedAreaHolder(area, 1);
   return area.get();
 }
 
 void DomStorageDispatcher::ProxyImpl::CloseCachedArea(
     DomStorageCachedArea* area) {
   std::string key = GetCachedAreaKey(area->namespace_id(), area->origin());
   CachedAreaHolder* holder = GetAreaHolder(key);
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
@@ skipping 62 matching lines @@
 DomStorageDispatcher::DomStorageDispatcher()
     : proxy_(new ProxyImpl(RenderThreadImpl::current())) {
 }
 
 DomStorageDispatcher::~DomStorageDispatcher() {
   proxy_->Shutdown();
 }
 
 scoped_refptr<DomStorageCachedArea> DomStorageDispatcher::OpenCachedArea(
     int connection_id, int64 namespace_id, const GURL& origin) {
+  /*
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_OpenStorageArea(
           connection_id, namespace_id, origin));
-  return proxy_->OpenCachedArea(namespace_id, origin);
+          */
+  scoped_refptr<IPC::SyncMessageFilter> sync_msg_filter(
+      RenderThreadImpl::current()->sync_message_filter());
+  int64 storage_size = 0;
+  sync_msg_filter->Send(new DOMStorageHostMsg_OpenStorageArea(
+          connection_id, namespace_id, origin, &storage_size));
+  return proxy_->OpenCachedArea(namespace_id, origin, storage_size);
 }
 
 void DomStorageDispatcher::CloseCachedArea(
     int connection_id, DomStorageCachedArea* area) {
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_CloseStorageArea(connection_id));
   proxy_->CloseCachedArea(area);
 }
 
 bool DomStorageDispatcher::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DomStorageDispatcher, msg)
     IPC_MESSAGE_HANDLER(DOMStorageMsg_Event, OnStorageEvent)
     IPC_MESSAGE_HANDLER(DOMStorageMsg_AsyncOperationComplete,
                         OnAsyncOperationComplete)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void DomStorageDispatcher::OnStorageEvent(
     const DOMStorageMsg_Event_Params& params) {
   RenderThreadImpl::current()->EnsureWebKitInitialized();
 
   bool originated_in_process = params.connection_id != 0;
   WebStorageAreaImpl* originating_area = NULL;
   if (originated_in_process) {
     originating_area = WebStorageAreaImpl::FromConnectionId(
         params.connection_id);
+    originating_area->cached_area()->set_global_storage_size(
+        params.storage_size);
   } else {
     DomStorageCachedArea* cached_area = proxy_->LookupCachedArea(
         params.namespace_id, params.origin);
-    if (cached_area)
+    if (cached_area) {
       cached_area->ApplyMutation(params.key, params.new_value);
+      cached_area->set_global_storage_size(params.storage_size);
+    }
   }
 
   if (params.namespace_id == dom_storage::kLocalStorageNamespaceId) {
     WebKit::WebStorageEventDispatcher::dispatchLocalStorageEvent(
         params.key,
         params.old_value,
         params.new_value,
         params.origin,
         params.page_url,
         originating_area,
@@ skipping 11 matching lines @@
         originating_area,
         originated_in_process);
   }
 }
 
 void DomStorageDispatcher::OnAsyncOperationComplete(bool success) {
   proxy_->CompleteOnePendingCallback(success);
 }
 
 }  // namespace content