Restore sessionStorage when chrome restarts.

content/browser/in_process_webkit/dom_storage_context.cc

 // 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.
 
 #include "content/browser/in_process_webkit/dom_storage_context.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/string_util.h"
 #include "content/browser/in_process_webkit/dom_storage_area.h"
+#include "content/browser/in_process_webkit/dom_storage_message_filter.h"
 #include "content/browser/in_process_webkit/dom_storage_namespace.h"
 #include "content/browser/in_process_webkit/webkit_context.h"
 #include "content/common/dom_storage_common.h"
 #include "content/public/browser/browser_thread.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/platform/WebString.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/quota/special_storage_policy.h"
 
 using content::BrowserThread;
@@ skipping 21 matching lines @@
       file_util::Delete(file_path, false);
     }
   }
 }
 
 }  // namespace
 
 const FilePath::CharType DOMStorageContext::kLocalStorageDirectory[] =
     FILE_PATH_LITERAL("Local Storage");
 
+const FilePath::CharType DOMStorageContext::kSessionStorageDirectory[] =
+    FILE_PATH_LITERAL("Session Storage");
+
 const FilePath::CharType DOMStorageContext::kLocalStorageExtension[] =
     FILE_PATH_LITERAL(".localstorage");
 
 DOMStorageContext::DOMStorageContext(
     WebKitContext* webkit_context,
     quota::SpecialStoragePolicy* special_storage_policy)
     : last_storage_area_id_(0),
       last_session_storage_namespace_id_on_ui_thread_(kLocalStorageNamespaceId),
       last_session_storage_namespace_id_on_io_thread_(kLocalStorageNamespaceId),
       clear_local_state_on_exit_(false),
@@ skipping 42 matching lines @@
     return ++last_session_storage_namespace_id_on_ui_thread_;
   return --last_session_storage_namespace_id_on_io_thread_;
 }
 
 int64 DOMStorageContext::CloneSessionStorage(int64 original_id) {
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 clone_id = AllocateSessionStorageNamespaceId();
   BrowserThread::PostTask(
       BrowserThread::WEBKIT_DEPRECATED, FROM_HERE,
       base::Bind(&DOMStorageContext::CompleteCloningSessionStorage, this,
-                 original_id, clone_id));
+                 original_id, clone_id, data_path_));
   return clone_id;
 }
 
 void DOMStorageContext::RegisterStorageArea(DOMStorageArea* storage_area) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 id = storage_area->id();
   DCHECK(!GetStorageArea(id));
   storage_area_map_[id] = storage_area;
 }
 
@@ skipping 12 matching lines @@
   return iter->second;
 }
 
 void DOMStorageContext::DeleteSessionStorageNamespace(int64 namespace_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   StorageNamespaceMap::iterator iter =
       storage_namespace_map_.find(namespace_id);
   if (iter == storage_namespace_map_.end())
     return;
   DCHECK(iter->second->dom_storage_type() == DOM_STORAGE_SESSION);
+  FilePath session_storage_directory =
+      iter->second->session_storage_directory();
   delete iter->second;
   storage_namespace_map_.erase(iter);
+
+  if (!save_session_state_ &&
+      !session_storage_directory.empty() &&
+      !data_path_.empty()) {
+    FilePath to_delete = data_path_.Append(kSessionStorageDirectory)
+        .Append(session_storage_directory);
+  }
 }
 
 DOMStorageNamespace* DOMStorageContext::GetStorageNamespace(
     int64 id, bool allocation_allowed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   StorageNamespaceMap::iterator iter = storage_namespace_map_.find(id);
   if (iter != storage_namespace_map_.end())
     return iter->second;
   if (!allocation_allowed)
     return NULL;
   if (id == kLocalStorageNamespaceId)
     return CreateLocalStorage();
   return CreateSessionStorage(id);
 }
 
+DOMStorageNamespace* DOMStorageContext::RecreateSessionStorageNamespace(
+    int64 id,
+    const FilePath& session_storage_directory) {
+  FilePath dir_path;
+  if (!data_path_.empty()) {
+    dir_path = data_path_.Append(kSessionStorageDirectory)
+        .Append(session_storage_directory);
+  }
+  DOMStorageNamespace* new_namespace =
+      DOMStorageNamespace::CreateSessionStorageNamespace(this, dir_path, id);
+  RegisterStorageNamespace(new_namespace);
+  return new_namespace;
+}
+
 void DOMStorageContext::RegisterMessageFilter(
     DOMStorageMessageFilter* message_filter) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(message_filter_set_.find(message_filter) ==
          message_filter_set_.end());
   message_filter_set_.insert(message_filter);
 }
 
 void DOMStorageContext::UnregisterMessageFilter(
     DOMStorageMessageFilter* message_filter) {
@@ skipping 11 matching lines @@
 
 void DOMStorageContext::PurgeMemory() {
   // It is only safe to purge the memory from the LocalStorage namespace,
   // because it is backed by disk and can be reloaded later.  If we purge a
   // SessionStorage namespace, its data will be gone forever, because it isn't
   // currently backed by disk.
   DOMStorageNamespace* local_storage =
       GetStorageNamespace(kLocalStorageNamespaceId, false);
   if (local_storage)
     local_storage->PurgeMemory();
+  // In non-incognito profiles, the sessionStorage is backed up on the disk, and
+  // can be purged.
+  if (!data_path_.empty()) {
+    for (StorageNamespaceMap::iterator it = storage_namespace_map_.begin();
+         it != storage_namespace_map_.end(); ++it) {
+    }
+  }
 }
 
 void DOMStorageContext::DeleteDataModifiedSince(const base::Time& cutoff) {
   // Make sure that we don't delete a database that's currently being accessed
   // by unloading all of the databases temporarily.
   PurgeMemory();
 
   file_util::FileEnumerator file_enumerator(
       data_path_.Append(kLocalStorageDirectory), false,
       file_util::FileEnumerator::FILES);
@@ skipping 50 matching lines @@
   if (!data_path_.empty())
     dir_path = data_path_.Append(kLocalStorageDirectory);
   DOMStorageNamespace* new_namespace =
       DOMStorageNamespace::CreateLocalStorageNamespace(this, dir_path);
   RegisterStorageNamespace(new_namespace);
   return new_namespace;
 }
 
 DOMStorageNamespace* DOMStorageContext::CreateSessionStorage(
     int64 namespace_id) {
+  FilePath dir_path;
+  if (!data_path_.empty()) {
+    // We cannot derive the directory name for the sessionStorage databases
+    // directly from |namespace_id|. There is no guarantee that the same
+    // namespace ID won't be reused before we restore the session.
+    file_util::CreateDirectory(data_path_.Append(kSessionStorageDirectory));
+    file_util::CreateTemporaryDirInDir(
+        data_path_.Append(kSessionStorageDirectory), "", &dir_path);
+  }
   DOMStorageNamespace* new_namespace =
-      DOMStorageNamespace::CreateSessionStorageNamespace(this, namespace_id);
+      DOMStorageNamespace::CreateSessionStorageNamespace(this, dir_path,
+                                                         namespace_id);
   RegisterStorageNamespace(new_namespace);
   return new_namespace;
 }
 
 void DOMStorageContext::RegisterStorageNamespace(
     DOMStorageNamespace* storage_namespace) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   int64 id = storage_namespace->id();
   DCHECK(!GetStorageNamespace(id, false));
   storage_namespace_map_[id] = storage_namespace;
 }
 
 /* static */
 void DOMStorageContext::CompleteCloningSessionStorage(
-    DOMStorageContext* context, int64 existing_id, int64 clone_id) {
+    DOMStorageContext* context, int64 existing_id, int64 clone_id,
+    const FilePath& data_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT_DEPRECATED));
   DOMStorageNamespace* existing_namespace =
       context->GetStorageNamespace(existing_id, false);
   // If nothing exists, then there's nothing to clone.
-  if (existing_namespace)
-    context->RegisterStorageNamespace(existing_namespace->Copy(clone_id));
+  if (existing_namespace) {
+    if (data_path.empty()) {
+      // Incognito session storage.
+      context->RegisterStorageNamespace(existing_namespace->Copy(clone_id));
+    } else {
+      DOMStorageNamespace* clone_namespace =
+          context->CreateSessionStorage(clone_id);
+      // Copy (in-memory) data from the existing namespace to the clone. Rely on
+      // lazy writing to sync the data eventually on disk.
+      DOMStorageNamespace* existing_namespace =
+          context->GetStorageNamespace(existing_id, false);
+      DCHECK(existing_namespace);
+
+      // Ensure the copying won't cause storage events.
+      DOMStorageMessageFilter::SetIgnoreStorageEvents(true);
+
+      existing_namespace->CopyDataTo(clone_namespace);
+
+      DOMStorageMessageFilter::SetIgnoreStorageEvents(false);
+    }
+  }
 }
 
 FilePath DOMStorageContext::GetLocalStorageFilePath(
     const string16& origin_id) const {
   FilePath storageDir = data_path_.Append(
       DOMStorageContext::kLocalStorageDirectory);
   FilePath::StringType id =
       webkit_glue::WebStringToFilePathString(origin_id);
   return storageDir.Append(id.append(kLocalStorageExtension));
 }
+
+void DOMStorageContext::DeleteUnneededSessionStorages(
+    const std::set<std::string>& needed_session_storages) {
+  file_util::FileEnumerator file_enumerator(
+      data_path_.Append(kSessionStorageDirectory),
+      false, file_util::FileEnumerator::DIRECTORIES);
+  for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
+       file_path = file_enumerator.Next()) {
+    if (needed_session_storages.find(file_path.BaseName().value()) ==
+        needed_session_storages.end())
+      file_util::Delete(file_path, true);
+  }
+}