Get rid of the half-working traces of locking, caching, and quotas. It

probably shoudln't have been added in to begin with.

BUG=none
TEST=none

Review URL: http://codereview.chromium.org/203015

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@25966 0039d316-1c4b-4281-b951-d872f2087c98

9 files changed, 16 insertions, 280 deletions

diff --git a/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc b/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc
index bd1ba65..49fdfda 100644
--- a/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc
+++ b/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc
@@ -65,18 +65,14 @@ bool DOMStorageDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                     OnNamespaceId)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageCloneNamespaceId,
                                     OnCloneNamespaceId)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageDerefNamespaceId,
-                        OnDerefNamespaceId)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageStorageAreaId,
                                     OnStorageAreaId)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageLock, OnLock)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageUnlock, OnUnlock)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageLength, OnLength)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageKey, OnKey)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageGetItem, OnGetItem)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageSetItem, OnSetItem)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageRemoveItem, OnRemoveItem)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageClear, OnClear)
+    IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageClear, OnClear)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   if (handled)
@@ -145,23 +141,6 @@ void DOMStorageDispatcherHost::OnCloneNamespaceId(int64 namespace_id,
   Send(reply_msg);
 }
 
-void DOMStorageDispatcherHost::OnDerefNamespaceId(int64 namespace_id) {
-  DCHECK(!shutdown_);
-  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
-    webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnDerefNamespaceId, namespace_id));
-    return;
-  }
-
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  StorageNamespace* storage_namespace =
-      Context()->GetStorageNamespace(namespace_id);
-  CHECK(storage_namespace);  // TODO(jorlow): Do better than this.
-  // TODO(jorlow): Track resources here so we can free them (even beyond just
-  //               when the renderer process dies).
-}
-
 void DOMStorageDispatcherHost::OnStorageAreaId(int64 namespace_id,
                                                const string16& origin,
                                                IPC::Message* reply_msg) {
@@ -184,41 +163,6 @@ void DOMStorageDispatcherHost::OnStorageAreaId(int64 namespace_id,
   Send(reply_msg);
 }
 
-void DOMStorageDispatcherHost::OnLock(int64 storage_area_id,
-                                      IPC::Message* reply_msg) {
-  DCHECK(!shutdown_);
-  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
-    webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnLock, storage_area_id, reply_msg));
-    return;
-  }
-
-  StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
-  CHECK(storage_area);  // TODO(jorlow): Do better than this.
-  // TODO(jorlow): Implement locking, quotas, etc...
-  bool invalidate_cache = true;
-  size_t bytes_left_in_quota = 9999999;
-  ViewHostMsg_DOMStorageLock::WriteReplyParams(reply_msg, invalidate_cache,
-                                               bytes_left_in_quota);
-  Send(reply_msg);
-}
-
-void DOMStorageDispatcherHost::OnUnlock(int64 storage_area_id) {
-  DCHECK(!shutdown_);
-  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
-    webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnUnlock, storage_area_id));
-    return;
-  }
-
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
-  CHECK(storage_area);  // TODO(jorlow): Do better than this.
-  // TODO(jorlow): Do something.
-}
-
 void DOMStorageDispatcherHost::OnLength(int64 storage_area_id,
                                         IPC::Message* reply_msg) {
   DCHECK(!shutdown_);
@@ -310,23 +254,17 @@ void DOMStorageDispatcherHost::OnRemoveItem(int64 storage_area_id,
   storage_area->RemoveItem(key);
 }
 
-void DOMStorageDispatcherHost::OnClear(int64 storage_area_id,
-                                       IPC::Message* reply_msg) {
+void DOMStorageDispatcherHost::OnClear(int64 storage_area_id) {
   DCHECK(!shutdown_);
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     MessageLoop* webkit_loop = webkit_thread_->GetMessageLoop();
     webkit_loop->PostTask(FROM_HERE, NewRunnableMethod(this,
-        &DOMStorageDispatcherHost::OnClear, storage_area_id, reply_msg));
+        &DOMStorageDispatcherHost::OnClear, storage_area_id));
     return;
   }
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  // TODO(jorlow): Return the total quota for this domain.
-  size_t bytes_left_in_quota = 9999999;
   StorageArea* storage_area = Context()->GetStorageArea(storage_area_id);
   CHECK(storage_area);  // TODO(jorlow): Do better than this.
   storage_area->Clear();
-  ViewHostMsg_DOMStorageClear::WriteReplyParams(reply_msg,
-                                                bytes_left_in_quota);
-  Send(reply_msg);
 }
diff --git a/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h b/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h
index 72b061f..8f5c94d 100644
--- a/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h
+++ b/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h
@@ -39,11 +39,8 @@ class DOMStorageDispatcherHost :
   // Message Handlers.
   void OnNamespaceId(bool is_local_storage, IPC::Message* reply_msg);
   void OnCloneNamespaceId(int64 namespace_id, IPC::Message* reply_msg);
-  void OnDerefNamespaceId(int64 namespace_id);
   void OnStorageAreaId(int64 namespace_id, const string16& origin,
                        IPC::Message* reply_msg);
-  void OnLock(int64 storage_area_id, IPC::Message* reply_msg);
-  void OnUnlock(int64 storage_area_id);
   void OnLength(int64 storage_area_id, IPC::Message* reply_msg);
   void OnKey(int64 storage_area_id, unsigned index, IPC::Message* reply_msg);
   void OnGetItem(int64 storage_area_id, const string16& key,
@@ -51,7 +48,7 @@ class DOMStorageDispatcherHost :
   void OnSetItem(int64 storage_area_id, const string16& key,
                  const string16& value);
   void OnRemoveItem(int64 storage_area_id, const string16& key);
-  void OnClear(int64 storage_area_id, IPC::Message* reply_msg);
+  void OnClear(int64 storage_area_id);
 
   // A shortcut for accessing our context.
   DOMStorageContext* Context() {
diff --git a/chrome/common/render_messages_internal.h b/chrome/common/render_messages_internal.h
index 7b6ee02..350bb83 100644
--- a/chrome/common/render_messages_internal.h
+++ b/chrome/common/render_messages_internal.h
@@ -1620,29 +1620,12 @@ IPC_BEGIN_MESSAGES(ViewHost)
                               int64 /* namespace_id to clone */,
                               int64 /* new_namespace_id */)
 
-  // Explicitly drop a reference to a namespace.  This is done implicitly
-  // for all namespaces owned by a renderer process when it dies.
-  IPC_MESSAGE_CONTROL1(ViewHostMsg_DOMStorageDerefNamespaceId,
-                       int64 /* namespace_id */)
-
   // Get the storage area id for a particular origin within a namespace.
   IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DOMStorageStorageAreaId,
                               int64 /* namespace_id */,
                               string16 /* origin */,
                               int64 /* storage_area_id */)
 
-  // Lock a particular origin (per the DOM Storage spec).
-  IPC_SYNC_MESSAGE_CONTROL1_2(ViewHostMsg_DOMStorageLock,
-                              int64 /* storage_area_id */,
-                              bool /* invalidate_cache */,
-                              size_t /* bytes_left_in_quota */)
-
-  // Release the lock on a particular storage area.  This should happen
-  // whenever we exit a script region, do something synchronous, or
-  // explicitly drop the lock via navigator.releaseLock().
-  IPC_MESSAGE_CONTROL1(ViewHostMsg_DOMStorageUnlock,
-                       int64 /* storage_area_id */)
-
   // Get the length of a storage area.
   IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DOMStorageLength,
                               int64 /* storage_area_id */,
@@ -1672,9 +1655,8 @@ IPC_BEGIN_MESSAGES(ViewHost)
                        string16 /* key */)
 
   // Clear the storage area.
-  IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DOMStorageClear,
-                              int64 /* storage_area_id */,
-                              size_t /* bytes_left_in_quota */)
+  IPC_MESSAGE_CONTROL1(ViewHostMsg_DOMStorageClear,
+                       int64 /* storage_area_id */)
 
   // Get file size in bytes. Set result to -1 if failed to get the file size.
   IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_GetFileSize,
diff --git a/chrome/renderer/renderer_webstoragearea_impl.cc b/chrome/renderer/renderer_webstoragearea_impl.cc
index 825d967..b03396d 100644
--- a/chrome/renderer/renderer_webstoragearea_impl.cc
+++ b/chrome/renderer/renderer_webstoragearea_impl.cc
@@ -6,41 +6,20 @@
 
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/render_thread.h"
-#include "webkit/api/public/WebString.h"
 
 using WebKit::WebString;
 
 RendererWebStorageAreaImpl::RendererWebStorageAreaImpl(
-    int64 namespace_id,
-    const WebString& origin)
-    : namespace_id_(namespace_id),
-      origin_(origin),
-      storage_area_id_(kUninitializedStorageAreaId),
-      lock_held_(false),
-      bytes_left_in_quota_(0) {
+    int64 namespace_id, const WebString& origin) {
+  RenderThread::current()->Send(
+      new ViewHostMsg_DOMStorageStorageAreaId(namespace_id, origin,
+                                              &storage_area_id_));
 }
 
 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));
@@ -48,120 +27,32 @@ unsigned RendererWebStorageAreaImpl::length() {
 }
 
 WebString RendererWebStorageAreaImpl::key(unsigned index) {
-  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.
   NullableString16 key;
   RenderThread::current()->Send(
       new ViewHostMsg_DOMStorageKey(storage_area_id_, index, &key));
   return key;
 }
 
-WebString RendererWebStorageAreaImpl::getItem(const 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 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.
-  NullableString16 raw_value;
+WebString RendererWebStorageAreaImpl::getItem(const WebString& key) {
+  NullableString16 value;
   RenderThread::current()->Send(
-      new ViewHostMsg_DOMStorageGetItem(storage_area_id_, key, &raw_value));
-  WebString value = raw_value;  // Only do the conversion once.
-  SetCache(key, value);
+      new ViewHostMsg_DOMStorageGetItem(storage_area_id_, key, &value));
   return value;
 }
 
 void RendererWebStorageAreaImpl::setItem(const WebString& key,
                                          const 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 WebString& key) {
-  EnsureInitializedAndLocked();
-  bool update_succeeded = UpdateQuota(key, WebString());
-  DCHECK(update_succeeded);
   RenderThread::current()->Send(
       new ViewHostMsg_DOMStorageRemoveItem(storage_area_id_, key));
-  SetCache(key, 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 WebString& key,
-                                             const 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 WebString& value) {
-  cached_items_.erase(key);
-  cached_invalid_items_.erase(key);
-
-  if (!value.isNull())
-    cached_items_[key] = value;
-  else
-    cached_invalid_items_.insert(key);
+      new ViewHostMsg_DOMStorageClear(storage_area_id_));
 }
diff --git a/chrome/renderer/renderer_webstoragearea_impl.h b/chrome/renderer/renderer_webstoragearea_impl.h
index 0b734e8..57e13fc 100644
--- a/chrome/renderer/renderer_webstoragearea_impl.h
+++ b/chrome/renderer/renderer_webstoragearea_impl.h
@@ -6,7 +6,6 @@
 #define CHROME_RENDERER_RENDERER_WEBSTORAGEAREA_IMPL_H_
 
 #include "base/basictypes.h"
-#include "base/hash_tables.h"
 #include "base/string16.h"
 #include "webkit/api/public/WebStorageArea.h"
 #include "webkit/api/public/WebString.h"
@@ -18,8 +17,6 @@ class RendererWebStorageAreaImpl : public WebKit::WebStorageArea {
   virtual ~RendererWebStorageAreaImpl();
 
   // See WebStorageArea.h for documentation on these functions.
-  virtual void lock(bool& invalidate_cache, size_t& bytes_left_in_quota);
-  virtual void unlock();
   virtual unsigned length();
   virtual WebKit::WebString key(unsigned index);
   virtual WebKit::WebString getItem(const WebKit::WebString& key);
@@ -30,47 +27,8 @@ class RendererWebStorageAreaImpl : public WebKit::WebStorageArea {
   virtual void clear();
 
  private:
-  // Calls lock if we haven't already done so, and also gets a storage_area_id
-  // if we haven't done so.  Fetches quota and cache invalidation information
-  // while locking.  Only call on the WebKit thread.
-  void EnsureInitializedAndLocked();
-
-  // Update our quota calculation.  Returns true if we updated the quota.
-  // Returns false if we couldn't update because we would have exceeded the
-  // quota.  If an item is not in our cache, it'll require a getItem IPC in
-  // order to determine the existing value's size.
-  bool UpdateQuota(const WebKit::WebString& key,
-                   const WebKit::WebString& value);
-
-  // Set a key/value pair in our cache.
-  void SetCache(const string16& key, const WebKit::WebString& value);
-
-  // Used for initialization or storage_area_id_.
-  int64 namespace_id_;
-  string16 origin_;
-
-  // The ID we use for all IPC.  Initialized lazily.
+  // The ID we use for all IPC.
   int64 storage_area_id_;
-
-  // storage_area_id_ should equal this iff its unitialized.
-  static const int64 kUninitializedStorageAreaId = -1;
-
-  // Do we currently hold the lock on this storage area?
-  bool lock_held_;
-
-  // We track how many bytes are left in the quota between lock and unlock
-  // calls.  This allows us to avoid sync IPC on setItem.
-  size_t bytes_left_in_quota_;
-
-  // A cache of key/value pairs.  If the item exists, it's put in the
-  // cached_items_ map.  If not, it's added to the cached_invalid_items_ set.
-  // The lock IPC call tells us when to invalidate these caches.
-  // TODO(jorlow): Instead of a map + a set, use NullableString16 once it's
-  //               implemented: http://crbug.com/17343
-  typedef base::hash_map<string16, string16> CacheMap;
-  typedef base::hash_set<string16> CacheSet;
-  CacheMap cached_items_;
-  CacheSet cached_invalid_items_;
 };
 
 #endif  // CHROME_RENDERER_WEBSTORAGEAREA_IMPL_H_
diff --git a/chrome/renderer/renderer_webstoragenamespace_impl.cc b/chrome/renderer/renderer_webstoragenamespace_impl.cc
index 453bbcf..0457207 100644
--- a/chrome/renderer/renderer_webstoragenamespace_impl.cc
+++ b/chrome/renderer/renderer_webstoragenamespace_impl.cc
@@ -22,9 +22,6 @@ RendererWebStorageNamespaceImpl::RendererWebStorageNamespaceImpl(
 }
 
 RendererWebStorageNamespaceImpl::~RendererWebStorageNamespaceImpl() {
-  if (namespace_id_ != kUninitializedNamespaceId)
-    RenderThread::current()->Send(
-        new ViewHostMsg_DOMStorageDerefNamespaceId(namespace_id_));
 }
 
 WebKit::WebStorageArea* RendererWebStorageNamespaceImpl::createStorageArea(
diff --git a/webkit/api/public/WebStorageArea.h b/webkit/api/public/WebStorageArea.h
index 664b418..b67aea6 100644
--- a/webkit/api/public/WebStorageArea.h
+++ b/webkit/api/public/WebStorageArea.h
@@ -37,24 +37,12 @@ namespace WebKit {
     class WebString;
 
     // In WebCore, there's one distinct StorageArea per origin per StorageNamespace. This
-    // class wraps a StorageArea. With the possible exception of lock/unlock all of these
-    // methods map very obviously to the WebStorage (often called DOM Storage) spec.
+    // class wraps a StorageArea.  All the methods have obvious connections to the spec:
     // http://dev.w3.org/html5/webstorage/
     class WebStorageArea {
     public:
         virtual ~WebStorageArea() { }
 
-        // Lock the storage area. Before calling any other other methods on this interface,
-        // you should always call lock and wait for it to return. InvalidateCache tells you
-        // that since the last time you locked the cache, someone else has modified it.
-        // BytesLeftInQuota tells you how many bytes are currently unused in the quota.
-        // These are both optimizations and can be ignored if you'd like.
-        virtual void lock(bool& invalidateCache, size_t& bytesLeftInQuota) = 0;
-
-        // Unlock the storage area. You should call this at the end of the JavaScript context
-        // or when you're about to execute anything synchronous per the DOM Storage spec.
-        virtual void unlock() = 0;
-
         // The number of key/value pairs in the storage area.
         virtual unsigned length() = 0;
 
diff --git a/webkit/api/src/WebStorageAreaImpl.cpp b/webkit/api/src/WebStorageAreaImpl.cpp
index 13f79d2..c835424 100644
--- a/webkit/api/src/WebStorageAreaImpl.cpp
+++ b/webkit/api/src/WebStorageAreaImpl.cpp
@@ -47,19 +47,6 @@ WebStorageAreaImpl::~WebStorageAreaImpl()
 {
 }
 
-void WebStorageAreaImpl::lock(bool& invalidateCache, size_t& bytesLeftInQuota)
-{
-    // FIXME: Enable locking.  http://crbug.com/16877
-    invalidateCache = false;
-    // FIXME: Enable quota support.  http://crbug.com/16876
-    bytesLeftInQuota = 0;
-}
-
-void WebStorageAreaImpl::unlock()
-{
-    // FIXME: Enable locking.  http://crbug.com/16877
-}
-
 unsigned WebStorageAreaImpl::length()
 {
     return m_storageArea->length();
diff --git a/webkit/api/src/WebStorageAreaImpl.h b/webkit/api/src/WebStorageAreaImpl.h
index 648ee3e..5c57ae2 100644
--- a/webkit/api/src/WebStorageAreaImpl.h
+++ b/webkit/api/src/WebStorageAreaImpl.h
@@ -42,8 +42,6 @@ namespace WebKit {
     public:
         WebStorageAreaImpl(PassRefPtr<WebCore::StorageArea> storageArea);
         virtual ~WebStorageAreaImpl();
-        virtual void lock(bool& invalidateCache, size_t& bytesLeftInQuota);
-        virtual void unlock();
         virtual unsigned length();
         virtual WebString key(unsigned index);
         virtual WebString getItem(const WebString& key);