Introduce all the plumbing for Session Storage. This mostly consists of crea...

chrome/browser/in_process_webkit/dom_storage_dispatcher_host.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/browser/in_process_webkit/dom_storage_dispatcher_host.h"
 
 #include "base/nullable_string16.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/in_process_webkit/dom_storage_area.h"
 #include "chrome/browser/in_process_webkit/dom_storage_context.h"
@@ skipping 94 matching lines @@
           &DOMStorageDispatcherHost::OnStorageEvent, params));
 }
 
 bool DOMStorageDispatcherHost::OnMessageReceived(const IPC::Message& message,
                                                  bool *msg_is_ok) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   DCHECK(process_handle_);
 
   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)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageKey, OnKey)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageGetItem, OnGetItem)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DOMStorageSetItem, OnSetItem)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageRemoveItem, OnRemoveItem)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DOMStorageClear, OnClear)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
+int64 DOMStorageDispatcherHost::CloneSessionStorage(int64 original_id) {
+  return Context()->CloneSessionStorage(original_id);
+}
+
 void DOMStorageDispatcherHost::Send(IPC::Message* message) {
   if (!message_sender_) {
     delete message;
     return;
   }
 
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     message_sender_->Send(message);
     return;
   }
 
   // The IO thread can't go away while the WebKit thread is still running.
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::WEBKIT));
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       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) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
         this, &DOMStorageDispatcherHost::OnStorageAreaId, namespace_id, origin,
         reply_msg));
     return;
   }
 
   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_);
     delete reply_msg;
     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);
 }
 
 void DOMStorageDispatcherHost::OnLength(int64 storage_area_id,
                                         IPC::Message* reply_msg) {
   if (ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     ChromeThread::PostTask(ChromeThread::WEBKIT, FROM_HERE, NewRunnableMethod(
         this, &DOMStorageDispatcherHost::OnLength, storage_area_id, reply_msg));
     return;
   }
@@ skipping 125 matching lines @@
     const ViewMsg_DOMStorageEvent_Params& params) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
   const DOMStorageContext::DispatcherHostSet* set =
       Context()->GetDispatcherHostSet();
   DOMStorageContext::DispatcherHostSet::const_iterator cur = set->begin();
   while (cur != set->end()) {
     (*cur)->Send(new ViewMsg_DOMStorageEvent(params));
     ++cur;
   }
 }