Persist sessionStorage on disk.

webkit/dom_storage/dom_storage_area.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_area.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "webkit/database/database_util.h"
 #include "webkit/dom_storage/dom_storage_map.h"
 #include "webkit/dom_storage/dom_storage_namespace.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"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/glue/webkit_glue.h"
 
 using webkit_database::DatabaseUtil;
 
 namespace dom_storage {
 
 static const int kCommitTimerSeconds = 1;
 
 DomStorageArea::CommitBatch::CommitBatch()
@@ skipping 24 matching lines @@
   return DatabaseUtil::GetOriginFromIdentifier(origin_id);
 }
 
 DomStorageArea::DomStorageArea(
     int64 namespace_id, const GURL& origin,
     const FilePath& directory, DomStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id), origin_(origin),
       directory_(directory),
       task_runner_(task_runner),
       map_(new DomStorageMap(kPerAreaQuota)),
+      is_initial_import_done_(false),
+      is_shutdown_(false),
+      is_shallow_copy_(false) {
+  DCHECK(!directory.empty());
+  DCHECK_EQ(kLocalStorageNamespaceId, namespace_id);
+  FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_));
+  backing_.reset(new LocalStorageDatabase(path));
+}
+
+DomStorageArea::DomStorageArea(
+    int64 namespace_id, const GURL& origin,
+    SessionStorageDatabase* session_storage_backing,
+    DomStorageTaskRunner* task_runner)
+    : namespace_id_(namespace_id), origin_(origin),
+      task_runner_(task_runner),
+      map_(new DomStorageMap(kPerAreaQuota)),
+      session_storage_backing_(session_storage_backing),
+      is_initial_import_done_(false),
+      is_shutdown_(false),
+      is_shallow_copy_(false) {
+  DCHECK(namespace_id != kLocalStorageNamespaceId);
+}
+
+DomStorageArea::DomStorageArea(int64 namespace_id,
+                               const GURL& origin,
+                               DomStorageTaskRunner* task_runner)
+    : namespace_id_(namespace_id), origin_(origin),
+      task_runner_(task_runner),
+      map_(new DomStorageMap(kPerAreaQuota)),
       is_initial_import_done_(true),
-      is_shutdown_(false) {
-  if (namespace_id == kLocalStorageNamespaceId && !directory.empty()) {
-    FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_));
-    backing_.reset(new DomStorageDatabase(path));
-    is_initial_import_done_ = false;
-  }
+      is_shutdown_(false),
+      is_shallow_copy_(false) {
 }
 
 DomStorageArea::~DomStorageArea() {
 }
 
 unsigned DomStorageArea::Length() {
   if (is_shutdown_)
     return 0;
   InitialImportIfNeeded();
   return map_->Length();
@@ skipping 12 matching lines @@
   InitialImportIfNeeded();
   return map_->GetItem(key);
 }
 
 bool DomStorageArea::SetItem(const string16& key,
                              const string16& value,
                              NullableString16* old_value) {
   if (is_shutdown_)
     return false;
   InitialImportIfNeeded();
-  if (!map_->HasOneRef())
+  if (is_shallow_copy_) {
     map_ = map_->DeepCopy();
+    if (session_storage_backing_.get()) {
+      session_storage_backing_->DeepCopy(namespace_id_, origin_);

[michaeln, 2012/04/12 01:48:46]

see comments below about serializing deepcopy with other changes

[marja, 2012/04/19 10:20:50]

Done.

+    }
+    is_shallow_copy_ = false;
+  }
   bool success = map_->SetItem(key, value, old_value);
-  if (success && backing_.get()) {
+  if (success && GetBacking()) {
     CommitBatch* commit_batch = CreateCommitBatchIfNeeded();
     commit_batch->changed_values[key] = NullableString16(value, false);
   }
   return success;
 }
 
 bool DomStorageArea::RemoveItem(const string16& key, string16* old_value) {
   if (is_shutdown_)
     return false;
   InitialImportIfNeeded();
-  if (!map_->HasOneRef())
+  if (is_shallow_copy_) {
     map_ = map_->DeepCopy();
+    if (session_storage_backing_.get()) {
+      session_storage_backing_->DeepCopy(namespace_id_, origin_);

[michaeln, 2012/04/12 01:48:46]

The changes to the backing store made by DeepCopy have to be serialized with
other changes to the backing store, like made for SetItem and Clear. Otherwise,
you may be copying stale data here which is scheduled to be modified by an
in_flight_commit_batch_.

I think these calls to DeepCopy (actually all mutations to the backing store)
should happen on the COMMIT_SEQUENCE.

Maybe we can add a make_deep_copy_first flag to CommitBatch and have
CommitChanges() make the call to DeepCopy when needed.

[marja, 2012/04/19 10:20:50]

Done. deep_copy_first doens't work, since the same commit batch can contain
changes that need to happen before the deep copy, and changes that need to
happen after it.

E.g., if we do: SetItem, fork a new namespace, SetItem, then the first SetItem
needs to happen before the deep copy, so that the value is available in the
forked namespace, and the second SetItem needs to happen after the deep copy.

I moved the deep copying to happen in the COMMIT_SEQUENCE, and separated
changes-before-deep-copy from changes-after-deep-copy.

+    }
+    is_shallow_copy_ = false;
+  }
   bool success = map_->RemoveItem(key, old_value);
-  if (success && backing_.get()) {
+  if (success && GetBacking()) {
     CommitBatch* commit_batch = CreateCommitBatchIfNeeded();
     commit_batch->changed_values[key] = NullableString16(true);
   }
   return success;
 }
 
 bool DomStorageArea::Clear() {
   if (is_shutdown_)
     return false;
   InitialImportIfNeeded();
   if (map_->Length() == 0)
     return false;
 
   map_ = new DomStorageMap(kPerAreaQuota);

[michaeln, 2012/04/12 01:48:46]

if this area is a 'shallow copy', we'll need to coin a new mapid for it in the
session database at this point, no point in actually copying in this case, but
we do need to break the association between this area and the old populated map
(if its shared with another area).

Flags for CommitChanges() could inform it of what do to...

if (commit_batch->make_deep_copy_first) {
  if (commit_batch->clear_all_first)
    // create a new mapid for the area w/o bothering to copy
  else
    DeepCopy();
}

[marja, 2012/04/19 10:20:50]

Done.

 
-  if (backing_.get()) {
+  if (GetBacking()) {
     CommitBatch* commit_batch = CreateCommitBatchIfNeeded();
     commit_batch->clear_all_first = true;
     commit_batch->changed_values.clear();
   }
 
   return true;
 }
 
 DomStorageArea* DomStorageArea::ShallowCopy(int64 destination_namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, destination_namespace_id);
-  DCHECK(!backing_.get());  // SessionNamespaces aren't stored on disk.
+  DCHECK(session_storage_backing_.get());
 
-  DomStorageArea* copy = new DomStorageArea(destination_namespace_id, origin_,
-                                            FilePath(), task_runner_);
+  session_storage_backing_->ShallowCopy(namespace_id_, origin_,

[michaeln, 2012/04/12 01:48:46]

see earlier comments about serializing changes in the backing store, this
probably needs to happen on the COMMIT_SEQUENCE too

[marja, 2012/04/19 10:20:50]

Done.

+                                        destination_namespace_id);
+
+  DomStorageArea* copy = new DomStorageArea(
+      destination_namespace_id, origin_, session_storage_backing_,
+      task_runner_);
+  copy->is_shallow_copy_ = true;
   copy->map_ = map_;
   copy->is_shutdown_ = is_shutdown_;
   return copy;
 }
 
 bool DomStorageArea::HasUncommittedChanges() const {
   DCHECK(!is_shutdown_);
   return commit_batch_.get() || in_flight_commit_batch_.get();
 }
 
 void DomStorageArea::DeleteOrigin() {
   DCHECK(!is_shutdown_);
   if (HasUncommittedChanges()) {
     // TODO(michaeln): This logically deletes the data immediately,
     // and in a matter of a second, deletes the rows from the backing
     // database file, but the file itself will linger until shutdown
     // or purge time. Ideally, this should delete the file more
     // quickly.
     Clear();
     return;
   }
   map_ = new DomStorageMap(kPerAreaQuota);
   if (backing_.get()) {
     is_initial_import_done_ = false;
-    backing_.reset(new DomStorageDatabase(backing_->file_path()));
+    backing_.reset(new LocalStorageDatabase(backing_->file_path()));
     file_util::Delete(backing_->file_path(), false);
     file_util::Delete(
-        DomStorageDatabase::GetJournalFilePath(backing_->file_path()), false);
+        LocalStorageDatabase::GetJournalFilePath(backing_->file_path()), false);
+  } else if (session_storage_backing_.get()) {
+    session_storage_backing_->DeleteOrigin(namespace_id_, origin_);

[michaeln, 2012/04/12 01:48:46]

probably needs to be serialized on the COMMIT_SEQUENCE

[marja, 2012/04/19 10:20:50]

Done.

   }
 }
 
 void DomStorageArea::PurgeMemory() {
   DCHECK(!is_shutdown_);
   if (!is_initial_import_done_ ||  // We're not using any memory.
       !backing_.get() ||  // We can't purge anything.
       HasUncommittedChanges())  // We leave things alone with changes pending.
     return;
 
   // Drop the in memory cache, we'll reload when needed.
   is_initial_import_done_ = false;
   map_ = new DomStorageMap(kPerAreaQuota);
 
   // Recreate the database object, this frees up the open sqlite connection
   // and its page cache.
-  backing_.reset(new DomStorageDatabase(backing_->file_path()));
+  backing_.reset(new LocalStorageDatabase(backing_->file_path()));
 }
 
 void DomStorageArea::Shutdown() {
   DCHECK(!is_shutdown_);
   is_shutdown_ = true;
   map_ = NULL;
-  if (!backing_.get())
+  if (!GetBacking())
     return;
 
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DomStorageTaskRunner::COMMIT_SEQUENCE,
       base::Bind(&DomStorageArea::ShutdownInCommitSequence, this));
   DCHECK(success);
 }
 
 void DomStorageArea::InitialImportIfNeeded() {
   if (is_initial_import_done_)
     return;
 
-  DCHECK_EQ(kLocalStorageNamespaceId, namespace_id_);
-  DCHECK(backing_.get());
+  DCHECK(GetBacking());
 
   ValuesMap initial_values;
-  backing_->ReadAllValues(&initial_values);
+  GetBacking()->ReadAllValues(namespace_id_, origin_, &initial_values);
   map_->SwapValues(&initial_values);
   is_initial_import_done_ = true;
 }
 
 DomStorageArea::CommitBatch* DomStorageArea::CreateCommitBatchIfNeeded() {
   DCHECK(!is_shutdown_);
   if (!commit_batch_.get()) {
     commit_batch_.reset(new CommitBatch());
 
     // Start a timer to commit any changes that accrue in the batch,
     // but only if a commit is not currently in flight. In that case
     // the timer will be started after the current commit has happened.
     if (!in_flight_commit_batch_.get()) {
       task_runner_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&DomStorageArea::OnCommitTimer, this),
           base::TimeDelta::FromSeconds(kCommitTimerSeconds));
     }
   }
   return commit_batch_.get();
 }
 
 void DomStorageArea::OnCommitTimer() {
-  DCHECK_EQ(kLocalStorageNamespaceId, namespace_id_);
   if (is_shutdown_)
     return;
 
-  DCHECK(backing_.get());
+  DCHECK(GetBacking());
   DCHECK(commit_batch_.get());
   DCHECK(!in_flight_commit_batch_.get());
 
   // This method executes on the primary sequence, we schedule
   // a task for immediate execution on the commit sequence.
   DCHECK(task_runner_->IsRunningOnPrimarySequence());
   in_flight_commit_batch_ = commit_batch_.Pass();
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DomStorageTaskRunner::COMMIT_SEQUENCE,
       base::Bind(&DomStorageArea::CommitChanges, this));
   DCHECK(success);
 }
 
 void DomStorageArea::CommitChanges() {
   // This method executes on the commit sequence.
   DCHECK(task_runner_->IsRunningOnCommitSequence());
   DCHECK(in_flight_commit_batch_.get());
-  bool success = backing_->CommitChanges(
+  bool success = GetBacking()->CommitChanges(
+      namespace_id_, origin_,
       in_flight_commit_batch_->clear_all_first,
       in_flight_commit_batch_->changed_values);
   DCHECK(success);  // TODO(michaeln): what if it fails?
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&DomStorageArea::OnCommitComplete, this));
 }
 
 void DomStorageArea::OnCommitComplete() {
   // We're back on the primary sequence in this method.
   DCHECK(task_runner_->IsRunningOnPrimarySequence());
   if (is_shutdown_)
     return;
   in_flight_commit_batch_.reset();
   if (commit_batch_.get()) {
     // More changes have accrued, restart the timer.
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&DomStorageArea::OnCommitTimer, this),
         base::TimeDelta::FromSeconds(kCommitTimerSeconds));
   }
 }
 
 void DomStorageArea::ShutdownInCommitSequence() {
   // This method executes on the commit sequence.
   DCHECK(task_runner_->IsRunningOnCommitSequence());
-  DCHECK(backing_.get());
+  DCHECK(GetBacking());
   if (commit_batch_.get()) {
     // Commit any changes that accrued prior to the timer firing.
-    bool success = backing_->CommitChanges(
+    bool success = GetBacking()->CommitChanges(
+        namespace_id_, origin_,
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   in_flight_commit_batch_.reset();
   backing_.reset();
+  session_storage_backing_ = NULL;
+}
+
+DomStorageDatabase* DomStorageArea::GetBacking() const {
+  DCHECK(!backing_.get() || !session_storage_backing_.get());
+  if (backing_.get())
+    return backing_.get();
+  return session_storage_backing_.get();
 }
 
 }  // namespace dom_storage