Implement the BackgroundFetch{Fail,ed} Service Worker events

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
@@ skipping 39 matching lines @@
 #include "content/renderer/service_worker/service_worker_type_converters.h"
 #include "content/renderer/service_worker/service_worker_type_util.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebMessagePortChannel.h"
 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
+#include "third_party/WebKit/public/platform/modules/background_fetch/WebBackgroundFetchSettledFetch.h"
 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationData.h"
 #include "third_party/WebKit/public/platform/modules/payments/WebPaymentAppRequest.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerClientQueryOptions.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerError.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerNetworkProvider.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
 #include "third_party/WebKit/public/web/modules/serviceworker/WebServiceWorkerContextProxy.h"
 
@@ skipping 85 matching lines @@
   web_client_info.uuid = blink::WebString::fromASCII(client_info.client_uuid);
   web_client_info.pageVisibilityState = client_info.page_visibility_state;
   web_client_info.isFocused = client_info.is_focused;
   web_client_info.url = client_info.url;
   web_client_info.frameType = GetBlinkFrameType(client_info.frame_type);
   web_client_info.clientType = client_info.client_type;
 
   return web_client_info;
 }
 
+// Converts the |request| to its equivalent type in the Blink API.
+// TODO(peter): Remove this when the Mojo FetchAPIRequest type exists.
+void ToWebServiceWorkerRequest(const ServiceWorkerFetchRequest& request,
+                               blink::WebServiceWorkerRequest* web_request) {
+  DCHECK(web_request);
+
+  web_request->setURL(blink::WebURL(request.url));
+  web_request->setMethod(blink::WebString::fromUTF8(request.method));
+  for (const auto& pair : request.headers) {
+    web_request->setHeader(blink::WebString::fromUTF8(pair.first),
+                           blink::WebString::fromUTF8(pair.second));
+  }
+  if (!request.blob_uuid.empty()) {
+    web_request->setBlob(blink::WebString::fromASCII(request.blob_uuid),
+                         request.blob_size);
+  }
+  web_request->setReferrer(
+      blink::WebString::fromUTF8(request.referrer.url.spec()),
+      request.referrer.policy);
+  web_request->setMode(GetBlinkFetchRequestMode(request.mode));
+  web_request->setIsMainResourceLoad(request.is_main_resource_load);
+  web_request->setCredentialsMode(
+      GetBlinkFetchCredentialsMode(request.credentials_mode));
+  web_request->setRedirectMode(
+      GetBlinkFetchRedirectMode(request.redirect_mode));
+  web_request->setRequestContext(
+      GetBlinkRequestContext(request.request_context_type));
+  web_request->setFrameType(GetBlinkFrameType(request.frame_type));
+  web_request->setClientId(blink::WebString::fromUTF8(request.client_id));
+  web_request->setIsReload(request.is_reload);
+}
+
+// Converts |response| to its equivalent type in the Blink API.
+// TODO(peter): Remove this when the Mojo FetchAPIResponse type exists.
+void ToWebServiceWorkerResponse(const ServiceWorkerResponse& response,
+                                blink::WebServiceWorkerResponse* web_response) {

[kinuko, 2017/03/24 04:03:59]

How long do you expect before you remove this? If this might be around for a
while I prefer letting CacheStorageDispatcher::PopulateWebResponseFromResonse
use this method too

[Peter Beverloo, 2017/03/24 14:11:09]

Assuming we make progress on Mojofication of FetchAPIFrequest, FetchAPIResponse
should be much easier. My estimate would be next week.

+  DCHECK(web_response);
+
+  std::vector<blink::WebURL> url_list;
+  for (const GURL& url : response.url_list)
+    url_list.push_back(blink::WebURL(url));
+
+  web_response->setURLList(blink::WebVector<blink::WebURL>(url_list));
+  web_response->setStatus(static_cast<unsigned short>(response.status_code));
+  web_response->setStatusText(blink::WebString::fromUTF8(response.status_text));
+  web_response->setResponseType(response.response_type);
+  for (const auto& pair : response.headers) {
+    web_response->setHeader(blink::WebString::fromUTF8(pair.first),
+                            blink::WebString::fromUTF8(pair.second));
+  }
+  if (!response.blob_uuid.empty()) {
+    web_response->setBlob(blink::WebString::fromASCII(response.blob_uuid),
+                          response.blob_size);
+  }
+  web_response->setStreamURL(blink::WebURL(response.stream_url));
+  web_response->setError(response.error);
+
+  // response_time

[shimazu, 2017/03/24 00:19:27]

Could you set the response time?

[Peter Beverloo, 2017/03/24 00:55:16]

Oops! Will do first thing tomorrow :)

[Peter Beverloo, 2017/03/24 14:11:09]

Done.

+
+  if (response.is_in_cache_storage) {
+    web_response->setCacheStorageCacheName(
+        blink::WebString::fromUTF8(response.cache_storage_cache_name));
+  }
+
+  std::vector<blink::WebString> cors_exposed_header_names;
+  for (const auto& name : response.cors_exposed_header_names)
+    cors_exposed_header_names.push_back(blink::WebString::fromUTF8(name));
+
+  web_response->setCorsExposedHeaderNames(
+      blink::WebVector<blink::WebString>(cors_exposed_header_names));
+}
+
 // Use this template in willDestroyWorkerContext to abort all the pending
 // events callbacks.
 template <typename T>
 void AbortPendingEventCallbacks(T& callbacks) {
   for (typename T::iterator it(&callbacks); !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
 }
 
 }  // namespace
 
 // Holding data that needs to be bound to the worker context on the
 // worker thread.
 struct ServiceWorkerContextClient::WorkerContextData {
   using ClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsCallbacks>>;
   using ClaimClientsCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientsClaimCallbacks>>;
   using ClientCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerClientCallbacks>>;
   using SkipWaitingCallbacksMap =
       IDMap<std::unique_ptr<blink::WebServiceWorkerSkipWaitingCallbacks>>;
   using ActivateEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchActivateEventCallback>>;
   using BackgroundFetchAbortEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchAbortEventCallback>>;
   using BackgroundFetchClickEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchBackgroundFetchClickEventCallback>>;
+  using BackgroundFetchFailEventCallbacksMap =
+      IDMap<std::unique_ptr<const DispatchBackgroundFetchFailEventCallback>>;
+  using BackgroundFetchedEventCallbacksMap =
+      IDMap<std::unique_ptr<const DispatchBackgroundFetchedEventCallback>>;
   using SyncEventCallbacksMap = IDMap<std::unique_ptr<const SyncCallback>>;
   using PaymentRequestEventCallbacksMap =
       IDMap<std::unique_ptr<const PaymentRequestEventCallback>>;
   using NotificationClickEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchNotificationClickEventCallback>>;
   using NotificationCloseEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchNotificationCloseEventCallback>>;
   using PushEventCallbacksMap =
       IDMap<std::unique_ptr<const DispatchPushEventCallback>>;
   using FetchEventCallbacksMap = IDMap<std::unique_ptr<const FetchCallback>>;
@@ skipping 27 matching lines @@
 
   // Pending callbacks for Activate Events.
   ActivateEventCallbacksMap activate_event_callbacks;
 
   // Pending callbacks for Background Fetch Abort Events.
   BackgroundFetchAbortEventCallbacksMap background_fetch_abort_event_callbacks;
 
   // Pending callbacks for Background Fetch Click Events.
   BackgroundFetchClickEventCallbacksMap background_fetch_click_event_callbacks;
 
+  // Pending callbacks for Background Fetch Fail Events.
+  BackgroundFetchFailEventCallbacksMap background_fetch_fail_event_callbacks;
+
+  // Pending callbacks for Background Fetched Events.
+  BackgroundFetchedEventCallbacksMap background_fetched_event_callbacks;
+
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
   // Pending callbacks for Payment Request Events.
   PaymentRequestEventCallbacksMap payment_request_event_callbacks;
 
   // Pending callbacks for Notification Click Events.
   NotificationClickEventCallbacksMap notification_click_event_callbacks;
 
   // Pending callbacks for Notification Close Events.
@@ skipping 321 matching lines @@
     v8::Local<v8::Context> context) {
   // At this point WillStopCurrentWorkerThread is already called, so
   // worker_task_runner_->RunsTasksOnCurrentThread() returns false
   // (while we're still on the worker thread).
   proxy_ = NULL;
 
   // Aborts all the pending events callbacks.
   AbortPendingEventCallbacks(context_->activate_event_callbacks);
   AbortPendingEventCallbacks(context_->background_fetch_abort_event_callbacks);
   AbortPendingEventCallbacks(context_->background_fetch_click_event_callbacks);
+  AbortPendingEventCallbacks(context_->background_fetch_fail_event_callbacks);
+  AbortPendingEventCallbacks(context_->background_fetched_event_callbacks);
   AbortPendingEventCallbacks(context_->sync_event_callbacks);
   AbortPendingEventCallbacks(context_->notification_click_event_callbacks);
   AbortPendingEventCallbacks(context_->notification_close_event_callbacks);
   AbortPendingEventCallbacks(context_->push_event_callbacks);
   AbortPendingEventCallbacks(context_->fetch_event_callbacks);
   AbortPendingEventCallbacks(context_->message_event_callbacks);
 
   // We have to clear callbacks now, as they need to be freed on the
   // same thread.
   context_.reset();
@@ skipping 105 matching lines @@
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const DispatchBackgroundFetchClickEventCallback* callback =
       context_->background_fetch_click_event_callbacks.Lookup(request_id);
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
   context_->background_fetch_click_event_callbacks.Remove(request_id);
 }
 
+void ServiceWorkerContextClient::didHandleBackgroundFetchFailEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result,
+    double event_dispatch_time) {
+  const DispatchBackgroundFetchFailEventCallback* callback =
+      context_->background_fetch_fail_event_callbacks.Lookup(request_id);
+  DCHECK(callback);
+  callback->Run(EventResultToStatus(result),
+                base::Time::FromDoubleT(event_dispatch_time));
+  context_->background_fetch_fail_event_callbacks.Remove(request_id);
+}
+
+void ServiceWorkerContextClient::didHandleBackgroundFetchedEvent(
+    int request_id,
+    blink::WebServiceWorkerEventResult result,
+    double event_dispatch_time) {
+  const DispatchBackgroundFetchedEventCallback* callback =
+      context_->background_fetched_event_callbacks.Lookup(request_id);
+  DCHECK(callback);
+  callback->Run(EventResultToStatus(result),
+                base::Time::FromDoubleT(event_dispatch_time));
+  context_->background_fetched_event_callbacks.Remove(request_id);
+}
+
 void ServiceWorkerContextClient::didHandleExtendableMessageEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const DispatchExtendableMessageEventCallback* callback =
       context_->message_event_callbacks.Lookup(request_id);
   DCHECK(callback);
   callback->Run(EventResultToStatus(result),
                 base::Time::FromDoubleT(event_dispatch_time));
   context_->message_event_callbacks.Remove(request_id);
@@ skipping 275 matching lines @@
 
   // TODO(peter): Use typemap when this is moved to blink-side.
   blink::WebServiceWorkerContextProxy::BackgroundFetchState web_state =
       mojo::ConvertTo<
           blink::WebServiceWorkerContextProxy::BackgroundFetchState>(state);
 
   proxy_->dispatchBackgroundFetchClickEvent(
       request_id, blink::WebString::fromUTF8(tag), web_state);
 }
 
+void ServiceWorkerContextClient::DispatchBackgroundFetchFailEvent(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    const DispatchBackgroundFetchFailEventCallback& callback) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchBackgroundFetchFailEvent");
+  int request_id = context_->background_fetch_fail_event_callbacks.Add(
+      base::MakeUnique<DispatchBackgroundFetchFailEventCallback>(callback));
+
+  blink::WebVector<blink::WebBackgroundFetchSettledFetch> web_fetches(
+      fetches.size());
+  for (size_t i = 0; i < fetches.size(); ++i) {
+    ToWebServiceWorkerRequest(fetches[i].request, &web_fetches[i].request);
+    ToWebServiceWorkerResponse(fetches[i].response, &web_fetches[i].response);
+  }
+
+  proxy_->dispatchBackgroundFetchFailEvent(
+      request_id, blink::WebString::fromUTF8(tag), web_fetches);
+}
+
+void ServiceWorkerContextClient::DispatchBackgroundFetchedEvent(
+    const std::string& tag,
+    const std::vector<BackgroundFetchSettledFetch>& fetches,
+    const DispatchBackgroundFetchedEventCallback& callback) {
+  TRACE_EVENT0("ServiceWorker",
+               "ServiceWorkerContextClient::DispatchBackgroundFetchedEvent");
+  int request_id = context_->background_fetched_event_callbacks.Add(
+      base::MakeUnique<DispatchBackgroundFetchedEventCallback>(callback));
+
+  blink::WebVector<blink::WebBackgroundFetchSettledFetch> web_fetches(
+      fetches.size());
+  for (size_t i = 0; i < fetches.size(); ++i) {
+    ToWebServiceWorkerRequest(fetches[i].request, &web_fetches[i].request);
+    ToWebServiceWorkerResponse(fetches[i].response, &web_fetches[i].response);
+  }
+
+  proxy_->dispatchBackgroundFetchedEvent(
+      request_id, blink::WebString::fromUTF8(tag), web_fetches);
+}
+
 void ServiceWorkerContextClient::DispatchExtendableMessageEvent(
     mojom::ExtendableMessageEventPtr event,
     const DispatchExtendableMessageEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchExtendableMessageEvent");
   int request_id = context_->message_event_callbacks.Add(
       base::MakeUnique<DispatchExtendableMessageEventCallback>(callback));
 
   blink::WebMessagePortChannelArray ports =
       WebMessagePortChannelImpl::CreateFromMessagePipeHandles(
@@ skipping 32 matching lines @@
     int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
     mojom::FetchEventPreloadHandlePtr preload_handle,
     const DispatchFetchEventCallback& callback) {
   std::unique_ptr<NavigationPreloadRequest> preload_request =
       preload_handle
           ? base::MakeUnique<NavigationPreloadRequest>(
                 fetch_event_id, request.url, std::move(preload_handle))
           : nullptr;
   const bool navigation_preload_sent = !!preload_request;
-  blink::WebServiceWorkerRequest webRequest;
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchFetchEvent");
   context_->fetch_event_callbacks.AddWithID(
       base::MakeUnique<FetchCallback>(callback), fetch_event_id);
   if (preload_request) {
     context_->preload_requests.AddWithID(std::move(preload_request),
                                          fetch_event_id);
   }
 
-  webRequest.setURL(blink::WebURL(request.url));
-  webRequest.setMethod(blink::WebString::fromUTF8(request.method));
-  for (ServiceWorkerHeaderMap::const_iterator it = request.headers.begin();
-       it != request.headers.end();
-       ++it) {
-    webRequest.setHeader(blink::WebString::fromUTF8(it->first),
-                         blink::WebString::fromUTF8(it->second));
-  }
-  if (!request.blob_uuid.empty()) {
-    webRequest.setBlob(blink::WebString::fromASCII(request.blob_uuid),
-                       request.blob_size);
-  }
-  webRequest.setReferrer(
-      blink::WebString::fromUTF8(request.referrer.url.spec()),
-      request.referrer.policy);
-  webRequest.setMode(GetBlinkFetchRequestMode(request.mode));
-  webRequest.setIsMainResourceLoad(request.is_main_resource_load);
-  webRequest.setCredentialsMode(
-      GetBlinkFetchCredentialsMode(request.credentials_mode));
-  webRequest.setRedirectMode(GetBlinkFetchRedirectMode(request.redirect_mode));
-  webRequest.setRequestContext(
-      GetBlinkRequestContext(request.request_context_type));
-  webRequest.setFrameType(GetBlinkFrameType(request.frame_type));
-  webRequest.setClientId(blink::WebString::fromUTF8(request.client_id));
-  webRequest.setIsReload(request.is_reload);
+  blink::WebServiceWorkerRequest web_request;
+  ToWebServiceWorkerRequest(request, &web_request);
+
   if (request.fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH) {
-    proxy_->dispatchForeignFetchEvent(fetch_event_id, webRequest);
+    proxy_->dispatchForeignFetchEvent(fetch_event_id, web_request);
   } else {
-    proxy_->dispatchFetchEvent(fetch_event_id, webRequest,
+    proxy_->dispatchFetchEvent(fetch_event_id, web_request,
                                navigation_preload_sent);
   }
 }
 
 void ServiceWorkerContextClient::DispatchNotificationClickEvent(
     const std::string& notification_id,
     const PlatformNotificationData& notification_data,
     int action_index,
     const base::Optional<base::string16>& reply,
     const DispatchNotificationClickEventCallback& callback) {
@@ skipping 251 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content