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/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/local_storage_database_adapter.h"
+#include "webkit/dom_storage/session_storage_database.h"
+#include "webkit/dom_storage/session_storage_database_adapter.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 37 matching lines @@
     FilePath path = directory.Append(DatabaseFileNameFromOrigin(origin_));
     backing_.reset(new LocalStorageDatabaseAdapter(path));
     is_initial_import_done_ = false;
   }
 }
 
 DomStorageArea::DomStorageArea(
     int64 namespace_id,
     const std::string& persistent_namespace_id,
     const GURL& origin,
+    SessionStorageDatabase* session_storage_backing,
     DomStorageTaskRunner* task_runner)
     : namespace_id_(namespace_id),
       persistent_namespace_id_(persistent_namespace_id),
       origin_(origin),
       task_runner_(task_runner),
       map_(new DomStorageMap(kPerAreaQuota + kPerAreaOverQuotaAllowance)),
+      session_storage_backing_(session_storage_backing),
       is_initial_import_done_(true),
       is_shutdown_(false),
       commit_batches_in_flight_(0) {
   DCHECK(namespace_id != kLocalStorageNamespaceId);
+  if (session_storage_backing) {
+    backing_.reset(new SessionStorageDatabaseAdapter(
+        session_storage_backing, persistent_namespace_id, origin));
+    is_initial_import_done_ = false;
+  }
 }
 
 DomStorageArea::~DomStorageArea() {
 }
 
 void DomStorageArea::ExtractValues(ValuesMap* map) {
   if (is_shutdown_)
     return;
   InitialImportIfNeeded();
   map_->ExtractValues(map);
@@ skipping 66 matching lines @@
   }
 
   return true;
 }
 
 DomStorageArea* DomStorageArea::ShallowCopy(
     int64 destination_namespace_id,
     const std::string& destination_persistent_namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id_);
   DCHECK_NE(kLocalStorageNamespaceId, destination_namespace_id);
-  DCHECK(!backing_.get());  // SessionNamespaces aren't stored on disk.
 
   DomStorageArea* copy = new DomStorageArea(
       destination_namespace_id, destination_persistent_namespace_id, origin_,
-      task_runner_);
+      session_storage_backing_, task_runner_);
   copy->map_ = map_;
   copy->is_shutdown_ = is_shutdown_;
+  copy->is_initial_import_done_ = true;
+
+  // All the uncommitted changes to this area need to happen before the actual
+  // shallow copy is made (scheduled by the upper layer). Another OnCommitTimer
+  // call might be in the event queue at this point, but it's handled gracefully
+  // when it fires.
+  if (commit_batch_.get())
+    OnCommitTimer();
   return copy;
 }
 
 bool DomStorageArea::HasUncommittedChanges() const {
   DCHECK(!is_shutdown_);
   return commit_batch_.get() || commit_batches_in_flight_;
 }
 
 void DomStorageArea::DeleteOrigin() {
   DCHECK(!is_shutdown_);
+  // This function shouldn't be called for sessionStorage.
+  DCHECK(session_storage_backing_.get());
   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 + kPerAreaOverQuotaAllowance);
@@ skipping 31 matching lines @@
       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());
 
   ValuesMap initial_values;
   backing_->ReadAllValues(&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
     // no commits are currently in flight. In that case the timer will be
     // started after the commits have happened.
     if (!commit_batches_in_flight_) {
       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(commit_batch_.get());
-  DCHECK(!commit_batches_in_flight_);
+
+  // It's possible that there is nothing to commit, since a shallow copy occured
+  // before the timer fired.
+  if (!commit_batch_.get())
+    return;
 
   // This method executes on the primary sequence, we schedule
   // a task for immediate execution on the commit sequence.
   DCHECK(task_runner_->IsRunningOnPrimarySequence());
   bool success = task_runner_->PostShutdownBlockingTask(
       FROM_HERE,
       DomStorageTaskRunner::COMMIT_SEQUENCE,
       base::Bind(&DomStorageArea::CommitChanges, this,
                  base::Owned(commit_batch_.release())));
   ++commit_batches_in_flight_;
   DCHECK(success);
 }
 
 void DomStorageArea::CommitChanges(const CommitBatch* commit_batch) {
   // This method executes on the commit sequence.
   DCHECK(task_runner_->IsRunningOnCommitSequence());
   bool success = backing_->CommitChanges(commit_batch->clear_all_first,
                                          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());
+  --commit_batches_in_flight_;
   if (is_shutdown_)
     return;
-  --commit_batches_in_flight_;
   if (commit_batch_.get() && !commit_batches_in_flight_) {
     // 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());
   if (commit_batch_.get()) {
     // Commit any changes that accrued prior to the timer firing.
     bool success = backing_->CommitChanges(
         commit_batch_->clear_all_first,
         commit_batch_->changed_values);
     DCHECK(success);
   }
   commit_batch_.reset();
   backing_.reset();
+  session_storage_backing_ = NULL;
 }
 
 }  // namespace dom_storage