DOM Storage: Add renderer-process IPC code.

chrome/renderer/renderer_webstoragearea_impl.cc

+// Copyright (c) 2009 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 "chrome/renderer/renderer_webstoragearea_impl.h"
+
+#include "chrome/common/render_messages.h"
+#include "chrome/renderer/render_thread.h"
+#include "webkit/api/public/WebString.h"
+
+RendererWebStorageAreaImpl::RendererWebStorageAreaImpl(
+    int64 namespace_id,
+    const WebKit::WebString& origin)
+    : namespace_id_(namespace_id),
+      origin_(origin),
+      storage_area_id_(kUninitializedStorageAreaId),
+      lock_held_(false),
+      bytes_left_in_quota_(0) {
+}
+
+RendererWebStorageAreaImpl::~RendererWebStorageAreaImpl() {
+}
+
+void RendererWebStorageAreaImpl::lock(bool& invalidate_cache,
+                                      size_t& bytes_left_in_quota) {
+  EnsureInitializedAndLocked();
+}
+
+void RendererWebStorageAreaImpl::unlock() {
+  if (storage_area_id_ != kUninitializedStorageAreaId) {
+    RenderThread::current()->Send(
+        new ViewHostMsg_DOMStorageUnlock(storage_area_id_));
+  }
+  lock_held_ = false;
+}
+
+unsigned RendererWebStorageAreaImpl::length() {
+  EnsureInitializedAndLocked();
+  // Right now this is always sync.  We could cache it, but I can't think of
+  // too many use cases where you'd repeatedly look up length() and not be
+  // doing so many key() lookups that the length() calls are the problem.
+  unsigned length;
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageLength(storage_area_id_, &length));
+  return length;
+}
+
+WebKit::WebString RendererWebStorageAreaImpl::key(unsigned index,
+                                                  bool& key_exception) {
+  EnsureInitializedAndLocked();
+  // Right now this is always sync.  We may want to optimize this by fetching
+  // chunks of keys rather than single keys (and flushing the cache on every
+  // mutation of the storage area) since this will most often be used to fetch
+  // all the keys at once.
+  string16 key;
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageKey(storage_area_id_, index,
+                                    &key_exception, &key));
+  return key;
+}
+
+WebKit::WebString RendererWebStorageAreaImpl::getItem(
+    const WebKit::WebString& webkit_key) {
+  EnsureInitializedAndLocked();
+  string16 key = webkit_key;
+
+  // Return from our cache if possible.
+  CacheMap::const_iterator iterator = cached_items_.find(key);
+  if (iterator != cached_items_.end())
+    return iterator->second;
+  if (cached_invalid_items_.find(key) != cached_invalid_items_.end())
+    return WebKit::WebString();  // Return a "null" string.
+
+  // The item is not in the cache, so we must do a sync IPC.  Afterwards,
+  // add it to the cache.
+  string16 raw_value;
+  bool value_is_null;
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageGetItem(storage_area_id_, key,
+                                        &raw_value, &value_is_null));
+  WebKit::WebString value = value_is_null ? WebKit::WebString()
+                                          : WebKit::WebString(raw_value);
+  SetCache(key, value);
+  return value;
+}
+
+void RendererWebStorageAreaImpl::setItem(const WebKit::WebString& key,
+                                         const WebKit::WebString& value,
+                                         bool& quota_exception) {
+  EnsureInitializedAndLocked();
+  quota_exception = !UpdateQuota(key, value);
+  if (quota_exception)
+    return;
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageSetItem(storage_area_id_, key, value));
+  SetCache(key, value);
+}
+
+void RendererWebStorageAreaImpl::removeItem(const WebKit::WebString& key) {
+  EnsureInitializedAndLocked();
+  bool update_succeeded = UpdateQuota(key, WebKit::WebString());
+  DCHECK(update_succeeded);
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageRemoveItem(storage_area_id_, key));
+  SetCache(key, WebKit::WebString());
+}
+
+void RendererWebStorageAreaImpl::clear() {
+  EnsureInitializedAndLocked();
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageClear(storage_area_id_,
+                                      &bytes_left_in_quota_));
+  // A possible optimization is a flag that says our cache is 100% complete.
+  // This could be set here, and then future gets would never require IPC.
+  cached_items_.clear();
+  cached_invalid_items_.clear();
+}
+
+void RendererWebStorageAreaImpl::EnsureInitializedAndLocked() {
+  if (storage_area_id_ == kUninitializedStorageAreaId) {
+    RenderThread::current()->Send(
+        new ViewHostMsg_DOMStorageStorageAreaId(namespace_id_, origin_,
+                                                &storage_area_id_));
+  }
+
+  if (lock_held_)
+    return;
+
+  bool invalidate_cache;
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageLock(storage_area_id_, &invalidate_cache,
+                                     &bytes_left_in_quota_));
+  lock_held_ = true;
+  if (invalidate_cache) {
+    cached_items_.clear();
+    cached_invalid_items_.clear();
+  }
+}
+
+bool RendererWebStorageAreaImpl::UpdateQuota(const WebKit::WebString& key,
+                                             const WebKit::WebString& value) {
+  // TODO(jorlow): Remove once the bytes_left_in_quota values we're getting
+  //               are accurate.
+  return true;
+
+  size_t existing_bytes = getItem(key).length();
+  size_t new_bytes = value.length();
+
+  if (existing_bytes < new_bytes) {
+    size_t delta = new_bytes - existing_bytes;
+    if (delta > bytes_left_in_quota_)
+      return false;
+    bytes_left_in_quota_ -= delta;
+  } else {
+    size_t delta = existing_bytes - new_bytes;
+    DCHECK(delta + bytes_left_in_quota_ >= bytes_left_in_quota_);
+    bytes_left_in_quota_ += delta;
+  }
+  return true;
+}
+
+void RendererWebStorageAreaImpl::SetCache(const string16& key,
+                                          const WebKit::WebString& value) {
+  cached_items_.erase(key);
+  cached_invalid_items_.erase(key);
+
+  if (!value.isNull())
+    cached_items_[key] = value;
+  else
+    cached_invalid_items_.insert(key);
+}