| // Copyright 2017 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/browser/page_load_metrics/observers/core/ukm_page_load_metrics_observer.h" |
| |
| #include <memory> |
| |
| #include "base/memory/raw_ptr.h" |
| #include "base/metrics/metrics_hashes.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/simple_test_clock.h" |
| #include "base/test/trace_event_analyzer.h" |
| #include "base/time/time.h" |
| #include "base/trace_event/traced_value.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/bookmarks/bookmark_model_factory.h" |
| #include "chrome/browser/content_settings/cookie_settings_factory.h" |
| #include "chrome/browser/history/history_service_factory.h" |
| #include "chrome/browser/history/history_tab_helper.h" |
| #include "chrome/browser/history_clusters/history_clusters_service_factory.h" |
| #include "chrome/browser/history_clusters/history_clusters_tab_helper.h" |
| #include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.h" |
| #include "chrome/browser/search_engines/template_url_service_factory.h" |
| #include "chrome/common/pref_names.h" |
| #include "chrome/test/base/search_test_utils.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "components/bookmarks/browser/bookmark_model.h" |
| #include "components/bookmarks/test/bookmark_test_helpers.h" |
| #include "components/content_settings/core/browser/cookie_settings.h" |
| #include "components/content_settings/core/common/content_settings.h" |
| #include "components/content_settings/core/common/pref_names.h" |
| #include "components/history/core/browser/history_service.h" |
| #include "components/history/core/browser/history_types.h" |
| #include "components/history/core/test/history_service_test_util.h" |
| #include "components/history_clusters/core/history_clusters_service.h" |
| #include "components/keyed_service/core/service_access_type.h" |
| #include "components/ntp_tiles/custom_links_store.h" |
| #include "components/page_load_metrics/browser/observers/core/largest_contentful_paint_handler.h" |
| #include "components/page_load_metrics/browser/page_load_metrics_observer.h" |
| #include "components/page_load_metrics/browser/page_load_tracker.h" |
| #include "components/page_load_metrics/common/page_visit_final_status.h" |
| #include "components/page_load_metrics/common/test/page_load_metrics_test_util.h" |
| #include "components/prefs/pref_service.h" |
| #include "components/search_engines/template_url_service.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/navigation_simulator.h" |
| #include "net/base/ip_endpoint.h" |
| #include "net/nqe/effective_connection_type.h" |
| #include "services/metrics/public/cpp/metrics_utils.h" |
| #include "services/metrics/public/cpp/ukm_builders.h" |
| #include "services/metrics/public/cpp/ukm_source.h" |
| #include "services/network/public/cpp/network_quality_tracker.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "third_party/abseil-cpp/absl/types/optional.h" |
| #include "third_party/metrics_proto/system_profile.pb.h" |
| #include "third_party/perfetto/include/perfetto/tracing/track.h" |
| |
| using content::NavigationSimulator; |
| using content::RenderFrameHost; |
| using content::RenderFrameHostTester; |
| using page_load_metrics::PageVisitFinalStatus; |
| using testing::AnyNumber; |
| using testing::Mock; |
| using testing::Return; |
| using UserInteractionLatenciesPtr = |
| page_load_metrics::mojom::UserInteractionLatenciesPtr; |
| using UserInteractionLatencies = |
| page_load_metrics::mojom::UserInteractionLatencies; |
| using UserInteractionLatency = page_load_metrics::mojom::UserInteractionLatency; |
| using UserInteractionType = page_load_metrics::mojom::UserInteractionType; |
| |
| namespace { |
| |
| using GeneratedNavigation = ukm::builders::GeneratedNavigation; |
| using LargestContentState = |
| page_load_metrics::PageLoadMetricsObserver::LargestContentState; |
| using LargestContentTextOrImage = |
| page_load_metrics::ContentfulPaintTimingInfo::LargestContentTextOrImage; |
| using PageLoad = ukm::builders::PageLoad; |
| using MobileFriendliness = ukm::builders::MobileFriendliness; |
| using PageLoad_Internal = ukm::builders::PageLoad_Internal; |
| using UserPerceivedPageVisit = ukm::builders::UserPerceivedPageVisit; |
| |
| const char kTestUrl1[] = "https://www.google.com/"; |
| const char kTestUrl2[] = "https://www.example.com/"; |
| const char kSubframeTestUrl[] = "https://www.google.com/subframe.html"; |
| |
| class MockNetworkQualityProvider : public network::NetworkQualityTracker { |
| public: |
| MOCK_CONST_METHOD0(GetEffectiveConnectionType, |
| net::EffectiveConnectionType()); |
| MOCK_CONST_METHOD0(GetHttpRTT, base::TimeDelta()); |
| MOCK_CONST_METHOD0(GetTransportRTT, base::TimeDelta()); |
| MOCK_CONST_METHOD0(GetDownstreamThroughputKbps, int32_t()); |
| }; |
| |
| } // namespace |
| |
| class UkmPageLoadMetricsObserverTest |
| : public page_load_metrics::PageLoadMetricsObserverTestHarness { |
| protected: |
| void RegisterObservers(page_load_metrics::PageLoadTracker* tracker) override { |
| std::unique_ptr<UkmPageLoadMetricsObserver> observer = |
| std::make_unique<UkmPageLoadMetricsObserver>( |
| &mock_network_quality_provider_); |
| observer_ = observer.get(); |
| tracker->AddObserver(std::move(observer)); |
| } |
| |
| void SetUp() override { |
| page_load_metrics::PageLoadMetricsObserverTestHarness::SetUp(); |
| page_load_metrics::LargestContentfulPaintHandler::SetTestMode(true); |
| |
| EXPECT_CALL(mock_network_quality_provider_, GetEffectiveConnectionType()) |
| .Times(AnyNumber()) |
| .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_UNKNOWN)); |
| |
| EXPECT_CALL(mock_network_quality_provider_, GetHttpRTT()) |
| .Times(AnyNumber()) |
| .WillRepeatedly(Return(base::TimeDelta())); |
| |
| EXPECT_CALL(mock_network_quality_provider_, GetTransportRTT()) |
| .Times(AnyNumber()) |
| .WillRepeatedly(Return(base::TimeDelta())); |
| |
| EXPECT_CALL(mock_network_quality_provider_, GetDownstreamThroughputKbps()) |
| .Times(AnyNumber()) |
| .WillRepeatedly(Return(int32_t())); |
| |
| bookmarks::BookmarkModel* bookmark_model = |
| BookmarkModelFactory::GetForBrowserContext(profile()); |
| bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model); |
| |
| HistoryTabHelper::CreateForWebContents(web_contents()); |
| HistoryTabHelper::FromWebContents(web_contents()) |
| ->SetForceEligibleTabForTesting(true); |
| |
| HistoryClustersTabHelper::CreateForWebContents(web_contents()); |
| } |
| |
| TestingProfile::TestingFactories GetTestingFactories() const override { |
| return { |
| {BookmarkModelFactory::GetInstance(), |
| BookmarkModelFactory::GetDefaultFactory()}, |
| {HistoryServiceFactory::GetInstance(), |
| HistoryServiceFactory::GetDefaultFactory()}, |
| {TemplateURLServiceFactory::GetInstance(), |
| base::BindRepeating(&TemplateURLServiceFactory::BuildInstanceFor)}}; |
| } |
| |
| MockNetworkQualityProvider& mock_network_quality_provider() { |
| return mock_network_quality_provider_; |
| } |
| |
| // Tests that LCP reports the given |value|, |
| // and tests that the LCP content type reported is |text_or_image|. If |
| // |test_main_frame| is set, also tests that the main frame LCP histograms |
| // also report |value|. If |text_or_image| is kText, then tests that image |
| // BPP is not reported, and otherwise tests that it matches |bpp_bucket|. |
| void TestLCP(int value, |
| LargestContentTextOrImage text_or_image, |
| bool test_main_frame, |
| uint32_t bpp_bucket = 0) { |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(entry, |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kPaintTiming_NavigationToLargestContentfulPaint2Name, |
| value); |
| if (test_main_frame) { |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, |
| PageLoad:: |
| kPaintTiming_NavigationToLargestContentfulPaint2_MainFrameName, |
| value); |
| } |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, PageLoad::kPageTiming_ForegroundDurationName)); |
| |
| if (text_or_image == LargestContentTextOrImage::kText) { |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, PageLoad::kPaintTiming_LargestContentfulPaintBPPName)); |
| } else { |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kPaintTiming_LargestContentfulPaintBPPName, |
| bpp_bucket); |
| } |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> internal_merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad_Internal::kEntryName); |
| EXPECT_EQ(1ul, internal_merged_entries.size()); |
| const ukm::mojom::UkmEntry* internal_entry = |
| internal_merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(internal_entry, |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| internal_entry, |
| PageLoad_Internal::kPaintTiming_LargestContentfulPaint_ContentTypeName, |
| static_cast<int>(text_or_image)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| internal_entry, |
| PageLoad_Internal:: |
| kPaintTiming_LargestContentfulPaint_TerminationStateName, |
| static_cast<int>(LargestContentState::kReported)); |
| } |
| |
| void TestNoLCP(LargestContentState state) { |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, PageLoad::kPaintTiming_NavigationToLargestContentfulPaint2Name)); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, |
| PageLoad:: |
| kPaintTiming_NavigationToLargestContentfulPaint2_MainFrameName)); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> internal_merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad_Internal::kEntryName); |
| EXPECT_EQ(1ul, internal_merged_entries.size()); |
| const ukm::mojom::UkmEntry* internal_entry = |
| internal_merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(internal_entry, |
| GURL(kTestUrl1)); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| internal_entry, |
| PageLoad_Internal:: |
| kPaintTiming_LargestContentfulPaint_ContentTypeName)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| internal_entry, |
| PageLoad_Internal:: |
| kPaintTiming_LargestContentfulPaint_TerminationStateName, |
| static_cast<int>(state)); |
| } |
| |
| UkmPageLoadMetricsObserver* observer() const { return observer_; } |
| |
| private: |
| raw_ptr<UkmPageLoadMetricsObserver> observer_; // Non-owning raw pointer. |
| |
| MockNetworkQualityProvider mock_network_quality_provider_; |
| }; |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, NoMetrics) { |
| EXPECT_EQ(0ul, tester()->test_ukm_recorder().sources_count()); |
| EXPECT_EQ(0ul, tester()->test_ukm_recorder().entries_count()); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, Basic) { |
| // PageLoadTiming with all recorded metrics other than FMP. This allows us to |
| // verify both that all metrics are logged, and that we don't log metrics that |
| // aren't present in the PageLoadTiming struct. Logging of FMP is verified in |
| // the FirstMeaningfulPaint test below. |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.parse_timing->parse_start = base::Milliseconds(100); |
| timing.document_timing->dom_content_loaded_event_start = |
| base::Milliseconds(200); |
| timing.paint_timing->first_paint = base::Milliseconds(250); |
| timing.paint_timing->first_contentful_paint = base::Milliseconds(300); |
| timing.document_timing->load_event_start = base::Milliseconds(500); |
| timing.input_to_navigation_start = base::Milliseconds(50); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kExperimental_InputToNavigationStartName, |
| 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kExperimental_Navigation_UserInitiatedName, |
| true); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNavigation_PageTransitionName, |
| ui::PAGE_TRANSITION_LINK); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kParseTiming_NavigationToParseStartName, |
| 100); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kDocumentTiming_NavigationToDOMContentLoadedEventFiredName, |
| 200); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kPaintTiming_NavigationToFirstPaintName, |
| 250); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kPaintTiming_NavigationToFirstContentfulPaintName, 300); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kDocumentTiming_NavigationToLoadEventFiredName, 500); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNet_HttpResponseCodeName, 200); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), |
| PageLoad:: |
| kExperimental_PaintTiming_NavigationToFirstMeaningfulPaintName)); |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), PageLoad::kPageTiming_ForegroundDurationName)); |
| } |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> pagevisit_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| ukm::builders::UserPerceivedPageVisit::kEntryName); |
| EXPECT_EQ(1ul, pagevisit_entries.size()); |
| for (const auto& kv : pagevisit_entries) { |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| ukm::builders::UserPerceivedPageVisit::kUserInitiatedName, true); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, FailedProvisionalLoad) { |
| EXPECT_CALL(mock_network_quality_provider(), GetEffectiveConnectionType()) |
| .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_2G)); |
| |
| // The following simulates a navigation that fails and should commit an error |
| // page, but finishes before the error page actually commits. |
| GURL url(kTestUrl1); |
| std::unique_ptr<content::NavigationSimulator> navigation = |
| content::NavigationSimulator::CreateRendererInitiated(url, main_rfh()); |
| navigation->Fail(net::ERR_TIMED_OUT); |
| navigation->AbortCommit(); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| // Make sure that only the following metrics are logged. In particular, no |
| // paint/document/etc timing metrics should be logged for failed provisional |
| // loads. |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNavigation_PageTransitionName, |
| ui::PAGE_TRANSITION_LINK); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_PROVISIONAL_LOAD_FAILED); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kNet_EffectiveConnectionType2_OnNavigationStartName, |
| metrics::SystemProfileProto::Network::EFFECTIVE_CONNECTION_TYPE_2G); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNet_ErrorCode_OnFailedProvisionalLoadName, |
| static_cast<int64_t>(net::ERR_TIMED_OUT) * -1); |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), PageLoad::kPageTiming_ForegroundDurationName)); |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), |
| PageLoad::kPageTiming_NavigationToFailedProvisionalLoadName)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kExperimental_Navigation_UserInitiatedName, |
| false); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, FirstMeaningfulPaint) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.parse_timing->parse_start = base::Milliseconds(10); |
| timing.paint_timing->first_meaningful_paint = base::Milliseconds(600); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kExperimental_PaintTiming_NavigationToFirstMeaningfulPaintName, |
| 600); |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), PageLoad::kPageTiming_ForegroundDurationName)); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestImagePaint) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u; |
| timing.paint_timing->largest_contentful_paint->image_bpp = 8.5; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(600, LargestContentTextOrImage::kImage, true /* test_main_frame */, |
| 30 /* image_bpp = "8.0 - 9.0" */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestImageLoading) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| // The largest image is loading so its paint time is set to TimeDelta(). |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::TimeDelta(); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u; |
| // There is a text paint, but it must be ignored because it is smaller than |
| // the image paint. |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 25u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestNoLCP(LargestContentState::kLargestImageLoading); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestImageLoadingSmallerThanText) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| // Largest image is loading. |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::TimeDelta(); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u; |
| // Largest text is larger than image. |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 80u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(600, LargestContentTextOrImage::kText, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestImagePaint_DiscardBackgroundResult) { |
| std::unique_ptr<base::SimpleTestClock> mock_clock( |
| new base::SimpleTestClock()); |
| mock_clock->SetNow(base::Time::NowFromSystemTime()); |
| |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(600); |
| PopulateRequiredTimingFields(&timing); |
| // The duration between nav start and first background set to 1ms. |
| mock_clock->Advance(base::Milliseconds(1)); |
| web_contents()->WasHidden(); |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, PageLoad::kPaintTiming_NavigationToLargestContentfulPaint2Name)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> internal_merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad_Internal::kEntryName); |
| // RecordTimingMetrics() is not called in this test. |
| EXPECT_EQ(0ul, internal_merged_entries.size()); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, AbortNeverForegrounded) { |
| std::unique_ptr<base::SimpleTestClock> mock_clock( |
| new base::SimpleTestClock()); |
| mock_clock->SetNow(base::Time::NowFromSystemTime()); |
| |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| PopulateRequiredTimingFields(&timing); |
| // The duration between nav start and first background set to 1ms. |
| mock_clock->Advance(base::Milliseconds(1)); |
| web_contents()->WasHidden(); |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kPageVisitFinalStatusName, |
| static_cast<int64_t>(PageVisitFinalStatus::kNeverForegrounded)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kNavigation_PageTransitionName, |
| ui::PAGE_TRANSITION_LINK); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kPageTiming_TotalForegroundDurationName, 0); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, FCPPlusPlus_DiscardBackgroundResult) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| |
| PopulateRequiredTimingFields(&timing); |
| |
| // Backgrounding. The backgrounding time will be recorded. This time is very |
| // short but indefinite, so we should make sure we set a large enough time for |
| // the timings so that they are larger than the backgrounding time. |
| web_contents()->WasHidden(); |
| // Set a large enough value to make sure it will be larger than backgrounding |
| // time, so that the result will be discarded. |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Seconds(10); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Seconds(10); |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, PageLoad::kPaintTiming_NavigationToLargestContentfulPaint2Name)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> internal_merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad_Internal::kEntryName); |
| // RecordTimingMetrics() is not called in this test. |
| EXPECT_EQ(0ul, internal_merged_entries.size()); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, FCPPlusPlus_ReportLastCandidate) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(60); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 10u; |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(60); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 10u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| tester()->SimulateTimingUpdate(timing); |
| |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 10u; |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 10u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // There's a tie here and in this case the LCP handler returns image as the |
| // type. |
| TestLCP(600, LargestContentTextOrImage::kImage, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestTextPaint) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 50u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(600, LargestContentTextOrImage::kText, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestContentfulPaint_Trace) { |
| // TODO(https://crbug.com/1266001): Improve unit tests support for tracing. |
| // In particular, the initialization call below is most likely too narrow / |
| // doesn't take care of everything that is needed. In the future we might |
| // need to 1) initialize tracing from a better place (maybe |
| // RenderViewHostTestEnabler) and 2) initialize more broadly (maybe via |
| // tracing::PerfettoTracedProcess::SetupForTesting method once it is |
| // reintroduced). |
| perfetto::internal::TrackRegistry::InitializeInstance(); |
| |
| using trace_analyzer::Query; |
| trace_analyzer::Start("*"); |
| { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = |
| 1000; |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| } |
| auto analyzer = trace_analyzer::Stop(); |
| trace_analyzer::TraceEventVector events; |
| Query q = Query::EventNameIs( |
| "NavStartToLargestContentfulPaint::Candidate::AllFrames::UKM"); |
| analyzer->FindEvents(q, &events); |
| EXPECT_EQ(1u, events.size()); |
| EXPECT_EQ("loading", events[0]->category); |
| EXPECT_TRUE(events[0]->HasArg("data")); |
| base::Value arg; |
| EXPECT_TRUE(events[0]->GetArgAsValue("data", &arg)); |
| ASSERT_TRUE(arg.is_dict()); |
| int time = arg.FindIntKey("durationInMilliseconds").value_or(0); |
| EXPECT_EQ(600, time); |
| int size = arg.FindIntKey("size").value_or(0); |
| EXPECT_EQ(1000, size); |
| const std::string* type = arg.FindStringKey("type"); |
| ASSERT_TRUE(type); |
| EXPECT_EQ("text", *type); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaint_Trace_InvalidateCandidate) { |
| using trace_analyzer::Query; |
| trace_analyzer::Start("loading"); |
| { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = |
| 1000; |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| absl::optional<base::TimeDelta>(); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 0; |
| PopulateRequiredTimingFields(&timing); |
| |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| } |
| auto analyzer = trace_analyzer::Stop(); |
| |
| trace_analyzer::TraceEventVector candidate_events; |
| Query candidate_query = Query::EventNameIs( |
| "NavStartToLargestContentfulPaint::Candidate::AllFrames::UKM"); |
| analyzer->FindEvents(candidate_query, &candidate_events); |
| EXPECT_EQ(1u, candidate_events.size()); |
| |
| trace_analyzer::TraceEventVector invalidate_events; |
| Query invalidate_query = Query::EventNameIs( |
| "NavStartToLargestContentfulPaint::" |
| "Invalidate::AllFrames::UKM"); |
| analyzer->FindEvents(invalidate_query, &invalidate_events); |
| EXPECT_EQ(1u, invalidate_events.size()); |
| EXPECT_EQ("loading", invalidate_events[0]->category); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestContentfulPaint_OnlyText) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 1000; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(600, LargestContentTextOrImage::kText, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LargestContentfulPaint_OnlyImage) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = |
| 1000; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(600, LargestContentTextOrImage::kImage, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaint_ImageLargerThanText) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(600); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = |
| 1000; |
| timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(1000); |
| timing.paint_timing->largest_contentful_paint->largest_text_paint_size = 500; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(600, LargestContentTextOrImage::kImage, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaintAllFrames_OnlySubframe) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| PopulateRequiredTimingFields(&timing); |
| |
| page_load_metrics::mojom::PageLoadTiming subframe_timing; |
| page_load_metrics::InitPageLoadTimingForTest(&subframe_timing); |
| subframe_timing.navigation_start = base::Time::FromDoubleT(2); |
| subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(4780); |
| subframe_timing.paint_timing->largest_contentful_paint |
| ->largest_image_paint_size = 100u; |
| PopulateExperimentalLCP(subframe_timing.paint_timing); |
| PopulateRequiredTimingFields(&subframe_timing); |
| |
| // Commit the main frame and a subframe. |
| NavigateAndCommit(GURL(kTestUrl1)); |
| RenderFrameHost* subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("subframe")); |
| |
| // Simulate timing updates in the main frame and the subframe. |
| tester()->SimulateTimingUpdate(timing); |
| tester()->SimulateTimingUpdate(subframe_timing, subframe); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(4780, LargestContentTextOrImage::kImage, false /* test_main_frame */); |
| |
| // Now test that there is no main-frame LCP. |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry, |
| PageLoad:: |
| kPaintTiming_NavigationToLargestContentfulPaint2_MainFrameName)); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaintAllFrames_SubframeImageLoading) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| PopulateRequiredTimingFields(&timing); |
| |
| page_load_metrics::mojom::PageLoadTiming subframe_timing; |
| page_load_metrics::InitPageLoadTimingForTest(&subframe_timing); |
| subframe_timing.navigation_start = base::Time::FromDoubleT(2); |
| // Subframe's largest image is still loading. |
| subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::TimeDelta(); |
| subframe_timing.paint_timing->largest_contentful_paint |
| ->largest_image_paint_size = 100u; |
| // Subframe has text but it should be ignored as it's smaller than image. |
| subframe_timing.paint_timing->largest_contentful_paint->largest_text_paint = |
| base::Milliseconds(3000); |
| subframe_timing.paint_timing->largest_contentful_paint |
| ->largest_text_paint_size = 80u; |
| PopulateExperimentalLCP(subframe_timing.paint_timing); |
| PopulateRequiredTimingFields(&subframe_timing); |
| |
| // Commit the main frame and a subframe. |
| NavigateAndCommit(GURL(kTestUrl1)); |
| RenderFrameHost* subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("subframe")); |
| |
| // Simulate timing updates in the main frame and the subframe. |
| tester()->SimulateTimingUpdate(timing); |
| tester()->SimulateTimingUpdate(subframe_timing, subframe); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestNoLCP(LargestContentState::kLargestImageLoading); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaintAllFrames_OnlyMainFrame) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(4780); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = |
| 100u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| page_load_metrics::mojom::PageLoadTiming subframe_timing; |
| page_load_metrics::InitPageLoadTimingForTest(&subframe_timing); |
| subframe_timing.navigation_start = base::Time::FromDoubleT(2); |
| PopulateRequiredTimingFields(&subframe_timing); |
| |
| // Commit the main frame and a subframe. |
| NavigateAndCommit(GURL(kTestUrl1)); |
| RenderFrameHost* subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("subframe")); |
| |
| // Simulate timing updates in the main frame and the subframe. |
| tester()->SimulateTimingUpdate(timing); |
| tester()->SimulateTimingUpdate(subframe_timing, subframe); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(4780, LargestContentTextOrImage::kImage, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaintAllFrames_CrossSiteSubFrame) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(4780); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = |
| 100u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| // Subframe timing for same-site |
| page_load_metrics::mojom::PageLoadTiming subframe_timing; |
| page_load_metrics::InitPageLoadTimingForTest(&subframe_timing); |
| subframe_timing.navigation_start = base::Time::FromDoubleT(2); |
| subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(4790); |
| subframe_timing.paint_timing->largest_contentful_paint |
| ->largest_image_paint_size = 110u; |
| PopulateExperimentalLCP(subframe_timing.paint_timing); |
| PopulateRequiredTimingFields(&subframe_timing); |
| |
| // Subframe timing for cross-site |
| page_load_metrics::mojom::PageLoadTiming subframe_timing2; |
| page_load_metrics::InitPageLoadTimingForTest(&subframe_timing2); |
| subframe_timing2.navigation_start = base::Time::FromDoubleT(2); |
| subframe_timing2.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(4800); |
| subframe_timing2.paint_timing->largest_contentful_paint |
| ->largest_image_paint_size = 50u; |
| PopulateExperimentalLCP(subframe_timing2.paint_timing); |
| PopulateRequiredTimingFields(&subframe_timing2); |
| |
| // Commit the main frame and a subframe. |
| const char kSameSiteSubframeTestUrl[] = |
| "https://sub.google.com/subframe.html"; |
| const char kCrossSiteSubframeTestUrl[] = "https://example.com/subframe.html"; |
| NavigateAndCommit(GURL(kTestUrl1)); |
| RenderFrameHost* same_site_subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSameSiteSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("same_site_subframe")); |
| RenderFrameHost* cross_site_subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kCrossSiteSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("cross_site_subframe")); |
| |
| // Simulate timing updates in the main frame and the subframe. |
| tester()->SimulateTimingUpdate(timing); |
| tester()->SimulateTimingUpdate(subframe_timing, same_site_subframe); |
| tester()->SimulateTimingUpdate(subframe_timing2, cross_site_subframe); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // Now test that there is a cross site subframe lcp. |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, |
| PageLoad:: |
| kPaintTiming_NavigationToLargestContentfulPaint2_CrossSiteSubFrameName, |
| 4800); |
| } |
| |
| // This is to test whether LargestContentfulPaintAllFrames can merge the |
| // candidates from different frames correctly. The metric should pick the larger |
| // candidate during merging. |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| LargestContentfulPaintAllFrames_MergeFrameCandidateBySize) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(4780); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| page_load_metrics::mojom::PageLoadTiming subframe_timing; |
| page_load_metrics::InitPageLoadTimingForTest(&subframe_timing); |
| subframe_timing.navigation_start = base::Time::FromDoubleT(2); |
| subframe_timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| base::Milliseconds(990); |
| subframe_timing.paint_timing->largest_contentful_paint |
| ->largest_image_paint_size = 100u; |
| PopulateExperimentalLCP(subframe_timing.paint_timing); |
| PopulateRequiredTimingFields(&subframe_timing); |
| |
| // Commit the main frame and a subframe. |
| NavigateAndCommit(GURL(kTestUrl1)); |
| RenderFrameHost* subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("subframe")); |
| |
| // Simulate timing updates in the main frame and the subframe. |
| tester()->SimulateTimingUpdate(timing); |
| tester()->SimulateTimingUpdate(subframe_timing, subframe); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestLCP(990, LargestContentTextOrImage::kImage, false /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| NormalizedUserInteractionLatenciesWithoutAllLatencies) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| page_load_metrics::mojom::InputTiming input_timing; |
| input_timing.num_interactions = 3; |
| input_timing.max_event_durations = |
| UserInteractionLatencies::NewWorstInteractionLatency( |
| base::Milliseconds(120)); |
| input_timing.total_event_durations = |
| UserInteractionLatencies::NewWorstInteractionLatency( |
| base::Milliseconds(140)); |
| |
| tester()->SimulateInputTimingUpdate(input_timing); |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_WorstUserInteractionLatency_MaxEventDurationName, |
| 120); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_WorstUserInteractionLatency_TotalEventDurationName, |
| 140); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| NormalizedUserInteractionLatenciesWithAllLatencies) { |
| // Flip the flag. |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitAndEnableFeature( |
| blink::features::kSendAllUserInteractionLatencies); |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| page_load_metrics::mojom::InputTiming input_timing; |
| input_timing.num_interactions = 3; |
| input_timing.max_event_durations = |
| UserInteractionLatencies::NewUserInteractionLatencies({}); |
| auto& max_event_durations = |
| input_timing.max_event_durations->get_user_interaction_latencies(); |
| |
| max_event_durations.emplace_back(UserInteractionLatency::New( |
| base::Milliseconds(50), UserInteractionType::kKeyboard)); |
| max_event_durations.emplace_back(UserInteractionLatency::New( |
| base::Milliseconds(100), UserInteractionType::kTapOrClick)); |
| max_event_durations.emplace_back(UserInteractionLatency::New( |
| base::Milliseconds(150), UserInteractionType::kDrag)); |
| input_timing.total_event_durations = |
| UserInteractionLatencies::NewUserInteractionLatencies({}); |
| auto& total_event_durations = |
| input_timing.total_event_durations->get_user_interaction_latencies(); |
| |
| total_event_durations.emplace_back(UserInteractionLatency::New( |
| base::Milliseconds(55), UserInteractionType::kKeyboard)); |
| total_event_durations.emplace_back(UserInteractionLatency::New( |
| base::Milliseconds(105), UserInteractionType::kTapOrClick)); |
| total_event_durations.emplace_back(UserInteractionLatency::New( |
| base::Milliseconds(155), UserInteractionType::kDrag)); |
| |
| tester()->SimulateInputTimingUpdate(input_timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_WorstUserInteractionLatency_MaxEventDurationName, |
| 150); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_WorstUserInteractionLatencyOverBudget_MaxEventDurationName, |
| 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_SumOfUserInteractionLatencyOverBudget_MaxEventDurationName, |
| 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_AverageUserInteractionLatencyOverBudget_MaxEventDurationName, |
| 16); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_SlowUserInteractionLatencyOverBudget_HighPercentile_MaxEventDurationName, |
| 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_SlowUserInteractionLatencyOverBudget_HighPercentile2_MaxEventDurationName, |
| 50); |
| |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_WorstUserInteractionLatency_TotalEventDurationName, |
| 155); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_WorstUserInteractionLatencyOverBudget_TotalEventDurationName, |
| 55); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_SumOfUserInteractionLatencyOverBudget_TotalEventDurationName, |
| 65); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_AverageUserInteractionLatencyOverBudget_TotalEventDurationName, |
| 21); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_SlowUserInteractionLatencyOverBudget_HighPercentile_TotalEventDurationName, |
| 55); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad:: |
| kInteractiveTiming_SlowUserInteractionLatencyOverBudget_HighPercentile2_TotalEventDurationName, |
| 55); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| FirstInputDelayAndTimestampAndProcessingTime) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.interactive_timing->first_input_delay = base::Milliseconds(50); |
| timing.interactive_timing->first_input_timestamp = base::Milliseconds(712); |
| timing.interactive_timing->first_input_processing_time = |
| base::Milliseconds(25); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_FirstInputDelay4Name, 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_FirstInputTimestamp4Name, |
| 712); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kInteractiveTiming_FirstInputProcessingTimesName, 25); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LongestInputDelayAndTimestamp) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.interactive_timing->longest_input_delay = base::Milliseconds(50); |
| timing.interactive_timing->longest_input_timestamp = base::Milliseconds(712); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_LongestInputDelay4Name, |
| 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kInteractiveTiming_LongestInputTimestamp4Name, 712); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, InputTiming) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| page_load_metrics::mojom::InputTiming input_timing; |
| input_timing.num_input_events = 2; |
| input_timing.total_input_delay = base::Milliseconds(100); |
| input_timing.total_adjusted_input_delay = base::Milliseconds(10); |
| tester()->SimulateInputTimingUpdate(input_timing); |
| |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_NumInputEventsName, 2); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_TotalInputDelayName, 100); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kInteractiveTiming_TotalAdjustedInputDelayName, 10); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, MobileFriendliness) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| blink::MobileFriendliness mobile_friendliness; |
| mobile_friendliness.viewport_device_width = false; |
| mobile_friendliness.viewport_hardcoded_width = 533; |
| mobile_friendliness.viewport_initial_scale_x10 = 10; |
| mobile_friendliness.allow_user_zoom = true; |
| mobile_friendliness.small_text_ratio = 2; |
| const int expected_viewport_hardcoded_width = 520; |
| const int expected_viewport_initial_scale = 10; |
| |
| tester()->SimulateMobileFriendlinessUpdate(mobile_friendliness); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| MobileFriendliness::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), MobileFriendliness::kViewportDeviceWidthName, false); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), MobileFriendliness::kViewportHardcodedWidthName, |
| expected_viewport_hardcoded_width); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), MobileFriendliness::kViewportInitialScaleX10Name, |
| expected_viewport_initial_scale); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), MobileFriendliness::kAllowUserZoomName, true); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), MobileFriendliness::kSmallTextRatioName, 2); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, FirstScrollDelayAndTimestamp) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.interactive_timing->first_scroll_delay = base::Milliseconds(50); |
| timing.interactive_timing->first_scroll_timestamp = base::Milliseconds(70); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_FirstScrollDelayName, 50); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kInteractiveTiming_FirstScrollTimestampName, |
| 64); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, MultiplePageLoads) { |
| page_load_metrics::mojom::PageLoadTiming timing1; |
| page_load_metrics::InitPageLoadTimingForTest(&timing1); |
| timing1.parse_timing->parse_start = base::Milliseconds(10); |
| timing1.navigation_start = base::Time::FromDoubleT(1); |
| timing1.paint_timing->first_contentful_paint = base::Milliseconds(200); |
| PopulateRequiredTimingFields(&timing1); |
| |
| // Second navigation reports no timing metrics. |
| page_load_metrics::mojom::PageLoadTiming timing2; |
| page_load_metrics::InitPageLoadTimingForTest(&timing2); |
| timing2.navigation_start = base::Time::FromDoubleT(1); |
| PopulateRequiredTimingFields(&timing2); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing1); |
| |
| NavigateAndCommit(GURL(kTestUrl2)); |
| tester()->SimulateTimingUpdate(timing2); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(2ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry1 = nullptr; |
| const ukm::mojom::UkmEntry* entry2 = nullptr; |
| for (const auto& kv : merged_entries) { |
| if (tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), |
| PageLoad::kPaintTiming_NavigationToFirstContentfulPaintName)) { |
| entry1 = kv.second.get(); |
| } else { |
| entry2 = kv.second.get(); |
| } |
| } |
| ASSERT_NE(entry1, nullptr); |
| ASSERT_NE(entry2, nullptr); |
| |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(entry1, |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry1, PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_NEW_NAVIGATION); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry1, PageLoad::kPaintTiming_NavigationToFirstContentfulPaintName, 200); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry1, |
| PageLoad:: |
| kExperimental_PaintTiming_NavigationToFirstMeaningfulPaintName)); |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry1, PageLoad::kPageTiming_ForegroundDurationName)); |
| |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(entry2, |
| GURL(kTestUrl2)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry2, PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry2, PageLoad::kParseTiming_NavigationToParseStartName)); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry2, PageLoad::kPaintTiming_NavigationToFirstContentfulPaintName)); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry2, |
| PageLoad:: |
| kExperimental_PaintTiming_NavigationToFirstMeaningfulPaintName)); |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| entry2, PageLoad::kPageTiming_ForegroundDurationName)); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, NetworkQualityEstimates) { |
| EXPECT_CALL(mock_network_quality_provider(), GetEffectiveConnectionType()) |
| .WillRepeatedly(Return(net::EFFECTIVE_CONNECTION_TYPE_3G)); |
| EXPECT_CALL(mock_network_quality_provider(), GetHttpRTT()) |
| .WillRepeatedly(Return(base::Milliseconds(100))); |
| EXPECT_CALL(mock_network_quality_provider(), GetTransportRTT()) |
| .WillRepeatedly(Return(base::Milliseconds(200))); |
| EXPECT_CALL(mock_network_quality_provider(), GetDownstreamThroughputKbps()) |
| .WillRepeatedly(Return(300)); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kNet_EffectiveConnectionType2_OnNavigationStartName, |
| metrics::SystemProfileProto::Network::EFFECTIVE_CONNECTION_TYPE_3G); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNet_HttpRttEstimate_OnNavigationStartName, |
| 100); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kNet_TransportRttEstimate_OnNavigationStartName, 200); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| PageLoad::kNet_DownstreamKbpsEstimate_OnNavigationStartName, 300); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, PageTransitionReload) { |
| GURL url(kTestUrl1); |
| tester()->NavigateWithPageTransitionAndCommit(GURL(kTestUrl1), |
| ui::PAGE_TRANSITION_RELOAD); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNavigation_PageTransitionName, |
| ui::PAGE_TRANSITION_RELOAD); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, PageSizeMetrics) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr> resources; |
| // Cached resource. |
| resources.push_back(CreateResource(true /* was_cached */, 0 /* delta_bytes */, |
| 20 * 1024 /* encoded_body_length */, |
| 30 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| // Uncached resource. |
| resources.push_back(CreateResource( |
| false /* was_cached */, 40 * 1024 /* delta_bytes */, |
| 40 * 1024 /* encoded_body_length */, 50 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| tester()->SimulateResourceDataUseUpdate(resources); |
| |
| int64_t network_bytes = 0; |
| int64_t cache_bytes = 0; |
| for (const auto& request : resources) { |
| if (request->cache_type == |
| page_load_metrics::mojom::CacheType::kNotCached) { |
| network_bytes += request->delta_bytes; |
| } else { |
| cache_bytes += request->encoded_body_length; |
| } |
| } |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| int64_t bucketed_network_bytes = |
| ukm::GetExponentialBucketMin(network_bytes, 1.3); |
| int64_t bucketed_cache_bytes = ukm::GetExponentialBucketMin(cache_bytes, 1.3); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.NetworkBytes2", bucketed_network_bytes); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.CacheBytes2", bucketed_cache_bytes); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, JSSizeMetrics) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr> resources; |
| // 30 kilobytes after decoding. |
| resources.push_back(CreateResource(true /* was_cached */, 0 /* delta_bytes */, |
| 20 * 1024 /* encoded_body_length */, |
| 30 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| |
| // 50 kilobytes after decoding. |
| resources.push_back(CreateResource( |
| false /* was_cached */, 40 * 1024 /* delta_bytes */, |
| 40 * 1024 /* encoded_body_length */, 50 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| |
| // 120 kilobytes after decoding, not JS. |
| resources.push_back(CreateResource( |
| false /* was_cached */, 40 * 1024 /* delta_bytes */, |
| 100 * 1024 /* encoded_body_length */, |
| 120 * 1024 /* decoded_body_length */, true /* is_complete */)); |
| |
| resources[0]->mime_type = "application/javascript"; |
| resources[1]->mime_type = "application/javascript"; |
| resources[2]->mime_type = "test"; |
| |
| tester()->SimulateResourceDataUseUpdate(resources); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // Metrics look at decoded body length. |
| // 30 + 50 = 80 kilobytes. |
| int64_t bucketed_network_js_bytes = |
| ukm::GetExponentialBucketMinForBytes(80 * 1024); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.JavaScriptBytes2", bucketed_network_js_bytes); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, JSMaxSizeMetrics) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr> resources; |
| |
| // 30 kilobytes after decoding. |
| resources.push_back(CreateResource(true /* was_cached */, 0 /* delta_bytes */, |
| 20 * 1024 /* encoded_body_length */, |
| 30 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| |
| // 500 kilobytes after decoding. |
| resources.push_back(CreateResource( |
| false /* was_cached */, 400 * 1024 /* delta_bytes */, |
| 400 * 1024 /* encoded_body_length */, |
| 500 * 1024 /* decoded_body_length */, true /* is_complete */)); |
| |
| // 120 kilobytes after decoding, not JS. |
| resources.push_back(CreateResource( |
| false /* was_cached */, 40 * 1024 /* delta_bytes */, |
| 100 * 1024 /* encoded_body_length */, |
| 120 * 1024 /* decoded_body_length */, true /* is_complete */)); |
| |
| resources[0]->mime_type = "application/javascript"; |
| resources[1]->mime_type = "application/javascript"; |
| resources[2]->mime_type = "test"; |
| |
| tester()->SimulateResourceDataUseUpdate(resources); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // Metrics look at max decoded body length. |
| // max(30,500) = 500 kilobytes. |
| int64_t bucketed_network_js_max_bytes = |
| ukm::GetExponentialBucketMinForBytes(500 * 1024); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.JavaScriptMaxBytes2", |
| bucketed_network_js_max_bytes); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, ImageMediaSizeMetrics) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| std::vector<page_load_metrics::mojom::ResourceDataUpdatePtr> resources; |
| resources.push_back(CreateResource( |
| false /* was_cached */, 10 * 1024 /* delta_bytes */, |
| 10 * 1024 /* encoded_body_length */, 10 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| resources.push_back(CreateResource( |
| false /* was_cached */, 20 * 1024 /* delta_bytes */, |
| 20 * 1024 /* encoded_body_length */, 20 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| resources.push_back(CreateResource( |
| false /* was_cached */, 50 * 1024 /* delta_bytes */, |
| 50 * 1024 /* encoded_body_length */, 50 * 1024 /* decoded_body_length */, |
| true /* is_complete */)); |
| |
| resources[0]->mime_type = "image/png"; |
| resources[0]->is_main_frame_resource = true; |
| resources[1]->mime_type = "image/jpg"; |
| resources[1]->is_main_frame_resource = false; |
| resources[2]->mime_type = "video/mp4"; |
| |
| tester()->SimulateResourceDataUseUpdate(resources); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| // 30 KB for all images, 20 KB for subframe images, and 50 KB for media. |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.ImageBytes2", |
| ukm::GetExponentialBucketMinForBytes(30 * 1024)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.ImageSubframeBytes2", |
| ukm::GetExponentialBucketMinForBytes(20 * 1024)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), "Net.MediaBytes2", |
| ukm::GetExponentialBucketMinForBytes(50 * 1024)); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, CpuTimeMetrics) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate some CPU usage. |
| page_load_metrics::mojom::CpuTiming cpu_timing(base::Milliseconds(500)); |
| tester()->SimulateCpuTimingUpdate(cpu_timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kCpuTimeName, 500); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LayoutInstability) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| base::TimeTicks current_time = base::TimeTicks::Now(); |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data(1.0, 1.0, 0, 0, 0, |
| 0, {}); |
| render_data.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(4000), 0.5)); |
| render_data.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(3500), 0.5)); |
| |
| tester()->SimulateRenderDataUpdate(render_data); |
| |
| // Simulate hiding the tab (the report should include shifts after hide). |
| web_contents()->WasHidden(); |
| |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data_2(1.5, 0.0, 0, 0, |
| 0, 0, {}); |
| render_data_2.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(2500), 1.5)); |
| tester()->SimulateRenderDataUpdate(render_data_2); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, PageLoad::kLayoutInstability_CumulativeShiftScoreName, 250); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kLayoutInstability_CumulativeShiftScore_MainFrame_BeforeInputOrScrollName, |
| 100); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kLayoutInstability_MaxCumulativeShiftScore_SessionWindow_Gap1000ms_Max5000msName, |
| 250); |
| ukm_recorder.ExpectEntryMetric(kv.second.get(), |
| PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| } |
| EXPECT_THAT(tester()->histogram_tester().GetAllSamples( |
| "PageLoad.LayoutInstability.CumulativeShiftScore"), |
| testing::ElementsAre(base::Bucket(25, 1))); |
| EXPECT_THAT(tester()->histogram_tester().GetAllSamples( |
| "PageLoad.LayoutInstability.MaxCumulativeShiftScore." |
| "SessionWindow.Gap1000ms.Max5000ms"), |
| testing::ElementsAre(base::Bucket(25, 1))); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| ExperimentalLayoutInstabilityRecordOnHidden) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| base::TimeTicks current_time = base::TimeTicks::Now(); |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data(1.0, 1.0, 0, 0, 0, |
| 0, {}); |
| render_data.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(4000), 0.5)); |
| render_data.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(3500), 0.5)); |
| |
| tester()->SimulateRenderDataUpdate(render_data); |
| |
| // Simulate hiding the tab (the experimental CLS metrics should include |
| // shifts before the first hide). |
| web_contents()->WasHidden(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kExperimental_LayoutInstability_CumulativeShiftScoreAtFirstOnHiddenName, |
| 100); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kExperimental_LayoutInstability_MaxCumulativeShiftScoreAtFirstOnHidden_SessionWindow_Gap1000ms_Max5000msName, |
| 100); |
| } |
| |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data_2(1.5, 0.0, 0, 0, |
| 0, 0, {}); |
| render_data_2.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(2500), 1.5)); |
| tester()->SimulateRenderDataUpdate(render_data_2); |
| |
| // Simulate closing the tab (the CLS metrics should include all the shifts |
| // before the tab closes). |
| DeleteContents(); |
| |
| const auto& ukm_recorder_2 = tester()->test_ukm_recorder(); |
| merged_entries = ukm_recorder_2.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder_2.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kExperimental_LayoutInstability_CumulativeShiftScoreAtFirstOnHiddenName, |
| 100); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kExperimental_LayoutInstability_MaxCumulativeShiftScoreAtFirstOnHidden_SessionWindow_Gap1000ms_Max5000msName, |
| 100); |
| ukm_recorder_2.ExpectEntryMetric( |
| ukm_entry, PageLoad::kLayoutInstability_CumulativeShiftScoreName, 250); |
| ukm_recorder_2.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kLayoutInstability_CumulativeShiftScore_MainFrame_BeforeInputOrScrollName, |
| 100); |
| ukm_recorder_2.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kLayoutInstability_MaxCumulativeShiftScore_SessionWindow_Gap1000ms_Max5000msName, |
| 250); |
| ukm_recorder_2.ExpectEntryMetric(kv.second.get(), |
| PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| } |
| EXPECT_THAT(tester()->histogram_tester().GetAllSamples( |
| "PageLoad.LayoutInstability.CumulativeShiftScore"), |
| testing::ElementsAre(base::Bucket(25, 1))); |
| EXPECT_THAT(tester()->histogram_tester().GetAllSamples( |
| "PageLoad.LayoutInstability.MaxCumulativeShiftScore." |
| "SessionWindow.Gap1000ms.Max5000ms"), |
| testing::ElementsAre(base::Bucket(25, 1))); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| ExperimentalLayoutInstabilityRecordOnPageOpenBackground) { |
| // Open the page at the background. |
| web_contents()->WasHidden(); |
| NavigateAndCommit(GURL(kTestUrl1)); |
| base::TimeTicks current_time = base::TimeTicks::Now(); |
| |
| // Bring the tab to the foreground and simulate a layout shift. |
| web_contents()->WasShown(); |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data(1.0, 1.0, 0, 0, 0, |
| 0, {}); |
| render_data.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(4000), 0.5)); |
| render_data.new_layout_shifts.emplace_back( |
| page_load_metrics::mojom::LayoutShift::New( |
| current_time - base::Milliseconds(3500), 0.5)); |
| |
| tester()->SimulateRenderDataUpdate(render_data); |
| |
| // Simulate hiding the tab (the report should include shifts before hide). |
| web_contents()->WasHidden(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kExperimental_LayoutInstability_CumulativeShiftScoreAtFirstOnHiddenName, |
| 100); |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad:: |
| kExperimental_LayoutInstability_MaxCumulativeShiftScoreAtFirstOnHidden_SessionWindow_Gap1000ms_Max5000msName, |
| 100); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, SiteInstanceRenderProcessAssignment) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const int64_t* metric = ukm_recorder.GetEntryMetric( |
| kv.second.get(), |
| ukm::builders::PageLoad::kSiteInstanceRenderProcessAssignmentName); |
| EXPECT_TRUE(metric); |
| EXPECT_NE(0u, *metric); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, MHTMLNotTrackedOfflinePreview) { |
| auto navigation = content::NavigationSimulator::CreateBrowserInitiated( |
| GURL(kTestUrl1), web_contents()); |
| navigation->SetContentsMimeType("multipart/related"); |
| navigation->Commit(); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(0ul, merged_entries.size()); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LayoutInstabilitySubframeAggregation) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate layout instability in the main frame. |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data(1.0, 1.0, 0, 0, 0, |
| 0, {}); |
| tester()->SimulateRenderDataUpdate(render_data); |
| |
| RenderFrameHost* subframe = |
| NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("subframe")); |
| |
| // Simulate layout instability in the subframe. |
| render_data.layout_shift_delta = 1.5; |
| tester()->SimulateRenderDataUpdate(render_data, subframe); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // CLS score should be the sum of LS scores from all frames. |
| EXPECT_THAT(tester()->histogram_tester().GetAllSamples( |
| "PageLoad.LayoutInstability.CumulativeShiftScore"), |
| testing::ElementsAre(base::Bucket(25, 1))); |
| |
| // Main-frame (DCLS) score includes only the LS scores in the main frame. |
| EXPECT_THAT(tester()->histogram_tester().GetAllSamples( |
| "PageLoad.LayoutInstability.CumulativeShiftScore.MainFrame"), |
| testing::ElementsAre(base::Bucket(10, 1))); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| |
| // Check CLS score in UKM. |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, PageLoad::kLayoutInstability_CumulativeShiftScoreName, 250); |
| |
| // Check DCLS score in UKM. |
| ukm_recorder.ExpectEntryMetric( |
| ukm_entry, |
| PageLoad::kLayoutInstability_CumulativeShiftScore_MainFrameName, 100); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, ThirdPartyCookieBlockingDisabled) { |
| profile()->GetPrefs()->SetInteger( |
| prefs::kCookieControlsMode, |
| static_cast<int>(content_settings::CookieControlsMode::kOff)); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| EXPECT_FALSE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), |
| PageLoad::kThirdPartyCookieBlockingEnabledForSiteName)); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, ThirdPartyCookieBlockingEnabled) { |
| profile()->GetPrefs()->SetInteger( |
| prefs::kCookieControlsMode, |
| static_cast<int>(content_settings::CookieControlsMode::kBlockThirdParty)); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kThirdPartyCookieBlockingEnabledForSiteName, |
| true); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| ThirdPartyCookieBlockingDisabledForSite) { |
| profile()->GetPrefs()->SetInteger( |
| prefs::kCookieControlsMode, |
| static_cast<int>(content_settings::CookieControlsMode::kBlockThirdParty)); |
| auto cookie_settings = CookieSettingsFactory::GetForProfile(profile()); |
| cookie_settings->SetThirdPartyCookieSetting(GURL(kTestUrl1), |
| CONTENT_SETTING_ALLOW); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kThirdPartyCookieBlockingEnabledForSiteName, |
| false); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, NotSearchOrHomePage) { |
| static const char kOtherURL[] = "https://www.other.com"; |
| |
| NavigateAndCommit(GURL(kOtherURL)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| GeneratedNavigation::kEntryName); |
| EXPECT_EQ(0ul, merged_entries.size()); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, HomePageReported) { |
| static const char kOtherURL[] = "https://www.homepage.com/"; |
| |
| Profile::FromBrowserContext(browser_context()) |
| ->GetPrefs() |
| ->SetString(prefs::kHomePage, kOtherURL); |
| |
| NavigateAndCommit(GURL(kOtherURL)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| GeneratedNavigation::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kOtherURL)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| GeneratedNavigation::kFirstURLIsDefaultSearchEngineName, false); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| GeneratedNavigation::kFinalURLIsDefaultSearchEngineName, false); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), GeneratedNavigation::kFirstURLIsHomePageName, true); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), GeneratedNavigation::kFinalURLIsHomePageName, true); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, DefaultSearchReported) { |
| static const char16_t kShortName[] = u"test"; |
| static const char kSearchURL[] = |
| "https://www.searchurl.com/search?q={searchTerms}"; |
| static const char kSearchURLWithQuery[] = |
| "https://www.searchurl.com/search?q=somequery"; |
| |
| TemplateURLService* model = TemplateURLServiceFactory::GetForProfile( |
| Profile::FromBrowserContext(browser_context())); |
| ASSERT_TRUE(model); |
| search_test_utils::WaitForTemplateURLServiceToLoad(model); |
| ASSERT_TRUE(model->loaded()); |
| |
| TemplateURLData data; |
| data.SetShortName(kShortName); |
| data.SetKeyword(data.short_name()); |
| data.SetURL(kSearchURL); |
| |
| // Set the DSE to the test URL. |
| TemplateURL* template_url = model->Add(std::make_unique<TemplateURL>(data)); |
| ASSERT_TRUE(template_url); |
| model->SetUserSelectedDefaultSearchProvider(template_url); |
| |
| NavigateAndCommit(GURL(kSearchURLWithQuery)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| GeneratedNavigation::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl( |
| kv.second.get(), GURL(kSearchURLWithQuery)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| GeneratedNavigation::kFirstURLIsDefaultSearchEngineName, true); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), |
| GeneratedNavigation::kFinalURLIsDefaultSearchEngineName, true); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), GeneratedNavigation::kFirstURLIsHomePageName, false); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), GeneratedNavigation::kFinalURLIsHomePageName, false); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, NoLargestContentfulPaint) { |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| PopulateRequiredTimingFields(&timing); |
| |
| NavigateAndCommit(GURL(kTestUrl1)); |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| TestNoLCP(LargestContentState::kNotFound); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, FCPHiddenWhileFlushing) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate hiding the tab. |
| web_contents()->WasHidden(); |
| |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.parse_timing->parse_start = base::TimeDelta(); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->first_contentful_paint = |
| tester()->GetDelegateForCommittedLoad().GetTimeToFirstBackground(); |
| PopulateRequiredTimingFields(&timing); |
| |
| // Simulate FCP at the same time as the hide (but reported after). |
| tester()->SimulateTimingUpdate(timing); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| // Check that we reported the FCP UKM. |
| for (const auto& kv : merged_entries) { |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric( |
| kv.second.get(), |
| PageLoad::kPaintTiming_NavigationToFirstContentfulPaintName)); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, LCPHiddenWhileFlushing) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| // Simulate hiding the tab. |
| web_contents()->WasHidden(); |
| base::TimeDelta time_to_first_background = |
| *tester()->GetDelegateForCommittedLoad().GetTimeToFirstBackground(); |
| |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| timing.navigation_start = base::Time::FromDoubleT(1); |
| timing.paint_timing->largest_contentful_paint->largest_image_paint = |
| time_to_first_background; |
| timing.paint_timing->largest_contentful_paint->largest_image_paint_size = 50u; |
| PopulateExperimentalLCP(timing.paint_timing); |
| PopulateRequiredTimingFields(&timing); |
| |
| // Simulate LCP at the same time as the hide (but reported after). |
| tester()->SimulateTimingUpdate(timing); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // Check that we reported the LCP UKM. |
| TestLCP(time_to_first_background.InMilliseconds(), |
| LargestContentTextOrImage::kImage, true /* test_main_frame */); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, AppEnterBackground) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| page_load_metrics::mojom::PageLoadTiming timing; |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| |
| tester()->SimulateAppEnterBackground(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_APP_ENTER_BACKGROUND); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, IsExistingBookmark) { |
| GURL url(kTestUrl1); |
| |
| bookmarks::BookmarkModel* model = |
| BookmarkModelFactory::GetForBrowserContext(browser_context()); |
| ASSERT_TRUE(model); |
| ASSERT_TRUE( |
| model->AddURL(model->bookmark_bar_node(), 0, std::u16string(), url)); |
| |
| NavigateAndCommit(url); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kIsExistingBookmarkName, 1); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kIsNewBookmarkName, 0); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, IsNewBookmark) { |
| GURL url(kTestUrl1); |
| |
| history::HistoryService* history_service = |
| HistoryServiceFactory::GetForProfile(profile(), |
| ServiceAccessType::IMPLICIT_ACCESS); |
| ASSERT_TRUE(history_service); |
| history_service->AddPage(url, base::Time::Now(), |
| history::VisitSource::SOURCE_BROWSED); |
| |
| NavigateAndCommit(url); |
| history::BlockUntilHistoryProcessesPendingRequests(history_service); |
| |
| bookmarks::BookmarkModel* model = |
| BookmarkModelFactory::GetForBrowserContext(browser_context()); |
| ASSERT_TRUE(model); |
| ASSERT_TRUE( |
| model->AddURL(model->bookmark_bar_node(), 0, std::u16string(), url)); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kIsExistingBookmarkName, 0); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kIsNewBookmarkName, 1); |
| } |
| |
| // Android does not have NTP Custom Links. |
| #if !BUILDFLAG(IS_ANDROID) |
| TEST_F(UkmPageLoadMetricsObserverTest, IsNTPCustomLink) { |
| GURL url(kTestUrl1); |
| |
| history::HistoryService* history_service = |
| HistoryServiceFactory::GetForProfile(profile(), |
| ServiceAccessType::IMPLICIT_ACCESS); |
| ASSERT_TRUE(history_service); |
| history_service->AddPage(url, base::Time::Now(), |
| history::VisitSource::SOURCE_BROWSED); |
| |
| NavigateAndCommit(url); |
| history::BlockUntilHistoryProcessesPendingRequests(history_service); |
| |
| ntp_tiles::CustomLinksStore custom_link_store(profile()->GetPrefs()); |
| custom_link_store.StoreLinks({ |
| {url, u"Test Title"}, |
| }); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kIsNTPCustomLinkName, 1); |
| } |
| #endif // !BUILDFLAG(IS_ANDROID) |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, DurationSinceLastVisitSeconds) { |
| // TODO(tommycli): Should we move this test to either HistoryClustersService |
| // or HistoryClustersTabHelper? On the one hand, the logic resides there. On |
| // the other hand this serves as a good integration test with UKM. |
| GURL url(kTestUrl1); |
| |
| history::HistoryService* history_service = |
| HistoryServiceFactory::GetForProfile(profile(), |
| ServiceAccessType::IMPLICIT_ACCESS); |
| ASSERT_TRUE(history_service); |
| // Fake that we visited this site 45 days ago. |
| history_service->AddPage(url, base::Time::Now() - base::Days(45), |
| history::VisitSource::SOURCE_BROWSED); |
| NavigateAndCommit(url); |
| history::BlockUntilHistoryProcessesPendingRequests(history_service); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| // Verify UKM records that we visited the page clamped to 30 days ago to |
| // respect the UKM retention period. |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kDurationSinceLastVisitSecondsName, |
| base::Days(30).InSeconds()); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| DurationSinceLastVisitSecondsHistoryServiceLosesRace) { |
| GURL url(kTestUrl1); |
| |
| // Simulate that we navigated, but HistoryService doesn't respond back to the |
| // UKM observer before it's destroyed. |
| NavigateAndCommit(url); |
| DeleteContents(); |
| |
| // Verify UKM records -1 in this case. |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| const ukm::mojom::UkmEntry* entry = merged_entries.begin()->second.get(); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| entry, PageLoad::kDurationSinceLastVisitSecondsName, -1); |
| } |
| |
| class TestOfflinePreviewsUkmPageLoadMetricsObserver |
| : public UkmPageLoadMetricsObserver { |
| public: |
| explicit TestOfflinePreviewsUkmPageLoadMetricsObserver( |
| MockNetworkQualityProvider* network_quality_provider) |
| : UkmPageLoadMetricsObserver(network_quality_provider) {} |
| |
| ~TestOfflinePreviewsUkmPageLoadMetricsObserver() override = default; |
| |
| bool IsOfflinePreview(content::WebContents* web_contents) const override { |
| return true; |
| } |
| }; |
| |
| class OfflinePreviewsUKMPageLoadMetricsObserverTest |
| : public UkmPageLoadMetricsObserverTest { |
| public: |
| OfflinePreviewsUKMPageLoadMetricsObserverTest() = default; |
| ~OfflinePreviewsUKMPageLoadMetricsObserverTest() override = default; |
| |
| void RegisterObservers(page_load_metrics::PageLoadTracker* tracker) override { |
| tracker->AddObserver( |
| std::make_unique<TestOfflinePreviewsUkmPageLoadMetricsObserver>( |
| &mock_network_quality_provider())); |
| } |
| }; |
| |
| TEST_F(OfflinePreviewsUKMPageLoadMetricsObserverTest, OfflinePreviewReported) { |
| auto navigation = content::NavigationSimulator::CreateBrowserInitiated( |
| GURL(kTestUrl1), web_contents()); |
| navigation->SetContentsMimeType("multipart/related"); |
| navigation->Commit(); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), |
| GURL(kTestUrl1)); |
| tester()->test_ukm_recorder().ExpectEntryMetric( |
| kv.second.get(), PageLoad::kNavigation_PageEndReason3Name, |
| page_load_metrics::END_CLOSE); |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, NavigationTiming) { |
| GURL url(kTestUrl1); |
| NavigateAndCommit(url); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| using ukm::builders::NavigationTiming; |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| tester()->test_ukm_recorder().GetMergedEntriesByName( |
| NavigationTiming::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| const std::vector<const char*> metrics = { |
| NavigationTiming::kFirstRequestStartName, |
| NavigationTiming::kFirstResponseStartName, |
| NavigationTiming::kFirstLoaderCallbackName, |
| NavigationTiming::kFinalRequestStartName, |
| NavigationTiming::kFinalResponseStartName, |
| NavigationTiming::kFinalLoaderCallbackName, |
| NavigationTiming::kNavigationCommitSentName}; |
| |
| for (const auto& kv : merged_entries) { |
| tester()->test_ukm_recorder().ExpectEntrySourceHasUrl(kv.second.get(), url); |
| |
| // Verify if the elapsed times from the navigation start are recorded. |
| for (const char* metric : metrics) { |
| EXPECT_TRUE(tester()->test_ukm_recorder().EntryHasMetric(kv.second.get(), |
| metric)); |
| } |
| } |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, CLSNeverForegroundedNoReport) { |
| web_contents()->WasHidden(); |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data(1.0, 1.0, 0, 0, 0, |
| 0, {}); |
| tester()->SimulateRenderDataUpdate(render_data); |
| |
| // Simulate closing the tab. |
| DeleteContents(); |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| EXPECT_FALSE(ukm_recorder.EntryHasMetric( |
| ukm_entry, PageLoad::kLayoutInstability_CumulativeShiftScoreName)); |
| } |
| } |
| |
| class CLSUkmPageLoadMetricsObserverTest |
| : public UkmPageLoadMetricsObserverTest { |
| protected: |
| void RunBeforeInputOrScrollCase(bool input_in_subframe); |
| void SimulateShiftDelta(float delta, content::RenderFrameHost* frame); |
| RenderFrameHost* NavigateSubframe(); |
| void VerifyUKMBuckets(int total, int before_input_or_scroll); |
| void InitPageLoadTimingWithInputOrScroll( |
| page_load_metrics::mojom::PageLoadTiming& timing, |
| base::TimeDelta timestamp); |
| }; |
| |
| void CLSUkmPageLoadMetricsObserverTest::SimulateShiftDelta( |
| float delta, |
| content::RenderFrameHost* frame) { |
| page_load_metrics::mojom::FrameRenderDataUpdate render_data(delta, delta, 0, |
| 0, 0, 0, {}); |
| tester()->SimulateRenderDataUpdate(render_data, frame); |
| } |
| |
| RenderFrameHost* CLSUkmPageLoadMetricsObserverTest::NavigateSubframe() { |
| return NavigationSimulator::NavigateAndCommitFromDocument( |
| GURL(kSubframeTestUrl), |
| RenderFrameHostTester::For(web_contents()->GetMainFrame()) |
| ->AppendChild("subframe")); |
| } |
| |
| void CLSUkmPageLoadMetricsObserverTest::VerifyUKMBuckets( |
| int total, |
| int before_input_or_scroll) { |
| const char* total_name = |
| PageLoad::kLayoutInstability_CumulativeShiftScoreName; |
| const char* before_input_or_scroll_name = |
| PageLoad::kLayoutInstability_CumulativeShiftScore_BeforeInputOrScrollName; |
| |
| const auto& ukm_recorder = tester()->test_ukm_recorder(); |
| std::map<ukm::SourceId, ukm::mojom::UkmEntryPtr> merged_entries = |
| ukm_recorder.GetMergedEntriesByName(PageLoad::kEntryName); |
| EXPECT_EQ(1ul, merged_entries.size()); |
| |
| for (const auto& kv : merged_entries) { |
| const ukm::mojom::UkmEntry* ukm_entry = kv.second.get(); |
| ukm_recorder.ExpectEntrySourceHasUrl(ukm_entry, GURL(kTestUrl1)); |
| |
| ukm_recorder.ExpectEntryMetric(ukm_entry, total_name, total); |
| ukm_recorder.ExpectEntryMetric(ukm_entry, before_input_or_scroll_name, |
| before_input_or_scroll); |
| } |
| } |
| |
| void CLSUkmPageLoadMetricsObserverTest::InitPageLoadTimingWithInputOrScroll( |
| page_load_metrics::mojom::PageLoadTiming& timing, |
| base::TimeDelta timestamp) { |
| page_load_metrics::InitPageLoadTimingForTest(&timing); |
| PopulateRequiredTimingFields(&timing); |
| timing.paint_timing->first_input_or_scroll_notified_timestamp = timestamp; |
| } |
| |
| void CLSUkmPageLoadMetricsObserverTest::RunBeforeInputOrScrollCase( |
| bool input_in_subframe) { |
| NavigateAndCommit(GURL(kTestUrl1)); |
| |
| RenderFrameHost* main_frame = web_contents()->GetMainFrame(); |
| RenderFrameHost* subframe = NavigateSubframe(); |
| |
| SimulateShiftDelta(1.0, main_frame); |
| SimulateShiftDelta(1.5, subframe); |
| |
| // Simulate input. |
| page_load_metrics::mojom::PageLoadTiming timing; |
| InitPageLoadTimingWithInputOrScroll(timing, base::Seconds(1)); |
| tester()->SimulateTimingUpdate(timing, |
| input_in_subframe ? subframe : main_frame); |
| |
| SimulateShiftDelta(1.2, main_frame); |
| SimulateShiftDelta(0.8, subframe); |
| |
| DeleteContents(); |
| |
| // Total CLS: 1.0 + 1.5 + 1.2 + 0.8 = 4.5 (bucket 450). |
| // Before input: 1.0 + 1.5 = 2.5 (bucket 250). |
| VerifyUKMBuckets(450, 250); |
| } |
| |
| TEST_F(CLSUkmPageLoadMetricsObserverTest, BeforeInputOrScroll_Main) { |
| RunBeforeInputOrScrollCase(false); |
| } |
| |
| TEST_F(CLSUkmPageLoadMetricsObserverTest, BeforeInputOrScroll_Sub) { |
| RunBeforeInputOrScrollCase(true); |
| } |
| |
| void TestViewportInitialScale(int expected, int input) { |
| blink::MobileFriendliness mf; |
| mf.viewport_initial_scale_x10 = input; |
| EXPECT_EQ(expected, page_load_metrics::GetBucketedViewportInitialScale(mf)); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, BucketingViewportInitialScale) { |
| // Default value to be ignored. |
| TestViewportInitialScale(-1, -1); |
| |
| // Typical case initail-scale=1.0. |
| TestViewportInitialScale(10, 10); |
| |
| // Bigger number cases. |
| TestViewportInitialScale(12, 12); |
| TestViewportInitialScale(14, 15); |
| TestViewportInitialScale(14, 15); |
| TestViewportInitialScale(14, 17); |
| TestViewportInitialScale(18, 18); |
| TestViewportInitialScale(18, 25); |
| TestViewportInitialScale(26, 26); |
| |
| // Smaller number cases. |
| TestViewportInitialScale(10, 9); |
| TestViewportInitialScale(8, 8); |
| TestViewportInitialScale(8, 7); |
| TestViewportInitialScale(6, 6); |
| TestViewportInitialScale(6, 3); |
| TestViewportInitialScale(2, 1); |
| TestViewportInitialScale(2, 0); |
| } |
| |
| void TestViewportHardcodedWidth(int expected, int input) { |
| blink::MobileFriendliness mf; |
| mf.viewport_hardcoded_width = input; |
| EXPECT_EQ(expected, page_load_metrics::GetBucketedViewportHardcodedWidth(mf)); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, BucketingViewportHardcodedWidth) { |
| // Default value to be ignored. |
| TestViewportHardcodedWidth(-1, -1); |
| |
| // Middle case. |
| TestViewportHardcodedWidth(500, 500); |
| |
| // Bigger number cases. |
| TestViewportHardcodedWidth(500, 509); |
| |
| TestViewportHardcodedWidth(510, 510); |
| TestViewportHardcodedWidth(510, 519); |
| TestViewportHardcodedWidth(520, 520); |
| TestViewportHardcodedWidth(520, 539); |
| TestViewportHardcodedWidth(540, 540); |
| TestViewportHardcodedWidth(540, 579); |
| TestViewportHardcodedWidth(580, 580); |
| TestViewportHardcodedWidth(580, 640); |
| TestViewportHardcodedWidth(820, 1000); |
| TestViewportHardcodedWidth(1780, 2000); |
| |
| // Smaller number cases. |
| TestViewportHardcodedWidth(500, 491); |
| TestViewportHardcodedWidth(490, 490); |
| TestViewportHardcodedWidth(480, 480); |
| TestViewportHardcodedWidth(460, 421); |
| TestViewportHardcodedWidth(180, 180); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| TestLogsBrowserInitiatedNavigationAsUserInitiated) { |
| // Simulate a browser initiated navigation, which is always considered |
| // user initiated. |
| auto& test_ukm_recorder = tester()->test_ukm_recorder(); |
| tester()->NavigateWithPageTransitionAndCommit( |
| GURL(kTestUrl1), ui::PageTransition::PAGE_TRANSITION_TYPED); |
| tester()->NavigateToUntrackedUrl(); |
| |
| auto result_metrics = test_ukm_recorder.FilteredHumanReadableMetricForEntry( |
| PageLoad::kEntryName, |
| PageLoad::kExperimental_Navigation_UserInitiatedName); |
| EXPECT_EQ(1U, result_metrics.size()); |
| EXPECT_EQ(PageLoad::kExperimental_Navigation_UserInitiatedName, |
| result_metrics[0].begin()->first); |
| EXPECT_TRUE(result_metrics[0].begin()->second); |
| // Check the UserPerceivedPageVisit version of the metrics as well. |
| result_metrics = test_ukm_recorder.FilteredHumanReadableMetricForEntry( |
| UserPerceivedPageVisit::kEntryName, |
| UserPerceivedPageVisit::kUserInitiatedName); |
| EXPECT_EQ(1U, result_metrics.size()); |
| EXPECT_EQ(UserPerceivedPageVisit::kUserInitiatedName, |
| result_metrics[0].begin()->first); |
| EXPECT_TRUE(result_metrics[0].begin()->second); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| TestLogsUserInitiatedRendererNavigationAsUserInitiated) { |
| auto& test_ukm_recorder = tester()->test_ukm_recorder(); |
| // Simulate a renderer initiated navigation. The associated navigation input |
| // start time means this will also be considered user initiated. |
| std::unique_ptr<content::NavigationSimulator> navigation = |
| content::NavigationSimulator::CreateRendererInitiated(GURL(kTestUrl1), |
| main_rfh()); |
| navigation->SetNavigationInputStart(base::TimeTicks::Now()); |
| navigation->Commit(); |
| tester()->NavigateToUntrackedUrl(); |
| auto result_metrics = test_ukm_recorder.FilteredHumanReadableMetricForEntry( |
| PageLoad::kEntryName, |
| PageLoad::kExperimental_Navigation_UserInitiatedName); |
| EXPECT_EQ(1U, result_metrics.size()); |
| EXPECT_EQ(PageLoad::kExperimental_Navigation_UserInitiatedName, |
| result_metrics[0].begin()->first); |
| EXPECT_TRUE(result_metrics[0].begin()->second); |
| |
| result_metrics = test_ukm_recorder.FilteredHumanReadableMetricForEntry( |
| UserPerceivedPageVisit::kEntryName, |
| UserPerceivedPageVisit::kUserInitiatedName); |
| EXPECT_EQ(1U, result_metrics.size()); |
| EXPECT_EQ(UserPerceivedPageVisit::kUserInitiatedName, |
| result_metrics[0].begin()->first); |
| EXPECT_TRUE(result_metrics[0].begin()->second); |
| } |
| |
| TEST_F(UkmPageLoadMetricsObserverTest, |
| TestLogsRendererInitiatedRendererNavigationAsUserInitiated) { |
| auto& test_ukm_recorder = tester()->test_ukm_recorder(); |
| // Simulate a renderer initiated navigation without an associated |
| // navigation input start time. This will be considered not user |
| // initiated. |
| std::unique_ptr<content::NavigationSimulator> navigation = |
| content::NavigationSimulator::CreateRendererInitiated(GURL(kTestUrl1), |
| main_rfh()); |
| navigation->Commit(); |
| tester()->NavigateToUntrackedUrl(); |
| auto result_metrics = test_ukm_recorder.FilteredHumanReadableMetricForEntry( |
| PageLoad::kEntryName, |
| PageLoad::kExperimental_Navigation_UserInitiatedName); |
| EXPECT_EQ(1U, result_metrics.size()); |
| EXPECT_EQ(PageLoad::kExperimental_Navigation_UserInitiatedName, |
| result_metrics[0].begin()->first); |
| EXPECT_FALSE(result_metrics[0].begin()->second); |
| |
| result_metrics = test_ukm_recorder.FilteredHumanReadableMetricForEntry( |
| UserPerceivedPageVisit::kEntryName, |
| UserPerceivedPageVisit::kUserInitiatedName); |
| EXPECT_EQ(1U, result_metrics.size()); |
| EXPECT_EQ(UserPerceivedPageVisit::kUserInitiatedName, |
| result_metrics[0].begin()->first); |
| EXPECT_FALSE(result_metrics[0].begin()->second); |
| } |
