[Page Load Metrics] PageLoadMetrics Mojofication.

chrome/renderer/page_load_metrics/metrics_render_frame_observer.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 "chrome/renderer/page_load_metrics/metrics_render_frame_observer.h"
 
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/renderer/page_load_metrics/page_timing_metrics_sender.h"
 #include "chrome/renderer/page_load_metrics/renderer_page_track_decider.h"
 #include "chrome/renderer/searchbox/search_bouncer.h"
+#include "content/public/common/associated_interface_provider.h"
 #include "content/public/renderer/render_frame.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebPerformance.h"
 #include "url/gurl.h"
 
 namespace page_load_metrics {
 
 namespace {
 
 base::TimeDelta ClampDelta(double event, double start) {
   if (event - start < 0)
     event = start;
   return base::Time::FromDoubleT(event) - base::Time::FromDoubleT(start);
 }
 
 }  //  namespace
 
 MetricsRenderFrameObserver::MetricsRenderFrameObserver(
     content::RenderFrame* render_frame)
     : content::RenderFrameObserver(render_frame) {}
 
 MetricsRenderFrameObserver::~MetricsRenderFrameObserver() {}
 
+void MetricsRenderFrameObserver::SendTiming(const PageLoadTiming& timing,
+                                            const PageLoadMetadata& metadata) {
+  if (HasNoRenderFrame())
+    return;
+  if (!page_load_metrics_) {
+    render_frame()->GetRemoteAssociatedInterfaces()->GetInterface(
+        &page_load_metrics_);
+  }
+  page_load_metrics_->UpdateTiming(timing, metadata);

[Zhen Wang, 2017/04/19 18:49:54]

Why should MetricsRenderFrameObserver care about sending the data? I think this
should still be done by PageTimingMetricsSender.

Ideally, MetricsRenderFrameObserver does not need to worry about whether it is
using old IPC or mojo. PageTimingMetricsSender will take care of it.

[lpy, 2017/04/19 21:05:05]

MetricsRenderFrameObserver is IPC::Sender, PageTimingMetricsSender only batches
page timing, and call MetricsRenderFrameObserver itself to send the timing over
IPC. I maintain this logic here by making MetricsRenderFrameObserver to
implement a PageTimingSender API.

And as it turns out, this is easier to test/verify by separating the logic of
sending and batching. If PageTimingMetricsSender is doing the actually sending,
we need to fake a sender in MetricsRenderFrameObserver test, and intercept the
creation of the sender. See Patch Set #13 in the prototype CL as an example:
https://codereview.chromium.org/2731583002/#ps380001

In my opinion, the name of PageTimingMetricsSender is misleading, as it only
batches the timing and calls IPC::Sender to send the timing.

[Zhen Wang, 2017/04/19 21:52:47]

Oh, I see.

+}
+
 void MetricsRenderFrameObserver::DidChangePerformanceTiming() {
   // Only track timing metrics for main frames.
   if (IsMainFrame())
     SendMetrics();
 }
 
 void MetricsRenderFrameObserver::DidObserveLoadingBehavior(
     blink::WebLoadingBehaviorFlag behavior) {
   if (page_timing_metrics_sender_)
     page_timing_metrics_sender_->DidObserveLoadingBehavior(behavior);
@@ skipping 21 matching lines @@
   // sending and recording metrics. Once page_timing_metrics_sender_ is
   // non-null, we will send metrics for the current page at some later time, as
   // those metrics become available.
   if (ShouldSendMetrics()) {
     PageLoadTiming timing;
     if (IsMainFrame()) {
       // Only populate PageLoadTiming for the main frame.
       timing = GetTiming();
       DCHECK(!timing.navigation_start.is_null());
     }
-    page_timing_metrics_sender_.reset(
-        new PageTimingMetricsSender(this, routing_id(), CreateTimer(), timing));
+    page_timing_metrics_sender_.reset(new PageTimingMetricsSender(
+        this, routing_id(), this, CreateTimer(), timing));
   }
 }
 
 void MetricsRenderFrameObserver::SendMetrics() {
   if (!page_timing_metrics_sender_)
     return;
   if (HasNoRenderFrame())
     return;
   PageLoadTiming timing(GetTiming());
   page_timing_metrics_sender_->Send(timing);
@@ skipping 90 matching lines @@
 
 void MetricsRenderFrameObserver::OnDestruct() {
   delete this;
 }
 
 bool MetricsRenderFrameObserver::IsMainFrame() const {
   return render_frame()->IsMainFrame();
 }
 
 }  // namespace page_load_metrics