ServiceWorker: Use mojo's data pipe for respondWith(stream)

content/common/service_worker/service_worker_event_dispatcher.mojom

 // Copyright 2016 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.
 
 module content.mojom;
 
 import "components/payments/content/payment_app.mojom";
 import "content/common/url_loader.mojom";
 import "mojo/common/string16.mojom";
 import "mojo/common/time.mojom";
 import "third_party/WebKit/public/platform/modules/background_sync/background_sync.mojom";
 import "third_party/WebKit/public/platform/modules/fetch/fetch_api_request.mojom";
 import "third_party/WebKit/public/platform/modules/serviceworker/service_worker_event_status.mojom";
+import "third_party/WebKit/public/platform/modules/serviceworker/service_worker_stream_handle.mojom";
 import "url/mojo/origin.mojom";
 
 [Native]
 struct PlatformNotificationData;
 
 [Native]
 struct PushEventPayload;
 
 [Native]
 struct ServiceWorkerResponse;
@@ skipping 19 matching lines @@
   URLLoaderClient& url_loader_client_request;
 };
 
 struct ExtendableMessageEvent {
   mojo.common.mojom.String16 message;
   url.mojom.Origin source_origin;
   array<handle<message_pipe>> message_ports;
   ExtendableMessageEventSource source;
 };
 
+// Browser-side interface which is passed through DispatchFetchEvent. The
+// renderer uses this interface to respond to a fetch event. This interface is
+// only used for responses where the body is a stream or doesn't exist.

[falken, 2017/04/12 08:00:16]

nit: Add "when the body is a blob, the legacy IPC blahblabhlah is used"

[shimazu, 2017/04/18 01:50:04]

Done.

+// TODO(shimazu): Use this interface for all responses after the blob system is
+// mojoified: https://crbug.com/611935.
+interface ServiceWorkerFetchResponseCallback {

[falken, 2017/04/12 08:00:16]

// Responds to the request with |response|. The body is empty.

[shimazu, 2017/04/18 01:50:04]

Done.

+  OnResponse(ServiceWorkerResponse response,
+             mojo.common.mojom.Time dispatch_event_time);

[falken, 2017/04/12 08:00:16]

// Responds to the request with |response|. The body is returned as a stream.

[shimazu, 2017/04/18 01:50:04]

Done.

+  OnResponseStream(ServiceWorkerResponse response,
+                   blink.mojom.ServiceWorkerStreamHandle stream_handle,

[falken, 2017/04/12 08:00:16]

Is it easier to understand if "stream_handle" is renamed "body" or maybe
"body_as_stream"?

[shimazu, 2017/04/18 01:50:04]

Done.

+                   mojo.common.mojom.Time dispatch_event_time);

[falken, 2017/04/12 08:00:16]

// Provides no response to the request. The browser will fall back to the
network.

[shimazu, 2017/04/18 01:50:04]

Done.

+  OnFallback(mojo.common.mojom.Time dispatch_event_time);
+};
+
 // Renderer-side interface bound to ServiceWorkerContextClient for dispatching
 // events.
 // Those events expecting such response
 // (blink.mojom.ServiceWorkerEventStatus, mojo.common.mojom.Time) are considered
 // 'simple events'. ServiceWorkerVersion::CreateSimpleEventCallback can be used
 // to create the callback for these.
 interface ServiceWorkerEventDispatcher {
   DispatchActivateEvent()
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   DispatchBackgroundFetchAbortEvent(string tag)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   DispatchBackgroundFetchClickEvent(string tag, BackgroundFetchState state)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   DispatchBackgroundFetchFailEvent(string tag,
                                    array<BackgroundFetchSettledFetch> fetches)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   DispatchBackgroundFetchedEvent(string tag,
                                  array<BackgroundFetchSettledFetch> fetches)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   // |fetch_event_id| is used internally when sending the response back to the
   // browser process.

[falken, 2017/04/12 08:00:16]

Can you add a comment explaining why this takes both
ServiceWorkerFetchResponseCallback in addition to the mojo callback?

IIRC this has to do this the waitUntil/respondWith duality.

Maybe: The callback is called once the event finishes, which means the event
handler ran and all outstanding respondWith() and waitUntil() promises have
settled. |response_callback| is called once the promise to respondWith()
settles, or when the event handler ran without calling respondWith().

[shimazu, 2017/04/18 01:50:04]

Done.

   DispatchFetchEvent(int32 fetch_event_id, blink.mojom.FetchAPIRequest request,
-                     FetchEventPreloadHandle? preload_handle)
+                     FetchEventPreloadHandle? preload_handle,
+                     ServiceWorkerFetchResponseCallback response_callback)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   DispatchNotificationClickEvent(string notification_id,
                                  PlatformNotificationData notification_data,
                                  int32 action_index,
                                  mojo.common.mojom.String16? reply)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
   DispatchNotificationCloseEvent(string notification_id,
                                  PlatformNotificationData notification_data)
@@ skipping 16 matching lines @@
   DispatchExtendableMessageEvent(ExtendableMessageEvent event)
       => (blink.mojom.ServiceWorkerEventStatus status,
           mojo.common.mojom.Time dispatch_event_time);
 
   // Pings the service worker to check if it is responsive. If the callback is
   // not called within a certain period of time, the browser will terminate the
   // worker. Unlike the other functions in this interface, Ping() does not
   // dispatch an event.
   Ping() => ();
 };