[Tab Metrics] Measure FP, FCP and FMP for Foreground Tab during Session Restore

chrome/browser/page_load_metrics/observers/session_restore_foreground_tab_page_load_metrics_observer_unittest.cc

Index: chrome/browser/page_load_metrics/observers/session_restore_foreground_tab_page_load_metrics_observer_unittest.cc
diff --git a/chrome/browser/page_load_metrics/observers/session_restore_foreground_tab_page_load_metrics_observer_unittest.cc b/chrome/browser/page_load_metrics/observers/session_restore_foreground_tab_page_load_metrics_observer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e8f865a5a6cbde6f06aac765890484713fa1d70c
--- /dev/null
+++ b/chrome/browser/page_load_metrics/observers/session_restore_foreground_tab_page_load_metrics_observer_unittest.cc
@@ -0,0 +1,230 @@
+// 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/session_restore_foreground_tab_page_load_metrics_observer.h"
+
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/page_load_metrics/observers/page_load_metrics_observer_test_harness.h"
+#include "chrome/browser/sessions/tab_loader.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/browser/ui/tabs/test_tab_strip_model_delegate.h"
+#include "chrome/test/base/testing_profile.h"
+
+#include "content/public/test/web_contents_tester.h"
+
+using RestoredTab = SessionRestoreDelegate::RestoredTab;
+
+namespace {
+
+const char kDefaultTestUrl[] = "https://google.com";
+const char kDefaultTestUrl2[] = "https://example.com";
+
+}  // namespace
+
+class SessionRestoreForegroundTabPageLoadMetricsObserverTest
+    : public page_load_metrics::PageLoadMetricsObserverTestHarness {
+ protected:
+  void RegisterObservers(page_load_metrics::PageLoadTracker* tracker) override {
+    std::unique_ptr<SessionRestoreForegroundTabPageLoadMetricsObserver>
+        observer = SessionRestoreForegroundTabPageLoadMetricsObserver::
+            CreateIfNeeded();
+    if (observer)
+      tracker->AddObserver(std::move(observer));
+  }
+
+  void SetUp() override {
+    page_load_metrics::PageLoadMetricsObserverTestHarness::SetUp();
+
+    // Stop the initial loading.
+    StopLoading(web_contents());
+
+    // Create the tab manager to register its SessionRestoreObserver before
+    // session restore starts.
+    g_browser_process->GetTabManager();
+
+    restored_tabs_.emplace_back(web_contents(), false, false, false);
+    PopulateAllFirstPaintTimings(&timing_);
+  }
+
+  void TearDown() override {
+    page_load_metrics::PageLoadMetricsObserverTestHarness::TearDown();
+    restored_tabs_.clear();
+  }
+
+  // Populate first paint and first [contentful,meaningful] paint timings.
+  void PopulateAllFirstPaintTimings(
+      page_load_metrics::mojom::PageLoadTiming* timing_) {
+    page_load_metrics::InitPageLoadTimingForTest(timing_);
+    timing_->navigation_start = base::Time::FromDoubleT(1);
+    timing_->paint_timing->first_meaningful_paint =
+        base::TimeDelta::FromMilliseconds(10);
+    PopulateRequiredTimingFields(timing_);
+  }
+
+  void ExpectFirstPaintMetricsTotalCount(int expected_total_count) {
+    histogram_tester().ExpectTotalCount(
+        internal::kHistogramSessionRestoreForegroundTabFirstPaint,
+        expected_total_count);
+    histogram_tester().ExpectTotalCount(
+        internal::kHistogramSessionRestoreForegroundTabFirstContentfulPaint,
+        expected_total_count);
+    histogram_tester().ExpectTotalCount(
+        internal::kHistogramSessionRestoreForegroundTabFirstMeaningfulPaint,
+        expected_total_count);
+  }
+
+  void RestoreTabs() {
+    TabLoader::RestoreTabs(restored_tabs_, base::TimeTicks());
+  }
+
+  void SimulateTimingUpdate() {
+    PageLoadMetricsObserverTestHarness::SimulateTimingUpdate(timing_);
+  }
+
+  void StopLoading(content::WebContents* contents) {
+    content::WebContentsTester::For(contents)->TestSetIsLoading(false);
+  }
+
+ private:
+  page_load_metrics::mojom::PageLoadTiming timing_;
+  std::vector<RestoredTab> restored_tabs_;
+};
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest, NoMetrics) {
+  ExpectFirstPaintMetricsTotalCount(0);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       FirstPaintsOutOfSessionRestore) {
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  SimulateTimingUpdate();
+
+  ExpectFirstPaintMetricsTotalCount(0);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       InitialForegroundTabChanged) {
+  TestTabStripModelDelegate tab_strip_delegate;
+  TabStripModel tab_strip(&tab_strip_delegate, profile());
+  tab_strip.AddObserver(g_browser_process->GetTabManager());
+
+  std::unique_ptr<content::WebContents> test_contents(CreateTestWebContents());
+  std::vector<RestoredTab> restored_tabs{
+      RestoredTab(test_contents.get(), false, false, false),
+      RestoredTab(web_contents(), false, false, false)};
+
+  // Tab strip with 2 tabs: tab 0 is foreground, tab 1 is background.
+  tab_strip.AppendWebContents(restored_tabs[0].contents(), true);
+  tab_strip.AppendWebContents(restored_tabs[1].contents(), false);
+
+  // Start loading tab 0 but do not finish loading it.
+  TabLoader::RestoreTabs(restored_tabs, base::TimeTicks());
+  content::WebContentsTester::For(restored_tabs[0].contents())
+      ->NavigateAndCommit(GURL(kDefaultTestUrl));
+
+  // Switch to tab 1 and load it completely.
+  tab_strip.ActivateTabAt(1, true);
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  SimulateTimingUpdate();
+
+  // No paint timings recorded because the initial foreground tab was changed.
+  ExpectFirstPaintMetricsTotalCount(0);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       ForegroundTabLoadedInSessionRestore) {
+  // Restore one tab which finishes loading in foreground.
+  RestoreTabs();
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  SimulateTimingUpdate();
+
+  ExpectFirstPaintMetricsTotalCount(1);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       BackgroundTabLoadedInSessionRestore) {
+  // Set the tab to background before the PageLoadMetricsObserver was created.
+  web_contents()->WasHidden();
+
+  // Load the restored tab in background.
+  RestoreTabs();
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  SimulateTimingUpdate();
+
+  // No paint timings recorded because the loaded tab was in background.
+  ExpectFirstPaintMetricsTotalCount(0);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       TabIsHiddenBeforeFirstPaints) {
+  // Hide the tab after it starts loading but before it finishes loading.
+  RestoreTabs();
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  web_contents()->WasHidden();
+  SimulateTimingUpdate();
+
+  // No paint timings recorded because tab was hidden before the first paints.
+  ExpectFirstPaintMetricsTotalCount(0);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       MultipleSessionRestoresWithoutInitialForegroundTabChange) {
+  // First session restore.
+  RestoreTabs();
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  SimulateTimingUpdate();
+  StopLoading(web_contents());
+
+  // Second session restore.
+  RestoreTabs();
+  NavigateAndCommit(GURL(kDefaultTestUrl2));
+  SimulateTimingUpdate();
+
+  ExpectFirstPaintMetricsTotalCount(2);
+}
+
+TEST_F(SessionRestoreForegroundTabPageLoadMetricsObserverTest,
+       MultipleSessionRestoresWithtInitialForegroundTabChange) {
+  TestTabStripModelDelegate tab_strip_delegate;
+  TabStripModel tab_strip(&tab_strip_delegate, profile());
+  tab_strip.AddObserver(g_browser_process->GetTabManager());
+
+  std::unique_ptr<content::WebContents> test_contents(CreateTestWebContents());
+  std::vector<RestoredTab> restored_tabs{
+      RestoredTab(test_contents.get(), false, false, false),
+      RestoredTab(web_contents(), false, false, false)};
+
+  // Tab strip with 2 tabs: tab 0 is foreground, tab 1 is background.
+  tab_strip.AppendWebContents(restored_tabs[0].contents(), true);
+  tab_strip.AppendWebContents(restored_tabs[1].contents(), false);
+
+  // First session restore.
+  TabLoader::RestoreTabs(restored_tabs, base::TimeTicks());
+
+  // Start and stop loading foreground tab 0 without first paints.
+  content::WebContentsTester::For(restored_tabs[0].contents())
+      ->NavigateAndCommit(GURL(kDefaultTestUrl));
+  StopLoading(test_contents.get());
+
+  // Switch to tab 1 to change the initial foreground tab.
+  tab_strip.ActivateTabAt(1, true);
+
+  // Load the foreground tab with first paints.
+  NavigateAndCommit(GURL(kDefaultTestUrl));
+  SimulateTimingUpdate();
+  StopLoading(web_contents());
+
+  // No paint timings recorded because the initial foreground tab was changed.
+  ExpectFirstPaintMetricsTotalCount(0);
+
+  // Second session restore.
+  TabLoader::RestoreTabs(restored_tabs, base::TimeTicks());
+
+  // Load the foreground tab with first paints.
+  NavigateAndCommit(GURL(kDefaultTestUrl2));
+  SimulateTimingUpdate();
+  StopLoading(web_contents());
+
+  ExpectFirstPaintMetricsTotalCount(1);
+}