AppCaches which belong to hosted apps are not protected from deletion

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 "app/sql/connection.h"
 #include "app/sql/transaction.h"
@@ skipping 1061 matching lines @@
       last_deletable_response_rowid_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(doom_callback_(
           this, &AppCacheStorageImpl::OnDeletedOneResponse)),
       ALLOW_THIS_IN_INITIALIZER_LIST(init_callback_(
           this, &AppCacheStorageImpl::OnDiskCacheInitialized)),
       database_(NULL), is_disabled_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
 }
 
 AppCacheStorageImpl::~AppCacheStorageImpl() {
   STLDeleteElements(&pending_simple_tasks_);

[michaeln, 2011/07/14 00:42:34]

I this this CL can be simplified a lot by posting a task to read what needs to
be read and delete things accordingly... assuming the service has a
clear_on_exit flag...

if (!cache_directory_.empty() && service_->clear_on_exit()) {
  AppCacheThread::PostTask(AppCacheThread::db(), FROM_HERE,
      NewRunnableFunction(ClearOnExit, 
          database_, service_->special_storage_policy()));
}


static void ClearOnExit(AppCacheDatabase* db, scoped_refptr<T> policy) {
  std::set<GURL> origins
  db->FindOriginsWithGroups(&origins);
  if (origins.empty())
    return;  // nothing to delete

  sql::Connection* connection = database_->db_connection();
  if (!connection) {
    NOTREACHED() << "Missing database connection.";
    return;
  }

  foreach origin in origins {
    if (policy && policy->IsProtected(origin))
      continue;

    std::vector<AppCacheDatabase::GroupRecord> groups;
    FindGroupsForOrigin(origin, &groups);
    foreach group in groups {
      sql::Transaction transaction(connection);
      if (!transaction.Begin()) {
        NOTREACHED() << "Failed to start transaction";
        return;
      }

      bool success = false;

      // Logic lifted from MakeGroupObsoleteTask::Run, could be shared.
      AppCacheDatabase::CacheRecord cache_record;
      if (db->FindCacheForGroup(group.group_id, &cache_record)) {
        std::vector<int64> response_ids
        db->FindResponseIdsForCacheAsVector(cache_record.cache_id,
                                            &response_ids);
        success =
          db->DeleteGroup(group.group_id,) &&
          db->DeleteCache(cache_record.cache_id) &&
          db->DeleteEntriesForCache(cache_record.cache_id) &&
          db->DeleteFallbackNameSpacesForCache(cache_record.cache_id) &&
          db->DeleteOnlineWhiteListForCache(cache_record.cache_id) &&
          db->InsertDeletableResponseIds(response_ids);
      } else {
        NOTREACHED() << "A existing group without a cache is unexpected";
        success = db->DeleteGroup(group_id_);
      }

      success = success && transaction.Commit();
      DCHECK(success);
    }
  }
}

[marja(google), 2011/07/14 10:31:59]

Done.

 
   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_)
     AppCacheThread::DeleteSoon(AppCacheThread::db(), FROM_HERE, database_);
@@ skipping 27 matching lines @@
   task->Schedule();
 }
 
 void AppCacheStorageImpl::GetAllInfo(Delegate* delegate) {
   DCHECK(delegate);
   scoped_refptr<GetAllInfoTask> task(new GetAllInfoTask(this));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
 
+void AppCacheStorageImpl::SyncGetAllInfo(Delegate* delegate) {
+  DCHECK(delegate);
+  scoped_refptr<GetAllInfoTask> task(new GetAllInfoTask(this));
+  task->AddDelegate(GetOrCreateDelegateReference(delegate));
+  task->Run();
+  task->RunCompleted();
+}
+
 void AppCacheStorageImpl::LoadCache(int64 id, Delegate* delegate) {
   DCHECK(delegate);
   if (is_disabled_) {
     delegate->OnCacheLoaded(NULL, id);
     return;
   }
 
   AppCache* cache = working_set_.GetCache(id);
   if (cache) {
     delegate->OnCacheLoaded(cache, id);
@@ skipping 47 matching lines @@
     delegate->OnGroupLoaded(group, manifest_url);
     return;
   }
 
   task = new GroupLoadTask(manifest_url, this);
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
   pending_group_loads_[manifest_url] = task.get();
 }
 
+void AppCacheStorageImpl::SyncLoadOrCreateGroup(
+    const GURL& manifest_url, Delegate* delegate) {
+  DCHECK(delegate);
+  if (is_disabled_) {
+    delegate->OnGroupLoaded(NULL, manifest_url);
+    return;
+  }
+
+  AppCacheGroup* group = working_set_.GetGroup(manifest_url);
+  if (group) {
+    delegate->OnGroupLoaded(group, manifest_url);
+    scoped_refptr<DatabaseTask> update_task(
+        new UpdateGroupLastAccessTimeTask(
+            this, group, base::Time::Now()));
+    update_task->Run();
+    update_task->RunCompleted();
+    return;
+  }
+
+  if (usage_map_.find(manifest_url.GetOrigin()) == usage_map_.end()) {
+    // No need to query the database, return a new group immediately.
+    scoped_refptr<AppCacheGroup> group(new AppCacheGroup(
+        service_, manifest_url, NewGroupId()));
+    delegate->OnGroupLoaded(group, manifest_url);
+    return;
+  }
+
+  scoped_refptr<GroupLoadTask> task = new GroupLoadTask(manifest_url, this);
+  task->AddDelegate(GetOrCreateDelegateReference(delegate));
+  task->Run();
+  task->RunCompleted();
+}
+
 void AppCacheStorageImpl::StoreGroupAndNewestCache(
     AppCacheGroup* group, AppCache* newest_cache, Delegate* delegate) {
   // TODO(michaeln): distinguish between a simple update of an existing
   // cache that just adds new master entry(s), and the insertion of a
   // whole new cache. The StoreGroupAndCacheTask as written will handle
   // the simple update case in a very heavy weight way (delete all and
   // the reinsert all over again).
   DCHECK(group && delegate && newest_cache);
   scoped_refptr<StoreGroupAndCacheTask> task(
       new StoreGroupAndCacheTask(this, group, newest_cache));
@@ skipping 159 matching lines @@
 
 void AppCacheStorageImpl::MakeGroupObsolete(
     AppCacheGroup* group, Delegate* delegate) {
   DCHECK(group && delegate);
   scoped_refptr<MakeGroupObsoleteTask> task(
       new MakeGroupObsoleteTask(this, group));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
 
+void AppCacheStorageImpl::SyncMakeGroupObsolete(
+    AppCacheGroup* group, Delegate* delegate) {
+  DCHECK(group && delegate);
+  scoped_refptr<MakeGroupObsoleteTask> task(
+      new MakeGroupObsoleteTask(this, group));
+  task->AddDelegate(GetOrCreateDelegateReference(delegate));
+  task->Run();
+  task->RunCompleted();
+}
+
 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
     const GURL& manifest_url, int64 response_id) {
   return new AppCacheResponseReader(response_id, disk_cache());
 }
 
 AppCacheResponseWriter* AppCacheStorageImpl::CreateResponseWriter(
     const GURL& manifest_url) {
   return new AppCacheResponseWriter(NewResponseId(), disk_cache());
 }
 
@@ skipping 185 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