Report an error message when an update job results in an error.

webkit/appcache/appcache_update_job.cc

 // Copyright (c) 2010 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/appcache_update_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
@@ skipping 88 matching lines @@
   void SendProgressNotifications(
       const GURL& url, int num_total, int num_complete) {
     for (NotifyHostMap::iterator it = hosts_to_notify.begin();
          it != hosts_to_notify.end(); ++it) {
       AppCacheFrontend* frontend = it->first;
       frontend->OnProgressEventRaised(it->second, url,
                                       num_total, num_complete);
     }
   }
 
+  void SendErrorNotifications(const std::string& error_message) {
+    DCHECK(!error_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);
+    }
+  }
+
  private:
   NotifyHostMap hosts_to_notify;
 };
 
 AppCacheUpdateJob::AppCacheUpdateJob(AppCacheService* service,
                                      AppCacheGroup* group)
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
       service_(service),
       group_(group),
       update_type_(UNKNOWN_TYPE),
@@ skipping 110 matching lines @@
 
 void AppCacheUpdateJob::OnPolicyCheckComplete(int rv) {
   policy_callback_->Release();  // Balanced in CheckPolicy.
   if (rv == net::OK) {
     FetchManifest(true);
     return;
   }
 
   group_->NotifyContentBlocked();
 
+  const char* kErrorMessage =
+      "Cache creation was blocked by the content policy";
   MessageLoop::current()->PostTask(FROM_HERE,
       method_factory_.NewRunnableMethod(
-          &AppCacheUpdateJob::HandleCacheFailure));
+          &AppCacheUpdateJob::HandleCacheFailure,
+          kErrorMessage));
 }
 
-void AppCacheUpdateJob::HandleCacheFailure() {
-  // TODO(michaeln): For now this is only invoked from one point
-  // of failure. Overtime, attempt the migrate the various places
-  // where we can detect a failure condition to use this same
-  // method to enter the cache_failure state.
+void AppCacheUpdateJob::HandleCacheFailure(const std::string& error_message) {
+  // 6.9.4 cache failure steps 2-8.
+  DCHECK(internal_state_ != CACHE_FAILURE);
+  DCHECK(!error_message.empty());
   internal_state_ = CACHE_FAILURE;
   CancelAllUrlFetches();
-  CancelAllMasterEntryFetches();
-  MaybeCompleteUpdate();
+  CancelAllMasterEntryFetches(error_message);
+  NotifyAllError(error_message);
+  DiscardInprogressCache();
+  internal_state_ = COMPLETED;
+  DeleteSoon();  // To unwind the stack prior to deletion.
 }
 
 void AppCacheUpdateJob::FetchManifest(bool is_first_fetch) {
   DCHECK(!manifest_url_request_);
   manifest_url_request_ = new URLRequest(manifest_url_, this);
   UpdateJobInfo::RequestType fetch_type = is_first_fetch ?
       UpdateJobInfo::MANIFEST_FETCH : UpdateJobInfo::MANIFEST_REFETCH;
   manifest_url_request_->SetUserData(this, new UpdateJobInfo(fetch_type));
   manifest_url_request_->set_context(service_->request_context());
   manifest_url_request_->set_load_flags(
@@ skipping 242 matching lines @@
         new net::HttpResponseInfo(request->response_info()));
     if (update_type_ == UPGRADE_ATTEMPT)
       CheckIfManifestChanged();  // continues asynchronously
     else
       ContinueHandleManifestFetchCompleted(true);
   } else if (response_code == 304 && update_type_ == UPGRADE_ATTEMPT) {
     ContinueHandleManifestFetchCompleted(false);
   } else if (response_code == 404 || response_code == 410) {
     service_->storage()->MakeGroupObsolete(group_, this);  // async
   } else {
-    internal_state_ = CACHE_FAILURE;
-    CancelAllMasterEntryFetches();
-    MaybeCompleteUpdate();  // if not done, run async cache failure steps
+    const char* kFormatString = "Manifest fetch failed (%d) %s";
+    const std::string message = StringPrintf(kFormatString, response_code,
+                                             manifest_url_.spec().c_str());
+    HandleCacheFailure(message);
   }
 }
 
 void AppCacheUpdateJob::OnGroupMadeObsolete(AppCacheGroup* group,
                                             bool success) {
   DCHECK(master_entry_fetches_.empty());
-  CancelAllMasterEntryFetches();
+  CancelAllMasterEntryFetches("The group has been made obsolete");
   if (success) {
     DCHECK(group->is_obsolete());
     NotifyAllAssociatedHosts(OBSOLETE_EVENT);
     internal_state_ = COMPLETED;
+    MaybeCompleteUpdate();
   } else {
     // Treat failure to mark group obsolete as a cache failure.
-    internal_state_ = CACHE_FAILURE;
+    HandleCacheFailure("Failed to make the group as obsolete");
   }
-  MaybeCompleteUpdate();
 }
 
 void AppCacheUpdateJob::ContinueHandleManifestFetchCompleted(bool changed) {
   DCHECK(internal_state_ == FETCH_MANIFEST);
 
   if (!changed) {
     DCHECK(update_type_ == UPGRADE_ATTEMPT);
     internal_state_ = NO_UPDATE;
 
     // Wait for pending master entries to download.
     FetchMasterEntries();
     MaybeCompleteUpdate();  // if not done, run async 6.9.4 step 7 substeps
     return;
   }
 
   Manifest manifest;
   if (!ParseManifest(manifest_url_, manifest_data_.data(),
                      manifest_data_.length(), manifest)) {
-    LOG(INFO) << "Failed to parse manifest: " << manifest_url_;
-    internal_state_ = CACHE_FAILURE;
-    CancelAllMasterEntryFetches();
-    MaybeCompleteUpdate();  // if not done, run async cache failure steps
+    const char* kFormatString = "Failed to parse manifest %s";
+    const std::string message = StringPrintf(kFormatString,
+                                             manifest_url_.spec().c_str());
+    HandleCacheFailure(message);
+    LOG(INFO) << message;
     return;
   }
 
   // Proceed with update process. Section 6.9.4 steps 8-20.
   internal_state_ = DOWNLOADING;
   inprogress_cache_ = new AppCache(service_,
                                    service_->storage()->NewCacheId());
   BuildUrlFileList(manifest);
   inprogress_cache_->InitializeWithManifest(&manifest);
 
@@ skipping 12 matching lines @@
   FetchUrls();
   FetchMasterEntries();
   MaybeCompleteUpdate();  // if not done, continues when async fetches complete
 }
 
 void AppCacheUpdateJob::HandleUrlFetchCompleted(URLRequest* request) {
   DCHECK(internal_state_ == DOWNLOADING);
 
   const GURL& url = request->original_url();
   pending_url_fetches_.erase(url);
-  NotifyProgress(url);
+  NotifyAllProgress(url);
   ++url_fetches_completed_;
 
   int response_code = request->status().is_success()
       ? request->GetResponseCode() : -1;
   AppCacheEntry& entry = url_file_list_.find(url)->second;
 
   if (request->status().is_success() && (response_code / 100 == 2)) {
     // Associate storage with the new entry.
     UpdateJobInfo* info =
         static_cast<UpdateJobInfo*>(request->GetUserData(this));
     DCHECK(info->response_writer_.get());
     entry.set_response_id(info->response_writer_->response_id());
     entry.set_response_size(info->response_writer_->amount_written());
 
     if (!inprogress_cache_->AddOrModifyEntry(url, entry))
       duplicate_response_ids_.push_back(entry.response_id());
 
     // Foreign entries will be detected during cache selection.
     // Note: 6.9.4, step 17.9 possible optimization: if resource is HTML or XML
     // file whose root element is an html element with a manifest attribute
     // whose value doesn't match the manifest url of the application cache
     // being processed, mark the entry as being foreign.
   } else {
     LOG(INFO) << "Request status: " << request->status().status()
         << " os_error: " << request->status().os_error()
         << " response code: " << response_code;
     if (entry.IsExplicit() || entry.IsFallback()) {
-      internal_state_ = CACHE_FAILURE;
-      CancelAllUrlFetches();
-      CancelAllMasterEntryFetches();
+      const char* kFormatString = "Resource fetch failed (%d) %s";
+      const std::string message = StringPrintf(kFormatString, response_code,
+                                               request->url().spec().c_str());
+      HandleCacheFailure(message);
+      return;
     } else if (response_code == 404 || response_code == 410) {
       // Entry is skipped.  They are dropped from the cache.
     } else if (update_type_ == UPGRADE_ATTEMPT) {
       // Copy the response from the newest complete cache.
       AppCache* cache = group_->newest_complete_cache();
       AppCacheEntry* copy = cache->GetEntry(url);
       if (copy) {
         entry.set_response_id(copy->response_id());
         entry.set_response_size(copy->response_size());
         inprogress_cache_->AddOrModifyEntry(url, entry);
       }
     }
   }
 
   // Fetch another URL now that one request has completed.
-  if (internal_state_ != CACHE_FAILURE)
-    FetchUrls();
-
+  DCHECK(internal_state_ != CACHE_FAILURE);
+  FetchUrls();
   MaybeCompleteUpdate();
 }
 
 void AppCacheUpdateJob::HandleMasterEntryFetchCompleted(URLRequest* request) {
   DCHECK(internal_state_ == NO_UPDATE || internal_state_ == DOWNLOADING);
 
   // TODO(jennb): Handle downloads completing during cache failure when update
   // no longer fetches master entries directly. For now, we cancel all pending
   // master entry fetches when entering cache failure state so this will never
   // be called in CACHE_FAILURE state.
@@ skipping 39 matching lines @@
       AppCacheHost* host = *host_it;
       host_notifier.AddHost(host);
 
       // In downloading case, disassociate host from inprogress cache.
       if (inprogress_cache_)
         host->AssociateCache(NULL);
 
       host->RemoveObserver(this);
     }
     hosts.clear();
-    host_notifier.SendNotifications(ERROR_EVENT);
+
+    const char* kFormatString = "Master entry fetch failed (%d) %s";
+    const std::string message = StringPrintf(kFormatString, response_code,
+                                             request->url().spec().c_str());
+    host_notifier.SendErrorNotifications(message);
 
     // In downloading case, update result is different if all master entries
     // failed vs. only some failing.
     if (inprogress_cache_) {
       // Only count successful downloads to know if all master entries failed.
       pending_master_entries_.erase(found);
       --master_entries_completed_;
 
       // Section 6.9.4, step 22.3.
       if (update_type_ == CACHE_ATTEMPT && pending_master_entries_.empty()) {
-        CancelAllUrlFetches();
-        internal_state_ = CACHE_FAILURE;
+        HandleCacheFailure(message);
+        return;
       }
     }
   }
 
-  if (internal_state_ != CACHE_FAILURE)
-    FetchMasterEntries();
-
+  DCHECK(internal_state_ != CACHE_FAILURE);
+  FetchMasterEntries();
   MaybeCompleteUpdate();
 }
 
 void AppCacheUpdateJob::HandleManifestRefetchCompleted(URLRequest* request) {
   DCHECK(internal_state_ == REFETCH_MANIFEST);
   manifest_url_request_ = NULL;
 
   int response_code = request->status().is_success()
       ? request->GetResponseCode() : -1;
   if (response_code == 304 || manifest_data_ == manifest_refetch_data_) {
@@ skipping 10 matching lines @@
       scoped_refptr<HttpResponseInfoIOBuffer> io_buffer =
           new HttpResponseInfoIOBuffer(manifest_response_info_.release());
       manifest_response_writer_->WriteInfo(io_buffer,
                                            &manifest_info_write_callback_);
     }
   } else {
     LOG(INFO) << "Request status: " << request->status().status()
         << " os_error: " << request->status().os_error()
         << " response code: " << response_code;
     ScheduleUpdateRetry(kRerunDelayMs);
-    internal_state_ = CACHE_FAILURE;
-    MaybeCompleteUpdate();  // will definitely complete
+    HandleCacheFailure("Manifest changed during update, scheduling retry");
   }
 }
 
 void AppCacheUpdateJob::OnManifestInfoWriteComplete(int result) {
   if (result > 0) {
     scoped_refptr<net::StringIOBuffer> io_buffer =
         new net::StringIOBuffer(manifest_data_);
     manifest_response_writer_->WriteData(io_buffer, manifest_data_.length(),
                                          &manifest_data_write_callback_);
   } else {
-    internal_state_ = CACHE_FAILURE;
-    MaybeCompleteUpdate();  // will definitely complete
+    HandleCacheFailure("Failed to write the manifest headers to storage");
   }
 }
 
 void AppCacheUpdateJob::OnManifestDataWriteComplete(int result) {
   if (result > 0) {
     AppCacheEntry entry(AppCacheEntry::MANIFEST,
         manifest_response_writer_->response_id(),
         manifest_response_writer_->amount_written());
     if (!inprogress_cache_->AddOrModifyEntry(manifest_url_, entry))
       duplicate_response_ids_.push_back(entry.response_id());
     StoreGroupAndCache();
   } else {
-    internal_state_ = CACHE_FAILURE;
-    MaybeCompleteUpdate();  // will definitely complete
+    HandleCacheFailure("Failed to write the manifest data to storage");
   }
 }
 
 void AppCacheUpdateJob::StoreGroupAndCache() {
   DCHECK(stored_state_ == UNSTORED);
   stored_state_ = STORING;
   scoped_refptr<AppCache> newest_cache;
   if (inprogress_cache_)
     newest_cache.swap(inprogress_cache_);
   else
     newest_cache = group_->newest_complete_cache();
   newest_cache->set_update_time(base::Time::Now());
   service_->storage()->StoreGroupAndNewestCache(group_, newest_cache,
                                                 this);  // async
 }
 
 void AppCacheUpdateJob::OnGroupAndNewestCacheStored(AppCacheGroup* group,
                                                     AppCache* newest_cache,
                                                     bool success) {
   DCHECK(stored_state_ == STORING);
   if (success) {
     stored_state_ = STORED;
+    MaybeCompleteUpdate();  // will definitely complete
   } else {
-    internal_state_ = CACHE_FAILURE;
-
     // Restore inprogress_cache_ to get the proper events delivered
     // and the proper cleanup to occur.
     if (newest_cache != group->newest_complete_cache())
       inprogress_cache_ = newest_cache;
+
+    HandleCacheFailure("Failed to commit new cache to storage");
   }
-  MaybeCompleteUpdate();  // will definitely complete
 }
 
 void AppCacheUpdateJob::NotifySingleHost(AppCacheHost* host,
                                          EventID event_id) {
   std::vector<int> ids(1, host->host_id());
   host->frontend()->OnEventRaised(ids, event_id);
 }
 
-void AppCacheUpdateJob::NotifyAllPendingMasterHosts(EventID event_id) {
-  // Collect hosts so we only send one notification per frontend.
-  // A host can only be associated with a single pending master entry
-  // so no need to worry about duplicate hosts being added to the notifier.
-  HostNotifier host_notifier;
-  for (PendingMasters::iterator it = pending_master_entries_.begin();
-       it != pending_master_entries_.end(); ++it) {
-    PendingHosts& hosts = it->second;
-    for (PendingHosts::iterator host_it = hosts.begin();
-         host_it != hosts.end(); ++host_it) {
-      host_notifier.AddHost(*host_it);
-    }
-  }
-
-  host_notifier.SendNotifications(event_id);
-}
-
 void AppCacheUpdateJob::NotifyAllAssociatedHosts(EventID event_id) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendNotifications(event_id);
 }
 
-void AppCacheUpdateJob::NotifyProgress(const GURL& url) {
+void AppCacheUpdateJob::NotifyAllProgress(const GURL& url) {
   HostNotifier host_notifier;
   AddAllAssociatedHostsToNotifier(&host_notifier);
   host_notifier.SendProgressNotifications(
       url, url_file_list_.size(), url_fetches_completed_);
 }
 
-void AppCacheUpdateJob::NotifyFinalProgress() {
+void AppCacheUpdateJob::NotifyAllFinalProgress() {
   DCHECK(url_file_list_.size() == url_fetches_completed_);
-  NotifyProgress(GURL());
+  NotifyAllProgress(GURL());
+}
+
+void AppCacheUpdateJob::NotifyAllError(const std::string& error_message) {
+  HostNotifier host_notifier;
+  AddAllAssociatedHostsToNotifier(&host_notifier);
+  host_notifier.SendErrorNotifications(error_message);
 }
 
 void AppCacheUpdateJob::AddAllAssociatedHostsToNotifier(
     HostNotifier* host_notifier) {
   // Collect hosts so we only send one notification per frontend.
   // A host can only be associated with a single cache so no need to worry
   // about duplicate hosts being added to the notifier.
   if (inprogress_cache_) {
     DCHECK(internal_state_ == DOWNLOADING || internal_state_ == CACHE_FAILURE);
     host_notifier->AddHosts(inprogress_cache_->associated_hosts());
@@ skipping 95 matching lines @@
   while (pending_url_fetches_.size() < kMaxConcurrentUrlFetches &&
          !urls_to_fetch_.empty()) {
     const GURL url = urls_to_fetch_.front().first;
     bool storage_checked = urls_to_fetch_.front().second;
     urls_to_fetch_.pop_front();
 
     AppCache::EntryMap::iterator it = url_file_list_.find(url);
     DCHECK(it != url_file_list_.end());
     AppCacheEntry& entry = it->second;
     if (ShouldSkipUrlFetch(entry)) {
-      NotifyProgress(url);
+      NotifyAllProgress(url);
       ++url_fetches_completed_;
     } else if (AlreadyFetchedEntry(url, entry.types())) {
-      NotifyProgress(url);
+      NotifyAllProgress(url);
       ++url_fetches_completed_;  // saved a URL request
     } else if (!storage_checked && MaybeLoadFromNewestCache(url, entry)) {
       // Continues asynchronously after data is loaded from newest cache.
     } else {
       // Send URL request for the resource.
       URLRequest* request = new URLRequest(url, this);
       request->SetUserData(this, new UpdateJobInfo(UpdateJobInfo::URL_FETCH));
       request->set_context(service_->request_context());
       request->set_load_flags(
           request->load_flags() | net::LOAD_DISABLE_INTERCEPT);
@@ skipping 107 matching lines @@
       request->set_load_flags(
           request->load_flags() | net::LOAD_DISABLE_INTERCEPT);
       request->Start();
       master_entry_fetches_.insert(PendingUrlFetches::value_type(url, request));
     }
 
     master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
   }
 }
 
-void AppCacheUpdateJob::CancelAllMasterEntryFetches() {
+void AppCacheUpdateJob::CancelAllMasterEntryFetches(
+    const std::string& error_message) {
   // 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
   // directly.
 
   // Cancel all in-progress fetches.
   for (PendingUrlFetches::iterator it = master_entry_fetches_.begin();
        it != master_entry_fetches_.end(); ++it) {
     delete it->second;
     master_entries_to_fetch_.insert(it->first);  // back in unfetched list
@@ skipping 15 matching lines @@
          host_it != hosts.end(); ++host_it) {
       AppCacheHost* host = *host_it;
       host->AssociateCache(NULL);
       host_notifier.AddHost(host);
       host->RemoveObserver(this);
     }
     hosts.clear();
 
     master_entries_to_fetch_.erase(master_entries_to_fetch_.begin());
   }
-  host_notifier.SendNotifications(ERROR_EVENT);
+  host_notifier.SendErrorNotifications(error_message);
 }
 
 bool AppCacheUpdateJob::MaybeLoadFromNewestCache(const GURL& url,
                                                  AppCacheEntry& entry) {
   if (update_type_ != UPGRADE_ATTEMPT)
     return false;
 
   AppCache* newest = group_->newest_complete_cache();
   AppCacheEntry* copy_me = newest->GetEntry(url);
   if (!copy_me || !copy_me->has_response_id())
@@ skipping 28 matching lines @@
   } else {
     // Check if response can be re-used according to HTTP caching semantics.
     // Responses with a "vary" header get treated as expired.
     const std::string name = "vary";
     std::string value;
     void* iter = NULL;
     if (http_info->headers->RequiresValidation(http_info->request_time,
                                                http_info->response_time,
                                                base::Time::Now()) ||
         http_info->headers->EnumerateHeader(&iter, name, &value)) {
+      // TODO(michaeln): Make a conditional request when we can in this case.
       LoadFromNewestCacheFailed(url);
     } else {
       DCHECK(group_->newest_complete_cache());
       AppCacheEntry* copy_me = group_->newest_complete_cache()->GetEntry(url);
       DCHECK(copy_me);
       DCHECK(copy_me->response_id() == response_id);
 
       AppCache::EntryMap::iterator it = url_file_list_.find(url);
       DCHECK(it != url_file_list_.end());
       AppCacheEntry& entry = it->second;
       entry.set_response_id(response_id);
       entry.set_response_size(copy_me->response_size());
       inprogress_cache_->AddOrModifyEntry(url, entry);
-      NotifyProgress(url);
+      NotifyAllProgress(url);
       ++url_fetches_completed_;
     }
   }
   loading_responses_.erase(found);
 
   MaybeCompleteUpdate();
 }
 
 void AppCacheUpdateJob::LoadFromNewestCacheFailed(const GURL& url) {
   if (internal_state_ == CACHE_FAILURE)
     return;
 
   // Re-insert url at front of fetch list. Indicate storage has been checked.
   urls_to_fetch_.push_front(AppCacheUpdateJob::UrlsToFetch(url, true));
   FetchUrls();
 }
 
 void AppCacheUpdateJob::MaybeCompleteUpdate() {
+  DCHECK(internal_state_ != CACHE_FAILURE);
+
   // Must wait for any pending master entries or url fetches to complete.
   if (master_entries_completed_ != pending_master_entries_.size() ||
       url_fetches_completed_ != url_file_list_.size()) {
     DCHECK(internal_state_ != COMPLETED);
     return;
   }
 
   switch (internal_state_) {
     case NO_UPDATE:
       if (master_entries_completed_ > 0) {
@@ skipping 11 matching lines @@
       NotifyAllAssociatedHosts(NO_UPDATE_EVENT);
       DiscardDuplicateResponses();
       internal_state_ = COMPLETED;
       break;
     case DOWNLOADING:
       internal_state_ = REFETCH_MANIFEST;
       FetchManifest(false);
       break;
     case REFETCH_MANIFEST:
       DCHECK(stored_state_ == STORED);
-      NotifyFinalProgress();
+      NotifyAllFinalProgress();
       if (update_type_ == CACHE_ATTEMPT)
         NotifyAllAssociatedHosts(CACHED_EVENT);
       else
         NotifyAllAssociatedHosts(UPDATE_READY_EVENT);
       DiscardDuplicateResponses();
       internal_state_ = COMPLETED;
       break;
     case CACHE_FAILURE:
-      // 6.9.4 cache failure steps 2-8.
-      NotifyAllAssociatedHosts(ERROR_EVENT);
-      DiscardInprogressCache();
-      // For a CACHE_ATTEMPT, group will be discarded when the host(s) that
-      // started this update removes its reference to the group. Nothing more
-      // to do here.
-      internal_state_ = COMPLETED;
+      NOTREACHED();  // See HandleCacheFailure
       break;
     default:
       break;
   }
 
   // Let the stack unwind before deletion to make it less risky as this
   // method is called from multiple places in this file.
   if (internal_state_ == COMPLETED)
     DeleteSoon();
 }
@@ skipping 73 matching lines @@
 
   // Break the connection with the group so the group cannot call delete
   // on this object after we've posted a task to delete ourselves.
   group_->SetUpdateStatus(AppCacheGroup::IDLE);
   group_ = NULL;
 
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 }  // namespace appcache