Expose details for appcache error events [Chromium]

webkit/browser/appcache/appcache_storage_impl.cc

 // Copyright (c) 2012 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/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 1104 matching lines @@
 void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
   DCHECK(storage_->pending_foreign_markings_.front().first == entry_url_ &&
          storage_->pending_foreign_markings_.front().second == cache_id_);
   storage_->pending_foreign_markings_.pop_front();
 }
 
 // MakeGroupObsoleteTask -------
 
 class AppCacheStorageImpl::MakeGroupObsoleteTask : public DatabaseTask {
  public:
-  MakeGroupObsoleteTask(AppCacheStorageImpl* storage, AppCacheGroup* group);
+  MakeGroupObsoleteTask(AppCacheStorageImpl* storage,
+                        AppCacheGroup* group,
+                        int response_code);
 
   // DatabaseTask:
   virtual void Run() OVERRIDE;
   virtual void RunCompleted() OVERRIDE;
   virtual void CancelCompletion() OVERRIDE;
 
  protected:
   virtual ~MakeGroupObsoleteTask() {}
 
  private:
   scoped_refptr<AppCacheGroup> group_;
   int64 group_id_;
   GURL origin_;
   bool success_;
+  int response_code_;
   int64 new_origin_usage_;
   std::vector<int64> newly_deletable_response_ids_;
 };
 
 AppCacheStorageImpl::MakeGroupObsoleteTask::MakeGroupObsoleteTask(
-    AppCacheStorageImpl* storage, AppCacheGroup* group)
-    : DatabaseTask(storage), group_(group), group_id_(group->group_id()),
+    AppCacheStorageImpl* storage,
+    AppCacheGroup* group,
+    int response_code)
+    : DatabaseTask(storage),
+      group_(group),
+      group_id_(group->group_id()),
       origin_(group->manifest_url().GetOrigin()),
-      success_(false), new_origin_usage_(-1) {
-}
+      success_(false),
+      response_code_(response_code),
+      new_origin_usage_(-1) {}
 
 void AppCacheStorageImpl::MakeGroupObsoleteTask::Run() {
   DCHECK(!success_);
   sql::Connection* connection = database_->db_connection();
   if (!connection)
     return;
 
   sql::Transaction transaction(connection);
   if (!transaction.Begin())
     return;
@@ skipping 21 matching lines @@
     if (!storage_->is_disabled()) {
       storage_->UpdateUsageMapAndNotify(origin_, new_origin_usage_);
       group_->AddNewlyDeletableResponseIds(&newly_deletable_response_ids_);
 
       // 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.
       storage_->working_set()->RemoveGroup(group_.get());
     }
   }
-  FOR_EACH_DELEGATE(delegates_, OnGroupMadeObsolete(group_.get(), success_));
+  FOR_EACH_DELEGATE(
+      delegates_, OnGroupMadeObsolete(group_.get(), success_, response_code_));
   group_ = NULL;
 }
 
 void AppCacheStorageImpl::MakeGroupObsoleteTask::CancelCompletion() {
   // Overriden to safely drop our reference to the group
   // which is not thread safe refcounted.
   DatabaseTask::CancelCompletion();
   group_ = NULL;
 }
 
@@ skipping 398 matching lines @@
     DCHECK(entry);
     if (entry)
       entry->add_types(AppCacheEntry::FOREIGN);
   }
   scoped_refptr<MarkEntryAsForeignTask> task(
       new MarkEntryAsForeignTask(this, entry_url, cache_id));
   task->Schedule();
   pending_foreign_markings_.push_back(std::make_pair(entry_url, cache_id));
 }
 
-void AppCacheStorageImpl::MakeGroupObsolete(
-    AppCacheGroup* group, Delegate* delegate) {
+void AppCacheStorageImpl::MakeGroupObsolete(AppCacheGroup* group,
+                                            Delegate* delegate,
+                                            int response_code) {
   DCHECK(group && delegate);
   scoped_refptr<MakeGroupObsoleteTask> task(
-      new MakeGroupObsoleteTask(this, group));
+      new MakeGroupObsoleteTask(this, group, response_code));
   task->AddDelegate(GetOrCreateDelegateReference(delegate));
   task->Schedule();
 }
 
 AppCacheResponseReader* AppCacheStorageImpl::CreateResponseReader(
     const GURL& manifest_url, int64 group_id, int64 response_id) {
   return new AppCacheResponseReader(response_id, group_id, disk_cache());
 }
 
 AppCacheResponseWriter* AppCacheStorageImpl::CreateResponseWriter(
@@ skipping 216 matching lines @@
       base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
                   weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::CallScheduleReinitialize() {
   service_->ScheduleReinitialize();
   // note: 'this' may be deleted at this point.
 }
 
 }  // namespace appcache