Service Worker: Add an experimental API FetchEvent#addPerformanceEntry

This CL starts to implement FetchEvent WorkerTiming. This feature enables a
service worker to attach PerformanceMark/PerformanceMeasure timings to a
request during the fetch event handler. The timings will then be exposed to the
page using PerformanceResourceTiming.

This patch extends PerformanceMark/Measure by
PerformanceEntry::toMojoPerformanceMarkOrMeasure() to pass them via Mojo pipe.
A pair of Mojo endpoints for FetchEventWorkerTiming is made in
ServiceWorkerSubresourceLoader::DispatchFetchEvent() and Mojo remote will be
moved to FetchEvent.
Mojo remote is null for navigation and subresources because it is unsupported
yet. This feature won't work after this patch is merged because Mojo receiver
and remote aren't be connected anywhere.
These will be connected in the other patch.

Explainer : https://github.com/wanderview/fetchevent-worker-timing/blob/master/explainer.md
Design doc: https://docs.google.com/document/d/1-ebnv7OFiVd3k2-jbtQGO5s3BKHIp7lRx3ujhgNKvB0

Bug: 900700
Change-Id: Ie6c870faf0309990ccf8dbd986091fb2f1597dc5
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1903115
Commit-Queue: Yuta Kasai <yutakasai@google.com>
Reviewed-by: Kent Tamura <tkent@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Nicolás Peña Moreno <npm@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#715171}

content/renderer/service_worker/service_worker_subresource_loader.cc

@@ -262,6 +262,11 @@ void ServiceWorkerSubresourceLoader::DispatchFetchEvent() {
   params->request = blink::mojom::FetchAPIRequest::From(resource_request_);
   params->client_id = controller_connector_->client_id();
 
+  // TODO(https://crbug.com/900700): Implement this, making the remote
+  // connected to a receiver which is passed to
+  // blink::PerformanceResourceTiming.
+  params->worker_timing_remote = mojo::NullRemote();
+
   // TODO(falken): Grant the controller service worker's process access to files
   // in the body, like ServiceWorkerFetchDispatcher::DispatchFetchEvent() does.
   controller->DispatchFetchEventForSubresource(

third_party/blink/public/mojom/BUILD.gn

@@ -129,6 +129,8 @@ mojom("mojom_platform") {
     "speech/speech_recognition_result.mojom",
     "speech/speech_recognizer.mojom",
     "speech/speech_synthesis.mojom",
+    "timing/performance_mark_or_measure.mojom",
+    "timing/worker_timing_container.mojom",
     "ukm/ukm.mojom",
     "user_agent/user_agent_metadata.mojom",
     "v8_cache_options.mojom",

third_party/blink/public/mojom/service_worker/dispatch_fetch_event_params.mojom

@@ -7,6 +7,7 @@ module blink.mojom;
 import "services/network/public/mojom/url_loader.mojom";
 import "third_party/blink/public/mojom/blob/blob.mojom";
 import "third_party/blink/public/mojom/fetch/fetch_api_request.mojom";
+import "third_party/blink/public/mojom/timing/worker_timing_container.mojom";
 
 // Used for service worker navigation preload, to create
 // FetchEvent#preloadResponse.
@@ -24,4 +25,9 @@ struct DispatchFetchEventParams {
   string client_id;
   // FetchEvent#preloadResponse.
   FetchEventPreloadHandle? preload_handle;
+
+  // This is currently always null because it's still being implemented.
+  // TODO(https://crbug.com/900700): Make this non-nullable when implementation
+  // is complete (including support for both navigation and subresource requests).
+  pending_remote<blink.mojom.WorkerTimingContainer>? worker_timing_remote;
 };

third_party/blink/public/mojom/timing/OWNERS

+npm@chromium.org
+
+per-file *.mojom=set noparent
+per-file *.mojom=file://ipc/SECURITY_OWNERS
+
+# TEAM: speed-metrics-dev@chromium.org
+# COMPONENT: Blink>PerformanceAPIs

third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom

+// Copyright 2019 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 blink.mojom;
+
+import "mojo/public/mojom/base/big_buffer.mojom";
+
+// This struct represents PerformanceMark and PerformanceMeasure.
+// https://w3c.github.io/user-timing/#performancemark
+// https://w3c.github.io/user-timing/#performancemeasure
+struct PerformanceMarkOrMeasure {
+  enum EntryType{
+    kMark,
+    kMeasure,
+  };
+  string name;
+  EntryType entry_type;
+  double start_time;
+  double duration;
+  // Nullable because PerformanceMark and PerformanceMeasure might not have a
+  // detail.
+  mojo_base.mojom.BigBuffer? detail;
+};

third_party/blink/public/mojom/timing/worker_timing_container.mojom

+// Copyright 2019 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 blink.mojom;
+
+import "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom";
+
+// Used to implement FetchEvent WorkerTiming (https://crbug.com/900700).
+// A service worker uses this interface to send performance timings to a client
+// (a document/worker controlled by the service worker) during the fetch event
+// for a request. The client then incorporates the timings into the
+// blink::PerformanceResourceTiming for the request. The client may be in a
+// different renderer process than the service worker.
+interface WorkerTimingContainer {
+  // Corresponds to FetchEvent#addPerformanceEntry.
+  // https://github.com/wanderview/fetchevent-worker-timing/blob/master/explainer.md
+  AddPerformanceEntry(PerformanceMarkOrMeasure entry);
+};

third_party/blink/renderer/core/timing/performance_entry.cc

@@ -31,6 +31,7 @@
 #include "third_party/blink/renderer/core/timing/performance_entry.h"
 
 #include "base/atomic_sequence_num.h"
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_value.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_object_builder.h"
 #include "third_party/blink/renderer/core/performance_entry_names.h"
@@ -59,6 +60,22 @@ DOMHighResTimeStamp PerformanceEntry::duration() const {
   return duration_;
 }
 
+mojom::blink::PerformanceMarkOrMeasurePtr
+PerformanceEntry::ToMojoPerformanceMarkOrMeasure() {
+  DCHECK(EntryTypeEnum() == kMark || EntryTypeEnum() == kMeasure);
+  auto mojo_performance_mark_or_measure =
+      mojom::blink::PerformanceMarkOrMeasure::New();
+  mojo_performance_mark_or_measure->name = name_;
+  mojo_performance_mark_or_measure->entry_type =
+      EntryTypeEnum() == kMark
+          ? mojom::blink::PerformanceMarkOrMeasure::EntryType::kMark
+          : mojom::blink::PerformanceMarkOrMeasure::EntryType::kMeasure;
+  mojo_performance_mark_or_measure->start_time = start_time_;
+  mojo_performance_mark_or_measure->duration = duration_;
+  // PerformanceMark/Measure overrides will add the detail field.
+  return mojo_performance_mark_or_measure;
+}
+
 PerformanceEntry::EntryType PerformanceEntry::ToEntryTypeEnum(
     const AtomicString& entry_type) {
   if (entry_type == performance_entry_names::kLongtask)

third_party/blink/renderer/core/timing/performance_entry.h

@@ -32,6 +32,7 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_ENTRY_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_ENTRY_H_
 
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink-forward.h"
 #include "third_party/blink/renderer/core/core_export.h"
 #include "third_party/blink/renderer/core/dom/dom_high_res_time_stamp.h"
 #include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
@@ -111,6 +112,13 @@ class CORE_EXPORT PerformanceEntry : public ScriptWrappable {
     return valid_timeline_entry_types.Contains(entry_type);
   }
 
+  // PerformanceMark/Measure override this and it returns Mojo structure pointer
+  // which has all members of PerformanceMark/Measure. Common data members are
+  // set by PerformanceMark/Measure calling
+  // PerformanceEntry::ToMojoPerformanceMarkOrMeasure().
+  virtual mojom::blink::PerformanceMarkOrMeasurePtr
+  ToMojoPerformanceMarkOrMeasure();
+
  protected:
   PerformanceEntry(const AtomicString& name,
                    double start_time,

third_party/blink/renderer/core/timing/performance_mark.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 #include "third_party/blink/renderer/core/timing/performance_mark.h"
 
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_value.h"
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
@@ -76,6 +77,14 @@ PerformanceEntryType PerformanceMark::EntryTypeEnum() const {
   return PerformanceEntry::EntryType::kMark;
 }
 
+mojom::blink::PerformanceMarkOrMeasurePtr
+PerformanceMark::ToMojoPerformanceMarkOrMeasure() {
+  auto mojo_performance_mark_or_measure =
+      PerformanceEntry::ToMojoPerformanceMarkOrMeasure();
+  mojo_performance_mark_or_measure->detail = serialized_detail_->GetWireData();
+  return mojo_performance_mark_or_measure;
+}
+
 ScriptValue PerformanceMark::detail(ScriptState* script_state) {
   v8::Isolate* isolate = script_state->GetIsolate();
   if (!serialized_detail_)

third_party/blink/renderer/core/timing/performance_mark.h

@@ -26,6 +26,7 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_MARK_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_MARK_H_
 
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink-forward.h"
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
 #include "third_party/blink/renderer/core/timing/performance_entry.h"
 #include "third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h"
@@ -61,6 +62,8 @@ class CORE_EXPORT PerformanceMark final : public PerformanceEntry {
 
   AtomicString entryType() const override;
   PerformanceEntryType EntryTypeEnum() const override;
+  mojom::blink::PerformanceMarkOrMeasurePtr ToMojoPerformanceMarkOrMeasure()
+      override;
 
   ScriptValue detail(ScriptState*);
 

third_party/blink/renderer/core/timing/performance_measure.cc

@@ -4,6 +4,7 @@
 
 #include "third_party/blink/renderer/core/timing/performance_measure.h"
 
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_value.h"
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
 #include "third_party/blink/renderer/core/performance_entry_names.h"
@@ -67,6 +68,14 @@ PerformanceEntryType PerformanceMeasure::EntryTypeEnum() const {
   return PerformanceEntry::EntryType::kMeasure;
 }
 
+mojom::blink::PerformanceMarkOrMeasurePtr
+PerformanceMeasure::ToMojoPerformanceMarkOrMeasure() {
+  auto mojo_performance_mark_or_measure =
+      PerformanceEntry::ToMojoPerformanceMarkOrMeasure();
+  mojo_performance_mark_or_measure->detail = serialized_detail_->GetWireData();
+  return mojo_performance_mark_or_measure;
+}
+
 void PerformanceMeasure::Trace(blink::Visitor* visitor) {
   visitor->Trace(deserialized_detail_map_);
   PerformanceEntry::Trace(visitor);

third_party/blink/renderer/core/timing/performance_measure.h

@@ -27,6 +27,7 @@
 #define THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_MEASURE_H_
 
 #include "base/memory/scoped_refptr.h"
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink-forward.h"
 #include "third_party/blink/renderer/bindings/core/v8/serialization/serialized_script_value.h"
 #include "third_party/blink/renderer/core/timing/performance_entry.h"
 #include "third_party/blink/renderer/platform/bindings/trace_wrapper_v8_reference.h"
@@ -38,7 +39,7 @@ namespace blink {
 
 class ExceptionState;
 
-class PerformanceMeasure final : public PerformanceEntry {
+class CORE_EXPORT PerformanceMeasure final : public PerformanceEntry {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
@@ -60,6 +61,8 @@ class PerformanceMeasure final : public PerformanceEntry {
 
   AtomicString entryType() const override;
   PerformanceEntryType EntryTypeEnum() const override;
+  mojom::blink::PerformanceMarkOrMeasurePtr ToMojoPerformanceMarkOrMeasure()
+      override;
 
   void Trace(blink::Visitor* visitor) override;
 

third_party/blink/renderer/modules/service_worker/fetch_event.cc

@@ -7,6 +7,8 @@
 #include "third_party/blink/renderer/modules/service_worker/fetch_event.h"
 
 #include "base/memory/scoped_refptr.h"
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink.h"
+#include "third_party/blink/public/mojom/timing/worker_timing_container.mojom-blink.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_error.h"
 #include "third_party/blink/public/platform/web_url_response.h"
 #include "third_party/blink/renderer/bindings/core/v8/to_v8_for_core.h"
@@ -14,6 +16,8 @@
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/fetch/request.h"
 #include "third_party/blink/renderer/core/fetch/response.h"
+#include "third_party/blink/renderer/core/timing/performance_mark.h"
+#include "third_party/blink/renderer/core/timing/performance_measure.h"
 #include "third_party/blink/renderer/core/timing/worker_global_scope_performance.h"
 #include "third_party/blink/renderer/modules/service_worker/fetch_respond_with_observer.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_error.h"
@@ -30,18 +34,8 @@ FetchEvent* FetchEvent::Create(ScriptState* script_state,
                                const AtomicString& type,
                                const FetchEventInit* initializer) {
   return MakeGarbageCollected<FetchEvent>(script_state, type, initializer,
-                                          nullptr, nullptr, false);
-}
-
-FetchEvent* FetchEvent::Create(ScriptState* script_state,
-                               const AtomicString& type,
-                               const FetchEventInit* initializer,
-                               FetchRespondWithObserver* respond_with_observer,
-                               WaitUntilObserver* wait_until_observer,
-                               bool navigation_preload_sent) {
-  return MakeGarbageCollected<FetchEvent>(
-      script_state, type, initializer, respond_with_observer,
-      wait_until_observer, navigation_preload_sent);
+                                          nullptr, nullptr, mojo::NullRemote(),
+                                          false);
 }
 
 Request* FetchEvent::request() const {
@@ -93,6 +87,8 @@ FetchEvent::FetchEvent(ScriptState* script_state,
                        const FetchEventInit* initializer,
                        FetchRespondWithObserver* respond_with_observer,
                        WaitUntilObserver* wait_until_observer,
+                       mojo::PendingRemote<mojom::blink::WorkerTimingContainer>
+                           worker_timing_remote,
                        bool navigation_preload_sent)
     : ExtendableEvent(type, initializer, wait_until_observer),
       ContextClient(ExecutionContext::From(script_state)),
@@ -100,7 +96,8 @@ FetchEvent::FetchEvent(ScriptState* script_state,
       preload_response_property_(MakeGarbageCollected<PreloadResponseProperty>(
           ExecutionContext::From(script_state),
           this,
-          PreloadResponseProperty::kPreloadResponse)) {
+          PreloadResponseProperty::kPreloadResponse)),
+      worker_timing_remote_(std::move(worker_timing_remote)) {
   if (!navigation_preload_sent)
     preload_response_property_->ResolveWithUndefined();
 
@@ -212,6 +209,24 @@ void FetchEvent::OnNavigationPreloadComplete(
       ->GenerateAndAddResourceTiming(*info);
 }
 
+void FetchEvent::addPerformanceEntry(PerformanceMark* performance_mark) {
+  if (worker_timing_remote_) {
+    auto mojo_performance_mark =
+        performance_mark->ToMojoPerformanceMarkOrMeasure();
+    worker_timing_remote_->AddPerformanceEntry(
+        std::move(mojo_performance_mark));
+  }
+}
+
+void FetchEvent::addPerformanceEntry(PerformanceMeasure* performance_measure) {
+  if (worker_timing_remote_) {
+    auto mojo_performance_measure =
+        performance_measure->ToMojoPerformanceMarkOrMeasure();
+    worker_timing_remote_->AddPerformanceEntry(
+        std::move(mojo_performance_measure));
+  }
+}
+
 void FetchEvent::Trace(blink::Visitor* visitor) {
   visitor->Trace(observer_);
   visitor->Trace(request_);

third_party/blink/renderer/modules/service_worker/fetch_event.h

@@ -7,6 +7,8 @@
 
 #include <memory>
 
+#include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink-forward.h"
+#include "third_party/blink/public/mojom/timing/worker_timing_container.mojom-blink.h"
 #include "third_party/blink/renderer/bindings/core/v8/active_script_wrappable.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_property.h"
@@ -25,6 +27,8 @@ namespace blink {
 
 class ExceptionState;
 class FetchRespondWithObserver;
+class PerformanceMark;
+class PerformanceMeasure;
 class Request;
 class Response;
 class ScriptState;
@@ -49,18 +53,14 @@ class MODULES_EXPORT FetchEvent final
   static FetchEvent* Create(ScriptState*,
                             const AtomicString& type,
                             const FetchEventInit*);
-  static FetchEvent* Create(ScriptState*,
-                            const AtomicString& type,
-                            const FetchEventInit*,
-                            FetchRespondWithObserver*,
-                            WaitUntilObserver*,
-                            bool navigation_preload_sent);
 
   FetchEvent(ScriptState*,
              const AtomicString& type,
              const FetchEventInit*,
              FetchRespondWithObserver*,
              WaitUntilObserver*,
+             mojo::PendingRemote<mojom::blink::WorkerTimingContainer>
+                 worker_timing_remote,
              bool navigation_preload_sent);
   ~FetchEvent() override;
 
@@ -71,6 +71,8 @@ class MODULES_EXPORT FetchEvent final
 
   void respondWith(ScriptState*, ScriptPromise, ExceptionState&);
   ScriptPromise preloadResponse(ScriptState*);
+  void addPerformanceEntry(PerformanceMark*);
+  void addPerformanceEntry(PerformanceMeasure*);
 
   void OnNavigationPreloadResponse(ScriptState*,
                                    std::unique_ptr<WebURLResponse>,
@@ -96,6 +98,9 @@ class MODULES_EXPORT FetchEvent final
   Member<PreloadResponseProperty> preload_response_property_;
   std::unique_ptr<WebURLResponse> preload_response_;
   Member<DataPipeBytesConsumer::CompletionNotifier> body_completion_notifier_;
+  // This is currently always null while https://crbug.com/900700 is being
+  // implemented.
+  mojo::Remote<mojom::blink::WorkerTimingContainer> worker_timing_remote_;
   String client_id_;
   String resulting_client_id_;
   bool is_reload_;

third_party/blink/renderer/modules/service_worker/fetch_event.idl

@@ -16,4 +16,10 @@
 
     [CallWith=ScriptState, RaisesException] void respondWith(Promise<Response> r);
     [CallWith=ScriptState] readonly attribute Promise<any> preloadResponse;
+    // FetchEvent#addPerformanceEntry
+    // https://github.com/wanderview/fetchevent-worker-timing/blob/master/explainer.md
+    [RuntimeEnabled=ServiceWorkerFetchEventWorkerTiming]
+        void addPerformanceEntry(PerformanceMark entry);
+    [RuntimeEnabled=ServiceWorkerFetchEventWorkerTiming]
+        void addPerformanceEntry(PerformanceMeasure entry);
 };

third_party/blink/renderer/modules/service_worker/service_worker_global_scope.cc

@@ -39,6 +39,7 @@
 #include "mojo/public/cpp/bindings/pending_remote.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/mojom/appcache/appcache.mojom-blink.h"
+#include "third_party/blink/public/mojom/timing/worker_timing_container.mojom-blink.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_error.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_url.h"
@@ -1402,9 +1403,12 @@ void ServiceWorkerGlobalScope::DispatchFetchEventInternal(
       !fetch_request.is_main_resource_load ? String() : params->client_id);
   event_init->setIsReload(fetch_request.is_reload);
   ScriptState* script_state = ScriptController()->GetScriptState();
-  FetchEvent* fetch_event = FetchEvent::Create(
+  FetchEvent* fetch_event = MakeGarbageCollected<FetchEvent>(
       script_state, event_type_names::kFetch, event_init, respond_with_observer,
-      wait_until_observer, navigation_preload_sent);
+      wait_until_observer,
+      mojo::PendingRemote<mojom::blink::WorkerTimingContainer>(
+          std::move(params->worker_timing_remote)),
+      navigation_preload_sent);
   if (navigation_preload_sent) {
     // Keep |fetchEvent| until OnNavigationPreloadComplete() or
     // onNavigationPreloadError() will be called.

third_party/blink/renderer/platform/runtime_enabled_features.json5

@@ -1500,6 +1500,10 @@
       name: "ServiceWorkerClientLifecycleState",
       status: "experimental",
     },
+    {
+      name: "ServiceWorkerFetchEventWorkerTiming",
+      status: "experimental",
+    },
     {
       name: "SetRootScroller",
       status: "experimental",

third_party/blink/web_tests/http/tests/serviceworker/webexposed/global-interface-listing-service-worker-expected.txt

@@ -497,6 +497,7 @@ interface FetchEvent : ExtendableEvent
     getter preloadResponse
     getter request
     getter resultingClientId
+    method addPerformanceEntry
     method constructor
     method respondWith
 interface File : Blob