Service Worker event dispatcher for Background Fetch

content/browser/background_fetch/background_fetch_event_dispatcher.cc

Index: content/browser/background_fetch/background_fetch_event_dispatcher.cc
diff --git a/content/browser/background_fetch/background_fetch_event_dispatcher.cc b/content/browser/background_fetch/background_fetch_event_dispatcher.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2d3a37a05f31ab400011a3ed3706e7178afbc47f
--- /dev/null
+++ b/content/browser/background_fetch/background_fetch_event_dispatcher.cc
@@ -0,0 +1,200 @@
+// 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.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.
+const char* HistogramSuffixForEventType(ServiceWorkerMetrics::EventType event) {
+  switch (event) {
+    case ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_ABORT:
+      return "AbortEvent";
+    case ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_CLICK:
+      return "ClickEvent";
+    default:
+      NOTREACHED();
+      return "";
+  }
+}
+
+// Records the result of a dispatched Background Fetch event.
+void RecordDispatchResult(
+    ServiceWorkerMetrics::EventType event,
+    BackgroundFetchEventDispatcher::DispatchResult result) {
+  std::string histogram_name =
+      base::StringPrintf("BackgroundFetch.EventDispatchResult.%s",

[Ilya Sherman, 2017/03/16 03:58:50]

nit: I'm pretty sure that returning an std::string from
HistogramSuffixForEventType and writing this as

    "BackgroundFetch.EventDispatchResult." + HistogramSuffixForEventType(event)

would be both easier to read and more efficient (or at least comparably
efficient).

[Peter Beverloo, 2017/03/16 16:05:58]

Done.

+                         HistogramSuffixForEventType(event));
+
+  // Used because the |histogram_name| is not a constant.
+  base::LinearHistogram::FactoryGet(

[Ilya Sherman, 2017/03/16 03:58:50]

Could you use a function from histogram_functions.h instead?

[Peter Beverloo, 2017/03/16 16:05:58]

Aaaaah. With pleasure - done :)

+      histogram_name,
+      BackgroundFetchEventDispatcher::DISPATCH_RESULT_SUCCESS /* minimum */,
+      BackgroundFetchEventDispatcher::DISPATCH_RESULT_MAX /* maximum */,
+      BackgroundFetchEventDispatcher::DISPATCH_RESULT_MAX + 1 /* buckets */,
+      base::Histogram::kUmaTargetedHistogramFlag)
+      ->Add(result);
+}
+
+// Records the failure reason of a failed dispatch for |metric_name|.
+void RecordFailureResult(ServiceWorkerMetrics::EventType event,
+                         const char* metric_name,
+                         ServiceWorkerStatusCode service_worker_status) {
+  std::string histogram_name =
+      base::StringPrintf("BackgroundFetch.EventDispatchFailure.%s.%s",
+                         metric_name, HistogramSuffixForEventType(event));
+
+  // Used because the |histogram_name| is not a constant.
+  base::LinearHistogram::FactoryGet(
+      histogram_name, SERVICE_WORKER_OK /* minimum */,
+      SERVICE_WORKER_ERROR_MAX_VALUE /* maximum */,
+      SERVICE_WORKER_ERROR_MAX_VALUE + 1 /* buckets */,
+      base::Histogram::kUmaTargetedHistogramFlag)
+      ->Add(service_worker_status);
+}
+
+}  // namespace
+
+BackgroundFetchEventDispatcher::BackgroundFetchEventDispatcher(
+    const scoped_refptr<ServiceWorkerContextWrapper>& service_worker_context)
+    : service_worker_context_(service_worker_context) {}
+
+BackgroundFetchEventDispatcher::~BackgroundFetchEventDispatcher() = default;
+
+void BackgroundFetchEventDispatcher::DispatchBackgroundFetchAbortEvent(
+    int64_t service_worker_registration_id,
+    const std::string& tag,
+    base::Closure finished_closure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  LoadServiceWorkerRegistrationForDispatch(
+      ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_ABORT,
+      service_worker_registration_id, std::move(finished_closure),
+      base::Bind(
+          &BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchAbortEvent,
+          tag));
+}
+
+void BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchAbortEvent(
+    const std::string& tag,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version,
+    int request_id) {
+  DCHECK(service_worker_version);
+  service_worker_version->event_dispatcher()->DispatchBackgroundFetchAbortEvent(
+      tag, service_worker_version->CreateSimpleEventCallback(request_id));
+}
+
+void BackgroundFetchEventDispatcher::DispatchBackgroundFetchClickEvent(
+    int64_t service_worker_registration_id,
+    const std::string& tag,
+    mojom::BackgroundFetchState state,
+    base::Closure finished_closure) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  LoadServiceWorkerRegistrationForDispatch(
+      ServiceWorkerMetrics::EventType::BACKGROUND_FETCH_CLICK,
+      service_worker_registration_id, std::move(finished_closure),
+      base::Bind(
+          &BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchClickEvent,
+          tag, state));
+}
+
+void BackgroundFetchEventDispatcher::DoDispatchBackgroundFetchClickEvent(
+    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::LoadServiceWorkerRegistrationForDispatch(
+    ServiceWorkerMetrics::EventType event,
+    int64_t service_worker_registration_id,
+    base::Closure finished_closure,
+    ServiceWorkerLoadedCallback loaded_callback) {
+  service_worker_context_->FindReadyRegistrationForIdOnly(

[horo, 2017/03/16 07:08:22]

Can you use FindReadyRegistrationForId instead?
FindReadyRegistrationForId is more efficient than
FindReadyRegistrationForIdOnly.


Please make sure that the database of Background Fetch must be cleared when
ServiceWorkerContextObserver::OnStorageWiped() is called.
Once the database of Service Worker is wiped out, the same
service_worker_registration_id will be reused.

[Peter Beverloo, 2017/03/16 16:05:58]

We'll use the Service Worker database's user data system for storage, and will
have an observer for deleted registrations and wiped databases. This will likely
have to be async in some manner (I mentioned it to Matt a few weeks ago).

[Peter Beverloo, 2017/03/16 16:05:58]

Done.

+      service_worker_registration_id,
+      base::Bind(&BackgroundFetchEventDispatcher::StartActiveWorkerForDispatch,
+                 event, std::move(finished_closure),
+                 std::move(loaded_callback)));
+}
+
+void BackgroundFetchEventDispatcher::StartActiveWorkerForDispatch(
+    ServiceWorkerMetrics::EventType event,
+    base::Closure finished_closure,
+    ServiceWorkerLoadedCallback loaded_callback,
+    ServiceWorkerStatusCode service_worker_status,
+    scoped_refptr<ServiceWorkerRegistration> registration) {
+  if (service_worker_status != SERVICE_WORKER_OK) {
+    DidDispatchEvent(event, std::move(finished_closure), DispatchPhase::FINDING,
+                     service_worker_status);
+    return;
+  }
+
+  ServiceWorkerVersion* service_worker_version = registration->active_version();
+  DCHECK(service_worker_version);
+
+  service_worker_version->RunAfterStartWorker(
+      event,
+      base::Bind(&BackgroundFetchEventDispatcher::DispatchEvent, event,
+                 finished_closure, loaded_callback,
+                 make_scoped_refptr(service_worker_version)),
+      base::Bind(&BackgroundFetchEventDispatcher::DidDispatchEvent, event,
+                 finished_closure, DispatchPhase::STARTING));
+}
+
+void BackgroundFetchEventDispatcher::DispatchEvent(
+    ServiceWorkerMetrics::EventType event,
+    base::Closure finished_closure,
+    ServiceWorkerLoadedCallback loaded_callback,
+    scoped_refptr<ServiceWorkerVersion> service_worker_version) {
+  int request_id = service_worker_version->StartRequest(
+      event,
+      base::Bind(&BackgroundFetchEventDispatcher::DidDispatchEvent, event,
+                 std::move(finished_closure), DispatchPhase::DISPATCHING));
+
+  loaded_callback.Run(std::move(service_worker_version), request_id);
+}
+
+void BackgroundFetchEventDispatcher::DidDispatchEvent(
+    ServiceWorkerMetrics::EventType event,
+    base::Closure finished_closure,
+    DispatchPhase dispatch_phase,
+    ServiceWorkerStatusCode service_worker_status) {
+  // Record the histograms tracking event dispatching success.
+  switch (dispatch_phase) {
+    case DispatchPhase::FINDING:
+      RecordDispatchResult(event, DISPATCH_RESULT_CANNOT_FIND_WORKER);
+      RecordFailureResult(event, "FindWorker", service_worker_status);
+      break;
+    case DispatchPhase::STARTING:
+      RecordDispatchResult(event, DISPATCH_RESULT_CANNOT_START_WORKER);
+      RecordFailureResult(event, "StartWorker", service_worker_status);
+      break;
+    case DispatchPhase::DISPATCHING:
+      if (service_worker_status != SERVICE_WORKER_OK) {
+        RecordDispatchResult(event, DISPATCH_RESULT_CANNOT_DISPATCH_EVENT);
+        RecordFailureResult(event, "Dispatch", service_worker_status);
+      } else {
+        RecordDispatchResult(event, DISPATCH_RESULT_SUCCESS);
+      }
+      break;
+  }
+
+  finished_closure.Run();
+}
+
+}  // namespace content