The final step in making session storage cross-process. Remove dead code and do a bit of refactoring. Use the recently added session_storage_namespace_id_.

Next steps: a bit more testing then I think we're ready to take it out from behind its flag!

TEST=none
BUG=none

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

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

14 files changed, 133 insertions, 187 deletions

diff --git a/chrome/browser/in_process_webkit/browser_webkitclient_impl.cc b/chrome/browser/in_process_webkit/browser_webkitclient_impl.cc
index 4daf282..e0af7ee 100644
--- a/chrome/browser/in_process_webkit/browser_webkitclient_impl.cc
+++ b/chrome/browser/in_process_webkit/browser_webkitclient_impl.cc
@@ -105,15 +105,6 @@ BrowserWebKitClientImpl::createLocalStorageNamespace(
   return 0;
 }
 
-WebKit::WebStorageNamespace*
-BrowserWebKitClientImpl::createSessionStorageNamespace() {
-  // The "WebStorage" interface is used for renderer WebKit -> browser WebKit
-  // communication only.  "WebStorageClient" will be used for browser WebKit ->
-  // renderer WebKit.  So this will never be implemented.
-  NOTREACHED();
-  return 0;
-}
-
 void BrowserWebKitClientImpl::dispatchStorageEvent(
     const WebKit::WebString& key, const WebKit::WebString& old_value,
     const WebKit::WebString& new_value, const WebKit::WebString& origin,
diff --git a/chrome/browser/in_process_webkit/browser_webkitclient_impl.h b/chrome/browser/in_process_webkit/browser_webkitclient_impl.h
index 0879cc8..831296f 100644
--- a/chrome/browser/in_process_webkit/browser_webkitclient_impl.h
+++ b/chrome/browser/in_process_webkit/browser_webkitclient_impl.h
@@ -33,7 +33,6 @@ class BrowserWebKitClientImpl : public webkit_glue::WebKitClientImpl {
   virtual WebKit::WebData loadResource(const char* name);
   virtual WebKit::WebStorageNamespace* createLocalStorageNamespace(
       const WebKit::WebString& path, unsigned quota);
-  virtual WebKit::WebStorageNamespace* createSessionStorageNamespace();
   virtual void dispatchStorageEvent(const WebKit::WebString& key,
       const WebKit::WebString& oldValue, const WebKit::WebString& newValue,
       const WebKit::WebString& origin, const WebKit::WebURL& url,
diff --git a/chrome/browser/in_process_webkit/dom_storage_context.cc b/chrome/browser/in_process_webkit/dom_storage_context.cc
index 15099c2..3997c5f 100644
--- a/chrome/browser/in_process_webkit/dom_storage_context.cc
+++ b/chrome/browser/in_process_webkit/dom_storage_context.cc
@@ -36,37 +36,10 @@ DOMStorageContext::~DOMStorageContext() {
   // away.  And they remove themselves from this list.
   DCHECK(dispatcher_host_set_.empty());
 
-  // If we don't have any work to do on the WebKit thread, bail.
-  if (storage_namespace_map_.empty())
-    return;
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-
-  // The storage namespace destructor unregisters the storage namespace, so
-  // our iterator becomes invalid.  Thus we just keep deleting the first item
-  // until there are none left.
-  while (!storage_namespace_map_.empty())
-    delete storage_namespace_map_.begin()->second;
-}
-
-DOMStorageNamespace* DOMStorageContext::LocalStorage() {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  DOMStorageNamespace* storage_namespace = GetStorageNamespace(
-      kLocalStorageNamespaceId);
-  if (storage_namespace)
-    return storage_namespace;
-
-  FilePath data_path = webkit_context_->data_path();
-  FilePath dir_path;
-  if (!data_path.empty()) {
-    MigrateLocalStorageDirectory(data_path);
-    dir_path = data_path.AppendASCII(kLocalStorageDirectory);
+  for (StorageNamespaceMap::iterator iter(storage_namespace_map_.begin());
+       iter != storage_namespace_map_.end(); ++iter) {
+    delete iter->second;
   }
-  return DOMStorageNamespace::CreateLocalStorageNamespace(this, dir_path);
-}
-
-DOMStorageNamespace* DOMStorageContext::NewSessionStorage() {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  return DOMStorageNamespace::CreateSessionStorageNamespace(this);
 }
 
 int64 DOMStorageContext::AllocateStorageAreaId() {
@@ -112,28 +85,28 @@ DOMStorageArea* DOMStorageContext::GetStorageArea(int64 id) {
   return iter->second;
 }
 
-void DOMStorageContext::RegisterStorageNamespace(
-    DOMStorageNamespace* storage_namespace) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  int64 id = storage_namespace->id();
-  DCHECK(!GetStorageNamespace(id));
-  storage_namespace_map_[id] = storage_namespace;
-}
-
-void DOMStorageContext::UnregisterStorageNamespace(
-    DOMStorageNamespace* storage_namespace) {
+void DOMStorageContext::DeleteSessionStorageNamespace(int64 namespace_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  int64 id = storage_namespace->id();
-  DCHECK(GetStorageNamespace(id));
-  storage_namespace_map_.erase(id);
+  StorageNamespaceMap::iterator iter =
+      storage_namespace_map_.find(namespace_id);
+  if (iter == storage_namespace_map_.end())
+    return;
+  DCHECK(iter->second->dom_storage_type() == DOM_STORAGE_SESSION);
+  delete iter->second;
+  storage_namespace_map_.erase(iter);
 }
 
-DOMStorageNamespace* DOMStorageContext::GetStorageNamespace(int64 id) {
+DOMStorageNamespace* DOMStorageContext::GetStorageNamespace(
+    int64 id, bool allocation_allowed) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   StorageNamespaceMap::iterator iter = storage_namespace_map_.find(id);
-  if (iter == storage_namespace_map_.end())
+  if (iter != storage_namespace_map_.end())
+    return iter->second;
+  if (!allocation_allowed)
     return NULL;
-  return iter->second;
+  if (id == kLocalStorageNamespaceId)
+    return CreateLocalStorage();
+  return CreateSessionStorage(id);
 }
 
 void DOMStorageContext::RegisterDispatcherHost(
@@ -164,7 +137,7 @@ void DOMStorageContext::PurgeMemory() {
   // SessionStorage namespace, its data will be gone forever, because it isn't
   // currently backed by disk.
   DOMStorageNamespace* local_storage =
-      GetStorageNamespace(kLocalStorageNamespaceId);
+      GetStorageNamespace(kLocalStorageNamespaceId, false);
   if (local_storage)
     local_storage->PurgeMemory();
 }
@@ -186,12 +159,42 @@ void DOMStorageContext::DeleteDataModifiedSince(const base::Time& cutoff) {
   }
 }
 
+DOMStorageNamespace* DOMStorageContext::CreateLocalStorage() {
+  FilePath data_path = webkit_context_->data_path();
+  FilePath dir_path;
+  if (!data_path.empty()) {
+    MigrateLocalStorageDirectory(data_path);
+    dir_path = data_path.AppendASCII(kLocalStorageDirectory);
+  }
+  DOMStorageNamespace* new_namespace =
+      DOMStorageNamespace::CreateLocalStorageNamespace(this, dir_path);
+  RegisterStorageNamespace(new_namespace);
+  return new_namespace;
+}
+
+DOMStorageNamespace* DOMStorageContext::CreateSessionStorage(
+    int64 namespace_id) {
+  DOMStorageNamespace* new_namespace =
+      DOMStorageNamespace::CreateSessionStorageNamespace(this, namespace_id);
+  RegisterStorageNamespace(new_namespace);
+  return new_namespace;
+}
+
+void DOMStorageContext::RegisterStorageNamespace(
+    DOMStorageNamespace* storage_namespace) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
+  int64 id = storage_namespace->id();
+  DCHECK(!GetStorageNamespace(id, false));
+  storage_namespace_map_[id] = storage_namespace;
+}
+
+/* static */
 void DOMStorageContext::CompleteCloningSessionStorage(
     DOMStorageContext* context, int64 existing_id, int64 clone_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   DOMStorageNamespace* existing_namespace =
-      context->GetStorageNamespace(existing_id);
+      context->GetStorageNamespace(existing_id, false);
   // If nothing exists, then there's nothing to clone.
   if (existing_namespace)
-    existing_namespace->Copy(clone_id);
+    context->RegisterStorageNamespace(existing_namespace->Copy(clone_id));
 }
diff --git a/chrome/browser/in_process_webkit/dom_storage_context.h b/chrome/browser/in_process_webkit/dom_storage_context.h
index df472f3..fb68f4c9 100644
--- a/chrome/browser/in_process_webkit/dom_storage_context.h
+++ b/chrome/browser/in_process_webkit/dom_storage_context.h
@@ -28,12 +28,6 @@ class DOMStorageContext {
   explicit DOMStorageContext(WebKitContext* webkit_context);
   virtual ~DOMStorageContext();
 
-  // Get the local storage instance.  The pointer is owned by this class.
-  DOMStorageNamespace* LocalStorage();
-
-  // Get a new session storage namespace (but it's still owned by this class).
-  DOMStorageNamespace* NewSessionStorage();
-
   // Allocate a new storage area id.  Only call on the WebKit thread.
   int64 AllocateStorageAreaId();
 
@@ -50,12 +44,13 @@ class DOMStorageContext {
   void UnregisterStorageArea(DOMStorageArea* storage_area);
   DOMStorageArea* GetStorageArea(int64 id);
 
-  // Get a namespace from an id.  What's returned is owned by this class.  The
-  // caller of GetStorageNamespace must immediately register itself with the
-  // returned StorageNamespace.
-  void RegisterStorageNamespace(DOMStorageNamespace* storage_namespace);
-  void UnregisterStorageNamespace(DOMStorageNamespace* storage_namespace);
-  DOMStorageNamespace* GetStorageNamespace(int64 id);
+  // Called on WebKit thread when a session storage namespace can be deleted.
+  void DeleteSessionStorageNamespace(int64 namespace_id);
+
+  // Get a namespace from an id.  What's returned is owned by this class.  If
+  // allocation_allowed is true, then this function will create the storage
+  // namespace if it hasn't been already.
+  DOMStorageNamespace* GetStorageNamespace(int64 id, bool allocation_allowed);
 
   // Sometimes an event from one DOM storage dispatcher host requires
   // communication to all of them.
@@ -72,6 +67,15 @@ class DOMStorageContext {
   void DeleteDataModifiedSince(const base::Time& cutoff);
 
  private:
+  // Get the local storage instance.  The object is owned by this class.
+  DOMStorageNamespace* CreateLocalStorage();
+
+  // Get a new session storage namespace.  The object is owned by this class.
+  DOMStorageNamespace* CreateSessionStorage(int64 namespace_id);
+
+  // Used internally to register storage namespaces we create.
+  void RegisterStorageNamespace(DOMStorageNamespace* storage_namespace);
+
   // The WebKit thread half of CloneSessionStorage above.  Static because
   // DOMStorageContext isn't ref counted thus we can't use a runnable method.
   // That said, we know this is safe because this class is destroyed on the
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 dc8e3f3..31ed956 100644
--- a/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc
+++ b/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.cc
@@ -112,10 +112,6 @@ bool DOMStorageDispatcherHost::OnMessageReceived(const IPC::Message& message,
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(DOMStorageDispatcherHost, message, *msg_is_ok)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageNamespaceId,
-                                    OnNamespaceId)
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageCloneNamespaceId,
-                                    OnCloneNamespaceId)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageStorageAreaId,
                                     OnStorageAreaId)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageLength, OnLength)
@@ -151,50 +147,6 @@ void DOMStorageDispatcherHost::Send(IPC::Message* message) {
       NewRunnableMethod(this, &DOMStorageDispatcherHost::Send, message));
 }
 
-void DOMStorageDispatcherHost::OnNamespaceId(DOMStorageType storage_type,
-                                             IPC::Message* reply_msg) {
-  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
-        this, &DOMStorageDispatcherHost::OnNamespaceId, storage_type,
-        reply_msg));
-    return;
-  }
-
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  DOMStorageNamespace* new_namespace;
-  if (storage_type == DOM_STORAGE_LOCAL)
-    new_namespace = Context()->LocalStorage();
-  else
-    new_namespace = Context()->NewSessionStorage();
-  ViewHostMsg_DOMStorageNamespaceId::WriteReplyParams(reply_msg,
-                                                      new_namespace->id());
-  Send(reply_msg);
-}
-
-void DOMStorageDispatcherHost::OnCloneNamespaceId(int64 namespace_id,
-                                                  IPC::Message* reply_msg) {
-  if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
-    ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
-        this, &DOMStorageDispatcherHost::OnCloneNamespaceId, namespace_id,
-        reply_msg));
-    return;
-  }
-
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
-  DOMStorageNamespace* existing_namespace =
-      Context()->GetStorageNamespace(namespace_id);
-  if (!existing_namespace) {
-    BrowserRenderProcessHost::BadMessageTerminateProcess(
-        ViewHostMsg_DOMStorageCloneNamespaceId::ID, process_handle_);
-    delete reply_msg;
-    return;
-  }
-  DOMStorageNamespace* new_namespace = existing_namespace->Copy();
-  ViewHostMsg_DOMStorageCloneNamespaceId::WriteReplyParams(reply_msg,
-                                                           new_namespace->id());
-  Send(reply_msg);
-}
-
 void DOMStorageDispatcherHost::OnStorageAreaId(int64 namespace_id,
                                                const string16& origin,
                                                IPC::Message* reply_msg) {
@@ -207,7 +159,7 @@ void DOMStorageDispatcherHost::OnStorageAreaId(int64 namespace_id,
 
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   DOMStorageNamespace* storage_namespace =
-      Context()->GetStorageNamespace(namespace_id);
+      Context()->GetStorageNamespace(namespace_id, true);
   if (!storage_namespace) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(
         ViewHostMsg_DOMStorageStorageAreaId::ID, process_handle_);
@@ -215,8 +167,8 @@ void DOMStorageDispatcherHost::OnStorageAreaId(int64 namespace_id,
     return;
   }
   DOMStorageArea* storage_area = storage_namespace->GetStorageArea(origin);
-  ViewHostMsg_DOMStorageCloneNamespaceId::WriteReplyParams(reply_msg,
-                                                           storage_area->id());
+  ViewHostMsg_DOMStorageStorageAreaId::WriteReplyParams(reply_msg,
+                                                        storage_area->id());
   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 24aa739..55a87b5 100644
--- a/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h
+++ b/chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h
@@ -57,8 +57,6 @@ class DOMStorageDispatcherHost
   ~DOMStorageDispatcherHost();
 
   // Message Handlers.
-  void OnNamespaceId(DOMStorageType storage_type, IPC::Message* reply_msg);
-  void OnCloneNamespaceId(int64 namespace_id, IPC::Message* reply_msg);
   void OnStorageAreaId(int64 namespace_id, const string16& origin,
                        IPC::Message* reply_msg);
   void OnLength(int64 storage_area_id, IPC::Message* reply_msg);
diff --git a/chrome/browser/in_process_webkit/dom_storage_namespace.cc b/chrome/browser/in_process_webkit/dom_storage_namespace.cc
index 924d954..2750a9f 100644
--- a/chrome/browser/in_process_webkit/dom_storage_namespace.cc
+++ b/chrome/browser/in_process_webkit/dom_storage_namespace.cc
@@ -20,16 +20,15 @@ using WebKit::WebString;
 DOMStorageNamespace* DOMStorageNamespace::CreateLocalStorageNamespace(
     DOMStorageContext* dom_storage_context, const FilePath& data_dir_path) {
   int64 id = kLocalStorageNamespaceId;
-  DCHECK(!dom_storage_context->GetStorageNamespace(id));
+  DCHECK(!dom_storage_context->GetStorageNamespace(id, false));
   return new DOMStorageNamespace(dom_storage_context, id,
       webkit_glue::FilePathToWebString(data_dir_path), DOM_STORAGE_LOCAL);
 }
 
 /* static */
 DOMStorageNamespace* DOMStorageNamespace::CreateSessionStorageNamespace(
-    DOMStorageContext* dom_storage_context) {
-  int64 id = dom_storage_context->AllocateSessionStorageNamespaceId();
-  DCHECK(!dom_storage_context->GetStorageNamespace(id));
+    DOMStorageContext* dom_storage_context, int64 id) {
+  DCHECK(!dom_storage_context->GetStorageNamespace(id, false));
   return new DOMStorageNamespace(dom_storage_context, id, WebString(),
                                  DOM_STORAGE_SESSION);
 }
@@ -43,12 +42,11 @@ DOMStorageNamespace::DOMStorageNamespace(DOMStorageContext* dom_storage_context,
       data_dir_path_(data_dir_path),
       dom_storage_type_(dom_storage_type) {
   DCHECK(dom_storage_context_);
-  dom_storage_context_->RegisterStorageNamespace(this);
 }
 
 DOMStorageNamespace::~DOMStorageNamespace() {
-  dom_storage_context_->UnregisterStorageNamespace(this);
-
+  // TODO(jorlow): If the DOMStorageContext is being destructed, there's no need
+  //               to do these calls.  Maybe we should add a fast path?
   for (OriginToStorageAreaMap::iterator iter(origin_to_storage_area_.begin());
        iter != origin_to_storage_area_.end(); ++iter) {
     dom_storage_context_->UnregisterStorageArea(iter->second);
@@ -71,23 +69,19 @@ DOMStorageArea* DOMStorageNamespace::GetStorageArea(const string16& origin) {
   return storage_area;
 }
 
-// TODO(jorlow): Remove in the next patch.
-DOMStorageNamespace* DOMStorageNamespace::Copy() {
-  int64 id = dom_storage_context_->AllocateSessionStorageNamespaceId();
-  return Copy(id);
-}
-
 DOMStorageNamespace* DOMStorageNamespace::Copy(int64 id) {
   DCHECK(dom_storage_type_ == DOM_STORAGE_SESSION);
-  DCHECK(!dom_storage_context_->GetStorageNamespace(id));
+  DCHECK(!dom_storage_context_->GetStorageNamespace(id, false));
   DOMStorageNamespace* new_storage_namespace = new DOMStorageNamespace(
       dom_storage_context_, id, data_dir_path_, dom_storage_type_);
-  CreateWebStorageNamespaceIfNecessary();
-  new_storage_namespace->storage_namespace_.reset(storage_namespace_->copy());
+  // If we haven't used the namespace yet, there's nothing to copy.
+  if (storage_namespace_.get())
+    new_storage_namespace->storage_namespace_.reset(storage_namespace_->copy());
   return new_storage_namespace;
 }
 
 void DOMStorageNamespace::PurgeMemory() {
+  DCHECK(dom_storage_type_ == DOM_STORAGE_LOCAL);
   for (OriginToStorageAreaMap::iterator iter(origin_to_storage_area_.begin());
        iter != origin_to_storage_area_.end(); ++iter)
     iter->second->PurgeMemory();
diff --git a/chrome/browser/in_process_webkit/dom_storage_namespace.h b/chrome/browser/in_process_webkit/dom_storage_namespace.h
index c317c67..189d696 100644
--- a/chrome/browser/in_process_webkit/dom_storage_namespace.h
+++ b/chrome/browser/in_process_webkit/dom_storage_namespace.h
@@ -26,13 +26,13 @@ class DOMStorageNamespace {
   static DOMStorageNamespace* CreateLocalStorageNamespace(
       DOMStorageContext* dom_storage_context, const FilePath& data_dir_path);
   static DOMStorageNamespace* CreateSessionStorageNamespace(
-      DOMStorageContext* dom_storage_context);
+      DOMStorageContext* dom_storage_context, int64 namespace_id);
 
   ~DOMStorageNamespace();
 
   DOMStorageArea* GetStorageArea(const string16& origin);
-  DOMStorageNamespace* Copy();  // TODO(jorlow): Delete in next patch.
-  DOMStorageNamespace* Copy(int64 id);
+  DOMStorageNamespace* Copy(int64 clone_namespace_id);
+
   void PurgeMemory();
 
   const DOMStorageContext* dom_storage_context() const {
diff --git a/chrome/browser/in_process_webkit/webkit_context.cc b/chrome/browser/in_process_webkit/webkit_context.cc
index 5fdb358..783f7a6 100644
--- a/chrome/browser/in_process_webkit/webkit_context.cc
+++ b/chrome/browser/in_process_webkit/webkit_context.cc
@@ -15,7 +15,8 @@ WebKitContext::WebKitContext(const FilePath& data_path, bool is_incognito)
 
 WebKitContext::~WebKitContext() {
   // If the WebKit thread was ever spun up, delete the object there.  The task
-  // will just get deleted if the WebKit thread isn't created.
+  // will just get deleted if the WebKit thread isn't created (which only
+  // happens during testing).
   DOMStorageContext* dom_storage_context = dom_storage_context_.release();
   if (!ChromeThread::DeleteSoon(
           ChromeThread::WEBKIT, FROM_HERE, dom_storage_context)) {
@@ -26,33 +27,41 @@ WebKitContext::~WebKitContext() {
 }
 
 void WebKitContext::PurgeMemory() {
-  // DOMStorageContext::PurgeMemory() should only be called on the WebKit
-  // thread.
-  //
-  // Note that if there is no WebKit thread, then there's nothing in
-  // LocalStorage and it's OK to no-op here.
-  if (ChromeThread::CurrentlyOn(ChromeThread::WEBKIT)) {
-    dom_storage_context_->PurgeMemory();
-  } else {
-    // Since we're not on the WebKit thread, proxy the call over to it.  We
-    // can't post a task to call DOMStorageContext::PurgeMemory() directly
-    // because that class is not refcounted.
-    ChromeThread::PostTask(
+  if (!ChromeThread::CurrentlyOn(ChromeThread::WEBKIT)) {
+    bool result = ChromeThread::PostTask(
         ChromeThread::WEBKIT, FROM_HERE,
         NewRunnableMethod(this, &WebKitContext::PurgeMemory));
+    DCHECK(result);
+    return;
   }
+
+  dom_storage_context_->PurgeMemory();
 }
 
 void WebKitContext::DeleteDataModifiedSince(const base::Time& cutoff) {
-  // DOMStorageContext::DeleteDataModifiedSince() should only be called on the
-  // WebKit thread.
-  if (ChromeThread::CurrentlyOn(ChromeThread::WEBKIT)) {
-    dom_storage_context_->DeleteDataModifiedSince(cutoff);
-  } else {
+  if (!ChromeThread::CurrentlyOn(ChromeThread::WEBKIT)) {
     bool result = ChromeThread::PostTask(
         ChromeThread::WEBKIT, FROM_HERE,
         NewRunnableMethod(this, &WebKitContext::DeleteDataModifiedSince,
                           cutoff));
     DCHECK(result);
+    return;
+  }
+
+  dom_storage_context_->DeleteDataModifiedSince(cutoff);
+}
+
+
+void WebKitContext::DeleteSessionStorageNamespace(
+    int64 session_storage_namespace_id) {
+  if (!ChromeThread::CurrentlyOn(ChromeThread::WEBKIT)) {
+    ChromeThread::PostTask(
+        ChromeThread::WEBKIT, FROM_HERE,
+        NewRunnableMethod(this, &WebKitContext::DeleteSessionStorageNamespace,
+                          session_storage_namespace_id));
+    return;
   }
+
+  dom_storage_context_->DeleteSessionStorageNamespace(
+      session_storage_namespace_id);
 }
diff --git a/chrome/browser/in_process_webkit/webkit_context.h b/chrome/browser/in_process_webkit/webkit_context.h
index 38d9d7d..229e47f 100644
--- a/chrome/browser/in_process_webkit/webkit_context.h
+++ b/chrome/browser/in_process_webkit/webkit_context.h
@@ -14,7 +14,9 @@
 class WebKitThread;
 
 // There's one WebKitContext per profile.  Various DispatcherHost classes
-// have a pointer to the Context to store shared state.
+// have a pointer to the Context to store shared state.  Unfortunately, this
+// class has become a bit of a dumping ground for calls made on the UI thread
+// that need to be proxied over to the WebKit thread.
 //
 // This class is created on the UI thread and accessed on the UI, IO, and WebKit
 // threads.
@@ -43,6 +45,10 @@ class WebKitContext : public base::RefCountedThreadSafe<WebKitContext> {
   // last modified on or after the following time.
   void DeleteDataModifiedSince(const base::Time& cutoff);
 
+  // Delete the session storage namespace associated with this id.  Called from
+  // the UI thread.
+  void DeleteSessionStorageNamespace(int64 session_storage_namespace_id);
+
  private:
   friend class base::RefCountedThreadSafe<WebKitContext>;
   ~WebKitContext();
diff --git a/chrome/browser/tab_contents/navigation_controller.cc b/chrome/browser/tab_contents/navigation_controller.cc
index 83e7ba5..129bca2 100644
--- a/chrome/browser/tab_contents/navigation_controller.cc
+++ b/chrome/browser/tab_contents/navigation_controller.cc
@@ -149,6 +149,10 @@ NavigationController::~NavigationController() {
       NotificationType::TAB_CLOSED,
       Source<NavigationController>(this),
       NotificationService::NoDetails());
+
+  // When we go away, the session storage namespace will no longer be reachable.
+  profile_->GetWebKitContext()->DeleteSessionStorageNamespace(
+      session_storage_namespace_id_);
 }
 
 void NavigationController::RestoreFromState(
diff --git a/chrome/common/render_messages_internal.h b/chrome/common/render_messages_internal.h
index 2129da5..6f74aa7 100644
--- a/chrome/common/render_messages_internal.h
+++ b/chrome/common/render_messages_internal.h
@@ -1859,17 +1859,6 @@ IPC_BEGIN_MESSAGES(ViewHost)
   IPC_MESSAGE_CONTROL1(ViewHostMsg_SetCacheMode,
                        bool /* enabled */)
 
-  // There's one LocalStorage namespace per profile and one SessionStorage
-  // namespace per tab.  This will find or create the proper namespace.
-  IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DOMStorageNamespaceId,
-                              DOMStorageType /* storage_type */,
-                              int64 /* new_namespace_id */)
-
-  // Used by SessionStorage to clone a namespace per the spec.
-  IPC_SYNC_MESSAGE_CONTROL1_1(ViewHostMsg_DOMStorageCloneNamespaceId,
-                              int64 /* namespace_id to clone */,
-                              int64 /* new_namespace_id */)
-
   // Get the storage area id for a particular origin within a namespace.
   IPC_SYNC_MESSAGE_CONTROL2_1(ViewHostMsg_DOMStorageStorageAreaId,
                               int64 /* namespace_id */,
diff --git a/chrome/renderer/render_view.cc b/chrome/renderer/render_view.cc
index dcbda82..ed8b7a3 100644
--- a/chrome/renderer/render_view.cc
+++ b/chrome/renderer/render_view.cc
@@ -1466,7 +1466,9 @@ WebWidget* RenderView::createPopupMenu(const WebPopupMenuInfo& info) {
 WebStorageNamespace* RenderView::createSessionStorageNamespace() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess))
     return WebStorageNamespace::createSessionStorageNamespace();
-  return new RendererWebStorageNamespaceImpl(DOM_STORAGE_SESSION);
+  CHECK(session_storage_namespace_id_ != kInvalidSessionStorageNamespaceId);
+  return new RendererWebStorageNamespaceImpl(DOM_STORAGE_SESSION,
+                                             session_storage_namespace_id_);
 }
 
 void RenderView::didAddMessageToConsole(
diff --git a/chrome/renderer/renderer_webstoragenamespace_impl.cc b/chrome/renderer/renderer_webstoragenamespace_impl.cc
index 7bd704f..d5146e7f 100644
--- a/chrome/renderer/renderer_webstoragenamespace_impl.cc
+++ b/chrome/renderer/renderer_webstoragenamespace_impl.cc
@@ -14,16 +14,16 @@ using WebKit::WebString;
 
 RendererWebStorageNamespaceImpl::RendererWebStorageNamespaceImpl(
     DOMStorageType storage_type)
-    : storage_type_(storage_type) {
-  RenderThread::current()->Send(
-        new ViewHostMsg_DOMStorageNamespaceId(storage_type_,
-                                              &namespace_id_));
+    : storage_type_(storage_type),
+      namespace_id_(kLocalStorageNamespaceId) {
+  DCHECK(storage_type == DOM_STORAGE_LOCAL);
 }
 
 RendererWebStorageNamespaceImpl::RendererWebStorageNamespaceImpl(
     DOMStorageType storage_type, int64 namespace_id)
     : storage_type_(storage_type),
       namespace_id_(namespace_id) {
+  DCHECK(storage_type == DOM_STORAGE_SESSION);
 }
 
 RendererWebStorageNamespaceImpl::~RendererWebStorageNamespaceImpl() {
@@ -33,19 +33,14 @@ WebStorageArea* RendererWebStorageNamespaceImpl::createStorageArea(
     const WebString& origin) {
   // Ideally, we'd keep a hash map of origin to these objects.  Unfortunately
   // this doesn't seem practical because there's no good way to ref-count these
-  // objects, and it'd be unclear who owned them.  So, instead, we'll pay a
-  // price for an allocaiton and IPC for each.
+  // objects, and it'd be unclear who owned them.  So, instead, we'll pay the
+  // price in terms of wasted memory.
   return new RendererWebStorageAreaImpl(namespace_id_, origin);
 }
 
 WebStorageNamespace* RendererWebStorageNamespaceImpl::copy() {
-  // This cannot easily be deferred because we need a snapshot in time.
-  int64 new_namespace_id;
-  RenderThread::current()->Send(
-      new ViewHostMsg_DOMStorageCloneNamespaceId(namespace_id_,
-                                                 &new_namespace_id));
-  return new RendererWebStorageNamespaceImpl(storage_type_,
-                                             new_namespace_id);
+  NOTREACHED();  // We shouldn't ever reach this code in Chromium.
+  return NULL;
 }
 
 void RendererWebStorageNamespaceImpl::close() {