Implement the BackgroundFetch{Fail,ed} Service Worker events

content/browser/background_fetch/background_fetch_event_dispatcher.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_event_dispatcher.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/metrics/histogram_functions.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/public/browser/browser_thread.h"
 
 namespace content {
 
 namespace {
 
 // Returns the histogram suffix for the given |event| type.
 std::string HistogramSuffixForEventType(ServiceWorkerMetrics::EventType event) {
   switch (event) {
     case ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_ABORT:
       return "AbortEvent";
     case ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_CLICK:
       return "ClickEvent";
+    case ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_FAIL:
+      return "FailEvent";
+    case ServiceWorkerMetrics::EventType::BACKGROUND_FETCHED:
+      return "FetchedEvent";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
 // Records the result of a dispatched Background Fetch event.
 void RecordDispatchResult(
     ServiceWorkerMetrics::EventType event,
     BackgroundFetchEventDispatcher::DispatchResult result) {
@@ skipping 69 matching lines @@
     const std::string& tag,
     mojom::BackgroundFetchState state,
     scoped_refptr<ServiceWorkerVersion> service_worker_version,
     int request_id) {
   DCHECK(service_worker_version);
   service_worker_version->event_dispatcher()->DispatchBackgroundFetchClickEvent(
       tag, state,
       service_worker_version->CreateSimpleEventCallback(request_id));
 }
 
+void BackgroundFetchEventDispatcher::DispatchBackgroundFetchFailEvent(
+    int64_t service_worker_registration_id,
+    const GURL& origin,
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    base::Closure finished_closure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  LoadServiceWorkerRegistrationForDispatch(
+      ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_FAIL,
+      service_worker_registration_id, origin, std::move(finished_closure),
+      base::Bind(
+          &BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchFailEvent,
+          tag, fetches));
+}
+
+void BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchFailEvent(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    int request_id) {
+  DCHECK(service_worker_version);
+  service_worker_version->event_dispatcher()->DispatchBackgroundFetchFailEvent(
+      tag, fetches,
+      service_worker_version->CreateSimpleEventCallback(request_id));
+}
+
+void BackgroundFetchEventDispatcher::DispatchBackgroundFetchedEvent(
+    int64_t service_worker_registration_id,
+    const GURL& origin,
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    base::Closure finished_closure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  LoadServiceWorkerRegistrationForDispatch(
+      ServiceWorkerMetrics::EventType::BACKGROUND_FETCHED,
+      service_worker_registration_id, origin, std::move(finished_closure),
+      base::Bind(
+          &BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchedEvent,
+          tag, fetches));
+}
+
+void BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchedEvent(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    int request_id) {
+  DCHECK(service_worker_version);
+  service_worker_version->event_dispatcher()->DispatchBackgroundFetchedEvent(
+      tag, fetches,
+      service_worker_version->CreateSimpleEventCallback(request_id));
+}
+
 void BackgroundFetchEventDispatcher::LoadServiceWorkerRegistrationForDispatch(
     ServiceWorkerMetrics::EventType event,
     int64_t service_worker_registration_id,
     const GURL& origin,
     base::Closure finished_closure,
     ServiceWorkerLoadedCallback loaded_callback) {
   service_worker_context_->FindReadyRegistrationForId(
       service_worker_registration_id, origin,
       base::Bind(&BackgroundFetchEventDispatcher::StartActiveWorkerForDispatch,
                  event, std::move(finished_closure),
@@ skipping 59 matching lines @@
       } else {
         RecordDispatchResult(event, DISPATCH_RESULT_SUCCESS);
       }
       break;
   }
 
   finished_closure.Run();
 }
 
 }  // namespace content