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;
 }
 
+// delete_permanent is false if we're deleting only session-only origins.
 void ClearOnExit(
     AppCacheDatabase* database,
-    scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy) {
+    scoped_refptr<quota::SpecialStoragePolicy> special_storage_policy,
+    bool delete_permanent) {

[michaeln, 2011/08/26 21:31:01]

naming nit: Thoughout the project, this flag goes as "clear_on_exit" (or
something close to that with "clear" being the first term). It be nice to retain
that convention here. I see that conflicts with the existing function name since
now the function is used for multiple purposes... see comments in
~AppCacheStorageImpl about this...

[marja, 2011/08/29 09:41:42]

I renamed the flag to clear_all_appcaches (as opposed to clearing only
session-only appcaches), is that ok?

   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;
   }
 
+  // We're deleting only session-only data, and there is no policy. Delete
+  // nothing.
+  if (!delete_permanent && !special_storage_policy)
+    return;
+
   std::set<GURL>::const_iterator origin;
   for (origin = origins.begin(); origin != origins.end(); ++origin) {
+    // We're deleting session-only origins, and this origin is not a
+    // session-only origin.
+    if (!delete_permanent &&
+        !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::PostTask(
+        AppCacheThread::db(),
+        FROM_HERE,
+        NewRunnableFunction(
+            ClearOnExit,

[michaeln, 2011/08/26 21:31:01]

Since this is now done unconditionally, maybe rename the function to
CleanUpOnDatabaseThread (or something along those lines), and have it also be
responsible for calling delete on the database instance, in addition to being
responsible for doing clear_local_state and clear_session_only_state stuff.

[marja, 2011/08/29 09:41:42]

Renamed to CleanUpOnDatabaseThread.

+            database_,
+            make_scoped_refptr(service_->special_storage_policy()),
+            service()->clear_local_state_on_exit()));
     AppCacheThread::DeleteSoon(AppCacheThread::db(), FROM_HERE, database_);

[michaeln, 2011/08/26 21:31:01]

if you buy that, this line could be deleted

[marja, 2011/08/29 09:41:42]

Done.

   }
 }
 
 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