OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_obser
ver.h" | 5 #include "chrome/browser/page_load_metrics/observers/ukm_page_load_metrics_obser
ver.h" |
6 | 6 |
7 #include "base/memory/ptr_util.h" | 7 #include "base/memory/ptr_util.h" |
8 #include "base/metrics/metrics_hashes.h" | 8 #include "base/metrics/metrics_hashes.h" |
9 #include "base/optional.h" | 9 #include "base/optional.h" |
10 #include "base/time/time.h" | 10 #include "base/time/time.h" |
11 #include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_
test_harness.h" | 11 #include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_
test_harness.h" |
12 #include "chrome/test/base/testing_browser_process.h" | 12 #include "chrome/test/base/testing_browser_process.h" |
13 #include "components/metrics/proto/ukm/entry.pb.h" | 13 #include "components/ukm/test_ukm_recorder.h" |
14 #include "components/ukm/test_ukm_service.h" | |
15 #include "components/ukm/ukm_entry.h" | |
16 #include "components/ukm/ukm_source.h" | 14 #include "components/ukm/ukm_source.h" |
17 #include "testing/gmock/include/gmock/gmock.h" | 15 #include "testing/gmock/include/gmock/gmock.h" |
18 | 16 |
19 using testing::AnyNumber; | 17 using testing::AnyNumber; |
20 using testing::Mock; | 18 using testing::Mock; |
21 using testing::Return; | 19 using testing::Return; |
22 | 20 |
23 namespace { | 21 namespace { |
24 | 22 |
25 const char kTestUrl1[] = "https://www.google.com/"; | 23 const char kTestUrl1[] = "https://www.google.com/"; |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
64 .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN)); | 62 .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN)); |
65 | 63 |
66 EXPECT_CALL(mock_network_quality_provider_, GetHttpRTT()) | 64 EXPECT_CALL(mock_network_quality_provider_, GetHttpRTT()) |
67 .Times(AnyNumber()) | 65 .Times(AnyNumber()) |
68 .WillRepeatedly(Return(base::Optional<base::TimeDelta>())); | 66 .WillRepeatedly(Return(base::Optional<base::TimeDelta>())); |
69 | 67 |
70 EXPECT_CALL(mock_network_quality_provider_, GetTransportRTT()) | 68 EXPECT_CALL(mock_network_quality_provider_, GetTransportRTT()) |
71 .Times(AnyNumber()) | 69 .Times(AnyNumber()) |
72 .WillRepeatedly(Return(base::Optional<base::TimeDelta>())); | 70 .WillRepeatedly(Return(base::Optional<base::TimeDelta>())); |
73 | 71 |
74 TestingBrowserProcess::GetGlobal()->SetUkmService( | 72 TestingBrowserProcess::GetGlobal()->SetUkmRecorder(&test_ukm_recorder_); |
75 ukm_service_test_harness_.test_ukm_service()); | |
76 } | 73 } |
77 | 74 |
78 size_t ukm_source_count() { | 75 size_t ukm_source_count() { return test_ukm_recorder_.sources_count(); } |
79 return ukm_service_test_harness_.test_ukm_service()->sources_count(); | |
80 } | |
81 | 76 |
82 size_t ukm_entry_count() { | 77 size_t ukm_entry_count() { return test_ukm_recorder_.entries_count(); } |
83 return ukm_service_test_harness_.test_ukm_service()->entries_count(); | |
84 } | |
85 | 78 |
86 MockNetworkQualityProvider& mock_network_quality_provider() { | 79 MockNetworkQualityProvider& mock_network_quality_provider() { |
87 return mock_network_quality_provider_; | 80 return mock_network_quality_provider_; |
88 } | 81 } |
89 | 82 |
90 const ukm::UkmSource* GetUkmSourceForUrl(const char* url) { | 83 const ukm::UkmSource* GetUkmSourceForUrl(const char* url) { |
91 return ukm_service_test_harness_.test_ukm_service()->GetSourceForUrl(url); | 84 return test_ukm_recorder_.GetSourceForUrl(url); |
92 } | 85 } |
93 | 86 |
94 const ukm::UkmEntry* GetUkmEntry(size_t entry_index) { | 87 const ukm::mojom::UkmEntry* GetUkmEntry(size_t entry_index) { |
95 return ukm_service_test_harness_.test_ukm_service()->GetEntry(entry_index); | 88 return test_ukm_recorder_.GetEntry(entry_index); |
96 } | 89 } |
97 | 90 |
98 std::vector<const ukm::UkmEntry*> GetUkmEntriesForSourceID( | 91 std::vector<const ukm::mojom::UkmEntry*> GetUkmEntriesForSourceID( |
99 int32_t source_id) { | 92 ukm::SourceId source_id) { |
100 std::vector<const ukm::UkmEntry*> entries; | 93 std::vector<const ukm::mojom::UkmEntry*> entries; |
101 for (size_t i = 0; i < ukm_entry_count(); ++i) { | 94 for (size_t i = 0; i < ukm_entry_count(); ++i) { |
102 const ukm::UkmEntry* entry = GetUkmEntry(i); | 95 const ukm::mojom::UkmEntry* entry = GetUkmEntry(i); |
103 if (entry->source_id() == source_id) | 96 if (entry->source_id == source_id) |
104 entries.push_back(entry); | 97 entries.push_back(entry); |
105 } | 98 } |
106 return entries; | 99 return entries; |
107 } | 100 } |
108 | 101 |
109 // Provides a single merged ukm::Entry proto that contains all metrics from | 102 // Provides a single merged ukm::mojom::UkmEntry proto that contains all |
110 // the given |entries|. |entries| must be non-empty, and all |entries| must | 103 // metrics from the given |entries|. |entries| must be non-empty, and all |
111 // have the same |source_id| and |event_hash|. | 104 // |entries| must have the same |source_id| and |event_hash|. |
112 ukm::Entry GetMergedEntryProto( | 105 ukm::mojom::UkmEntryPtr GetMergedEntry( |
113 const std::vector<const ukm::UkmEntry*>& entries) { | 106 const std::vector<const ukm::mojom::UkmEntry*>& entries) { |
114 EXPECT_FALSE(entries.empty()); | 107 EXPECT_FALSE(entries.empty()); |
115 ukm::Entry merged_entry; | 108 ukm::mojom::UkmEntryPtr merged_entry = ukm::mojom::UkmEntry::New(); |
116 for (auto* entry : entries) { | 109 for (const auto* entry : entries) { |
117 ukm::Entry entry_proto; | 110 if (merged_entry->event_hash) { |
118 entry->PopulateProto(&entry_proto); | 111 EXPECT_EQ(merged_entry->source_id, entry->source_id); |
119 EXPECT_TRUE(entry_proto.has_source_id()); | 112 EXPECT_EQ(merged_entry->event_hash, entry->event_hash); |
120 EXPECT_TRUE(entry_proto.has_event_hash()); | 113 } else { |
121 if (merged_entry.has_source_id()) { | 114 merged_entry->event_hash = entry->event_hash; |
122 EXPECT_EQ(merged_entry.source_id(), entry_proto.source_id()); | 115 merged_entry->source_id = entry->source_id; |
123 EXPECT_EQ(merged_entry.event_hash(), entry_proto.event_hash()); | |
124 } | 116 } |
125 merged_entry.MergeFrom(entry_proto); | 117 for (const auto& metric : entry->metrics) { |
| 118 merged_entry->metrics.emplace_back(metric->Clone()); |
| 119 } |
126 } | 120 } |
127 return merged_entry; | 121 return merged_entry; |
128 } | 122 } |
129 | 123 |
130 ukm::Entry GetMergedEntryProtoForSourceID(int32_t source_id) { | 124 ukm::mojom::UkmEntryPtr GetMergedEntryForSourceID(ukm::SourceId source_id) { |
131 ukm::Entry entry = GetMergedEntryProto(GetUkmEntriesForSourceID(source_id)); | 125 ukm::mojom::UkmEntryPtr entry = |
132 EXPECT_EQ(source_id, entry.source_id()); | 126 GetMergedEntry(GetUkmEntriesForSourceID(source_id)); |
133 EXPECT_TRUE(entry.has_event_hash()); | 127 EXPECT_EQ(source_id, entry->source_id); |
| 128 EXPECT_NE(0UL, entry->event_hash); |
134 return entry; | 129 return entry; |
135 } | 130 } |
136 | 131 |
137 static const ukm::Entry_Metric* FindMetric( | 132 static bool HasMetric(const char* name, |
138 const char* name, | 133 const ukm::mojom::UkmEntry* entry) WARN_UNUSED_RESULT { |
139 const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) | 134 return ukm::TestUkmRecorder::FindMetric(entry, name) != nullptr; |
140 WARN_UNUSED_RESULT { | |
141 for (const auto& metric : metrics) { | |
142 if (metric.metric_hash() == base::HashMetricName(name)) | |
143 return &metric; | |
144 } | |
145 return nullptr; | |
146 } | 135 } |
147 | 136 |
148 static bool HasMetric( | 137 static void ExpectMetric(const char* name, |
149 const char* name, | 138 int64_t expected_value, |
150 const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) | 139 const ukm::mojom::UkmEntry* entry) { |
151 WARN_UNUSED_RESULT { | 140 const ukm::mojom::UkmMetric* metric = |
152 return FindMetric(name, metrics) != nullptr; | 141 ukm::TestUkmRecorder::FindMetric(entry, name); |
153 } | |
154 | |
155 static void ExpectMetric( | |
156 const char* name, | |
157 int64_t expected_value, | |
158 const google::protobuf::RepeatedPtrField<ukm::Entry_Metric>& metrics) { | |
159 const ukm::Entry_Metric* metric = FindMetric(name, metrics); | |
160 EXPECT_NE(nullptr, metric) << "Failed to find metric: " << name; | 142 EXPECT_NE(nullptr, metric) << "Failed to find metric: " << name; |
161 EXPECT_EQ(expected_value, metric->value()); | 143 EXPECT_EQ(expected_value, metric->value); |
162 } | 144 } |
163 | 145 |
164 private: | 146 private: |
165 MockNetworkQualityProvider mock_network_quality_provider_; | 147 MockNetworkQualityProvider mock_network_quality_provider_; |
166 ukm::UkmServiceTestingHarness ukm_service_test_harness_; | 148 ukm::TestUkmRecorder test_ukm_recorder_; |
167 }; | 149 }; |
168 | 150 |
169 TEST_F(UkmPageLoadMetricsObserverTest, NoMetrics) { | 151 TEST_F(UkmPageLoadMetricsObserverTest, NoMetrics) { |
170 EXPECT_EQ(0ul, ukm_source_count()); | 152 EXPECT_EQ(0ul, ukm_source_count()); |
171 EXPECT_EQ(0ul, ukm_entry_count()); | 153 EXPECT_EQ(0ul, ukm_entry_count()); |
172 } | 154 } |
173 | 155 |
174 TEST_F(UkmPageLoadMetricsObserverTest, Basic) { | 156 TEST_F(UkmPageLoadMetricsObserverTest, Basic) { |
175 // PageLoadTiming with all recorded metrics other than FMP. This allows us to | 157 // PageLoadTiming with all recorded metrics other than FMP. This allows us to |
176 // verify both that all metrics are logged, and that we don't log metrics that | 158 // verify both that all metrics are logged, and that we don't log metrics that |
(...skipping 14 matching lines...) Expand all Loading... |
191 SimulateTimingUpdate(timing); | 173 SimulateTimingUpdate(timing); |
192 | 174 |
193 // Simulate closing the tab. | 175 // Simulate closing the tab. |
194 DeleteContents(); | 176 DeleteContents(); |
195 | 177 |
196 EXPECT_EQ(1ul, ukm_source_count()); | 178 EXPECT_EQ(1ul, ukm_source_count()); |
197 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); | 179 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); |
198 EXPECT_EQ(GURL(kTestUrl1), source->url()); | 180 EXPECT_EQ(GURL(kTestUrl1), source->url()); |
199 | 181 |
200 EXPECT_GE(ukm_entry_count(), 1ul); | 182 EXPECT_GE(ukm_entry_count(), 1ul); |
201 ukm::Entry entry_proto = GetMergedEntryProtoForSourceID(source->id()); | 183 ukm::mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source->id()); |
202 EXPECT_EQ(entry_proto.source_id(), source->id()); | 184 EXPECT_EQ(entry->source_id, source->id()); |
203 EXPECT_EQ(entry_proto.event_hash(), | 185 EXPECT_EQ(entry->event_hash, |
204 base::HashMetricName(internal::kUkmPageLoadEventName)); | 186 base::HashMetricName(internal::kUkmPageLoadEventName)); |
205 EXPECT_FALSE(entry_proto.metrics().empty()); | 187 EXPECT_FALSE(entry->metrics.empty()); |
206 ExpectMetric(internal::kUkmPageTransition, ui::PAGE_TRANSITION_LINK, | 188 ExpectMetric(internal::kUkmPageTransition, ui::PAGE_TRANSITION_LINK, |
207 entry_proto.metrics()); | 189 entry.get()); |
208 ExpectMetric(internal::kUkmParseStartName, 100, entry_proto.metrics()); | 190 ExpectMetric(internal::kUkmParseStartName, 100, entry.get()); |
209 ExpectMetric(internal::kUkmDomContentLoadedName, 200, entry_proto.metrics()); | 191 ExpectMetric(internal::kUkmDomContentLoadedName, 200, entry.get()); |
210 ExpectMetric(internal::kUkmFirstContentfulPaintName, 300, | 192 ExpectMetric(internal::kUkmFirstContentfulPaintName, 300, entry.get()); |
211 entry_proto.metrics()); | 193 ExpectMetric(internal::kUkmLoadEventName, 500, entry.get()); |
212 ExpectMetric(internal::kUkmLoadEventName, 500, entry_proto.metrics()); | 194 EXPECT_FALSE(HasMetric(internal::kUkmFirstMeaningfulPaintName, entry.get())); |
213 EXPECT_FALSE( | 195 EXPECT_TRUE(HasMetric(internal::kUkmForegroundDurationName, entry.get())); |
214 HasMetric(internal::kUkmFirstMeaningfulPaintName, entry_proto.metrics())); | |
215 EXPECT_TRUE( | |
216 HasMetric(internal::kUkmForegroundDurationName, entry_proto.metrics())); | |
217 } | 196 } |
218 | 197 |
219 TEST_F(UkmPageLoadMetricsObserverTest, FailedProvisionalLoad) { | 198 TEST_F(UkmPageLoadMetricsObserverTest, FailedProvisionalLoad) { |
220 EXPECT_CALL(mock_network_quality_provider(), GetEffectiveConnectionType()) | 199 EXPECT_CALL(mock_network_quality_provider(), GetEffectiveConnectionType()) |
221 .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_2G)); | 200 .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_2G)); |
222 | 201 |
223 GURL url(kTestUrl1); | 202 GURL url(kTestUrl1); |
224 content::RenderFrameHostTester* rfh_tester = | 203 content::RenderFrameHostTester* rfh_tester = |
225 content::RenderFrameHostTester::For(main_rfh()); | 204 content::RenderFrameHostTester::For(main_rfh()); |
226 rfh_tester->SimulateNavigationStart(url); | 205 rfh_tester->SimulateNavigationStart(url); |
227 rfh_tester->SimulateNavigationError(url, net::ERR_TIMED_OUT); | 206 rfh_tester->SimulateNavigationError(url, net::ERR_TIMED_OUT); |
228 rfh_tester->SimulateNavigationStop(); | 207 rfh_tester->SimulateNavigationStop(); |
229 | 208 |
230 // Simulate closing the tab. | 209 // Simulate closing the tab. |
231 DeleteContents(); | 210 DeleteContents(); |
232 | 211 |
233 EXPECT_EQ(1ul, ukm_source_count()); | 212 EXPECT_EQ(1ul, ukm_source_count()); |
234 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); | 213 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); |
235 EXPECT_EQ(GURL(kTestUrl1), source->url()); | 214 EXPECT_EQ(GURL(kTestUrl1), source->url()); |
236 | 215 |
237 EXPECT_GE(ukm_entry_count(), 1ul); | 216 EXPECT_GE(ukm_entry_count(), 1ul); |
238 ukm::Entry entry_proto = GetMergedEntryProtoForSourceID(source->id()); | 217 ukm::mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source->id()); |
239 EXPECT_EQ(entry_proto.source_id(), source->id()); | 218 EXPECT_EQ(entry->source_id, source->id()); |
240 EXPECT_EQ(entry_proto.event_hash(), | 219 EXPECT_EQ(entry->event_hash, |
241 base::HashMetricName(internal::kUkmPageLoadEventName)); | 220 base::HashMetricName(internal::kUkmPageLoadEventName)); |
242 | 221 |
243 // Make sure that only the following metrics are logged. In particular, no | 222 // Make sure that only the following metrics are logged. In particular, no |
244 // paint/document/etc timing metrics should be logged for failed provisional | 223 // paint/document/etc timing metrics should be logged for failed provisional |
245 // loads. | 224 // loads. |
246 EXPECT_EQ(5, entry_proto.metrics().size()); | 225 EXPECT_EQ(5ul, entry->metrics.size()); |
247 ExpectMetric(internal::kUkmPageTransition, ui::PAGE_TRANSITION_LINK, | 226 ExpectMetric(internal::kUkmPageTransition, ui::PAGE_TRANSITION_LINK, |
248 entry_proto.metrics()); | 227 entry.get()); |
249 ExpectMetric(internal::kUkmEffectiveConnectionType, | 228 ExpectMetric(internal::kUkmEffectiveConnectionType, |
250 net::EFFECTIVE_CONNECTION_TYPE_2G, entry_proto.metrics()); | 229 net::EFFECTIVE_CONNECTION_TYPE_2G, entry.get()); |
251 ExpectMetric(internal::kUkmNetErrorCode, | 230 ExpectMetric(internal::kUkmNetErrorCode, |
252 static_cast<int64_t>(net::ERR_TIMED_OUT) * -1, | 231 static_cast<int64_t>(net::ERR_TIMED_OUT) * -1, entry.get()); |
253 entry_proto.metrics()); | 232 EXPECT_TRUE(HasMetric(internal::kUkmForegroundDurationName, entry.get())); |
254 EXPECT_TRUE( | 233 EXPECT_TRUE(HasMetric(internal::kUkmFailedProvisionaLoadName, entry.get())); |
255 HasMetric(internal::kUkmForegroundDurationName, entry_proto.metrics())); | |
256 EXPECT_TRUE( | |
257 HasMetric(internal::kUkmFailedProvisionaLoadName, entry_proto.metrics())); | |
258 } | 234 } |
259 | 235 |
260 TEST_F(UkmPageLoadMetricsObserverTest, FirstMeaningfulPaint) { | 236 TEST_F(UkmPageLoadMetricsObserverTest, FirstMeaningfulPaint) { |
261 page_load_metrics::PageLoadTiming timing; | 237 page_load_metrics::PageLoadTiming timing; |
262 timing.navigation_start = base::Time::FromDoubleT(1); | 238 timing.navigation_start = base::Time::FromDoubleT(1); |
263 timing.paint_timing.first_meaningful_paint = | 239 timing.paint_timing.first_meaningful_paint = |
264 base::TimeDelta::FromMilliseconds(600); | 240 base::TimeDelta::FromMilliseconds(600); |
265 PopulateRequiredTimingFields(&timing); | 241 PopulateRequiredTimingFields(&timing); |
266 | 242 |
267 NavigateAndCommit(GURL(kTestUrl1)); | 243 NavigateAndCommit(GURL(kTestUrl1)); |
268 SimulateTimingUpdate(timing); | 244 SimulateTimingUpdate(timing); |
269 | 245 |
270 // Simulate closing the tab. | 246 // Simulate closing the tab. |
271 DeleteContents(); | 247 DeleteContents(); |
272 | 248 |
273 EXPECT_EQ(1ul, ukm_source_count()); | 249 EXPECT_EQ(1ul, ukm_source_count()); |
274 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); | 250 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); |
275 EXPECT_EQ(GURL(kTestUrl1), source->url()); | 251 EXPECT_EQ(GURL(kTestUrl1), source->url()); |
276 | 252 |
277 EXPECT_GE(ukm_entry_count(), 1ul); | 253 EXPECT_GE(ukm_entry_count(), 1ul); |
278 ukm::Entry entry_proto = GetMergedEntryProtoForSourceID(source->id()); | 254 ukm::mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source->id()); |
279 EXPECT_EQ(entry_proto.source_id(), source->id()); | 255 EXPECT_EQ(entry->source_id, source->id()); |
280 EXPECT_EQ(entry_proto.event_hash(), | 256 EXPECT_EQ(entry->event_hash, |
281 base::HashMetricName(internal::kUkmPageLoadEventName)); | 257 base::HashMetricName(internal::kUkmPageLoadEventName)); |
282 EXPECT_FALSE(entry_proto.metrics().empty()); | 258 EXPECT_FALSE(entry->metrics.empty()); |
283 ExpectMetric(internal::kUkmFirstMeaningfulPaintName, 600, | 259 ExpectMetric(internal::kUkmFirstMeaningfulPaintName, 600, entry.get()); |
284 entry_proto.metrics()); | 260 EXPECT_TRUE(HasMetric(internal::kUkmForegroundDurationName, entry.get())); |
285 EXPECT_TRUE( | |
286 HasMetric(internal::kUkmForegroundDurationName, entry_proto.metrics())); | |
287 } | 261 } |
288 | 262 |
289 TEST_F(UkmPageLoadMetricsObserverTest, MultiplePageLoads) { | 263 TEST_F(UkmPageLoadMetricsObserverTest, MultiplePageLoads) { |
290 page_load_metrics::PageLoadTiming timing1; | 264 page_load_metrics::PageLoadTiming timing1; |
291 timing1.navigation_start = base::Time::FromDoubleT(1); | 265 timing1.navigation_start = base::Time::FromDoubleT(1); |
292 timing1.paint_timing.first_contentful_paint = | 266 timing1.paint_timing.first_contentful_paint = |
293 base::TimeDelta::FromMilliseconds(200); | 267 base::TimeDelta::FromMilliseconds(200); |
294 PopulateRequiredTimingFields(&timing1); | 268 PopulateRequiredTimingFields(&timing1); |
295 | 269 |
296 // Second navigation reports no timing metrics. | 270 // Second navigation reports no timing metrics. |
(...skipping 11 matching lines...) Expand all Loading... |
308 DeleteContents(); | 282 DeleteContents(); |
309 | 283 |
310 EXPECT_EQ(2ul, ukm_source_count()); | 284 EXPECT_EQ(2ul, ukm_source_count()); |
311 const ukm::UkmSource* source1 = GetUkmSourceForUrl(kTestUrl1); | 285 const ukm::UkmSource* source1 = GetUkmSourceForUrl(kTestUrl1); |
312 const ukm::UkmSource* source2 = GetUkmSourceForUrl(kTestUrl2); | 286 const ukm::UkmSource* source2 = GetUkmSourceForUrl(kTestUrl2); |
313 EXPECT_EQ(GURL(kTestUrl1), source1->url()); | 287 EXPECT_EQ(GURL(kTestUrl1), source1->url()); |
314 EXPECT_EQ(GURL(kTestUrl2), source2->url()); | 288 EXPECT_EQ(GURL(kTestUrl2), source2->url()); |
315 EXPECT_NE(source1->id(), source2->id()); | 289 EXPECT_NE(source1->id(), source2->id()); |
316 | 290 |
317 EXPECT_GE(ukm_entry_count(), 2ul); | 291 EXPECT_GE(ukm_entry_count(), 2ul); |
318 ukm::Entry entry1_proto = GetMergedEntryProtoForSourceID(source1->id()); | 292 ukm::mojom::UkmEntryPtr entry1 = GetMergedEntryForSourceID(source1->id()); |
319 ukm::Entry entry2_proto = GetMergedEntryProtoForSourceID(source2->id()); | 293 ukm::mojom::UkmEntryPtr entry2 = GetMergedEntryForSourceID(source2->id()); |
320 EXPECT_NE(entry1_proto.source_id(), entry2_proto.source_id()); | 294 EXPECT_NE(entry1->source_id, entry2->source_id); |
321 | 295 |
322 EXPECT_EQ(entry1_proto.source_id(), source1->id()); | 296 EXPECT_EQ(entry1->source_id, source1->id()); |
323 EXPECT_EQ(entry1_proto.event_hash(), | 297 EXPECT_EQ(entry1->event_hash, |
324 base::HashMetricName(internal::kUkmPageLoadEventName)); | 298 base::HashMetricName(internal::kUkmPageLoadEventName)); |
325 EXPECT_FALSE(entry1_proto.metrics().empty()); | 299 EXPECT_FALSE(entry1->metrics.empty()); |
326 ExpectMetric(internal::kUkmFirstContentfulPaintName, 200, | 300 ExpectMetric(internal::kUkmFirstContentfulPaintName, 200, entry1.get()); |
327 entry1_proto.metrics()); | 301 EXPECT_FALSE(HasMetric(internal::kUkmFirstMeaningfulPaintName, entry2.get())); |
328 EXPECT_FALSE(HasMetric(internal::kUkmFirstMeaningfulPaintName, | 302 EXPECT_TRUE(HasMetric(internal::kUkmForegroundDurationName, entry1.get())); |
329 entry2_proto.metrics())); | |
330 EXPECT_TRUE( | |
331 HasMetric(internal::kUkmForegroundDurationName, entry1_proto.metrics())); | |
332 | 303 |
333 EXPECT_EQ(entry2_proto.source_id(), source2->id()); | 304 EXPECT_EQ(entry2->source_id, source2->id()); |
334 EXPECT_EQ(entry2_proto.event_hash(), | 305 EXPECT_EQ(entry2->event_hash, |
335 base::HashMetricName(internal::kUkmPageLoadEventName)); | 306 base::HashMetricName(internal::kUkmPageLoadEventName)); |
336 EXPECT_FALSE(entry2_proto.metrics().empty()); | 307 EXPECT_FALSE(entry2->metrics.empty()); |
337 EXPECT_FALSE(HasMetric(internal::kUkmParseStartName, entry2_proto.metrics())); | 308 EXPECT_FALSE(HasMetric(internal::kUkmParseStartName, entry2.get())); |
338 EXPECT_FALSE(HasMetric(internal::kUkmFirstContentfulPaintName, | 309 EXPECT_FALSE(HasMetric(internal::kUkmFirstContentfulPaintName, entry2.get())); |
339 entry2_proto.metrics())); | 310 EXPECT_FALSE(HasMetric(internal::kUkmFirstMeaningfulPaintName, entry2.get())); |
340 EXPECT_FALSE(HasMetric(internal::kUkmFirstMeaningfulPaintName, | 311 EXPECT_TRUE(HasMetric(internal::kUkmForegroundDurationName, entry2.get())); |
341 entry2_proto.metrics())); | |
342 EXPECT_TRUE( | |
343 HasMetric(internal::kUkmForegroundDurationName, entry2_proto.metrics())); | |
344 } | 312 } |
345 | 313 |
346 TEST_F(UkmPageLoadMetricsObserverTest, NetworkQualityEstimates) { | 314 TEST_F(UkmPageLoadMetricsObserverTest, NetworkQualityEstimates) { |
347 EXPECT_CALL(mock_network_quality_provider(), GetEffectiveConnectionType()) | 315 EXPECT_CALL(mock_network_quality_provider(), GetEffectiveConnectionType()) |
348 .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_3G)); | 316 .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_3G)); |
349 EXPECT_CALL(mock_network_quality_provider(), GetHttpRTT()) | 317 EXPECT_CALL(mock_network_quality_provider(), GetHttpRTT()) |
350 .WillRepeatedly(Return(base::TimeDelta::FromMilliseconds(100))); | 318 .WillRepeatedly(Return(base::TimeDelta::FromMilliseconds(100))); |
351 EXPECT_CALL(mock_network_quality_provider(), GetTransportRTT()) | 319 EXPECT_CALL(mock_network_quality_provider(), GetTransportRTT()) |
352 .WillRepeatedly(Return(base::TimeDelta::FromMilliseconds(200))); | 320 .WillRepeatedly(Return(base::TimeDelta::FromMilliseconds(200))); |
353 | 321 |
354 NavigateAndCommit(GURL(kTestUrl1)); | 322 NavigateAndCommit(GURL(kTestUrl1)); |
355 | 323 |
356 // Simulate closing the tab. | 324 // Simulate closing the tab. |
357 DeleteContents(); | 325 DeleteContents(); |
358 | 326 |
359 EXPECT_EQ(1ul, ukm_source_count()); | 327 EXPECT_EQ(1ul, ukm_source_count()); |
360 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); | 328 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); |
361 EXPECT_EQ(GURL(kTestUrl1), source->url()); | 329 EXPECT_EQ(GURL(kTestUrl1), source->url()); |
362 | 330 |
363 EXPECT_GE(ukm_entry_count(), 1ul); | 331 EXPECT_GE(ukm_entry_count(), 1ul); |
364 ukm::Entry entry_proto = GetMergedEntryProtoForSourceID(source->id()); | 332 ukm::mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source->id()); |
365 EXPECT_EQ(entry_proto.source_id(), source->id()); | 333 EXPECT_EQ(entry->source_id, source->id()); |
366 EXPECT_EQ(entry_proto.event_hash(), | 334 EXPECT_EQ(entry->event_hash, |
367 base::HashMetricName(internal::kUkmPageLoadEventName)); | 335 base::HashMetricName(internal::kUkmPageLoadEventName)); |
368 EXPECT_FALSE(entry_proto.metrics().empty()); | 336 EXPECT_FALSE(entry->metrics.empty()); |
369 ExpectMetric(internal::kUkmEffectiveConnectionType, | 337 ExpectMetric(internal::kUkmEffectiveConnectionType, |
370 net::EFFECTIVE_CONNECTION_TYPE_3G, entry_proto.metrics()); | 338 net::EFFECTIVE_CONNECTION_TYPE_3G, entry.get()); |
371 ExpectMetric(internal::kUkmHttpRttEstimate, 100, entry_proto.metrics()); | 339 ExpectMetric(internal::kUkmHttpRttEstimate, 100, entry.get()); |
372 ExpectMetric(internal::kUkmTransportRttEstimate, 200, entry_proto.metrics()); | 340 ExpectMetric(internal::kUkmTransportRttEstimate, 200, entry.get()); |
373 } | 341 } |
374 | 342 |
375 TEST_F(UkmPageLoadMetricsObserverTest, PageTransitionReload) { | 343 TEST_F(UkmPageLoadMetricsObserverTest, PageTransitionReload) { |
376 GURL url(kTestUrl1); | 344 GURL url(kTestUrl1); |
377 NavigateWithPageTransitionAndCommit(GURL(kTestUrl1), | 345 NavigateWithPageTransitionAndCommit(GURL(kTestUrl1), |
378 ui::PAGE_TRANSITION_RELOAD); | 346 ui::PAGE_TRANSITION_RELOAD); |
379 | 347 |
380 // Simulate closing the tab. | 348 // Simulate closing the tab. |
381 DeleteContents(); | 349 DeleteContents(); |
382 | 350 |
383 EXPECT_EQ(1ul, ukm_source_count()); | 351 EXPECT_EQ(1ul, ukm_source_count()); |
384 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); | 352 const ukm::UkmSource* source = GetUkmSourceForUrl(kTestUrl1); |
385 EXPECT_EQ(GURL(kTestUrl1), source->url()); | 353 EXPECT_EQ(GURL(kTestUrl1), source->url()); |
386 | 354 |
387 EXPECT_GE(ukm_entry_count(), 1ul); | 355 EXPECT_GE(ukm_entry_count(), 1ul); |
388 ukm::Entry entry_proto = GetMergedEntryProtoForSourceID(source->id()); | 356 ukm::mojom::UkmEntryPtr entry = GetMergedEntryForSourceID(source->id()); |
389 EXPECT_EQ(entry_proto.source_id(), source->id()); | 357 EXPECT_EQ(entry->source_id, source->id()); |
390 EXPECT_EQ(entry_proto.event_hash(), | 358 EXPECT_EQ(entry->event_hash, |
391 base::HashMetricName(internal::kUkmPageLoadEventName)); | 359 base::HashMetricName(internal::kUkmPageLoadEventName)); |
392 EXPECT_FALSE(entry_proto.metrics().empty()); | 360 EXPECT_FALSE(entry->metrics.empty()); |
393 ExpectMetric(internal::kUkmPageTransition, ui::PAGE_TRANSITION_RELOAD, | 361 ExpectMetric(internal::kUkmPageTransition, ui::PAGE_TRANSITION_RELOAD, |
394 entry_proto.metrics()); | 362 entry.get()); |
395 } | 363 } |
OLD | NEW |