Persist sessionStorage on disk.

webkit/dom_storage/dom_storage_namespace.cc

Index: webkit/dom_storage/dom_storage_namespace.cc
diff --git a/webkit/dom_storage/dom_storage_namespace.cc b/webkit/dom_storage/dom_storage_namespace.cc
index 656d244345258d5328f384241e07c3e2b7652ab5..6ed21144cc88f911b0f00546c3e39c519f075928 100644
--- a/webkit/dom_storage/dom_storage_namespace.cc
+++ b/webkit/dom_storage/dom_storage_namespace.cc
@@ -5,10 +5,13 @@
 #include "webkit/dom_storage/dom_storage_namespace.h"
 
 #include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/location.h"
 #include "base/logging.h"
 #include "webkit/dom_storage/dom_storage_area.h"
 #include "webkit/dom_storage/dom_storage_task_runner.h"
 #include "webkit/dom_storage/dom_storage_types.h"
+#include "webkit/dom_storage/session_storage_database.h"
 
 namespace dom_storage {
 
@@ -22,9 +25,11 @@ DomStorageNamespace::DomStorageNamespace(
 
 DomStorageNamespace::DomStorageNamespace(
     int64 namespace_id,
+    SessionStorageDatabase* session_storage_database,
     DomStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
-      task_runner_(task_runner) {
+      task_runner_(task_runner),
+      session_storage_database_(session_storage_database) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
 }
 
@@ -36,8 +41,13 @@ DomStorageArea* DomStorageNamespace::OpenStorageArea(const GURL& origin) {
     ++(holder->open_count_);
     return holder->area_;
   }
-  DomStorageArea* area = new DomStorageArea(namespace_id_, origin,
-                                            directory_, task_runner_);
+  DomStorageArea* area;
+  if (namespace_id_ == kLocalStorageNamespaceId) {
+    area = new DomStorageArea(namespace_id_, origin, directory_, task_runner_);
+  } else {
+    area = new DomStorageArea(namespace_id_, origin, session_storage_database_,
+                              task_runner_);
+  }
   areas_[origin] = AreaHolder(area, 1);
   return area;
 }
@@ -54,13 +64,24 @@ void DomStorageNamespace::CloseStorageArea(DomStorageArea* area) {
 DomStorageNamespace* DomStorageNamespace::Clone(int64 clone_namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, clone_namespace_id);
-  DomStorageNamespace* clone =
-      new DomStorageNamespace(clone_namespace_id, task_runner_);
+  DomStorageNamespace* clone = new DomStorageNamespace(
+      clone_namespace_id, session_storage_database_, task_runner_);
   AreaMap::const_iterator it = areas_.begin();
+  // Clone the in-memory structures.
   for (; it != areas_.end(); ++it) {
     DomStorageArea* area = it->second.area_->ShallowCopy(clone_namespace_id);
     clone->areas_[it->first] = AreaHolder(area, 0);
   }
+  // And clone the on-disk structures, too.
+  if (session_storage_database_.get()) {
+    bool success = task_runner_->PostShutdownBlockingTask(
+        FROM_HERE,
+        DomStorageTaskRunner::COMMIT_SEQUENCE,
+        base::Bind(&SessionStorageDatabase::CloneNamespace,
+                   session_storage_database_.get(), namespace_id_,
+                   clone_namespace_id));
+    DCHECK(success);
+  }
   return clone;
 }
 
@@ -74,6 +95,11 @@ void DomStorageNamespace::DeleteOrigin(const GURL& origin) {
     scoped_refptr<DomStorageArea> area =
         new DomStorageArea(namespace_id_, origin, directory_, task_runner_);
     area->DeleteOrigin();
+  } else if (session_storage_database_.get()) {

[michaeln, 2012/05/16 08:10:55]

i think the DomStorageNamespace::DeleteOrigin method is unreachable for session
storage namespaces right now. also i think there's a race condition with this
handling of that function for session storage.

suppose immediately after this block executes, there's a call to
DomStorageNamespace::OpenStorageArea for this 'origin' followed by something
that causes the area to be read from the database. those calls to open+read on
the primary sequence will be racing with deletion scheduled on the commit
sequence by the area->DeleteOrigin() method call below.

since this is currently unreachable (its only reached via the
DomStorageContext::DeleteOrigin method which only calls thru for the local
storage namespace)... consider putting a
DCHECK(!session_storage_database_.get()) here for now

[marja, 2012/05/30 11:46:19]

Done.

Ah, yes, there was a race. What if I set is_initial_import_done to true in
DomStorageArea::DeleteOrigin, when it posts the actual deletion task... That
should remove the race, no?

But, anyhow, I don't have a clear idea on how this origin-based deletion should
work.. Should SessionStorageDatabase have a function to delete an origin from
all namespaces?

(I guess it's plugged into this "modification times for origins" logic, so
should it instead have a function to delete all origins which have been modified
after a certain time?)

+    scoped_refptr<DomStorageArea> area =
+        new DomStorageArea(namespace_id_, origin,
+                           session_storage_database_.get(), task_runner_);
+    area->DeleteOrigin();
   }
 }