Add storage code to appcache update process.

webkit/appcache/mock_appcache_storage.cc

 // Copyright (c) 2009 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/message_loop.h"
 #include "base/ref_counted.h"
 #include "base/stl_util-inl.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_entry.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_response.h"
 
 // This is a quick and easy 'mock' implementation of the storage interface
 // that doesn't put anything to disk.
 //
 // We simply add an extra reference to objects when they're put in storage,
 // and remove the extra reference when they are removed from storage.
 // Responses are never really removed from the in-memory disk cache.
 // Delegate callbacks are made asyncly to appropiately mimic what will
 // happen with a real disk-backed storage impl that involves IO on a
 // background thread.
 
 namespace appcache {
 
 MockAppCacheStorage::MockAppCacheStorage(AppCacheService* service)
     : AppCacheStorage(service),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+      simulate_make_group_obsolete_failure_(false),
+      simulate_store_group_and_newest_cache_failure_(false) {
   last_cache_id_ = 0;
   last_entry_id_ = 0;
   last_group_id_ = 0;
   last_response_id_ = 0;
 }
 
 MockAppCacheStorage::~MockAppCacheStorage() {
   STLDeleteElements(&pending_tasks_);
 }
 
@@ skipping 108 matching lines @@
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnGroupLoaded(group, manifest_url);
 }
 
 void MockAppCacheStorage::ProcessStoreGroupAndNewestCache(
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<AppCache> newest_cache,
     scoped_refptr<DelegateReference> delegate_ref) {
   DCHECK(group->newest_complete_cache() == newest_cache.get());
 
+  if (simulate_store_group_and_newest_cache_failure_) {
+    if (delegate_ref->delegate)
+      delegate_ref->delegate->OnGroupAndNewestCacheStored(group, false);
+    return;
+  }
+
   AddStoredGroup(group);
   AddStoredCache(group->newest_complete_cache());
 
   // Copy the collection prior to removal, on final release
   // of a cache the group's collection will change.
   AppCacheGroup::Caches copy = group->old_caches();
   RemoveStoredCaches(copy);
 
   if (delegate_ref->delegate)
     delegate_ref->delegate->OnGroupAndNewestCacheStored(group, true);
@@ skipping 19 matching lines @@
   // }
   if (delegate_ref->delegate) {
     delegate_ref->delegate->OnMainResponseFound(
         url, AppCacheEntry(), kNoCacheId, GURL());
   }
 }
 
 void MockAppCacheStorage::ProcessMakeGroupObsolete(
     scoped_refptr<AppCacheGroup> group,
     scoped_refptr<DelegateReference> delegate_ref) {
+  if (simulate_make_group_obsolete_failure_) {
+    if (delegate_ref->delegate)
+      delegate_ref->delegate->OnGroupMadeObsolete(group, false);
+    return;
+  }
+
   RemoveStoredGroup(group);
   if (group->newest_complete_cache())
     RemoveStoredCache(group->newest_complete_cache());
 
   // Copy the collection prior to removal, on final release
   // of a cache the group's collection will change.
   AppCacheGroup::Caches copy = group->old_caches();
   RemoveStoredCaches(copy);
 
   group->set_obsolete(true);
@@ skipping 88 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