Persist sessionStorage on disk.

content/public/browser/dom_storage_context.h

 // Copyright (c) 2011 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_DOM_STORAGE_CONTEXT_H_
 #define CONTENT_PUBLIC_BROWSER_DOM_STORAGE_CONTEXT_H_
 #pragma once
 
 #include <vector>
 
 #include "base/callback.h"
 #include "base/string16.h"
 #include "content/common/content_export.h"
 
 class FilePath;
 
 namespace base {
 class Time;
 }
 
 namespace content {
 
 class BrowserContext;
+class SessionStorageNamespace;
 
 // Represents the per-BrowserContext Local Storage data.
 class DOMStorageContext {
  public:
   typedef base::Callback<void(const std::vector<FilePath>&)>
       GetAllStorageFilesCallback;
 
   // Returns all the file paths of local storage files to the given callback.
   virtual void GetAllStorageFiles(
       const GetAllStorageFilesCallback& callback) = 0;
 
   // Get the file name of the local storage file for the given origin.
   virtual FilePath GetFilePath(const string16& origin_id) const = 0;
 
   // Deletes the local storage file for the given origin.
   virtual void DeleteForOrigin(const string16& origin_id) = 0;
 
   // Deletes a single local storage file.
   virtual void DeleteLocalStorageFile(const FilePath& file_path) = 0;
 
   // Delete any local storage files that have been touched since the cutoff
   // date that's supplied. Protected origins, per the SpecialStoragePolicy,
   // are not deleted by this method.
   virtual void DeleteDataModifiedSince(const base::Time& cutoff) = 0;
 
+  // Called when the sessionStorage for |namespace_id| can safely be deleted
+  // (it won't be used by session restore).
+  virtual void DoomSessionStorage(int64 namespace_id) = 0;

[michaeln, 2012/06/05 01:41:07]

Do you know where the callsite for this method should be? When does it get
called by whom? A little odd that one method works with the shorter lived ids
and the other works with longer lived persistent_ids.

[marja, 2012/06/06 13:37:10]

Atm the DoomSessionStorage is called by SessionService when it gets the "tab
destroyed" notification. Such a tab won't be restored in the next session
restore.

It's possible to know if the last exit was clean or unclean, but if it was
unclean, it's not (atm) possible to know if the "restore your session" infobar
is still visible or not (so there is no well-defined point in time where we can
be sure that the session restore won't happen).

Probably it wouldn't make it any easier to read through the session restore data
we're not going to use, and doom namespaces based on it. If we're didn't
restore, DomStorageContext::DeleteLeftoverDataInCommitSequence will delete all
the data in the db unless we have a good reason for not deleting something (an
existing SessionStorageDatabase, or we know the id is in the current session
restore data).

It doesn't really matter if this takes the int64 id or the persistent id (the
callsite knows both). Changed it to take a persistent id.

+
+  virtual SessionStorageNamespace* CreateSessionStorage(

[michaeln, 2012/06/05 01:41:07]

Probably should have the return value be of type scoped_refptr<T> here since
this is returning a newly created refcounted object. Would
RecreateSessionStorage(persistent_id) or even RestoreSessionStorage(...) be a
better name for this particular method since the intent is to restore an old one
from disk?

[marja, 2012/06/06 13:37:10]

Done. Changed the name to RecreateSessionStorage and made it to return
scoped_refptr.

+      const std::string& persistent_id) = 0;
+
  protected:
   virtual ~DOMStorageContext() {}
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_DOM_STORAGE_CONTEXT_H_