Adds an OptimizationGuidePageLoadMetricsObserver.

This change creates an OptimizationGuidePageLoadMetricsObserver to
provide pageload metric data to the Optimization Guide. Initially,
only the navigation timing, FCP, is captured. The metrics
from this observer will be provided to the Slow Page Prediction Model.

The next change will pass the metrics to the
OptimizationGuideKeyedService and eventually to the
OptimizationGuidePredictionManager for updating the features used to
evaluate the Slow Page Prediction model.

Bug: 1001194
Change-Id: Ibbde9150781a209f6c52d287ec98abc9b0540636
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1746593
Commit-Queue: Michael Crouse <mcrouse@chromium.org>
Auto-Submit: Michael Crouse <mcrouse@chromium.org>
Reviewed-by: Tarun Bansal <tbansal@chromium.org>
Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Reviewed-by: Sophie Chang <sophiechang@chromium.org>
Cr-Commit-Position: refs/heads/master@{#696610}

chrome/browser/BUILD.gn

@@ -956,6 +956,8 @@ jumbo_split_static_library("browser") {
     "optimization_guide/optimization_guide_keyed_service_factory.h",
     "optimization_guide/optimization_guide_navigation_data.cc",
     "optimization_guide/optimization_guide_navigation_data.h",
+    "optimization_guide/optimization_guide_session_statistic.cc",
+    "optimization_guide/optimization_guide_session_statistic.h",
     "optimization_guide/optimization_guide_web_contents_observer.cc",
     "optimization_guide/optimization_guide_web_contents_observer.h",
     "page_load_metrics/metrics_navigation_throttle.cc",
@@ -1012,6 +1014,8 @@ jumbo_split_static_library("browser") {
     "page_load_metrics/observers/offline_page_previews_page_load_metrics_observer.h",
     "page_load_metrics/observers/omnibox_suggestion_used_page_load_metrics_observer.cc",
     "page_load_metrics/observers/omnibox_suggestion_used_page_load_metrics_observer.h",
+    "page_load_metrics/observers/optimization_guide_page_load_metrics_observer.cc",
+    "page_load_metrics/observers/optimization_guide_page_load_metrics_observer.h",
     "page_load_metrics/observers/previews_lite_page_redirect_metrics_observer.cc",
     "page_load_metrics/observers/previews_lite_page_redirect_metrics_observer.h",
     "page_load_metrics/observers/previews_page_load_metrics_observer.cc",

chrome/browser/optimization_guide/optimization_guide_keyed_service.cc

@@ -9,6 +9,7 @@
 #include "chrome/browser/data_saver/data_saver_top_host_provider.h"
 #include "chrome/browser/optimization_guide/optimization_guide_hints_manager.h"
 #include "chrome/browser/optimization_guide/optimization_guide_navigation_data.h"
+#include "chrome/browser/optimization_guide/optimization_guide_session_statistic.h"
 #include "chrome/browser/optimization_guide/optimization_guide_web_contents_observer.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/leveldb_proto/public/proto_database_provider.h"
@@ -187,3 +188,12 @@ void OptimizationGuideKeyedService::Shutdown() {
     hints_manager_ = nullptr;
   }
 }
+
+void OptimizationGuideKeyedService::UpdateSessionFCP(base::TimeDelta fcp) {
+  // TODO(crbug/1001194): This will be passed to the
+  // OptimizationGuidePredictionManager that will own the FCP session
+  // statistics.
+  if (!session_fcp_)
+    session_fcp_ = std::make_unique<OptimizationGuideSessionStatistic>();
+  session_fcp_->AddSample(static_cast<float>(fcp.InMilliseconds()));
+}

chrome/browser/optimization_guide/optimization_guide_keyed_service.h

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "base/macros.h"
+#include "base/time/time.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/optimization_guide/optimization_guide_decider.h"
 #include "components/optimization_guide/proto/hints.pb.h"
@@ -33,6 +34,7 @@ class TopHostProvider;
 }  // namespace optimization_guide
 
 class OptimizationGuideHintsManager;
+class OptimizationGuideSessionStatistic;
 
 class OptimizationGuideKeyedService
     : public KeyedService,
@@ -78,12 +80,22 @@ class OptimizationGuideKeyedService
   // KeyedService implementation:
   void Shutdown() override;
 
+  // Update |session_fcp_| with the provided fcp value.
+  void UpdateSessionFCP(base::TimeDelta fcp);
+
+  OptimizationGuideSessionStatistic* GetSessionFCPForTesting() const {
+    return session_fcp_.get();
+  }
+
  private:
   content::BrowserContext* browser_context_;
 
   // Manages the storing, loading, and fetching of hints.
   std::unique_ptr<OptimizationGuideHintsManager> hints_manager_;
 
+  // The current session's FCP statistics for HTTP/HTTPS navigations.
+  std::unique_ptr<OptimizationGuideSessionStatistic> session_fcp_;
+
   // The top host provider to use for fetching information for the user's top
   // hosts. Will be null if the user has not consented to this type of browser
   // behavior.

chrome/browser/optimization_guide/optimization_guide_prediction_manager_browsertest.cc

+// Copyright 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/base64.h"
+#include "base/test/scoped_feature_list.h"
+#include "build/build_config.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/optimization_guide/optimization_guide_keyed_service.h"
+#include "chrome/browser/optimization_guide/optimization_guide_keyed_service_factory.h"
+#include "chrome/browser/optimization_guide/optimization_guide_session_statistic.h"
+#include "chrome/browser/page_load_metrics/page_load_metrics_test_waiter.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "components/optimization_guide/optimization_guide_features.h"
+#include "content/public/test/browser_test_utils.h"
+#include "net/test/embedded_test_server/http_request.h"
+#include "net/test/embedded_test_server/http_response.h"
+
+class OptimizationGuidePredictionManagerBrowserTest
+    : public InProcessBrowserTest {
+ public:
+  OptimizationGuidePredictionManagerBrowserTest() = default;
+  ~OptimizationGuidePredictionManagerBrowserTest() override = default;
+
+  void SetUp() override {
+    scoped_feature_list_.InitWithFeatures(
+        {optimization_guide::features::kOptimizationHints,
+         optimization_guide::features::kOptimizationGuideKeyedService},
+        {});
+    InProcessBrowserTest::SetUp();
+  }
+
+  void SetUpOnMainThread() override {
+    https_server_.reset(
+        new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+    https_server_->ServeFilesFromSourceDirectory(GetChromeTestDataDir());
+    ASSERT_TRUE(https_server_->Start());
+    https_url_with_content_ = https_server_->GetURL("/english_page.html");
+    https_url_without_content_ = https_server_->GetURL("/empty.html");
+  }
+
+  void TearDownOnMainThread() override {
+    EXPECT_TRUE(https_server_->ShutdownAndWaitUntilComplete());
+    InProcessBrowserTest::TearDownOnMainThread();
+  }
+
+  void RegisterWithKeyedService() {
+    OptimizationGuideKeyedServiceFactory::GetForProfile(browser()->profile())
+        ->RegisterOptimizationTypes({optimization_guide::proto::NOSCRIPT});
+  }
+
+  std::unique_ptr<page_load_metrics::PageLoadMetricsTestWaiter>
+  CreatePageLoadMetricsTestWaiter() {
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    return std::make_unique<page_load_metrics::PageLoadMetricsTestWaiter>(
+        web_contents);
+  }
+
+  GURL https_url_with_content() { return https_url_with_content_; }
+  GURL https_url_without_content() { return https_url_without_content_; }
+
+ private:
+  GURL https_url_with_content_, https_url_without_content_;
+  std::unique_ptr<net::EmbeddedTestServer> https_server_;
+  base::test::ScopedFeatureList scoped_feature_list_;
+
+  DISALLOW_COPY_AND_ASSIGN(OptimizationGuidePredictionManagerBrowserTest);
+};
+
+IN_PROC_BROWSER_TEST_F(OptimizationGuidePredictionManagerBrowserTest,
+                       FCPReachedSessionStatisticsUpdated) {
+  OptimizationGuideKeyedService* keyed_service =
+      OptimizationGuideKeyedServiceFactory::GetForProfile(browser()->profile());
+
+  RegisterWithKeyedService();
+  auto waiter = CreatePageLoadMetricsTestWaiter();
+  waiter->AddPageExpectation(
+      page_load_metrics::PageLoadMetricsTestWaiter::TimingField::kFirstPaint);
+  ui_test_utils::NavigateToURL(browser(), https_url_with_content());
+  waiter->Wait();
+
+  OptimizationGuideSessionStatistic* session_fcp =
+      keyed_service->GetSessionFCPForTesting();
+  EXPECT_TRUE(session_fcp);
+  EXPECT_EQ(1u, session_fcp->GetNumberOfSamples());
+}
+
+IN_PROC_BROWSER_TEST_F(OptimizationGuidePredictionManagerBrowserTest,
+                       NoFCPSessionStatisticsUnchanged) {
+  OptimizationGuideKeyedService* keyed_service =
+      OptimizationGuideKeyedServiceFactory::GetForProfile(browser()->profile());
+
+  RegisterWithKeyedService();
+  auto waiter = CreatePageLoadMetricsTestWaiter();
+  waiter->AddPageExpectation(
+      page_load_metrics::PageLoadMetricsTestWaiter::TimingField::kFirstPaint);
+  ui_test_utils::NavigateToURL(browser(), https_url_with_content());
+  waiter->Wait();
+
+  OptimizationGuideSessionStatistic* session_fcp =
+      keyed_service->GetSessionFCPForTesting();
+  float current_mean = session_fcp->GetMean();
+
+  waiter = CreatePageLoadMetricsTestWaiter();
+  waiter->AddPageExpectation(
+      page_load_metrics::PageLoadMetricsTestWaiter::TimingField::kFirstLayout);
+  ui_test_utils::NavigateToURL(browser(), https_url_without_content());
+  waiter->Wait();
+  EXPECT_EQ(1u, session_fcp->GetNumberOfSamples());
+  EXPECT_EQ(current_mean, session_fcp->GetMean());
+}

chrome/browser/optimization_guide/optimization_guide_session_statistic.cc

+// Copyright 2019 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/optimization_guide/optimization_guide_session_statistic.h"
+
+#include <cmath>
+
+OptimizationGuideSessionStatistic::OptimizationGuideSessionStatistic()
+    : num_samples_(0u), mean_(0.0), variance_sum_(0.0) {}
+
+OptimizationGuideSessionStatistic::~OptimizationGuideSessionStatistic() =
+    default;
+
+void OptimizationGuideSessionStatistic::AddSample(float sample) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  num_samples_++;
+  float new_mean = mean_ + (sample - mean_) / static_cast<float>(num_samples_);
+  variance_sum_ += (sample - mean_) * (sample - new_mean);
+  mean_ = new_mean;
+}
+
+float OptimizationGuideSessionStatistic::GetMean() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return mean_;
+}
+
+float OptimizationGuideSessionStatistic::GetVariance() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return num_samples_ > 1 ? variance_sum_ / static_cast<float>(num_samples_ - 1)
+                          : 0.0;
+}
+
+float OptimizationGuideSessionStatistic::GetStdDev() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return num_samples_ > 1 ? std::sqrt(GetVariance()) : 0.0;
+}
+
+size_t OptimizationGuideSessionStatistic::GetNumberOfSamples() const {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  return num_samples_;
+}

chrome/browser/optimization_guide/optimization_guide_session_statistic.h

+// Copyright 2019 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.
+
+#ifndef CHROME_BROWSER_OPTIMIZATION_GUIDE_OPTIMIZATION_GUIDE_SESSION_STATISTIC_H_
+#define CHROME_BROWSER_OPTIMIZATION_GUIDE_OPTIMIZATION_GUIDE_SESSION_STATISTIC_H_
+
+#include "base/sequence_checker.h"
+#include "base/values.h"
+
+// OptimizationGuideSessionStatistic calculates running statistics, mean and
+// variance, for real valued inputs one sample at a time.
+class OptimizationGuideSessionStatistic {
+ public:
+  OptimizationGuideSessionStatistic();
+  ~OptimizationGuideSessionStatistic();
+
+  // Update the statistics using the provided |sample|.
+  void AddSample(float sample);
+
+  // Return the current mean for the samples collected.
+  float GetMean() const;
+
+  // Return the current variance for the samples collected if the number of
+  // samples is at least 2, otherwise return 0.
+  float GetVariance() const;
+
+  // Return the current standard deviation for the samples collected if the
+  // number of samples is at least 2, otherwise return 0.
+  float GetStdDev() const;
+
+  // Return the number of samples that |this| has calculated statistics for.
+  size_t GetNumberOfSamples() const;
+
+ private:
+  size_t num_samples_;
+  float mean_;
+  // This holds the sum of the squared differences of the current sample with
+  // current sample mean. This is not the actual variance, that is provided
+  // through GetVariance().
+  float variance_sum_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
+  DISALLOW_COPY_AND_ASSIGN(OptimizationGuideSessionStatistic);
+};
+
+#endif  // CHROME_BROWSER_OPTIMIZATION_GUIDE_OPTIMIZATION_GUIDE_SESSION_STATISTIC_H_

chrome/browser/optimization_guide/optimization_guide_session_statistic_unittest.cc

+// Copyright 2019 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/optimization_guide/optimization_guide_session_statistic.h"
+
+#include <cmath>
+#include "testing/gtest/include/gtest/gtest.h"
+
+TEST(OptimzationGuideSessionStatisticTest,
+     CalculateSessionStatisticsForSamples) {
+  OptimizationGuideSessionStatistic stat;
+
+  stat.AddSample(100.0);
+  EXPECT_EQ(1u, stat.GetNumberOfSamples());
+  EXPECT_EQ(100.0, stat.GetMean());
+  EXPECT_EQ(0.0, stat.GetVariance());
+  EXPECT_EQ(0.0, stat.GetStdDev());
+
+  stat.AddSample(200.0);
+  EXPECT_EQ(2u, stat.GetNumberOfSamples());
+  EXPECT_EQ(150.0, stat.GetMean());
+  EXPECT_EQ(5000.0, stat.GetVariance());
+
+  stat.AddSample(150.0);
+  EXPECT_EQ(3u, stat.GetNumberOfSamples());
+  EXPECT_EQ(150.0, stat.GetMean());
+  EXPECT_EQ(2500.0, stat.GetVariance());
+  EXPECT_EQ(std::sqrt(2500.0), stat.GetStdDev());
+}
+
+TEST(OptimzationGuideSessionStatisticTest, VarianceWitthLessThanTwoSamples) {
+  OptimizationGuideSessionStatistic stat;
+
+  EXPECT_EQ(0u, stat.GetNumberOfSamples());
+  EXPECT_EQ(0.0, stat.GetVariance());
+  EXPECT_EQ(0.0, stat.GetStdDev());
+
+  stat.AddSample(10.);
+  EXPECT_EQ(1u, stat.GetNumberOfSamples());
+  EXPECT_EQ(0.0, stat.GetVariance());
+  EXPECT_EQ(0.0, stat.GetStdDev());
+}

chrome/browser/optimization_guide/optimization_guide_web_contents_observer.cc

@@ -136,4 +136,14 @@ void OptimizationGuideWebContentsObserver::
   inflight_optimization_guide_navigation_datas_.erase(navigation_id);
 }
 
+void OptimizationGuideWebContentsObserver::UpdateSessionTimingStatistics(
+    const page_load_metrics::mojom::PageLoadTiming& timing) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  if (!optimization_guide_keyed_service_)
+    return;
+
+  optimization_guide_keyed_service_->UpdateSessionFCP(
+      timing.paint_timing->first_contentful_paint.value());
+}
+
 WEB_CONTENTS_USER_DATA_KEY_IMPL(OptimizationGuideWebContentsObserver)

chrome/browser/optimization_guide/optimization_guide_web_contents_observer.h

@@ -12,6 +12,7 @@
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/optimization_guide/optimization_guide_navigation_data.h"
+#include "components/page_load_metrics/common/page_load_metrics.mojom.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 
@@ -35,6 +36,12 @@ class OptimizationGuideWebContentsObserver
   OptimizationGuideNavigationData* GetOrCreateOptimizationGuideNavigationData(
       content::NavigationHandle* navigation_handle);
 
+  // Captures the timing information at the time of FCP for the current
+  // navigation to be used by the Optimization Guide to make decisions. Other
+  // timing metric information may be missing (e.g., LCP, FMP).
+  void UpdateSessionTimingStatistics(
+      const page_load_metrics::mojom::PageLoadTiming& timing);
+
  private:
   friend class content::WebContentsUserData<
       OptimizationGuideWebContentsObserver>;

chrome/browser/page_load_metrics/observers/optimization_guide_page_load_metrics_observer.cc

+// Copyright 2019 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/optimization_guide_page_load_metrics_observer.h"
+#include "content/public/browser/navigation_handle.h"
+#include "url/gurl.h"
+
+OptimizationGuidePageLoadMetricsObserver::
+    OptimizationGuidePageLoadMetricsObserver() = default;
+
+OptimizationGuidePageLoadMetricsObserver::
+    ~OptimizationGuidePageLoadMetricsObserver() = default;
+
+page_load_metrics::PageLoadMetricsObserver::ObservePolicy
+OptimizationGuidePageLoadMetricsObserver::OnStart(
+    content::NavigationHandle* navigation_handle,
+    const GURL& currently_committed_url,
+    bool started_in_foreground) {
+  if (!started_in_foreground)
+    return STOP_OBSERVING;
+  if (!navigation_handle->GetURL().SchemeIsHTTPOrHTTPS())
+    return STOP_OBSERVING;
+  optimization_guide_web_contents_observer_ =
+      OptimizationGuideWebContentsObserver::FromWebContents(
+          navigation_handle->GetWebContents());
+  if (!optimization_guide_web_contents_observer_)
+    return STOP_OBSERVING;
+  return CONTINUE_OBSERVING;
+}
+
+page_load_metrics::PageLoadMetricsObserver::ObservePolicy
+OptimizationGuidePageLoadMetricsObserver::OnHidden(
+    const page_load_metrics::mojom::PageLoadTiming& timing) {
+  return STOP_OBSERVING;
+}
+
+page_load_metrics::PageLoadMetricsObserver::ObservePolicy
+OptimizationGuidePageLoadMetricsObserver::FlushMetricsOnAppEnterBackground(
+    const page_load_metrics::mojom::PageLoadTiming& timing) {
+  return STOP_OBSERVING;
+}
+
+void OptimizationGuidePageLoadMetricsObserver::OnFirstContentfulPaintInPage(
+    const page_load_metrics::mojom::PageLoadTiming& timing) {
+  if (!optimization_guide_web_contents_observer_)
+    return;
+  optimization_guide_web_contents_observer_->UpdateSessionTimingStatistics(
+      timing);
+}

chrome/browser/page_load_metrics/observers/optimization_guide_page_load_metrics_observer.h

+// Copyright 2019 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.
+
+#ifndef CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_OPTIMIZATION_GUIDE_PAGE_LOAD_METRICS_OBSERVER_H_
+#define CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_OPTIMIZATION_GUIDE_PAGE_LOAD_METRICS_OBSERVER_H_
+
+#include "base/macros.h"
+#include "chrome/browser/optimization_guide/optimization_guide_web_contents_observer.h"
+#include "chrome/browser/page_load_metrics/page_load_metrics_observer.h"
+
+// Observer responsible for capturing and recording page load metrics for the
+// Optimization Guide.
+class OptimizationGuidePageLoadMetricsObserver
+    : public page_load_metrics::PageLoadMetricsObserver {
+ public:
+  OptimizationGuidePageLoadMetricsObserver();
+  ~OptimizationGuidePageLoadMetricsObserver() override;
+
+  // page_load_metrics::PageLoadMetricsObserver:
+  void OnFirstContentfulPaintInPage(
+      const page_load_metrics::mojom::PageLoadTiming& timing) override;
+  ObservePolicy OnHidden(
+      const page_load_metrics::mojom::PageLoadTiming& timing) override;
+  ObservePolicy FlushMetricsOnAppEnterBackground(
+      const page_load_metrics::mojom::PageLoadTiming& timing) override;
+  ObservePolicy OnStart(content::NavigationHandle* navigation_handle,
+                        const GURL& currently_committed_url,
+                        bool started_in_foreground) override;
+
+ private:
+  // OptimizationGuideWebContentsObserver to pass any captured page load metrics
+  // needed for the Optimization Guide. Not owned.
+  OptimizationGuideWebContentsObserver*
+      optimization_guide_web_contents_observer_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(OptimizationGuidePageLoadMetricsObserver);
+};
+
+#endif  // CHROME_BROWSER_PAGE_LOAD_METRICS_OBSERVERS_OPTIMIZATION_GUIDE_PAGE_LOAD_METRICS_OBSERVER_H_

chrome/browser/page_load_metrics/page_load_metrics_initialize.cc

@@ -30,6 +30,7 @@
 #include "chrome/browser/page_load_metrics/observers/no_state_prefetch_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/offline_page_previews_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/omnibox_suggestion_used_page_load_metrics_observer.h"
+#include "chrome/browser/page_load_metrics/observers/optimization_guide_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/previews_lite_page_redirect_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/previews_page_load_metrics_observer.h"
 #include "chrome/browser/page_load_metrics/observers/previews_ukm_observer.h"
@@ -110,6 +111,8 @@ void PageLoadMetricsEmbedder::RegisterObservers(
     tracker->AddObserver(
         std::make_unique<
             previews::OfflinePagePreviewsPageLoadMetricsObserver>());
+    tracker->AddObserver(
+        std::make_unique<OptimizationGuidePageLoadMetricsObserver>());
     tracker->AddObserver(
         std::make_unique<PreviewsLitePageRedirectMetricsObserver>());
     tracker->AddObserver(

chrome/test/BUILD.gn

@@ -994,6 +994,7 @@ if (!is_android) {
       "../browser/ntp_snippets/content_suggestions_service_factory_browsertest.cc",
       "../browser/ntp_tiles/ntp_tiles_browsertest.cc",
       "../browser/optimization_guide/optimization_guide_keyed_service_browsertest.cc",
+      "../browser/optimization_guide/optimization_guide_prediction_manager_browsertest.cc",
       "../browser/page_load_metrics/observers/ad_metrics/ads_page_load_metrics_observer_browsertest.cc",
       "../browser/page_load_metrics/observers/amp_page_load_metrics_observer_browsertest.cc",
       "../browser/page_load_metrics/observers/data_saver_site_breakdown_metrics_observer_browsertest.cc",
@@ -3019,6 +3020,7 @@ test("unit_tests") {
     "../browser/notifications/stub_notification_center_mac.mm",
     "../browser/optimization_guide/optimization_guide_hints_manager_unittest.cc",
     "../browser/optimization_guide/optimization_guide_navigation_data_unittest.cc",
+    "../browser/optimization_guide/optimization_guide_session_statistic_unittest.cc",
     "../browser/page_load_metrics/metrics_web_contents_observer_unittest.cc",
     "../browser/page_load_metrics/observers/aborts_page_load_metrics_observer_unittest.cc",
     "../browser/page_load_metrics/observers/ad_metrics/ads_page_load_metrics_observer_unittest.cc",