Implement the BackgroundFetch{Fail,ed} Service Worker events

content/browser/background_fetch/background_fetch_event_dispatcher.h

 // 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.
 
 #ifndef CONTENT_BROWSER_BACKGROUND_FETCH_BACKGROUND_FETCH_EVENT_DISPATCHER_H_
 #define CONTENT_BROWSER_BACKGROUND_FETCH_BACKGROUND_FETCH_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/common/content_export.h"
 #include "content/common/service_worker/service_worker_event_dispatcher.mojom.h"
 
 namespace content {
 
+struct BackgroundFetchSettledFetch;
 class ServiceWorkerContextWrapper;
 class ServiceWorkerRegistration;
 class ServiceWorkerVersion;
 
 // Responsible for dispatching the Background Fetch API events on a given
 // Service Worker. Must only be used on the IO thread.
 class CONTENT_EXPORT BackgroundFetchEventDispatcher {
  public:
   // This enumeration is used for recording histograms. Treat as append-only.
   enum DispatchResult {
     DISPATCH_RESULT_SUCCESS = 0,
     DISPATCH_RESULT_CANNOT_FIND_WORKER = 1,
     DISPATCH_RESULT_CANNOT_START_WORKER = 2,
     DISPATCH_RESULT_CANNOT_DISPATCH_EVENT = 3,
 
     DISPATCH_RESULT_COUNT
   };
 
   explicit BackgroundFetchEventDispatcher(
       const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context);
   ~BackgroundFetchEventDispatcher();
 
-  // TODO(peter): Support the `backgroundfetched` event.
-  // TODO(peter): Support the `backgroundfetchfail` event.
-
   // Dispatches the `backgroundfetchabort` event, which indicates that an active
   // background fetch was aborted by the user or another external event.
   void DispatchBackgroundFetchAbortEvent(int64_t service_worker_registration_id,
                                          const GURL& origin,
                                          const std::string& tag,
                                          base::Closure finished_closure);
 
   // Dispatches the `backgroundfetchclick` event, which indicates that the user
   // interface displayed for an active background fetch was activated.
   void DispatchBackgroundFetchClickEvent(int64_t service_worker_registration_id,
                                          const GURL& origin,
                                          const std::string& tag,
                                          mojom::BackgroundFetchState state,
                                          base::Closure finished_closure);
 
+  // Dispatches the `backgroundfetchfail` event, which indicates that a
+  // background fetch has finished with one or more failed fetches. The request-
+  // response pairs are included.
+  void DispatchBackgroundFetchFailEvent(
+      int64_t service_worker_registration_id,
+      const GURL& origin,
+      const std::string& tag,
+      const std::vector<BackgroundFetchSettledFetch>& fetches,
+      base::Closure finished_closure);
+
+  // Dispatches the `backgroundfetched` event, which indicates that a background
+  // fetch has successfully completed. The request-response pairs are included.
+  void DispatchBackgroundFetchedEvent(
+      int64_t service_worker_registration_id,
+      const GURL& origin,
+      const std::string& tag,
+      const std::vector<BackgroundFetchSettledFetch>& fetches,
+      base::Closure finished_closure);
+
  private:
   using ServiceWorkerLoadedCallback =
       base::Callback<void(scoped_refptr<ServiceWorkerVersion>, int)>;
 
   // Phase at which the dispatching process finished. Used for UMA.
   enum class DispatchPhase { FINDING, STARTING, DISPATCHING };
 
   // Loads the Service Worker identified by |service_worker_registration_id| and
   // ensures that there is an activated version. Will invoke |finished_closure|,
   // log UMA and abort on error, or invoke |loaded_callback| on success.
@@ skipping 31 matching lines @@
   // Methods that actually invoke the event on an activated Service Worker.
   static void DoDispatchBackgroundFetchAbortEvent(
       const std::string& tag,
       scoped_refptr<ServiceWorkerVersion> service_worker_version,
       int request_id);
   static void DoDispatchBackgroundFetchClickEvent(
       const std::string& tag,
       mojom::BackgroundFetchState state,
       scoped_refptr<ServiceWorkerVersion> service_worker_version,
       int request_id);
+  static void DoDispatchBackgroundFetchFailEvent(
+      const std::string& tag,
+      const std::vector<BackgroundFetchSettledFetch>& fetches,
+      scoped_refptr<ServiceWorkerVersion> service_worker_version,
+      int request_id);
+  static void DoDispatchBackgroundFetchedEvent(
+      const std::string& tag,
+      const std::vector<BackgroundFetchSettledFetch>& fetches,
+      scoped_refptr<ServiceWorkerVersion> service_worker_version,
+      int request_id);
 
   scoped_refptr<ServiceWorkerContextWrapper> service_worker_context_;
 
   DISALLOW_COPY_AND_ASSIGN(BackgroundFetchEventDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_BACKGROUND_FETCH_BACKGROUND_FETCH_EVENT_DISPATCHER_H_