PageLoadMetrics renderer and browser implementation.

components/page_load_metrics/renderer/page_load_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 "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() {}
+
+// 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::DidStartProvisionalLoad() {
+  // A provisional page load has started. Shut down metrics reporting until the
+  // next page load is committed. Note that a provisoinal load may fail. We
+  // simply stop reporting metrics in that case, until the next successful page
+  // load is committed.
+  page_timing_metrics_sender_.reset();
+}
+
+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;
+
+  DCHECK(!page_timing_metrics_sender_);
+
+  // We only create a PageTimingMetricsSender if the page meets the criteria for
+  // 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) {
+    blink::WebPerformance performance = frame->performance();
+    return PageLoadTiming(performance);
+  }
+  return PageLoadTiming();
+}
+
+scoped_ptr<base::Timer> MainRenderFrameObserver::CreateTimer() const {
+  return scoped_ptr<base::Timer>(
+      new base::OneShotTimer<PageTimingMetricsSender>());
+}
+
+}  // namespace page_load_metrics