Optimized webstorage performance

content/renderer/renderer_webstoragearea_impl.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/renderer_webstoragearea_impl.h"
 
 #include "base/lazy_instance.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/dom_storage_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebURL.h"
+#include "third_party/WebKit/Source/Platform/chromium/public/WebCommon.h"
 #include "webkit/dom_storage/dom_storage_types.h"
 
 using WebKit::WebString;
 using WebKit::WebURL;
 
 typedef IDMap<RendererWebStorageAreaImpl> AreaImplMap;
 
 static base::LazyInstance<AreaImplMap>::Leaky
     g_all_areas_map = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 44 matching lines @@
 
 WebString RendererWebStorageAreaImpl::key(unsigned index) {
   NullableString16 key;
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_Key(connection_id_, index, &key));
   return key;
 }
 
 WebString RendererWebStorageAreaImpl::getItem(const WebString& key) {
   NullableString16 value;
-  RenderThreadImpl::current()->Send(
-      new DOMStorageHostMsg_GetItem(connection_id_, key, &value));
+  unsigned value_len;
+  base::SharedMemoryHandle browser_handle = base::SharedMemory::NULLHandle();
+  dom_storage::IPC_Flag ipc_flag;
+  RenderThreadImpl::current()->Send(new DOMStorageHostMsg_GetItem(
+                                    connection_id_, key,
+                                    reinterpret_cast<int*>(&ipc_flag),
+                                    &browser_handle, &value_len, &value));
+  if (ipc_flag == dom_storage::SharedMemory) {
+    base::SharedMemory shared_buf(browser_handle, true);
+    shared_buf.Map(value_len*sizeof(char16));
+    string16 shm_str;
+    shared_buf.Lock();
+    shm_str.append(static_cast<char16*>(shared_buf.memory()), value_len);
+    shared_buf.Unlock();
+    shared_buf.Close();
+    value = NullableString16(shm_str, false);
+  }
   return value;
 }
 
 void RendererWebStorageAreaImpl::setItem(
     const WebString& key, const WebString& value, const WebURL& url,
     WebStorageArea::Result& result, WebString& old_value_webkit) {
-  if (key.length() + value.length() > dom_storage::kPerAreaQuota) {
+  size_t value_len = value.length()*sizeof(WebKit::WebUChar);
+  base::SharedMemory shared_buf;
+  base::SharedMemoryHandle shared_mem_handle;
+  if (key.length() + value_len > dom_storage::kPerAreaQuota) {
     result = ResultBlockedByQuota;
     return;
   }
   NullableString16 old_value;
-  RenderThreadImpl::current()->Send(new DOMStorageHostMsg_SetItem(
-      connection_id_, key, value, url, &result, &old_value));
+
+  if (value_len < dom_storage::kShmEnableThreshold) {
+    RenderThreadImpl::current()->Send(new DOMStorageHostMsg_SetItem(
+        connection_id_, key, value, url, &result, &old_value));
+    old_value_webkit = old_value;
+    return;
+  }
+  // Try Allocate a shared memory buffer to hold the bulk of data.
+  // if fail, go through channel
+  if (!shared_buf.CreateAndMapAnonymous(value_len)) {

[michaeln, 2012/05/10 18:42:59]

See ChildThread::AllocateSharedMemory. According to that, on posix, shared
memory buffers cannot be created from within a sandboxed renderer. Unless a
buffer is pre-allocated for us by the main process and we have a handle to that
pre-allocated buffer, this allocation would involve another sync ipc.

[Pan, 2012/05/14 06:50:30]

Thanks :)
Yes, renderer cannot create a shared memory buffers in seccompsandbox, however,
in default sandbox, it can work at least till now. Shall we make sure that pass
seccompsandbox?
As a workaround in POSIX, I just submit a change that ask shm from browser
process firstly, this sync ipc cost less compare with a bulk data sync ipc
through channel.

On 2012/05/10 18:42:59, michaeln wrote:

+    RenderThreadImpl::current()->Send(new DOMStorageHostMsg_SetItem(
+        connection_id_, key, value, url, &result, &old_value));
+    old_value_webkit = old_value;
+    return;
+  }
+
+  // Go through shm, Copy the bits into shared memory.
+  shared_buf.Lock();
+  memcpy(shared_buf.memory(), value.data(), value_len);
+  shared_buf.Unlock();
+  // give to process
+  shared_mem_handle = shared_buf.handle();
+  RenderThreadImpl::current()->Send(new DOMStorageHostMsg_SetItemOpt(
+      connection_id_, key, value.length(), shared_mem_handle, url,
+      &result, &old_value));
+  shared_buf.Close();
   old_value_webkit = old_value;
 }
 
 void RendererWebStorageAreaImpl::removeItem(
     const WebString& key, const WebURL& url, WebString& old_value_webkit) {
   NullableString16 old_value;
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_RemoveItem(connection_id_, key, url, &old_value));
   old_value_webkit = old_value;
 }
 
 void RendererWebStorageAreaImpl::clear(
     const WebURL& url, bool& cleared_something) {
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_Clear(connection_id_, url, &cleared_something));
 }