Expose details for appcache error events

Chromium side. Would land after Blink side.

BUG=342555

Review URL: https://codereview.chromium.org/164933002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260732 0039d316-1c4b-4281-b951-d872f2087c98

16 files changed, 226 insertions, 89 deletions

diff --git a/webkit/browser/appcache/appcache_group_unittest.cc b/webkit/browser/appcache/appcache_group_unittest.cc
index 3497c26..bb574cb 100644
--- a/webkit/browser/appcache/appcache_group_unittest.cc
+++ b/webkit/browser/appcache/appcache_group_unittest.cc
@@ -38,8 +38,8 @@ class TestAppCacheFrontend : public appcache::AppCacheFrontend {
   }
 
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                  const std::string& message) OVERRIDE {
-  }
+                                  const appcache::ErrorDetails& details)
+      OVERRIDE {}
 
   virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                      const GURL& url,
diff --git a/webkit/browser/appcache/appcache_host.cc b/webkit/browser/appcache/appcache_host.cc
index 598b100..b4b4222 100644
--- a/webkit/browser/appcache/appcache_host.cc
+++ b/webkit/browser/appcache/appcache_host.cc
@@ -116,7 +116,12 @@ void AppCacheHost::SelectCache(const GURL& document_url,
       std::vector<int> host_ids(1, host_id_);
       frontend_->OnEventRaised(host_ids, CHECKING_EVENT);
       frontend_->OnErrorEventRaised(
-          host_ids, "Cache creation was blocked by the content policy");
+          host_ids,
+          ErrorDetails("Cache creation was blocked by the content policy",
+                       POLICY_ERROR,
+                       GURL(),
+                       0,
+                       false /*is_cross_origin*/));
       frontend_->OnContentBlocked(host_id_, manifest_url);
       return;
     }
diff --git a/webkit/browser/appcache/appcache_host_unittest.cc b/webkit/browser/appcache/appcache_host_unittest.cc
index 5e78ce8..3462e3a 100644
--- a/webkit/browser/appcache/appcache_host_unittest.cc
+++ b/webkit/browser/appcache/appcache_host_unittest.cc
@@ -60,7 +60,8 @@ class AppCacheHostTest : public testing::Test {
     }
 
     virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                    const std::string& message) OVERRIDE {
+                                    const appcache::ErrorDetails& details)
+        OVERRIDE {
       last_event_id_ = ERROR_EVENT;
     }
 
diff --git a/webkit/browser/appcache/appcache_request_handler_unittest.cc b/webkit/browser/appcache/appcache_request_handler_unittest.cc
index a931477..f9c9a74 100644
--- a/webkit/browser/appcache/appcache_request_handler_unittest.cc
+++ b/webkit/browser/appcache/appcache_request_handler_unittest.cc
@@ -44,7 +44,8 @@ class AppCacheRequestHandlerTest : public testing::Test {
                                appcache::EventID event_id) OVERRIDE {}
 
     virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                    const std::string& message) OVERRIDE {}
+                                    const appcache::ErrorDetails& details)
+        OVERRIDE {}
 
     virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
                                        const GURL& url,
diff --git a/webkit/browser/appcache/appcache_service.cc b/webkit/browser/appcache/appcache_service.cc
index 575355a..f330519 100644
--- a/webkit/browser/appcache/appcache_service.cc
+++ b/webkit/browser/appcache/appcache_service.cc
@@ -143,8 +143,9 @@ class AppCacheService::DeleteHelper : public AsyncHelper {
   // AppCacheStorage::Delegate implementation.
   virtual void OnGroupLoaded(
       appcache::AppCacheGroup* group, const GURL& manifest_url) OVERRIDE;
-  virtual void OnGroupMadeObsolete(
-      appcache::AppCacheGroup* group, bool success) OVERRIDE;
+  virtual void OnGroupMadeObsolete(appcache::AppCacheGroup* group,
+                                   bool success,
+                                   int response_code) OVERRIDE;
 
   GURL manifest_url_;
   DISALLOW_COPY_AND_ASSIGN(DeleteHelper);
@@ -155,7 +156,7 @@ void AppCacheService::DeleteHelper::OnGroupLoaded(
   if (group) {
     group->set_being_deleted(true);
     group->CancelUpdate();
-    service_->storage()->MakeGroupObsolete(group, this);
+    service_->storage()->MakeGroupObsolete(group, this, 0);
   } else {
     CallCallback(net::ERR_FAILED);
     delete this;
@@ -163,7 +164,9 @@ void AppCacheService::DeleteHelper::OnGroupLoaded(
 }
 
 void AppCacheService::DeleteHelper::OnGroupMadeObsolete(
-      appcache::AppCacheGroup* group, bool success) {
+    appcache::AppCacheGroup* group,
+    bool success,
+    int response_code) {
   CallCallback(success ? net::OK : net::ERR_FAILED);
   delete this;
 }
@@ -189,8 +192,9 @@ class AppCacheService::DeleteOriginHelper : public AsyncHelper {
   virtual void OnAllInfo(AppCacheInfoCollection* collection) OVERRIDE;
   virtual void OnGroupLoaded(
       appcache::AppCacheGroup* group, const GURL& manifest_url) OVERRIDE;
-  virtual void OnGroupMadeObsolete(
-      appcache::AppCacheGroup* group, bool success) OVERRIDE;
+  virtual void OnGroupMadeObsolete(appcache::AppCacheGroup* group,
+                                   bool success,
+                                   int response_code) OVERRIDE;
 
   void CacheCompleted(bool success);
 
@@ -236,14 +240,16 @@ void AppCacheService::DeleteOriginHelper::OnGroupLoaded(
   if (group) {
     group->set_being_deleted(true);
     group->CancelUpdate();
-    service_->storage()->MakeGroupObsolete(group, this);
+    service_->storage()->MakeGroupObsolete(group, this, 0);
   } else {
     CacheCompleted(false);
   }
 }
 
 void AppCacheService::DeleteOriginHelper::OnGroupMadeObsolete(
-      appcache::AppCacheGroup* group, bool success) {
+    appcache::AppCacheGroup* group,
+    bool success,
+    int response_code) {
   CacheCompleted(success);
 }
 
diff --git a/webkit/browser/appcache/appcache_storage.h b/webkit/browser/appcache/appcache_storage.h
index b7a696f..a6bdd0e 100644
--- a/webkit/browser/appcache/appcache_storage.h
+++ b/webkit/browser/appcache/appcache_storage.h
@@ -52,7 +52,9 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheStorage {
         bool would_exceed_quota) {}
 
     // If the operation fails, success will be false.
-    virtual void OnGroupMadeObsolete(AppCacheGroup* group, bool success) {}
+    virtual void OnGroupMadeObsolete(AppCacheGroup* group,
+                                     bool success,
+                                     int response_code) {}
 
     // If a load fails the 'response_info' will be NULL.
     virtual void OnResponseInfoLoaded(
@@ -140,8 +142,9 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheStorage {
   // Schedules a task to update persistent storage and doom the group and all
   // related caches and responses for deletion. Upon completion the in-memory
   // instance is marked as obsolete and the delegate callback is called.
-  virtual void MakeGroupObsolete(
-      AppCacheGroup* group, Delegate* delegate) = 0;
+  virtual void MakeGroupObsolete(AppCacheGroup* group,
+                                 Delegate* delegate,
+                                 int response_code) = 0;
 
   // Cancels all pending callbacks for the delegate. The delegate callbacks
   // will not be invoked after, however any scheduled operations will still
diff --git a/webkit/browser/appcache/appcache_storage_impl.cc b/webkit/browser/appcache/appcache_storage_impl.cc
index 66abca1..1b0c039 100644
--- a/webkit/browser/appcache/appcache_storage_impl.cc
+++ b/webkit/browser/appcache/appcache_storage_impl.cc
@@ -1122,7 +1122,9 @@ void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
 
 class AppCacheStorageImpl::MakeGroupObsoleteTask : public DatabaseTask {
  public:
-  MakeGroupObsoleteTask(AppCacheStorageImpl* storage, AppCacheGroup* group);
+  MakeGroupObsoleteTask(AppCacheStorageImpl* storage,
+                        AppCacheGroup* group,
+                        int response_code);
 
   // DatabaseTask:
   virtual void Run() OVERRIDE;
@@ -1137,16 +1139,22 @@ class AppCacheStorageImpl::MakeGroupObsoleteTask : public DatabaseTask {
   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_);
@@ -1188,7 +1196,8 @@ void AppCacheStorageImpl::MakeGroupObsoleteTask::RunCompleted() {
       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;
 }
 
@@ -1607,11 +1616,12 @@ void AppCacheStorageImpl::MarkEntryAsForeign(
   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();
 }
diff --git a/webkit/browser/appcache/appcache_storage_impl.h b/webkit/browser/appcache/appcache_storage_impl.h
index 2ea3ad6..482bb15 100644
--- a/webkit/browser/appcache/appcache_storage_impl.h
+++ b/webkit/browser/appcache/appcache_storage_impl.h
@@ -55,7 +55,8 @@ class AppCacheStorageImpl : public AppCacheStorage {
   virtual void MarkEntryAsForeign(const GURL& entry_url,
                                   int64 cache_id) OVERRIDE;
   virtual void MakeGroupObsolete(AppCacheGroup* group,
-                                 Delegate* delegate) OVERRIDE;
+                                 Delegate* delegate,
+                                 int response_code) OVERRIDE;
   virtual AppCacheResponseReader* CreateResponseReader(
       const GURL& manifest_url, int64 group_id, int64 response_id) OVERRIDE;
   virtual AppCacheResponseWriter* CreateResponseWriter(
diff --git a/webkit/browser/appcache/appcache_storage_impl_unittest.cc b/webkit/browser/appcache/appcache_storage_impl_unittest.cc
index 8a4d5d7..0e364f5 100644
--- a/webkit/browser/appcache/appcache_storage_impl_unittest.cc
+++ b/webkit/browser/appcache/appcache_storage_impl_unittest.cc
@@ -207,7 +207,8 @@ class AppCacheStorageImplTest : public testing::Test {
     }
 
     virtual void OnGroupMadeObsolete(AppCacheGroup* group,
-                                     bool success) OVERRIDE {
+                                     bool success,
+                                     int response_code) OVERRIDE {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
       test_->ScheduleNextTask();
@@ -820,7 +821,7 @@ class AppCacheStorageImplTest : public testing::Test {
     EXPECT_TRUE(database()->InsertOnlineWhiteList(&online_whitelist_record));
 
     // Conduct the test.
-    storage()->MakeGroupObsolete(group_.get(), delegate());
+    storage()->MakeGroupObsolete(group_.get(), delegate(), 0);
     EXPECT_FALSE(group_->is_obsolete());
   }
 
@@ -1607,7 +1608,8 @@ class AppCacheStorageImplTest : public testing::Test {
         const GURL& url,
         int num_total, int num_complete) OVERRIDE {}
     virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                    const std::string& message) OVERRIDE {
+                                    const appcache::ErrorDetails& details)
+        OVERRIDE {
       error_event_was_raised_ = true;
     }
     virtual void OnLogMessage(int host_id, LogLevel log_level,
diff --git a/webkit/browser/appcache/appcache_unittest.cc b/webkit/browser/appcache/appcache_unittest.cc
index c0e49204..a7b79a6 100644
--- a/webkit/browser/appcache/appcache_unittest.cc
+++ b/webkit/browser/appcache/appcache_unittest.cc
@@ -13,8 +13,8 @@ namespace {
 
 class MockAppCacheFrontend : public AppCacheFrontend {
  public:
-  virtual void OnCacheSelected(
-      int host_id, const appcache::AppCacheInfo& info) OVERRIDE {}
+  virtual void OnCacheSelected(int host_id, const AppCacheInfo& info) OVERRIDE {
+  }
   virtual void OnStatusChanged(const std::vector<int>& host_ids,
                                Status status) OVERRIDE {}
   virtual void OnEventRaised(const std::vector<int>& host_ids,
@@ -24,7 +24,7 @@ class MockAppCacheFrontend : public AppCacheFrontend {
       const GURL& url,
       int num_total, int num_complete) OVERRIDE {}
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                  const std::string& message) OVERRIDE {}
+                                  const ErrorDetails& details) OVERRIDE {}
   virtual void OnLogMessage(int host_id, LogLevel log_level,
                             const std::string& message) OVERRIDE {}
   virtual void OnContentBlocked(
diff --git a/webkit/browser/appcache/appcache_update_job.cc b/webkit/browser/appcache/appcache_update_job.cc
index 33a68b0..0cd087e 100644
--- a/webkit/browser/appcache/appcache_update_job.cc
+++ b/webkit/browser/appcache/appcache_update_job.cc
@@ -76,12 +76,12 @@ class HostNotifier {
     }
   }
 
-  void SendErrorNotifications(const std::string& error_message) {
-    DCHECK(!error_message.empty());
+  void SendErrorNotifications(const ErrorDetails& details) {
+    DCHECK(!details.message.empty());
     for (NotifyHostMap::iterator it = hosts_to_notify.begin();
          it != hosts_to_notify.end(); ++it) {
       AppCacheFrontend* frontend = it->first;
-      frontend->OnErrorEventRaised(it->second, error_message);
+      frontend->OnErrorEventRaised(it->second, details);
     }
   }
 
@@ -112,8 +112,9 @@ AppCacheUpdateJob::URLFetcher::URLFetcher(const GURL& url,
       retry_503_attempts_(0),
       buffer_(new net::IOBuffer(kBufferSize)),
       request_(job->service_->request_context()
-               ->CreateRequest(url, net::DEFAULT_PRIORITY, this, NULL)),
-      result_(UPDATE_OK) {}
+                   ->CreateRequest(url, net::DEFAULT_PRIORITY, this, NULL)),
+      result_(UPDATE_OK),
+      redirect_response_code_(-1) {}
 
 AppCacheUpdateJob::URLFetcher::~URLFetcher() {
 }
@@ -132,6 +133,7 @@ void AppCacheUpdateJob::URLFetcher::OnReceivedRedirect(
   DCHECK(request_ == request);
   // Redirect is not allowed by the update process.
   job_->MadeProgress();
+  redirect_response_code_ = request->GetResponseCode();
   request->Cancel();
   result_ = REDIRECT_ERROR;
   OnResponseCompleted();
@@ -158,6 +160,7 @@ void AppCacheUpdateJob::URLFetcher::OnResponseStarted(
         url_.GetOrigin() != job_->manifest_url_.GetOrigin()) {
       if (request->response_headers()->
               HasHeaderValue("cache-control", "no-store")) {
+        DCHECK_EQ(-1, redirect_response_code_);
         request->Cancel();
         result_ = SERVER_ERROR;  // Not the best match?
         OnResponseCompleted();
@@ -428,19 +431,18 @@ AppCacheResponseWriter* AppCacheUpdateJob::CreateResponseWriter() {
   return writer;
 }
 
-void AppCacheUpdateJob::HandleCacheFailure(
-    const std::string& error_message,
-    ResultType result,
-    const GURL& failed_resource_url) {
+void AppCacheUpdateJob::HandleCacheFailure(const ErrorDetails& error_details,
+                                           ResultType result,
+                                           const GURL& failed_resource_url) {
   // 6.9.4 cache failure steps 2-8.
   DCHECK(internal_state_ != CACHE_FAILURE);
-  DCHECK(!error_message.empty());
+  DCHECK(!error_details.message.empty());
   DCHECK(result != UPDATE_OK);
   internal_state_ = CACHE_FAILURE;
   LogHistogramStats(result, failed_resource_url);
   CancelAllUrlFetches();
-  CancelAllMasterEntryFetches(error_message);
-  NotifyAllError(error_message);
+  CancelAllMasterEntryFetches(error_details);
+  NotifyAllError(error_details);
   DiscardInprogressCache();
   internal_state_ = COMPLETED;
   DeleteSoon();  // To unwind the stack prior to deletion.
@@ -501,20 +503,32 @@ void AppCacheUpdateJob::HandleManifestFetchCompleted(
     ContinueHandleManifestFetchCompleted(false);
   } else if ((response_code == 404 || response_code == 410) &&
              update_type_ == UPGRADE_ATTEMPT) {
-    storage_->MakeGroupObsolete(group_, this);  // async
+    storage_->MakeGroupObsolete(group_, this, response_code);  // async
   } else {
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, manifest_url_, fetcher->result(), response_code);
-    HandleCacheFailure(message, fetcher->result(), GURL());
+    HandleCacheFailure(ErrorDetails(message,
+                                    appcache::MANIFEST_ERROR,
+                                    manifest_url_,
+                                    response_code,
+                                    false /*is_cross_origin*/),
+                       fetcher->result(),
+                       GURL());
   }
 }
 
 void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
-                                            bool success) {
+                                            bool success,
+                                            int response_code) {
   DCHECK(master_entry_fetches_.empty());
-  CancelAllMasterEntryFetches("The cache has been made obsolete, "
-                              "the manifest file returned 404 or 410");
+  CancelAllMasterEntryFetches(ErrorDetails(
+      "The cache has been made obsolete, "
+      "the manifest file returned 404 or 410",
+      appcache::MANIFEST_ERROR,
+      GURL(),
+      response_code,
+      false /*is_cross_origin*/));
   if (success) {
     DCHECK(group->is_obsolete());
     NotifyAllAssociatedHosts(OBSOLETE_EVENT);
@@ -522,8 +536,13 @@ void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
     MaybeCompleteUpdate();
   } else {
     // Treat failure to mark group obsolete as a cache failure.
-    HandleCacheFailure("Failed to mark the cache as obsolete",
-                       DB_ERROR, GURL());
+    HandleCacheFailure(ErrorDetails("Failed to mark the cache as obsolete",
+                                    UNKNOWN_ERROR,
+                                    GURL(),
+                                    0,
+                                    false /*is_cross_origin*/),
+                       DB_ERROR,
+                       GURL());
   }
 }
 
@@ -546,7 +565,11 @@ void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
     const char* kFormatString = "Failed to parse manifest %s";
     const std::string message = base::StringPrintf(kFormatString,
         manifest_url_.spec().c_str());
-    HandleCacheFailure(message, MANIFEST_ERROR, GURL());
+    HandleCacheFailure(
+        ErrorDetails(
+            message, SIGNATURE_ERROR, GURL(), 0, false /*is_cross_origin*/),
+        MANIFEST_ERROR,
+        GURL());
     VLOG(1) << message;
     return;
   }
@@ -585,7 +608,9 @@ void AppCacheUpdateJob::HandleUrlFetchCompleted(URLFetcher* fetcher) {
   ++url_fetches_completed_;
 
   int response_code = request->status().is_success()
-      ? request->GetResponseCode() : -1;
+                          ? request->GetResponseCode()
+                          : fetcher->redirect_response_code();
+
   AppCacheEntry& entry = url_file_list_.find(url)->second;
 
   if (response_code / 100 == 2) {
@@ -620,7 +645,32 @@ void AppCacheUpdateJob::HandleUrlFetchCompleted(URLFetcher* fetcher) {
         const char* kFormatString = "Resource fetch failed (%d) %s";
         std::string message = FormatUrlErrorMessage(
             kFormatString, url, fetcher->result(), response_code);
-        HandleCacheFailure(message, fetcher->result(), url);
+        ResultType result = fetcher->result();
+        bool is_cross_origin = url.GetOrigin() != manifest_url_.GetOrigin();
+        switch (result) {
+          case DISKCACHE_ERROR:
+            HandleCacheFailure(
+                ErrorDetails(
+                    message, UNKNOWN_ERROR, GURL(), 0, is_cross_origin),
+                result,
+                url);
+            break;
+          case NETWORK_ERROR:
+            HandleCacheFailure(
+                ErrorDetails(message, RESOURCE_ERROR, url, 0, is_cross_origin),
+                result,
+                url);
+            break;
+          default:
+            HandleCacheFailure(ErrorDetails(message,
+                                            RESOURCE_ERROR,
+                                            url,
+                                            response_code,
+                                            is_cross_origin),
+                               result,
+                               url);
+            break;
+        }
         return;
       }
     } else if (response_code == 404 || response_code == 410) {
@@ -705,7 +755,12 @@ void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(
     const char* kFormatString = "Manifest fetch failed (%d) %s";
     std::string message = FormatUrlErrorMessage(
         kFormatString, request->url(), fetcher->result(), response_code);
-    host_notifier.SendErrorNotifications(message);
+    host_notifier.SendErrorNotifications(
+        ErrorDetails(message,
+                     appcache::MANIFEST_ERROR,
+                     request->url(),
+                     response_code,
+                     false /*is_cross_origin*/));
 
     // In downloading case, update result is different if all master entries
     // failed vs. only some failing.
@@ -716,7 +771,13 @@ void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(
 
       // Section 6.9.4, step 22.3.
       if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
-        HandleCacheFailure(message, fetcher->result(), GURL());
+        HandleCacheFailure(ErrorDetails(message,
+                                        appcache::MANIFEST_ERROR,
+                                        request->url(),
+                                        response_code,
+                                        false /*is_cross_origin*/),
+                           fetcher->result(),
+                           GURL());
         return;
       }
     }
@@ -758,13 +819,24 @@ void AppCacheUpdateJob::HandleManifestRefetchCompleted(
             << " response code: " << response_code;
     ScheduleUpdateRetry(kRerunDelayMs);
     if (response_code == 200) {
-      HandleCacheFailure(
-          "Manifest changed during update", MANIFEST_ERROR, GURL());
+      HandleCacheFailure(ErrorDetails("Manifest changed during update",
+                                      CHANGED_ERROR,
+                                      GURL(),
+                                      0,
+                                      false /*is_cross_origin*/),
+                         MANIFEST_ERROR,
+                         GURL());
     } else {
       const char* kFormatString = "Manifest re-fetch failed (%d) %s";
       std::string message = FormatUrlErrorMessage(
           kFormatString, manifest_url_, fetcher->result(), response_code);
-      HandleCacheFailure(message, fetcher->result(), GURL());
+      HandleCacheFailure(ErrorDetails(message,
+                                      appcache::MANIFEST_ERROR,
+                                      GURL(),
+                                      response_code,
+                                      false /*is_cross_origin*/),
+                         fetcher->result(),
+                         GURL());
     }
   }
 }
@@ -779,8 +851,14 @@ void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
         base::Bind(&AppCacheUpdateJob::OnManifestDataWriteComplete,
                    base::Unretained(this)));
   } else {
-    HandleCacheFailure("Failed to write the manifest headers to storage",
-                       DISKCACHE_ERROR, GURL());
+    HandleCacheFailure(
+        ErrorDetails("Failed to write the manifest headers to storage",
+                     UNKNOWN_ERROR,
+                     GURL(),
+                     0,
+                     false /*is_cross_origin*/),
+        DISKCACHE_ERROR,
+        GURL());
   }
 }
 
@@ -793,8 +871,14 @@ void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
       duplicate_response_ids_.push_back(entry.response_id());
     StoreGroupAndCache();
   } else {
-    HandleCacheFailure("Failed to write the manifest data to storage",
-                       DISKCACHE_ERROR, GURL());
+    HandleCacheFailure(
+        ErrorDetails("Failed to write the manifest data to storage",
+                     UNKNOWN_ERROR,
+                     GURL(),
+                     0,
+                     false /*is_cross_origin*/),
+        DISKCACHE_ERROR,
+        GURL());
   }
 }
 
@@ -830,12 +914,17 @@ void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
       inprogress_cache_ = newest_cache;
 
     ResultType result = DB_ERROR;
+    ErrorReason reason = UNKNOWN_ERROR;
     std::string message("Failed to commit new cache to storage");
     if (would_exceed_quota) {
       message.append(", would exceed quota");
       result = QUOTA_ERROR;
+      reason = appcache::QUOTA_ERROR;
     }
-    HandleCacheFailure(message, result, GURL());
+    HandleCacheFailure(
+        ErrorDetails(message, reason, GURL(), 0, false /*is_cross_origin*/),
+        result,
+        GURL());
   }
 }
 
@@ -863,10 +952,10 @@ void AppCacheUpdateJob::NotifyAllFinalProgress() {
   NotifyAllProgress(GURL());
 }
 
-void AppCacheUpdateJob::NotifyAllError(const std::string& error_message) {
+void AppCacheUpdateJob::NotifyAllError(const ErrorDetails& details) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
-  host_notifier.SendErrorNotifications(error_message);
+  host_notifier.SendErrorNotifications(details);
 }
 
 void AppCacheUpdateJob::AddAllAssociatedHostsToNotifier(
@@ -920,8 +1009,14 @@ void AppCacheUpdateJob::CheckIfManifestChanged() {
     if (service_->storage() == storage_) {
       // Use a local variable because service_ is reset in HandleCacheFailure.
       AppCacheService* service = service_;
-      HandleCacheFailure("Manifest entry not found in existing cache",
-                         DB_ERROR, GURL());
+      HandleCacheFailure(
+          ErrorDetails("Manifest entry not found in existing cache",
+                       UNKNOWN_ERROR,
+                       GURL(),
+                       0,
+                       false /*is_cross_origin*/),
+          DB_ERROR,
+          GURL());
       AppCacheHistograms::AddMissingManifestEntrySample();
       service->DeleteAppCacheGroup(manifest_url_, net::CompletionCallback());
     }
@@ -1162,7 +1257,7 @@ void AppCacheUpdateJob::FetchMasterEntries() {
 }
 
 void AppCacheUpdateJob::CancelAllMasterEntryFetches(
-    const std::string& error_message) {
+    const ErrorDetails& error_details) {
   // For now, cancel all in-progress fetches for master entries and pretend
   // all master entries fetches have completed.
   // TODO(jennb): Delete this when update no longer fetches master entries
@@ -1198,7 +1293,7 @@ void AppCacheUpdateJob::CancelAllMasterEntryFetches(
 
     master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
   }
-  host_notifier.SendErrorNotifications(error_message);
+  host_notifier.SendErrorNotifications(error_details);
 }
 
 bool AppCacheUpdateJob::MaybeLoadFromNewestCache(const GURL& url,
diff --git a/webkit/browser/appcache/appcache_update_job.h b/webkit/browser/appcache/appcache_update_job.h
index 97ba905..09e8669 100644
--- a/webkit/browser/appcache/appcache_update_job.h
+++ b/webkit/browser/appcache/appcache_update_job.h
@@ -127,6 +127,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
       existing_entry_ = entry;
     }
     ResultType result() const { return result_; }
+    int redirect_response_code() const { return redirect_response_code_; }
 
    private:
     // URLRequest::Delegate overrides
@@ -154,6 +155,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
     scoped_refptr<net::HttpResponseHeaders> existing_response_headers_;
     std::string manifest_data_;
     ResultType result_;
+    int redirect_response_code_;
     scoped_ptr<AppCacheResponseWriter> response_writer_;
   };  // class URLFetcher
 
@@ -166,7 +168,9 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
                                            AppCache* newest_cache,
                                            bool success,
                                            bool would_exceed_quota) OVERRIDE;
-  virtual void OnGroupMadeObsolete(AppCacheGroup* group, bool success) OVERRIDE;
+  virtual void OnGroupMadeObsolete(AppCacheGroup* group,
+                                   bool success,
+                                   int response_code) OVERRIDE;
 
   // Methods for AppCacheHost::Observer.
   virtual void OnCacheSelectionComplete(AppCacheHost* host) OVERRIDE {}  // N/A
@@ -176,7 +180,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
   virtual void OnServiceReinitialized(
       AppCacheStorageReference* old_storage) OVERRIDE;
 
-  void HandleCacheFailure(const std::string& error_message,
+  void HandleCacheFailure(const ErrorDetails& details,
                           ResultType result,
                           const GURL& failed_resource_url);
 
@@ -197,7 +201,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
   void NotifyAllAssociatedHosts(EventID event_id);
   void NotifyAllProgress(const GURL& url);
   void NotifyAllFinalProgress();
-  void NotifyAllError(const std::string& error_message);
+  void NotifyAllError(const ErrorDetails& detals);
   void AddAllAssociatedHostsToNotifier(HostNotifier* notifier);
 
   // Checks if manifest is byte for byte identical with the manifest
@@ -224,7 +228,7 @@ class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheUpdateJob
   void AddMasterEntryToFetchList(AppCacheHost* host, const GURL& url,
                                  bool is_new);
   void FetchMasterEntries();
-  void CancelAllMasterEntryFetches(const std::string& error_message);
+  void CancelAllMasterEntryFetches(const ErrorDetails& details);
 
   // Asynchronously loads the entry from the newest complete cache if the
   // HTTP caching semantics allow.
diff --git a/webkit/browser/appcache/appcache_update_job_unittest.cc b/webkit/browser/appcache/appcache_update_job_unittest.cc
index ba3cf9a..c7c9e41 100644
--- a/webkit/browser/appcache/appcache_update_job_unittest.cc
+++ b/webkit/browser/appcache/appcache_update_job_unittest.cc
@@ -243,8 +243,9 @@ class MockFrontend : public AppCacheFrontend {
   }
 
   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
-                                  const std::string& message) OVERRIDE {
-    error_message_ = message;
+                                  const appcache::ErrorDetails& details)
+      OVERRIDE {
+    error_message_ = details.message;
     OnEventRaised(host_ids, ERROR_EVENT);
   }
 
diff --git a/webkit/browser/appcache/mock_appcache_storage.cc b/webkit/browser/appcache/mock_appcache_storage.cc
index 27f0a63..7611b90 100644
--- a/webkit/browser/appcache/mock_appcache_storage.cc
+++ b/webkit/browser/appcache/mock_appcache_storage.cc
@@ -139,15 +139,18 @@ void MockAppCacheStorage::MarkEntryAsForeign(
   }
 }
 
-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(
@@ -415,10 +418,12 @@ void MockAppCacheStorage::ProcessFindResponseForMainRequest(
 
 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;
   }
 
@@ -439,7 +444,8 @@ void MockAppCacheStorage::ProcessMakeGroupObsolete(
   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) {
diff --git a/webkit/browser/appcache/mock_appcache_storage.h b/webkit/browser/appcache/mock_appcache_storage.h
index cf9504a..8f1966e 100644
--- a/webkit/browser/appcache/mock_appcache_storage.h
+++ b/webkit/browser/appcache/mock_appcache_storage.h
@@ -48,7 +48,8 @@ class MockAppCacheStorage : public AppCacheStorage {
   virtual void MarkEntryAsForeign(const GURL& entry_url,
                                   int64 cache_id) OVERRIDE;
   virtual void MakeGroupObsolete(AppCacheGroup* group,
-                                 Delegate* delegate) OVERRIDE;
+                                 Delegate* delegate,
+                                 int response_code) OVERRIDE;
   virtual AppCacheResponseReader* CreateResponseReader(
       const GURL& manifest_url, int64 group_id, int64 response_id) OVERRIDE;
   virtual AppCacheResponseWriter* CreateResponseWriter(
@@ -77,9 +78,9 @@ class MockAppCacheStorage : public AppCacheStorage {
   void ProcessStoreGroupAndNewestCache(
       scoped_refptr<AppCacheGroup> group, scoped_refptr<AppCache> newest_cache,
       scoped_refptr<DelegateReference> delegate_ref);
-  void ProcessMakeGroupObsolete(
-      scoped_refptr<AppCacheGroup> group,
-      scoped_refptr<DelegateReference> delegate_ref);
+  void ProcessMakeGroupObsolete(scoped_refptr<AppCacheGroup> group,
+                                scoped_refptr<DelegateReference> delegate_ref,
+                                int response_code);
   void ProcessFindResponseForMainRequest(
       const GURL& url, scoped_refptr<DelegateReference> delegate_ref);
 
diff --git a/webkit/browser/appcache/mock_appcache_storage_unittest.cc b/webkit/browser/appcache/mock_appcache_storage_unittest.cc
index 0e187bd..ade1820 100644
--- a/webkit/browser/appcache/mock_appcache_storage_unittest.cc
+++ b/webkit/browser/appcache/mock_appcache_storage_unittest.cc
@@ -40,7 +40,8 @@ class MockAppCacheStorageTest : public testing::Test {
     }
 
     virtual void OnGroupMadeObsolete(AppCacheGroup* group,
-                                     bool success) OVERRIDE {
+                                     bool success,
+                                     int response_code) OVERRIDE {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
     }
@@ -353,7 +354,7 @@ TEST_F(MockAppCacheStorageTest, MakeGroupObsolete) {
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());
   EXPECT_FALSE(cache->HasOneRef());
   EXPECT_FALSE(group->HasOneRef());
-  storage->MakeGroupObsolete(group.get(), &delegate);
+  storage->MakeGroupObsolete(group.get(), &delegate, 0);
   EXPECT_FALSE(group->is_obsolete());
   EXPECT_EQ(size_t(1), storage->stored_caches_.size());
   EXPECT_EQ(size_t(1), storage->stored_groups_.size());