Fire the `backgroundfetchfail` event for failed fetches

content/browser/background_fetch/background_fetch_data_manager.cc

 // Copyright 2017 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 "content/browser/background_fetch/background_fetch_data_manager.h"
 
 #include <algorithm>
 #include <queue>
 
 #include "base/memory/ptr_util.h"
 #include "content/browser/background_fetch/background_fetch_constants.h"
 #include "content/browser/background_fetch/background_fetch_context.h"
 #include "content/browser/background_fetch/background_fetch_cross_origin_filter.h"
 #include "content/browser/background_fetch/background_fetch_request_info.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_item.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponseType.h"
 
 namespace content {
 
+// Returns whether the response contained in the Background Fetch |request| is
+// considered OK. See https://fetch.spec.whatwg.org/#ok-status aka a successful
+// 2xx status per https://tools.ietf.org/html/rfc7231#section-6.3.
+bool IsOK(const BackgroundFetchRequestInfo& request) {
+  int status = request.GetResponseCode();
+  return status >= 200 && status < 300;
+}
+
 // The Registration Data class encapsulates the data stored for a particular
 // Background Fetch registration. This roughly matches the on-disk format that
 // will be adhered to in the future.
 class BackgroundFetchDataManager::RegistrationData {
  public:
   RegistrationData(const std::vector<ServiceWorkerFetchRequest>& requests,
                    const BackgroundFetchOptions& options)
       : options_(options) {
     int request_index = 0;
 
@@ skipping 157 matching lines @@
     SettledFetchesCallback callback) {
   auto iter = registrations_.find(registration_id);
   DCHECK(iter != registrations_.end());
 
   RegistrationData* registration_data = iter->second.get();
   DCHECK(!registration_data->HasPendingRequests());
 
   const std::vector<scoped_refptr<BackgroundFetchRequestInfo>>& requests =
       registration_data->GetCompletedRequests();
 
+  bool background_fetch_succeeded = true;
+
   std::vector<BackgroundFetchSettledFetch> settled_fetches;
   settled_fetches.reserve(requests.size());
 
   std::vector<std::unique_ptr<BlobHandle>> blob_handles;
 
   for (const auto& request : requests) {
     BackgroundFetchSettledFetch settled_fetch;
     settled_fetch.request = request->fetch_request();
 
     // The |filter| decides which values can be passed on to the Service Worker.
@@ skipping 20 matching lines @@
                 base::Time() /* expected_modification_time */);
 
         // TODO(peter): Appropriately handle !blob_handle
         if (blob_handle) {
           settled_fetch.response.blob_uuid = blob_handle->GetUUID();
           settled_fetch.response.blob_size = request->GetFileSize();
 
           blob_handles.push_back(std::move(blob_handle));
         }
       }
+    } else {
+      // TODO(crbug.com/711354): Consider Background Fetches as failed when the
+      // response cannot be relayed to the developer.
+      background_fetch_succeeded = false;
     }
 
     // TODO: settled_fetch.response.error
     settled_fetch.response.response_time = request->GetResponseTime();
     // TODO: settled_fetch.response.cors_exposed_header_names
 
+    background_fetch_succeeded = background_fetch_succeeded && IsOK(*request);
+
     settled_fetches.push_back(settled_fetch);
   }
 
   std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE,
+                          background_fetch_succeeded,
                           std::move(settled_fetches), std::move(blob_handles));
 }
 
 void BackgroundFetchDataManager::DeleteRegistration(
     const BackgroundFetchRegistrationId& registration_id,
     DeleteRegistrationCallback callback) {
   auto iter = registrations_.find(registration_id);
   if (iter == registrations_.end()) {
     std::move(callback).Run(blink::mojom::BackgroundFetchError::INVALID_TAG);
     return;
   }
 
   registrations_.erase(iter);
 
   std::move(callback).Run(blink::mojom::BackgroundFetchError::NONE);
 }
 
 }  // namespace content