Session-only appcache.

webkit/appcache/appcache_storage_impl.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 "webkit/appcache/appcache_storage_impl.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 50 matching lines @@
         database->DeleteFallbackNameSpacesForCache(cache_record.cache_id) &&
         database->DeleteOnlineWhiteListForCache(cache_record.cache_id) &&
         database->InsertDeletableResponseIds(*deletable_response_ids);
   } else {
     NOTREACHED() << "A existing group without a cache is unexpected";
     success = database->DeleteGroup(group_id);
   }
   return success;
 }
 
-void ClearOnExit(
+// Deletes all appcache data (if clear_all_data is true), or session-only
+// appcache data. Also, schedules the database to be destroyed.
+void CleanUpOnDatabaseThread(
     AppCacheDatabase* database,
-    scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
+    scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
+    bool clear_all_appcaches) {
+  scoped_ptr<AppCacheDatabase> database_to_delete(database);
+
+  if (!clear_all_appcaches && !special_storage_policy)
+    return;
+
   std::set<GURL> origins;
   database->FindOriginsWithGroups(&origins);
   if (origins.empty())
     return;  // nothing to delete
 
   sql::Connection* connection = database->db_connection();
   if (!connection) {
     NOTREACHED() << "Missing database connection.";
     return;
   }
 
   std::set<GURL>::const_iterator origin;
   for (origin = origins.begin(); origin != origins.end(); ++origin) {
+    if (!clear_all_appcaches &&
+        !special_storage_policy->IsStorageSessionOnly(*origin))
+      continue;
     if (special_storage_policy &&
         special_storage_policy->IsStorageProtected(*origin))
       continue;
 
     std::vector<AppCacheDatabase::GroupRecord> groups;
     database->FindGroupsForOrigin(*origin, &groups);
     std::vector<AppCacheDatabase::GroupRecord>::const_iterator group;
     for (group = groups.begin(); group != groups.end(); ++group) {
       sql::Transaction transaction(connection);
       if (!transaction.Begin()) {
@@ skipping 1044 matching lines @@
   STLDeleteElements(&pending_simple_tasks_);
 
   std::for_each(pending_quota_queries_.begin(),
                 pending_quota_queries_.end(),
                 std::mem_fun(&DatabaseTask::CancelCompletion));
   std::for_each(scheduled_database_tasks_.begin(),
                 scheduled_database_tasks_.end(),
                 std::mem_fun(&DatabaseTask::CancelCompletion));
 
   if (database_) {
-    if (service()->clear_local_state_on_exit()) {
-      AppCacheThread::PostTask(
-          AppCacheThread::db(),
-          FROM_HERE,
-          NewRunnableFunction(
-              ClearOnExit,
-              database_,
-              make_scoped_refptr(service_->special_storage_policy())));
-    }
-    AppCacheThread::DeleteSoon(AppCacheThread::db(), FROM_HERE, database_);
+    AppCacheThread::PostTask(
+        AppCacheThread::db(),
+        FROM_HERE,
+        NewRunnableFunction(
+            CleanUpOnDatabaseThread,
+            database_,
+            make_scoped_refptr(service_->special_storage_policy()),
+            service()->clear_local_state_on_exit()));
   }
 }
 
 void AppCacheStorageImpl::Initialize(const FilePath& cache_directory,
                                      base::MessageLoopProxy* cache_thread) {
   cache_directory_ = cache_directory;
   cache_thread_ = cache_thread;
   is_incognito_ = cache_directory_.empty();
 
   FilePath db_file_path;
@@ skipping 469 matching lines @@
     Disable();
     if (!is_incognito_) {
       VLOG(1) << "Deleting existing appcache data and starting over.";
       AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
           NewRunnableFunction(DeleteDirectory, cache_directory_));
     }
   }
 }
 
 }  // namespace appcache