PageLoadMetrics renderer and browser implementation.

components/page_load_metrics/renderer/page_load_metrics_render_frame_observer.cc

Index: components/page_load_metrics/renderer/page_load_metrics_render_frame_observer.cc
diff --git a/components/page_load_metrics/renderer/page_load_metrics_render_frame_observer.cc b/components/page_load_metrics/renderer/page_load_metrics_render_frame_observer.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e31bd8ff9f572459534c5c7cb8f67ba3d3c4d0fa
--- /dev/null
+++ b/components/page_load_metrics/renderer/page_load_metrics_render_frame_observer.cc
@@ -0,0 +1,118 @@
+// 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 "base/time/time.h"
+#include "base/timer/timer.h"
+#include "components/page_load_metrics/renderer/page_load_metrics_render_frame_observer.h"
+#include "components/page_load_metrics/renderer/page_timing_metrics_sender.h"
+#include "content/public/renderer/render_frame.h"
+#include "third_party/WebKit/public/platform/WebURLResponse.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 {
+
+MainRenderFrameObserver::MainRenderFrameObserver(
+    content::RenderFrame* render_frame)
+    : content::RenderFrameObserver(render_frame) {}
+
+MainRenderFrameObserver::~MainRenderFrameObserver() {}
+
+void MainRenderFrameObserver::OnStop() {

[Bryan McQuade, 2015/09/09 17:33:28]

likewise, what are the cases where this gets called and is it still needed if we
get the DidChangePerformanceTiming callback?

[Charlie Harrison, 2015/09/09 19:42:34]

From what I can tell this is synonymous with DidFailProvisionalLoad in some
cases, but other cases it gets called when a load is stopped after the
provisional load succeeds.

+  SendMetrics();
+}
+
+// TODO(bmcquade): use DidChangePerformanceTiming instead, once available.
+// CL 1289053003
+void MainRenderFrameObserver::DidFinishDocumentLoad() {
+  SendMetrics();
+}
+
+// TODO(bmcquade): use DidChangePerformanceTiming instead, once available.
+// CL 1289053003
+void MainRenderFrameObserver::DidFinishLoad() {
+  SendMetrics();
+}
+
+void MainRenderFrameObserver::DidFailProvisionalLoad(

[Bryan McQuade, 2015/09/09 16:26:26]

just for my own knowledge, what are the cases where this gets called? do we
continue to need it once we have the DidChangePerformanceTiming callback? If
not, can you add:
// TODO(bmcquade): remove this callback once we switch to
DidChangePerformanceTiming.

[Charlie Harrison, 2015/09/09 17:32:03]

This gets called when a load is cancelled or errors and is still provisional.
For non provisional loads, RFO needs to add a DidFailLoad method, which right
now only RVO has.

+    const blink::WebURLError& e) {
+  SendMetrics();
+}
+
+void MainRenderFrameObserver::DidCommitProvisionalLoad(
+    bool is_new_navigation,
+    bool is_same_page_navigation) {
+  // Same-page navigations (e.g. an in-document navigation from a fragment
+  // link) aren't full page loads, since they don't go to network to load the
+  // main HTML resource. DidStartProvisionalLoad doesn't get invoked for same
+  // page navigations, so we may still have an active
+  // page_timing_metrics_sender_ at this point.
+  if (is_same_page_navigation)
+    return;
+
+  // We only create a PageTimingMetricsSender if the page meets the criteria for

[Bryan McQuade, 2015/09/09 16:26:26]

now that we don't hook into DidStartProvisionalLoad to reset the sender, we
should probably add:

// Make sure to release the sender for the previous navigation, if we have one.
page_timing_metrics_sender_.reset();

or you could do this below as part of an if/else block.

[Charlie Harrison, 2015/09/09 17:32:03]

Done.

+  // 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()) {
+    page_timing_metrics_sender_.reset(
+        new PageTimingMetricsSender(this, routing_id(), CreateTimer()));
+  }
+}
+
+void MainRenderFrameObserver::SendMetrics() {
+  if (!page_timing_metrics_sender_)
+    return;
+
+  PageLoadTiming timing(GetTiming());
+  page_timing_metrics_sender_->Send(timing);
+}
+
+bool MainRenderFrameObserver::ShouldSendMetrics() const {
+  const blink::WebLocalFrame& frame = *render_frame()->GetWebFrame();
+  // We only generate historgrams for main frames.
+  if (frame.parent())
+    return false;
+
+  const blink::WebDocument& document = frame.document();
+  // Ignore non-HTTP schemes (e.g. chrome://).
+  const GURL& url = document.url();
+  if (!url.SchemeIsHTTPOrHTTPS())
+    return false;
+
+  const blink::WebURLResponse& url_response = frame.dataSource()->response();
+  // Ignore multipart responses (e.g. MHTML).
+  if (url_response.isMultipartPayload())
+    return false;
+
+  // Ignore non-HTML documents (e.g. SVG). Note that images are treated by
+  // Blink as HTML documents, so to exclude images, we must perform
+  // additional mime type checking below.
+  if (!document.isHTMLDocument() && !document.isXHTMLDocument())
+    return false;
+
+  // Ignore non-HTML mime types (e.g. images).
+  std::string mime_type = url_response.mimeType().utf8();
+  if (mime_type != "text/html" && mime_type != "application/xhtml+xml")
+    return false;
+
+  return true;
+}
+
+PageLoadTiming MainRenderFrameObserver::GetTiming() const {
+  blink::WebLocalFrame* frame = render_frame()->GetWebFrame();
+  if (frame)
+    return PageLoadTiming(frame->performance());
+  return PageLoadTiming();
+}
+
+scoped_ptr<base::Timer> MainRenderFrameObserver::CreateTimer() const {
+  return scoped_ptr<base::Timer>(
+      new base::OneShotTimer<PageTimingMetricsSender>());
+}
+
+}  // namespace page_load_metrics