AppCaches which belong to hosted apps are not protected from deletion

webkit/appcache/mock_appcache_storage.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/mock_appcache_storage.h"
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
@@ skipping 32 matching lines @@
 MockAppCacheStorage::~MockAppCacheStorage() {
   STLDeleteElements(&pending_tasks_);
 }
 
 void MockAppCacheStorage::GetAllInfo(Delegate* delegate) {
   ScheduleTask(method_factory_.NewRunnableMethod(
       &MockAppCacheStorage::ProcessGetAllInfo,
       make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
+void MockAppCacheStorage::SyncGetAllInfo(Delegate* delegate) {
+  ProcessGetAllInfo(make_scoped_refptr(GetOrCreateDelegateReference(delegate)));
+}
+
 void MockAppCacheStorage::LoadCache(int64 id, Delegate* delegate) {
   DCHECK(delegate);
   AppCache* cache = working_set_.GetCache(id);
   if (ShouldCacheLoadAppearAsync(cache)) {
     ScheduleTask(method_factory_.NewRunnableMethod(
         &MockAppCacheStorage::ProcessLoadCache,
         id, make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
   ProcessLoadCache(id, GetOrCreateDelegateReference(delegate));
 }
 
 void MockAppCacheStorage::LoadOrCreateGroup(
     const GURL& manifest_url, Delegate* delegate) {
   DCHECK(delegate);
   AppCacheGroup* group = working_set_.GetGroup(manifest_url);
   if (ShouldGroupLoadAppearAsync(group)) {
     ScheduleTask(method_factory_.NewRunnableMethod(
         &MockAppCacheStorage::ProcessLoadOrCreateGroup,
         manifest_url,
         make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
     return;
   }
   ProcessLoadOrCreateGroup(
       manifest_url, GetOrCreateDelegateReference(delegate));
 }
 
+void MockAppCacheStorage::SyncLoadOrCreateGroup(
+    const GURL& manifest_url, Delegate* delegate) {
+  DCHECK(delegate);
+  ProcessLoadOrCreateGroup(
+      manifest_url,
+      make_scoped_refptr(GetOrCreateDelegateReference(delegate)));
+}
+
 void MockAppCacheStorage::StoreGroupAndNewestCache(
     AppCacheGroup* group, AppCache* newest_cache, Delegate* delegate) {
   DCHECK(group && delegate && newest_cache);
 
   // Always make this operation look async.
   ScheduleTask(method_factory_.NewRunnableMethod(
       &MockAppCacheStorage::ProcessStoreGroupAndNewestCache,
       make_scoped_refptr(group),
       make_scoped_refptr(newest_cache),
       make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
@@ skipping 48 matching lines @@
     AppCacheGroup* group, Delegate* delegate) {
   DCHECK(group && delegate);
 
   // Always make this method look async.
   ScheduleTask(method_factory_.NewRunnableMethod(
       &MockAppCacheStorage::ProcessMakeGroupObsolete,
       make_scoped_refptr(group),
       make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
 }
 
+void MockAppCacheStorage::SyncMakeGroupObsolete(
+    AppCacheGroup* group, Delegate* delegate) {
+  DCHECK(group && delegate);
+  ProcessMakeGroupObsolete(
+      make_scoped_refptr(group),
+      make_scoped_refptr(GetOrCreateDelegateReference(delegate)));
+}
+
 AppCacheResponseReader* MockAppCacheStorage::CreateResponseReader(
     const GURL& manifest_url, int64 response_id) {
   return new AppCacheResponseReader(response_id, disk_cache());
 }
 
 AppCacheResponseWriter* MockAppCacheStorage::CreateResponseWriter(
     const GURL& manifest_url) {
   return new AppCacheResponseWriter(NewResponseId(), disk_cache());
 }
 
@@ skipping 323 matching lines @@
 bool MockAppCacheStorage::ShouldCacheLoadAppearAsync(const AppCache* cache) {
   if (!cache)
     return true;
 
   // If the 'stored' ref is the only ref, real storage will have to load from
   // the database.
   return IsCacheStored(cache) && cache->HasOneRef();
 }
 
 }  // namespace appcache