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_database.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& localstorage_directory,
     const FilePath& sessionstorage_directory,
     quota::SpecialStoragePolicy* special_storage_policy,
     DomStorageTaskRunner* task_runner)
     : localstorage_directory_(localstorage_directory),
       sessionstorage_directory_(sessionstorage_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();
+  if (!sessionstorage_directory_.empty()) {
+    session_storage_database_ =
+        new SessionStorageDatabase(sessionstorage_directory_);
+  }
 }
 
 DomStorageContext::~DomStorageContext() {
 }
 
 DomStorageNamespace* DomStorageContext::GetStorageNamespace(
     int64 namespace_id) {
   if (is_shutdown_)
     return NULL;
   StorageNamespaceMap::iterator found = namespaces_.find(namespace_id);
@@ skipping 29 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 (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 39 matching lines @@
   if (clear_local_state_ || has_session_only_origins) {
     // We may have to delete something. We continue on the
     // commit sequence after area shutdown tasks have cycled
     // thru that sequence (and closed their database files).
     bool success = task_runner_->PostShutdownBlockingTask(
         FROM_HERE,
         DomStorageTaskRunner::COMMIT_SEQUENCE,
         base::Bind(&DomStorageContext::ClearLocalStateInCommitSequence, this));
     DCHECK(success);
   }
+
+  // If the last exit was unclean, the session storage backing might contain
+  // leftover data. Delete it now.
+  // TODO(marja): When doing a session restore, protect parts of the data from
+  // deletion.
+  bool success = task_runner_->PostShutdownBlockingTask(
+      FROM_HERE,
+      DomStorageTaskRunner::COMMIT_SEQUENCE,
+      base::Bind(&DomStorageContext::DeleteLeftoverDataInCommitSequence, this));

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

it might be premature to have this here, feels like how/when to identify which
areas to retain and which to nix is not entirely worked out

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

Should I make it so that this CL just deletes all data on clean exit (as it's
not going to associate the data back to the Namespaces after restoring the
session)?

How I think this could work:
- Normally, DeleteSessionNamespace is called for each namespace on exit.
- At that time, we know if we're going to restore the session or not.
- If we're not going to restore, then just delete the data as it is now.
- Also, we need some way to delete the data after a crash: there will be data in
the database but no DomStorageSession or SessionStorageNamespaceImpl classes
associated with it. When should we delete such data? On a clean exit?
- If we're going to restore, the session restore system would tell
DomStorageContext a list of namespace IDs that should be protected from
deletion. DeleteSessionNamespace wouldn't tell delete those. (This functionality
would be in a separate CL.)

So, in this CL I would do this:
- DeleteSessionNamespace always deletes the data.
- We also (somehow) delete the data which is left over after a crash.

In the next CL, I would do this:
- On exit, when we're going to restore, protect parts of the data from deletion.
I'd imagine this works so that the session restore system keeps track of what
namespace id's are associated with the tabs it knows about, and on exit, gives
that list to DomStorageContext.
- When restoring a session, associate the data in the database with the restored
tabs.
- We don't always restore the session after a crash, so that leftover data still
needs to be deleted somewhere.

Wdyt?

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

Maybe don't try to answer this question just yet, and instead make progress on
parts we are certain about (DomStorageArea + session db backing). As coded this
method will delete everything provided there's a clean shutdown (so what why
bother having written it to disk). Let's have chromium built from trunk not
write to disk until its ready to restore from disk.
about when to delete dead stuff, incrementally while up and running is probably
the best answer, at startup isn't an option at all, at shutdown doesn't happen
sometimes and when it does happen a million other things happen too (so it takes
quite a while already)
another way to think about it maybe... DomStorageContext assumes by default that
all new and existing session are to be kept forever... until session restore
says otherwise, DomStorageContext then remembers which its been told can go away
will eventually make those go away.

So as session restore figures out something is no longer needed, it call
DSC.RevokeSessionStorage(id) or some such method. And when doing 'restore', the
session restore can query DSC for a list of unrevoked session ids and call
revoke on those not needing to be restored.

It's probably worth taking a stab at that session restore logic prior to coming
to any final decisions about this aspect of things.

+  DCHECK(success);
 }
 
 void DomStorageContext::AddEventObserver(EventObserver* observer) {
   event_observers_.AddObserver(observer);
 }
 
 void DomStorageContext::RemoveEventObserver(EventObserver* observer) {
   event_observers_.RemoveObserver(observer);
 }
 
@@ skipping 25 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);
+  // TODO(marja): When doing a session restore, protect parts of the data from
+  // deletion.

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

maybe the way the session handling logic in chrome keeps sessions alive across
restarts is by setting a 'restorable' attribute on those
SessionStorageNamespaces, and this lower level logic would avoid deletion of
them.

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

Hmm, not sure yet how this would work.

Could the session restore system tell DomStorageContext a list of namespace ids
not to delete, and they would then be protected from deletion in this function?
(The "which namespace ids are in the session restore data" would be somewhat
easy to maintain. I'm atm slightly confused about which tabs would be restorable
(by the session restore, only the open ones, but by the tab restorer, some
others, and how could SessionStorageNamespaceImpl get to know that...)

+  if (session_storage_database_.get()) {
+    bool success = task_runner_->PostShutdownBlockingTask(
+        FROM_HERE,
+        DomStorageTaskRunner::COMMIT_SEQUENCE,
+        base::Bind(&DomStorageContext::DeleteSessionNamespaceInCommitSequence,
+                   this, namespace_id));
+    DCHECK(success);
+  }
 }
 
 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 18 matching lines @@
     const bool kNotRecursive = false;
     FilePath database_file_path = localstorage_directory_.Append(
         DomStorageArea::DatabaseFileNameFromOrigin(origin));
     file_util::Delete(database_file_path, kNotRecursive);
     file_util::Delete(
         DomStorageDatabase::GetJournalFilePath(database_file_path),
         kNotRecursive);
   }
 }
 
+void DomStorageContext::DeleteSessionNamespaceInCommitSequence(
+    int64 namespace_id) {
+  session_storage_database_->DeleteNamespace(namespace_id);
+}
+
+void DomStorageContext::DeleteLeftoverDataInCommitSequence() {
+  session_storage_database_->DeleteLeftoverData();
+}
+
 }  // namespace dom_storage