Implement the BackgroundFetch{Fail,ed} Service Worker events

content/browser/service_worker/embedded_worker_test_helper.cc

 // Copyright 2014 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/service_worker/embedded_worker_test_helper.h"
 
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_registry.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_dispatcher_host.h"
+#include "content/common/background_fetch/background_fetch_types.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
 #include "content/common/service_worker/embedded_worker_start_params.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
@@ skipping 133 matching lines @@
 
   void DispatchBackgroundFetchClickEvent(
       const std::string& tag,
       mojom::BackgroundFetchState state,
       const DispatchBackgroundFetchClickEventCallback& callback) override {
     if (!helper_)
       return;
     helper_->OnBackgroundFetchClickEventStub(tag, state, callback);
   }
 
+  void DispatchBackgroundFetchFailEvent(
+      const std::string& tag,
+      const std::vector<BackgroundFetchSettledFetch>& fetches,
+      const DispatchBackgroundFetchFailEventCallback& callback) override {
+    if (!helper_)
+      return;
+    helper_->OnBackgroundFetchFailEventStub(tag, fetches, callback);
+  }
+
+  void DispatchBackgroundFetchedEvent(
+      const std::string& tag,
+      const std::vector<BackgroundFetchSettledFetch>& fetches,
+      const DispatchBackgroundFetchedEventCallback& callback) override {
+    if (!helper_)
+      return;
+    helper_->OnBackgroundFetchedEventStub(tag, fetches, callback);
+  }
+
   void DispatchFetchEvent(int fetch_event_id,
                           const ServiceWorkerFetchRequest& request,
                           mojom::FetchEventPreloadHandlePtr preload_handle,
                           const DispatchFetchEventCallback& callback) override {
     if (!helper_)
       return;
     helper_->OnFetchEventStub(thread_id_, fetch_event_id, request,
                               std::move(preload_handle), callback);
   }
 
@@ skipping 218 matching lines @@
 }
 
 void EmbeddedWorkerTestHelper::OnBackgroundFetchClickEvent(
     const std::string& tag,
     mojom::BackgroundFetchState state,
     const mojom::ServiceWorkerEventDispatcher::
         DispatchBackgroundFetchClickEventCallback& callback) {
   callback.Run(SERVICE_WORKER_OK, base::Time::Now());
 }
 
+void EmbeddedWorkerTestHelper::OnBackgroundFetchFailEvent(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    const mojom::ServiceWorkerEventDispatcher::
+        DispatchBackgroundFetchFailEventCallback& callback) {
+  callback.Run(SERVICE_WORKER_OK, base::Time::Now());
+}
+
+void EmbeddedWorkerTestHelper::OnBackgroundFetchedEvent(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    const mojom::ServiceWorkerEventDispatcher::
+        DispatchBackgroundFetchedEventCallback& callback) {
+  callback.Run(SERVICE_WORKER_OK, base::Time::Now());
+}
+
 void EmbeddedWorkerTestHelper::OnExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     const mojom::ServiceWorkerEventDispatcher::
         DispatchExtendableMessageEventCallback& callback) {
   callback.Run(SERVICE_WORKER_OK, base::Time::Now());
 }
 
 void EmbeddedWorkerTestHelper::OnInstallEvent(int embedded_worker_id,
                                               int request_id) {
   // The installing worker may have been doomed and terminated.
@@ skipping 196 matching lines @@
     const std::string& tag,
     mojom::BackgroundFetchState state,
     const mojom::ServiceWorkerEventDispatcher::
         DispatchBackgroundFetchClickEventCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&EmbeddedWorkerTestHelper::OnBackgroundFetchClickEvent,
                  AsWeakPtr(), tag, state, callback));
 }
 
+void EmbeddedWorkerTestHelper::OnBackgroundFetchFailEventStub(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    const mojom::ServiceWorkerEventDispatcher::
+        DispatchBackgroundFetchFailEventCallback& callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(&EmbeddedWorkerTestHelper::OnBackgroundFetchFailEvent,
+                 AsWeakPtr(), tag, fetches, callback));
+}
+
+void EmbeddedWorkerTestHelper::OnBackgroundFetchedEventStub(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    const mojom::ServiceWorkerEventDispatcher::
+        DispatchBackgroundFetchedEventCallback& callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnBackgroundFetchedEvent,
+                            AsWeakPtr(), tag, fetches, callback));
+}
+
 void EmbeddedWorkerTestHelper::OnExtendableMessageEventStub(
     mojom::ExtendableMessageEventPtr event,
     const mojom::ServiceWorkerEventDispatcher::
         DispatchExtendableMessageEventCallback& callback) {
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EmbeddedWorkerTestHelper::OnExtendableMessageEvent,
                             AsWeakPtr(), base::Passed(&event), callback));
 }
 
 void EmbeddedWorkerTestHelper::OnInstallEventStub(int request_id) {
@@ skipping 78 matching lines @@
                  service_manager::InterfaceProviderSpec());
 
   std::unique_ptr<service_manager::InterfaceProvider> remote_interfaces(
       new service_manager::InterfaceProvider);
   remote_interfaces->Bind(std::move(interfaces));
   rph->SetRemoteInterfaces(std::move(remote_interfaces));
   return registry;
 }
 
 }  // namespace content