Appcache, local storage, indexed db, databases: skip exit-time deletion when restarting.

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_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;
 
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
 void ClearLocalState(const FilePath& domstorage_path,
-                     quota::SpecialStoragePolicy* special_storage_policy) {
+                     quota::SpecialStoragePolicy* special_storage_policy,
+                     bool clear_all_databases) {
   file_util::FileEnumerator file_enumerator(
       domstorage_path, false, file_util::FileEnumerator::FILES);
   for (FilePath file_path = file_enumerator.Next(); !file_path.empty();
        file_path = file_enumerator.Next()) {
     if (file_path.Extension() == DOMStorageContext::kLocalStorageExtension) {
       GURL origin(WebSecurityOrigin::createFromDatabaseIdentifier(
           webkit_glue::FilePathToWebString(file_path.BaseName())).toString());
-      if (!special_storage_policy->IsStorageProtected(origin))
-        file_util::Delete(file_path, false);
+      if (special_storage_policy->IsStorageProtected(origin))
+        continue;
+      if (!clear_all_databases &&
+          !special_storage_policy->IsStorageSessionOnly(origin)) {
+        continue;
+      }
+      file_util::Delete(file_path, false);
     }
   }
 }
 
 }  // namespace
 
 const FilePath::CharType DOMStorageContext::kLocalStorageDirectory[] =
     FILE_PATH_LITERAL("Local 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),
+      save_session_state_(false),
       special_storage_policy_(special_storage_policy) {
   data_path_ = webkit_context->data_path();
 }
 
 DOMStorageContext::~DOMStorageContext() {
   // This should not go away until all DOM Storage message filters have gone
   // away.  And they remove themselves from this list.
   DCHECK(message_filter_set_.empty());
 
   for (StorageNamespaceMap::iterator iter(storage_namespace_map_.begin());
        iter != storage_namespace_map_.end(); ++iter) {
     delete iter->second;
   }
 
+  if (save_session_state_)
+    return;
+
+  bool has_session_only_databases =
+      special_storage_policy_.get() &&
+      special_storage_policy_->HasSessionOnlyOrigins();
+
+  // Clearning only session-only databases, and there are none.
+  if (!clear_local_state_on_exit_ && !has_session_only_databases)
+    return;
+
   // Not being on the WEBKIT thread here means we are running in a unit test
   // where no clean up is needed.
-  if (clear_local_state_on_exit_ &&
-      BrowserThread::CurrentlyOn(BrowserThread::WEBKIT)) {
+  if (BrowserThread::CurrentlyOn(BrowserThread::WEBKIT)) {
     ClearLocalState(data_path_.Append(kLocalStorageDirectory),
-                    special_storage_policy_);
+                    special_storage_policy_,
+                    clear_local_state_on_exit_);
   }
 }
 
 int64 DOMStorageContext::AllocateStorageAreaId() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
   return ++last_storage_area_id_;
 }
 
 int64 DOMStorageContext::AllocateSessionStorageNamespaceId() {
   if (BrowserThread::CurrentlyOn(BrowserThread::UI))
@@ skipping 105 matching lines @@
     if (special_storage_policy_->IsStorageProtected(origin))
       continue;
 
     file_util::FileEnumerator::FindInfo find_info;
     file_enumerator.GetFindInfo(&find_info);
     if (file_util::HasFileBeenModifiedSince(find_info, cutoff))
       file_util::Delete(path, false);
   }
 }
 
-void DOMStorageContext::DeleteSessionOnlyData() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
-
-  // 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);
-  for (FilePath path = file_enumerator.Next(); !path.value().empty();
-       path = file_enumerator.Next()) {
-    GURL origin(WebSecurityOrigin::createFromDatabaseIdentifier(
-        webkit_glue::FilePathToWebString(path.BaseName())).toString());
-    if (!special_storage_policy_->IsStorageSessionOnly(origin))
-      continue;
-    if (special_storage_policy_->IsStorageProtected(origin))
-      continue;
-
-    file_util::Delete(path, false);
-  }
-}
-
 void DOMStorageContext::DeleteLocalStorageFile(const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::WEBKIT));
 
   // Make sure that we don't delete a database that's currently being accessed
   // by unloading all of the databases temporarily.
   // TODO(bulach): both this method and DeleteDataModifiedSince could purge
   // only the memory used by the specific file instead of all memory at once.
   // See http://crbug.com/32000
   PurgeMemory();
   file_util::Delete(file_path, false);
@@ skipping 59 matching lines @@
 }
 
 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));
 }