| OLD | NEW |
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "components/page_load_metrics/renderer/metrics_render_frame_observer.h" | |
| 6 | |
| 7 #include <string> | |
| 8 | |
| 9 #include "base/memory/ptr_util.h" | |
| 10 #include "base/time/time.h" | |
| 11 #include "base/timer/timer.h" | |
| 12 #include "components/page_load_metrics/renderer/page_timing_metrics_sender.h" | |
| 13 #include "content/public/renderer/render_frame.h" | |
| 14 #include "third_party/WebKit/public/platform/WebURLResponse.h" | |
| 15 #include "third_party/WebKit/public/web/WebDataSource.h" | |
| 16 #include "third_party/WebKit/public/web/WebDocument.h" | |
| 17 #include "third_party/WebKit/public/web/WebLocalFrame.h" | |
| 18 #include "third_party/WebKit/public/web/WebPerformance.h" | |
| 19 #include "url/gurl.h" | |
| 20 | |
| 21 namespace page_load_metrics { | |
| 22 | |
| 23 namespace { | |
| 24 | |
| 25 base::TimeDelta ClampDelta(double event, double start) { | |
| 26 if (event - start < 0) | |
| 27 event = start; | |
| 28 return base::Time::FromDoubleT(event) - base::Time::FromDoubleT(start); | |
| 29 } | |
| 30 | |
| 31 } // namespace | |
| 32 | |
| 33 MetricsRenderFrameObserver::MetricsRenderFrameObserver( | |
| 34 content::RenderFrame* render_frame) | |
| 35 : content::RenderFrameObserver(render_frame) {} | |
| 36 | |
| 37 MetricsRenderFrameObserver::~MetricsRenderFrameObserver() {} | |
| 38 | |
| 39 void MetricsRenderFrameObserver::DidChangePerformanceTiming() { | |
| 40 SendMetrics(); | |
| 41 } | |
| 42 | |
| 43 void MetricsRenderFrameObserver::DidObserveLoadingBehavior( | |
| 44 blink::WebLoadingBehaviorFlag behavior) { | |
| 45 if (page_timing_metrics_sender_) | |
| 46 page_timing_metrics_sender_->DidObserveLoadingBehavior(behavior); | |
| 47 } | |
| 48 | |
| 49 void MetricsRenderFrameObserver::DidCommitProvisionalLoad( | |
| 50 bool is_new_navigation, | |
| 51 bool is_same_page_navigation) { | |
| 52 // Same-page navigations (e.g. an in-document navigation from a fragment | |
| 53 // link) aren't full page loads, since they don't go to network to load the | |
| 54 // main HTML resource. DidStartProvisionalLoad doesn't get invoked for same | |
| 55 // page navigations, so we may still have an active | |
| 56 // page_timing_metrics_sender_ at this point. | |
| 57 if (is_same_page_navigation) | |
| 58 return; | |
| 59 | |
| 60 // Make sure to release the sender for a previous navigation, if we have one. | |
| 61 page_timing_metrics_sender_.reset(); | |
| 62 | |
| 63 // We only create a PageTimingMetricsSender if the page meets the criteria for | |
| 64 // sending and recording metrics. Once page_timing_metrics_sender_ is | |
| 65 // non-null, we will send metrics for the current page at some later time, as | |
| 66 // those metrics become available. | |
| 67 if (ShouldSendMetrics()) { | |
| 68 PageLoadTiming timing(GetTiming()); | |
| 69 DCHECK(!timing.navigation_start.is_null()); | |
| 70 page_timing_metrics_sender_.reset( | |
| 71 new PageTimingMetricsSender(this, routing_id(), CreateTimer(), timing)); | |
| 72 } | |
| 73 } | |
| 74 | |
| 75 void MetricsRenderFrameObserver::SendMetrics() { | |
| 76 if (!page_timing_metrics_sender_) | |
| 77 return; | |
| 78 if (HasNoRenderFrame()) | |
| 79 return; | |
| 80 PageLoadTiming timing(GetTiming()); | |
| 81 page_timing_metrics_sender_->Send(timing); | |
| 82 } | |
| 83 | |
| 84 bool MetricsRenderFrameObserver::ShouldSendMetrics() const { | |
| 85 if (HasNoRenderFrame()) | |
| 86 return false; | |
| 87 const blink::WebLocalFrame* frame = render_frame()->GetWebFrame(); | |
| 88 // We only generate historgrams for main frames. | |
| 89 if (frame->parent()) | |
| 90 return false; | |
| 91 | |
| 92 const blink::WebDocument& document = frame->document(); | |
| 93 // Ignore non-HTTP schemes (e.g. chrome://). | |
| 94 const GURL& url = document.url(); | |
| 95 if (!url.SchemeIsHTTPOrHTTPS()) | |
| 96 return false; | |
| 97 | |
| 98 const blink::WebURLResponse& url_response = frame->dataSource()->response(); | |
| 99 | |
| 100 // Ignore non-HTML documents (e.g. SVG). Note that images are treated by | |
| 101 // Blink as HTML documents, so to exclude images, we must perform | |
| 102 // additional mime type checking below. | |
| 103 if (!document.isHTMLDocument() && !document.isXHTMLDocument()) | |
| 104 return false; | |
| 105 | |
| 106 // Ignore non-HTML mime types (e.g. images). | |
| 107 std::string mime_type = url_response.mimeType().utf8(); | |
| 108 if (mime_type != "text/html" && mime_type != "application/xhtml+xml") | |
| 109 return false; | |
| 110 | |
| 111 return true; | |
| 112 } | |
| 113 | |
| 114 PageLoadTiming MetricsRenderFrameObserver::GetTiming() const { | |
| 115 const blink::WebPerformance& perf = | |
| 116 render_frame()->GetWebFrame()->performance(); | |
| 117 | |
| 118 PageLoadTiming timing; | |
| 119 double start = perf.navigationStart(); | |
| 120 timing.navigation_start = base::Time::FromDoubleT(start); | |
| 121 if (perf.responseStart() > 0.0) | |
| 122 timing.response_start = ClampDelta(perf.responseStart(), start); | |
| 123 if (perf.domLoading() > 0.0) | |
| 124 timing.dom_loading = ClampDelta(perf.domLoading(), start); | |
| 125 if (perf.domContentLoadedEventStart() > 0.0) | |
| 126 timing.dom_content_loaded_event_start = | |
| 127 ClampDelta(perf.domContentLoadedEventStart(), start); | |
| 128 if (perf.loadEventStart() > 0.0) | |
| 129 timing.load_event_start = ClampDelta(perf.loadEventStart(), start); | |
| 130 if (perf.firstLayout() > 0.0) | |
| 131 timing.first_layout = ClampDelta(perf.firstLayout(), start); | |
| 132 if (perf.firstPaint() > 0.0) | |
| 133 timing.first_paint = ClampDelta(perf.firstPaint(), start); | |
| 134 if (perf.firstTextPaint() > 0.0) | |
| 135 timing.first_text_paint = ClampDelta(perf.firstTextPaint(), start); | |
| 136 if (perf.firstImagePaint() > 0.0) | |
| 137 timing.first_image_paint = ClampDelta(perf.firstImagePaint(), start); | |
| 138 if (perf.firstContentfulPaint() > 0.0) | |
| 139 timing.first_contentful_paint = | |
| 140 ClampDelta(perf.firstContentfulPaint(), start); | |
| 141 if (perf.parseStart() > 0.0) | |
| 142 timing.parse_start = ClampDelta(perf.parseStart(), start); | |
| 143 if (perf.parseStop() > 0.0) | |
| 144 timing.parse_stop = ClampDelta(perf.parseStop(), start); | |
| 145 if (timing.parse_start) { | |
| 146 // If we started parsing, record all parser durations such as the amount of | |
| 147 // time blocked on script load, even if those values are zero. | |
| 148 timing.parse_blocked_on_script_load_duration = | |
| 149 base::TimeDelta::FromSecondsD(perf.parseBlockedOnScriptLoadDuration()); | |
| 150 timing.parse_blocked_on_script_load_from_document_write_duration = | |
| 151 base::TimeDelta::FromSecondsD( | |
| 152 perf.parseBlockedOnScriptLoadFromDocumentWriteDuration()); | |
| 153 } | |
| 154 return timing; | |
| 155 } | |
| 156 | |
| 157 std::unique_ptr<base::Timer> MetricsRenderFrameObserver::CreateTimer() const { | |
| 158 return base::WrapUnique(new base::OneShotTimer); | |
| 159 } | |
| 160 | |
| 161 bool MetricsRenderFrameObserver::HasNoRenderFrame() const { | |
| 162 bool no_frame = !render_frame() || !render_frame()->GetWebFrame(); | |
| 163 DCHECK(!no_frame); | |
| 164 return no_frame; | |
| 165 } | |
| 166 | |
| 167 void MetricsRenderFrameObserver::OnDestruct() { | |
| 168 delete this; | |
| 169 } | |
| 170 | |
| 171 } // namespace page_load_metrics | |
| OLD | NEW |