Migrate PerformanceResourceTiming to use GC mojo wrappers.

No behavior change. This CL reduces potential risks of use-after-free bugs.

Bug: 1049056
Change-Id: I3513d21c4af320700269118b3b573a794125a6c9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2154356
Commit-Queue: Minoru Chikamune <chikamune@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#771676}

third_party/blink/renderer/core/frame/remote_frame.cc

@@ -282,7 +282,8 @@ void RemoteFrame::AddResourceTimingFromChild(
   // WorkerTimingContainer for navigation from the calling function.
   DOMWindowPerformance::performance(*owner_element->GetDocument().domWindow())
       ->AddResourceTiming(std::move(timing), owner_element->localName(),
-                          /*worker_timing_receiver=*/mojo::NullReceiver());
+                          /*worker_timing_receiver=*/mojo::NullReceiver(),
+                          owner_element->GetDocument().GetExecutionContext());
 }
 
 void RemoteFrame::DidStartLoading() {

third_party/blink/renderer/core/loader/worker_resource_timing_notifier_impl.cc

@@ -70,7 +70,8 @@ void WorkerResourceTimingNotifierImpl::AddResourceTiming(
     DCHECK(inside_execution_context_->IsContextThread());
     GetPerformance(*inside_execution_context_)
         ->AddResourceTiming(std::move(info), initiator_type,
-                            std::move(worker_timing_receiver));
+                            std::move(worker_timing_receiver),
+                            inside_execution_context_);
   } else {
     PostCrossThreadTask(
         *task_runner_, FROM_HERE,
@@ -93,7 +94,8 @@ void WorkerResourceTimingNotifierImpl::AddCrossThreadResourceTiming(
   DCHECK(outside_execution_context_->IsContextThread());
   GetPerformance(*outside_execution_context_)
       ->AddResourceTiming(std::move(info), AtomicString(initiator_type),
-                          std::move(worker_timing_receiver));
+                          std::move(worker_timing_receiver),
+                          outside_execution_context_);
 }
 
 void WorkerResourceTimingNotifierImpl::Trace(Visitor* visitor) const {

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

@@ -503,7 +503,7 @@ void Performance::GenerateAndAddResourceTiming(
   AddResourceTiming(
       GenerateResourceTiming(*security_origin, info, *context),
       !initiator_type.IsNull() ? initiator_type : info.InitiatorType(),
-      info.TakeWorkerTimingReceiver());
+      info.TakeWorkerTimingReceiver(), context);
 }
 
 mojom::blink::ResourceTimingInfoPtr Performance::GenerateResourceTiming(
@@ -592,9 +592,11 @@ void Performance::AddResourceTiming(
     mojom::blink::ResourceTimingInfoPtr info,
     const AtomicString& initiator_type,
     mojo::PendingReceiver<mojom::blink::WorkerTimingContainer>
-        worker_timing_receiver) {
+        worker_timing_receiver,
+    ExecutionContext* context) {
   auto* entry = MakeGarbageCollected<PerformanceResourceTiming>(
-      *info, time_origin_, initiator_type, std::move(worker_timing_receiver));
+      *info, time_origin_, initiator_type, std::move(worker_timing_receiver),
+      context);
   NotifyObserversOfEntry(*entry);
   // https://w3c.github.io/resource-timing/#dfn-add-a-performanceresourcetiming-entry
   if (CanAddResourceTimingEntry() &&

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

@@ -180,7 +180,8 @@ class CORE_EXPORT Performance : public EventTargetWithInlineData {
       mojom::blink::ResourceTimingInfoPtr,
       const AtomicString& initiator_type,
       mojo::PendingReceiver<mojom::blink::WorkerTimingContainer>
-          worker_timing_receiver);
+          worker_timing_receiver,
+      ExecutionContext* context);
 
   void NotifyNavigationTimingToObservers();
 

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

@@ -57,7 +57,8 @@ PerformanceNavigationTiming::PerformanceNavigationTiming(
                : g_empty_atom,
           time_origin,
           SecurityOrigin::IsSecure(frame->GetDocument()->Url()),
-          std::move(server_timing)),
+          std::move(server_timing),
+          frame->DomWindow()),
       ExecutionContextClient(frame),
       resource_timing_info_(info) {
   DCHECK(frame);
@@ -317,4 +318,4 @@ void PerformanceNavigationTiming::BuildJSONValue(
   builder.AddString("type", type());
   builder.AddNumber("redirectCount", redirectCount());
 }
-}
+}  // namespace blink

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

@@ -43,6 +43,7 @@
 #include "third_party/blink/renderer/platform/loader/fetch/resource_request.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_response.h"
 #include "third_party/blink/renderer/platform/loader/fetch/resource_timing_info.h"
+#include "third_party/blink/renderer/platform/scheduler/public/thread_scheduler.h"
 
 namespace blink {
 
@@ -51,7 +52,8 @@ PerformanceResourceTiming::PerformanceResourceTiming(
     base::TimeTicks time_origin,
     const AtomicString& initiator_type,
     mojo::PendingReceiver<mojom::blink::WorkerTimingContainer>
-        worker_timing_receiver)
+        worker_timing_receiver,
+    ExecutionContext* context)
     : PerformanceEntry(AtomicString(info.name),
                        Performance::MonotonicTimeToDOMHighResTimeStamp(
                            time_origin,
@@ -83,7 +85,12 @@ PerformanceResourceTiming::PerformanceResourceTiming(
       is_secure_context_(info.is_secure_context),
       server_timing_(
           PerformanceServerTiming::FromParsedServerTiming(info.server_timing)),
-      worker_timing_receiver_(this, std::move(worker_timing_receiver)) {}
+      worker_timing_receiver_(this, context) {
+  DCHECK(context);
+  worker_timing_receiver_.Bind(
+      std::move(worker_timing_receiver),
+      context->GetTaskRunner(TaskType::kMiscPlatformAPI));
+}
 
 // This constructor is for PerformanceNavigationTiming.
 // TODO(https://crbug.com/900700): Set a Mojo pending receiver for
@@ -93,14 +100,19 @@ PerformanceResourceTiming::PerformanceResourceTiming(
     const AtomicString& name,
     base::TimeTicks time_origin,
     bool is_secure_context,
-    HeapVector<Member<PerformanceServerTiming>> server_timing)
+    HeapVector<Member<PerformanceServerTiming>> server_timing,
+    ExecutionContext* context)
     : PerformanceEntry(name, 0.0, 0.0),
       time_origin_(time_origin),
       context_type_(mojom::RequestContextType::HYPERLINK),
       request_destination_(network::mojom::RequestDestination::kDocument),
       is_secure_context_(is_secure_context),
       server_timing_(std::move(server_timing)),
-      worker_timing_receiver_(this, mojo::NullReceiver()) {}
+      worker_timing_receiver_(this, context) {
+  DCHECK(context);
+  worker_timing_receiver_.Bind(
+      mojo::NullReceiver(), context->GetTaskRunner(TaskType::kMiscPlatformAPI));
+}
 
 PerformanceResourceTiming::~PerformanceResourceTiming() = default;
 
@@ -442,6 +454,7 @@ void PerformanceResourceTiming::AddPerformanceEntry(
 void PerformanceResourceTiming::Trace(Visitor* visitor) const {
   visitor->Trace(server_timing_);
   visitor->Trace(worker_timing_);
+  visitor->Trace(worker_timing_receiver_);
   PerformanceEntry::Trace(visitor);
 }
 

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

@@ -32,15 +32,17 @@
 #ifndef THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_RESOURCE_TIMING_H_
 #define THIRD_PARTY_BLINK_RENDERER_CORE_TIMING_PERFORMANCE_RESOURCE_TIMING_H_
 
-#include "mojo/public/cpp/bindings/receiver.h"
 #include "third_party/blink/public/mojom/fetch/fetch_api_request.mojom-blink.h"
 #include "third_party/blink/public/mojom/timing/performance_mark_or_measure.mojom-blink-forward.h"
 #include "third_party/blink/public/mojom/timing/resource_timing.mojom-blink.h"
 #include "third_party/blink/public/mojom/timing/worker_timing_container.mojom-blink.h"
 #include "third_party/blink/renderer/core/dom/dom_high_res_time_stamp.h"
+#include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/timing/performance_entry.h"
 #include "third_party/blink/renderer/core/timing/performance_server_timing.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
+#include "third_party/blink/renderer/platform/mojo/heap_mojo_receiver.h"
+#include "third_party/blink/renderer/platform/mojo/heap_mojo_wrapper_mode.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
 
 namespace blink {
@@ -60,13 +62,15 @@ class CORE_EXPORT PerformanceResourceTiming
       const AtomicString& name,
       base::TimeTicks time_origin,
       bool is_secure_context,
-      HeapVector<Member<PerformanceServerTiming>> server_timing);
+      HeapVector<Member<PerformanceServerTiming>> server_timing,
+      ExecutionContext* context);
   PerformanceResourceTiming(
       const mojom::blink::ResourceTimingInfo&,
       base::TimeTicks time_origin,
       const AtomicString& initiator_type,
       mojo::PendingReceiver<mojom::blink::WorkerTimingContainer>
-          worker_timing_receiver);
+          worker_timing_receiver,
+      ExecutionContext* context);
   ~PerformanceResourceTiming() override;
 
   AtomicString entryType() const override;
@@ -146,7 +150,10 @@ class CORE_EXPORT PerformanceResourceTiming
   // Used for getting entries from a service worker to add to
   // PerformanceResourceTiming#workerTiming. Null when no service worker handles
   // a request for the resource.
-  mojo::Receiver<mojom::blink::WorkerTimingContainer> worker_timing_receiver_;
+  HeapMojoReceiver<mojom::blink::WorkerTimingContainer,
+                   PerformanceResourceTiming,
+                   HeapMojoWrapperMode::kWithoutContextObserver>
+      worker_timing_receiver_;
 };
 
 }  // namespace blink

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

@@ -5,6 +5,7 @@
 #include "third_party/blink/renderer/core/timing/performance_resource_timing.h"
 
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
 
 namespace blink {
 
@@ -14,10 +15,15 @@ class PerformanceResourceTimingTest : public testing::Test {
                                   const AtomicString& connection_info) {
     mojom::blink::ResourceTimingInfo info;
     info.allow_timing_details = true;
-    PerformanceResourceTiming timing(
+    std::unique_ptr<DummyPageHolder> dummy_page_holder =
+        std::make_unique<DummyPageHolder>();
+    PerformanceResourceTiming* timing =
+        MakeGarbageCollected<PerformanceResourceTiming>(
             info, base::TimeTicks(), /*initiator_type=*/"",
-        mojo::PendingReceiver<mojom::blink::WorkerTimingContainer>());
-    return timing.GetNextHopProtocol(alpn_negotiated_protocol, connection_info);
+            mojo::PendingReceiver<mojom::blink::WorkerTimingContainer>(),
+            dummy_page_holder->GetDocument().GetExecutionContext());
+    return timing->GetNextHopProtocol(alpn_negotiated_protocol,
+                                      connection_info);
   }
 };