Expose details for appcache error events [Chromium]

webkit/browser/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/browser/appcache/mock_appcache_storage.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 121 matching lines @@
     const GURL& entry_url, int64 cache_id) {
   AppCache* cache = working_set_.GetCache(cache_id);
   if (cache) {
     AppCacheEntry* entry = cache->GetEntry(entry_url);
     DCHECK(entry);
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
   }
 }
 
-void MockAppCacheStorage::MakeGroupObsolete(
-    AppCacheGroup* group, Delegate* delegate) {
+void MockAppCacheStorage::MakeGroupObsolete(AppCacheGroup* group,
+                                            Delegate* delegate,
+                                            int response_code) {
   DCHECK(group && delegate);
 
   // Always make this method look async.
   ScheduleTask(
       base::Bind(&MockAppCacheStorage::ProcessMakeGroupObsolete,
-                 weak_factory_.GetWeakPtr(), make_scoped_refptr(group),
-                 make_scoped_refptr(GetOrCreateDelegateReference(delegate))));
+                 weak_factory_.GetWeakPtr(),
+                 make_scoped_refptr(group),
+                 make_scoped_refptr(GetOrCreateDelegateReference(delegate)),
+                 response_code));
 }
 
 AppCacheResponseReader* MockAppCacheStorage::CreateResponseReader(
     const GURL& manifest_url, int64 group_id, int64 response_id) {
   if (simulated_reader_)
     return simulated_reader_.release();
   return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* MockAppCacheStorage::CreateResponseWriter(
@@ skipping 247 matching lines @@
     return;
   }
 
   // Didn't find anything.
   delegate_ref->delegate->OnMainResponseFound(
       url, AppCacheEntry(), GURL(), AppCacheEntry(), kNoCacheId, 0, GURL());
 }
 
 void MockAppCacheStorage::ProcessMakeGroupObsolete(
     scoped_refptr<AppCacheGroup> group,
-    scoped_refptr<DelegateReference> delegate_ref) {
+    scoped_refptr<DelegateReference> delegate_ref,
+    int response_code) {
   if (simulate_make_group_obsolete_failure_) {
     if (delegate_ref->delegate)
-      delegate_ref->delegate->OnGroupMadeObsolete(group.get(), false);
+      delegate_ref->delegate->OnGroupMadeObsolete(
+          group.get(), false, response_code);
     return;
   }
 
   RemoveStoredGroup(group.get());
   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);
 
   // Also remove from the working set, caches for an 'obsolete' group
   // may linger in use, but the group itself cannot be looked up by
   // 'manifest_url' in the working set any longer.
   working_set()->RemoveGroup(group.get());
 
   if (delegate_ref->delegate)
-    delegate_ref->delegate->OnGroupMadeObsolete(group.get(), true);
+    delegate_ref->delegate->OnGroupMadeObsolete(
+        group.get(), true, response_code);
 }
 
 void MockAppCacheStorage::ScheduleTask(const base::Closure& task) {
   pending_tasks_.push_back(task);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&MockAppCacheStorage::RunOnePendingTask,
                  weak_factory_.GetWeakPtr()));
 }
 
@@ skipping 75 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