Persist sessionStorage on disk.

webkit/dom_storage/dom_storage_namespace.cc

 // Copyright (c) 2012 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 "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 {
 
 DomStorageNamespace::DomStorageNamespace(
     const FilePath& directory,
     DomStorageTaskRunner* task_runner)
     : namespace_id_(kLocalStorageNamespaceId),
       directory_(directory),
       task_runner_(task_runner) {
 }
 
 DomStorageNamespace::DomStorageNamespace(
     int64 namespace_id,
     DomStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
       task_runner_(task_runner) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
 }
 
+DomStorageNamespace::DomStorageNamespace(
+    int64 namespace_id,
+    SessionStorageDatabase* session_storage_database,
+    DomStorageTaskRunner* task_runner)
+    : namespace_id_(namespace_id),
+      task_runner_(task_runner),
+      session_storage_database_(session_storage_database) {
+  DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
+}
+
 DomStorageNamespace::~DomStorageNamespace() {
+  if (session_storage_database_.get())
+    session_storage_database_->DeleteNamespace(namespace_id_);

[michaeln, 2012/04/22 21:43:35]

should this be here given the logic in DomStorageContext?

[marja, 2012/05/11 12:18:32]

Done.

 }
 
 DomStorageArea* DomStorageNamespace::OpenStorageArea(const GURL& origin) {
   if (AreaHolder* holder = GetAreaHolder(origin)) {
     ++(holder->open_count_);
     return holder->area_;
   }
-  DomStorageArea* area = new DomStorageArea(namespace_id_, origin,
-                                            directory_, task_runner_);
+  DomStorageArea* area;
+  if (!directory_.empty()) {
+    // Local storage backed on disk.
+    area = new DomStorageArea(namespace_id_, origin, directory_, task_runner_);
+  } else if (session_storage_database_.get()) {
+    // Session storage backed on disk.
+    area = new DomStorageArea(namespace_id_, origin, session_storage_database_,
+                              task_runner_);
+  } else {
+    // In-memory.
+    area = new DomStorageArea(namespace_id_, origin, task_runner_);
+  }
   areas_[origin] = AreaHolder(area, 1);
   return area;
 }
 
 void DomStorageNamespace::CloseStorageArea(DomStorageArea* area) {
   AreaHolder* holder = GetAreaHolder(area->origin());
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
   --(holder->open_count_);
   // TODO(michaeln): Clean up areas that aren't needed in memory anymore.
   // The in-process-webkit based impl didn't do this either, but would be nice.
 }
 
 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();
+  // We need to commit all data to the database before making a shallow copy,
+  // otherwise the data which is written will cause a deep copy. ShallowCopy
+  // will ensure that the next task in the commit sequence will be committing
+  // the data.

[michaeln, 2012/04/22 21:43:35]

not sure this elaborate comment is needed here
// Clone the in-memory structures.

[marja, 2012/05/11 12:18:32]

Done. DomStorageArea::ShallowCopy will also put the pending changes to the task
queue so they'll be written on disk... but maybe this layer doesn't need to
care.

   for (; it != areas_.end(); ++it) {
     DomStorageArea* area = it->second.area_->ShallowCopy(clone_namespace_id);
     clone->areas_[it->first] = AreaHolder(area, 0);
   }
+  // CloneNamespaceInCommitSequence will be done after writing data.

[michaeln, 2012/04/22 21:43:35]

// And clone the on-disk structures too.

[marja, 2012/05/11 12:18:32]

Done.

+  bool success = task_runner_->PostShutdownBlockingTask(

[michaeln, 2012/04/22 21:43:35]

in mem-only cases (chromiumDRT and some tests) its valid for task_runner to be
null. in any cases where there is backing on disk, it cant be null.

i think you'll need an test here for if (session_db_) and only post the task to
clone in the db if non-null.

[marja, 2012/05/11 12:18:32]

Done.

+      FROM_HERE,
+      DomStorageTaskRunner::COMMIT_SEQUENCE,
+      base::Bind(&DomStorageNamespace::CloneNamespaceInCommitSequence, this,

[michaeln, 2012/04/22 21:43:35]

instead of binding to a helper method of this object, i think you could make a
closure directly around the SessionStorageDatabase method to avoid the
CloneNamespaceInCommitSequence helper in this class... one less helper method
would be nice

base::Bind(&SessionStorageDatabase::Clone, db_, orig_id, new_id)

[marja, 2012/05/11 12:18:32]

Done. For that to work, I needed to change the return value of
SessionStorageDatabase::CloneNamespace from bool to void, so that it can be
ignored here. (Not sure if there was a better way to do it, so that I could keep
the bool value and e.g., check it in tests.

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

The base::IgnoreResult template could probably work for that.

+                 clone_namespace_id));
+  DCHECK(success);
   return clone;
 }
 
 void DomStorageNamespace::DeleteOrigin(const GURL& origin) {
   AreaHolder* holder = GetAreaHolder(origin);
   if (holder) {
     holder->area_->DeleteOrigin();
     return;
   }
   if (!directory_.empty()) {
     scoped_refptr<DomStorageArea> area =
         new DomStorageArea(namespace_id_, origin, directory_, task_runner_);
     area->DeleteOrigin();
+  } else if (session_storage_database_.get()) {
+    scoped_refptr<DomStorageArea> area =
+        new DomStorageArea(namespace_id_, origin,
+                           session_storage_database_.get(), task_runner_);
+    area->DeleteOrigin();
   }
 }
 
 void DomStorageNamespace::PurgeMemory() {
   if (directory_.empty())
     return;  // We can't purge w/o backing on disk.
   AreaMap::iterator it = areas_.begin();
   while (it != areas_.end()) {
     // Leave it alone if changes are pending
     if (it->second.area_->HasUncommittedChanges()) {
@@ skipping 23 matching lines @@
 
 
 DomStorageNamespace::AreaHolder*
 DomStorageNamespace::GetAreaHolder(const GURL& origin) {
   AreaMap::iterator found = areas_.find(origin);
   if (found == areas_.end())
     return NULL;
   return &(found->second);
 }
 
+void DomStorageNamespace::CloneNamespaceInCommitSequence(
+    int64 clone_namespace_id) {
+  session_storage_database_->ShallowCopyNamespace(
+      namespace_id_, clone_namespace_id);
+}
+
 // AreaHolder
 
 DomStorageNamespace::AreaHolder::AreaHolder()
     : open_count_(0) {
 }
 
 DomStorageNamespace::AreaHolder::AreaHolder(
     DomStorageArea* area, int count)
     : area_(area), open_count_(count) {
 }
 
 DomStorageNamespace::AreaHolder::~AreaHolder() {
 }
 
 }  // namespace dom_storage