Persist sessionStorage on disk.

webkit/dom_storage/dom_storage_context.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_context.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/location.h"
 #include "base/time.h"
 #include "webkit/dom_storage/dom_storage_area.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/quota/special_storage_policy.h"
 
 using file_util::FileEnumerator;
 
 namespace dom_storage {
 
 DomStorageContext::UsageInfo::UsageInfo() : data_size(0) {}
 DomStorageContext::UsageInfo::~UsageInfo() {}
 
 DomStorageContext::DomStorageContext(
     const FilePath& directory,
     quota::SpecialStoragePolicy* special_storage_policy,
     DomStorageTaskRunner* task_runner)
     : directory_(directory),
       task_runner_(task_runner),
       is_shutdown_(false),
       clear_local_state_(false),
       save_session_state_(false),
       special_storage_policy_(special_storage_policy) {
   // AtomicSequenceNum starts at 0 but we want to start session
   // namespace ids at one since zero is reserved for the
   // kLocalStorageNamespaceId.
   session_id_sequence_.GetNext();
+  // FIXME(marja): hack.
+  if (!directory_.empty()) {
+    session_storage_database_ =
+        new SessionStorageDatabase(directory.Append("Session Storage"));
+    // Delete the possible leftover data from previous run from the session
+    // storage.
+    // TODO(marja): When doing a session restore, protect parts of the data from
+    // deletion and call this when we know if a session restore will happen.
+    session_storage_database_->DeleteLeftoverData();

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

This constructor is invoked on the UI thread in chrome early on during profile
creation. We definitely don't want to do a lot of IO at this early time. The
DeleteLeftoverData method results in lots of IO.

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

Yes, this was wrong.

If we crash, DeleteSessionNamespace()s won't be called, and we have leftover
data. When should such data be deleted? On the next startup? Or on the next
clean exit? (Atm, I put it to Shutdown().)

+  }
 }
 
 DomStorageContext::~DomStorageContext() {
 }
 
 DomStorageNamespace* DomStorageContext::GetStorageNamespace(
     int64 namespace_id) {
   if (is_shutdown_)
     return NULL;
   StorageNamespaceMap::iterator found = namespaces_.find(namespace_id);
@@ skipping 28 matching lines @@
       info.origin = DomStorageArea::OriginFromDatabaseFileName(path);
       if (include_file_info) {
         FileEnumerator::FindInfo find_info;
         enumerator.GetFindInfo(&find_info);
         info.data_size = FileEnumerator::GetFilesize(find_info);
         info.last_modified = FileEnumerator::GetLastModifiedTime(find_info);
       }
       infos->push_back(info);
     }
   }
+  // FIXME(marja): Get usage infos for sessionStorage.

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

The content settings ui doesn't show anything about session storage data
currently and the DeleteOrigin and DeleteDataModifiedSince methods only apply to
localstorage atm. Eventually blending in info about 'sessionstorage' usage is a
possibility.

Maybe open a bug for this instead of having a TODO buried in this class since it
also involves changes to the UI layer and programming interfaces used between
here and there?

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

Done. crbug.com/123599

 }
 
 void DomStorageContext::DeleteOrigin(const GURL& origin) {
   DCHECK(!is_shutdown_);
   DomStorageNamespace* local = GetStorageNamespace(kLocalStorageNamespaceId);
   local->DeleteOrigin(origin);
 }
 
 void DomStorageContext::DeleteDataModifiedSince(const base::Time& cutoff) {
   std::vector<UsageInfo> infos;
@@ skipping 84 matching lines @@
       EventObserver, event_observers_,
       OnDomStorageAreaCleared(area, page_url));
 }
 
 void DomStorageContext::CreateSessionNamespace(
     int64 namespace_id) {
   if (is_shutdown_)
     return;
   DCHECK(namespace_id != kLocalStorageNamespaceId);
   DCHECK(namespaces_.find(namespace_id) == namespaces_.end());
-  namespaces_[namespace_id] = new DomStorageNamespace(
-      namespace_id, task_runner_);
+  if (session_storage_database_.get()) {
+    // Session storage with backing.
+    namespaces_[namespace_id] = new DomStorageNamespace(
+        namespace_id, session_storage_database_.get(), task_runner_);
+  } else {
+    // Session storage without backing.
+    namespaces_[namespace_id] = new DomStorageNamespace(
+        namespace_id, task_runner_);
+  }
 }
 
 void DomStorageContext::DeleteSessionNamespace(
     int64 namespace_id) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
   namespaces_.erase(namespace_id);

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

This might be a better place to trigger deletion from the
session_storage_database than the namespace dtor? For two reasons...

1) The namespace dtor will get invoked eventually for all of them when
DomStorageContext is destructed. This will include namespaces that you
presumably want to keep around in the database. As coded the namespace dtor will
remove them from the database too.

2) There's no guarantee about what thread ~DomStorageContext (and consequently
~DomStorageNamespace) happens on. The DeleteSessionNamespace() and Shutdown()
methods are very determistic about that (they're invoked on the PRIMARY_SEQUENCE
defined by the DomStorageTaskRunner).

In general, things in this library are written to not depend on destruction as
much as explicit method calls for book keeping.

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

Done.

 }
 
 void DomStorageContext::CloneSessionNamespace(
     int64 existing_id, int64 new_id) {
   if (is_shutdown_)
     return;
   DCHECK_NE(kLocalStorageNamespaceId, existing_id);
   DCHECK_NE(kLocalStorageNamespaceId, new_id);
   StorageNamespaceMap::iterator found = namespaces_.find(existing_id);
   if (found != namespaces_.end())
@@ skipping 13 matching lines @@
       continue;
     if (!clear_local_state_ &&
         !special_storage_policy_->IsStorageSessionOnly(origin))
       continue;
 
     const bool kNotRecursive = false;
     FilePath database_file_path = directory_.Append(
         DomStorageArea::DatabaseFileNameFromOrigin(origin));
     file_util::Delete(database_file_path, kNotRecursive);
     file_util::Delete(
-        DomStorageDatabase::GetJournalFilePath(database_file_path),
+        LocalStorageDatabase::GetJournalFilePath(database_file_path),
         kNotRecursive);
   }
 }
 
 }  // namespace dom_storage