Create A Renderer Warmup Navigation Predictor Client

This client warms up a renderer when a cross-origin navigation is
likely.

This is the first CL and just makes the classes, boilerplate, and some
other common checks.

Reference
https://chromium-review.googlesource.com/c/chromium/src/+/2350145 for
what the whole impl will look like.

Bug: 1115259
Change-Id: I54996eaa7ed0edd5a8521dd4fffcbb4a3c2ecd04
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2350238Reviewed-by: Ryan Sturm <ryansturm@chromium.org>
Commit-Queue: Robert Ogden <robertogden@chromium.org>
Cr-Commit-Position: refs/heads/master@{#798329}

chrome/browser/BUILD.gn

@@ -841,6 +841,8 @@ static_library("browser") {
     "navigation_predictor/navigation_predictor_keyed_service_factory.h",
     "navigation_predictor/navigation_predictor_preconnect_client.cc",
     "navigation_predictor/navigation_predictor_preconnect_client.h",
+    "navigation_predictor/navigation_predictor_renderer_warmup_client.cc",
+    "navigation_predictor/navigation_predictor_renderer_warmup_client.h",
     "navigation_predictor/search_engine_preconnector.cc",
     "navigation_predictor/search_engine_preconnector.h",
     "net/chrome_cookie_notification_details.h",

chrome/browser/navigation_predictor/navigation_predictor_keyed_service.cc

@@ -8,6 +8,8 @@
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/histogram_macros_local.h"
 #include "build/build_config.h"
+#include "chrome/browser/navigation_predictor/navigation_predictor_renderer_warmup_client.h"
+#include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
@@ -119,7 +121,10 @@ NavigationPredictorKeyedService::Prediction::web_contents() const {
 
 NavigationPredictorKeyedService::NavigationPredictorKeyedService(
     content::BrowserContext* browser_context)
-    : search_engine_preconnector_(browser_context) {
+    : search_engine_preconnector_(browser_context),
+      renderer_warmup_client_(
+          std::make_unique<NavigationPredictorRendererWarmupClient>(
+              Profile::FromBrowserContext(browser_context))) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!browser_context->IsOffTheRecord());
 
@@ -127,6 +132,8 @@ NavigationPredictorKeyedService::NavigationPredictorKeyedService(
   // Start preconnecting to the search engine.
   search_engine_preconnector_.StartPreconnecting(/*with_startup_delay=*/true);
 #endif
+
+  AddObserver(renderer_warmup_client_.get());
 }
 
 NavigationPredictorKeyedService::~NavigationPredictorKeyedService() {

chrome/browser/navigation_predictor/navigation_predictor_keyed_service.h

@@ -5,6 +5,7 @@
 #ifndef CHROME_BROWSER_NAVIGATION_PREDICTOR_NAVIGATION_PREDICTOR_KEYED_SERVICE_H_
 #define CHROME_BROWSER_NAVIGATION_PREDICTOR_NAVIGATION_PREDICTOR_KEYED_SERVICE_H_
 
+#include <memory>
 #include <vector>
 
 #include "base/macros.h"
@@ -20,6 +21,8 @@ class BrowserContext;
 class WebContents;
 }  // namespace content
 
+class NavigationPredictorRendererWarmupClient;
+
 // Keyed service that can be used to receive notifications about the URLs for
 // the next predicted navigation.
 class NavigationPredictorKeyedService : public KeyedService {
@@ -144,6 +147,10 @@ class NavigationPredictorKeyedService : public KeyedService {
   // Manages preconnecting to the user's default search engine.
   SearchEnginePreconnector search_engine_preconnector_;
 
+  // Manages warming up a spare renderer based on predictions.
+  std::unique_ptr<NavigationPredictorRendererWarmupClient>
+      renderer_warmup_client_;
+
   DISALLOW_COPY_AND_ASSIGN(NavigationPredictorKeyedService);
 };
 

chrome/browser/navigation_predictor/navigation_predictor_renderer_warmup_client.cc

+// Copyright 2020 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/navigation_predictor/navigation_predictor_renderer_warmup_client.h"
+
+#include <algorithm>
+#include <vector>
+
+#include "base/feature_list.h"
+#include "base/metrics/field_trial_params.h"
+#include "base/system/sys_info.h"
+#include "base/time/default_tick_clock.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
+#include "components/search_engines/template_url_service.h"
+#include "content/public/browser/render_process_host.h"
+#include "url/gurl.h"
+#include "url/origin.h"
+
+namespace {
+const base::Feature kNavigationPredictorRendererWarmup{
+    "NavigationPredictorRendererWarmup", base::FEATURE_DISABLED_BY_DEFAULT};
+}
+
+NavigationPredictorRendererWarmupClient::
+    ~NavigationPredictorRendererWarmupClient() = default;
+NavigationPredictorRendererWarmupClient::
+    NavigationPredictorRendererWarmupClient(Profile* profile,
+                                            const base::TickClock* clock)
+    : profile_(profile),
+      counterfactual_(base::GetFieldTrialParamByFeatureAsBool(
+          kNavigationPredictorRendererWarmup,
+          "counterfactual",
+          false)),
+      mem_threshold_mb_(base::GetFieldTrialParamByFeatureAsInt(
+          kNavigationPredictorRendererWarmup,
+          "mem_threshold_mb",
+          1024)),
+      cooldown_duration_(base::TimeDelta::FromMilliseconds(
+          base::GetFieldTrialParamByFeatureAsInt(
+              kNavigationPredictorRendererWarmup,
+              "cooldown_duration_ms",
+              60 * 1000))) {
+  if (clock) {
+    tick_clock_ = clock;
+  } else {
+    tick_clock_ = base::DefaultTickClock::GetInstance();
+  }
+}
+
+void NavigationPredictorRendererWarmupClient::OnPredictionUpdated(
+    const base::Optional<NavigationPredictorKeyedService::Prediction>
+        prediction) {
+  if (!prediction) {
+    return;
+  }
+
+  if (prediction->prediction_source() !=
+      NavigationPredictorKeyedService::PredictionSource::
+          kAnchorElementsParsedFromWebPage) {
+    return;
+  }
+
+  if (!prediction->source_document_url()) {
+    return;
+  }
+
+  if (!prediction->source_document_url()->is_valid()) {
+    return;
+  }
+
+  if (!IsEligibleForWarmupOnCommonCriteria()) {
+    return;
+  }
+
+  // TODO(robertogden): Actually use the predicted URLs.
+
+  RecordMetricsAndMaybeDoWarmup();
+}
+
+void NavigationPredictorRendererWarmupClient::DoRendererWarmpup() {
+  content::RenderProcessHost::WarmupSpareRenderProcessHost(profile_);
+}
+
+bool NavigationPredictorRendererWarmupClient::BrowserHasSpareRenderer() const {
+  for (content::RenderProcessHost::iterator iter(
+           content::RenderProcessHost::AllHostsIterator());
+       !iter.IsAtEnd(); iter.Advance()) {
+    if (iter.GetCurrentValue()->IsUnused()) {
+      return true;
+    }
+  }
+  return false;
+}
+
+bool NavigationPredictorRendererWarmupClient::
+    IsEligibleForWarmupOnCommonCriteria() const {
+  if (!base::FeatureList::IsEnabled(kNavigationPredictorRendererWarmup)) {
+    return false;
+  }
+
+  base::TimeDelta duration_since_last_warmup =
+      tick_clock_->NowTicks() - last_warmup_time_;
+  if (cooldown_duration_ >= duration_since_last_warmup) {
+    return false;
+  }
+
+  if (mem_threshold_mb_ >= base::SysInfo::AmountOfPhysicalMemoryMB()) {
+    return false;
+  }
+
+  if (BrowserHasSpareRenderer()) {
+    return false;
+  }
+
+  return true;
+}
+
+void NavigationPredictorRendererWarmupClient::RecordMetricsAndMaybeDoWarmup() {
+  last_warmup_time_ = tick_clock_->NowTicks();
+
+  if (counterfactual_) {
+    return;
+  }
+
+  DoRendererWarmpup();
+}

chrome/browser/navigation_predictor/navigation_predictor_renderer_warmup_client.h

+// Copyright 2020 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_NAVIGATION_PREDICTOR_NAVIGATION_PREDICTOR_RENDERER_WARMUP_CLIENT_H_
+#define CHROME_BROWSER_NAVIGATION_PREDICTOR_NAVIGATION_PREDICTOR_RENDERER_WARMUP_CLIENT_H_
+
+#include "base/macros.h"
+#include "base/optional.h"
+#include "base/time/tick_clock.h"
+#include "base/time/time.h"
+#include "chrome/browser/navigation_predictor/navigation_predictor_keyed_service.h"
+
+class Profile;
+
+// A client of Navigation Predictor that uses predictions to initiate a renderer
+// warmup (in the form of starting a spare renderer process) when it is likely
+// the user will soon do a cross-origin navigation.
+class NavigationPredictorRendererWarmupClient
+    : public NavigationPredictorKeyedService::Observer {
+ public:
+  // If |clock| is null, then the default clock will be used.
+  explicit NavigationPredictorRendererWarmupClient(
+      Profile* profile,
+      const base::TickClock* clock = nullptr);
+  ~NavigationPredictorRendererWarmupClient() override;
+
+  // NavigationPredictorKeyedService::Observer:
+  void OnPredictionUpdated(
+      const base::Optional<NavigationPredictorKeyedService::Prediction>
+          prediction) override;
+
+ protected:
+  // Virtual for testing.
+  virtual void DoRendererWarmpup();
+
+  // Returns true if there is a spare renderer in the browser. Virtual for
+  // testing.
+  virtual bool BrowserHasSpareRenderer() const;
+
+ private:
+  // Checks if there is already a spare renderer or we requested a spare
+  // renderer too recently.
+  bool IsEligibleForWarmupOnCommonCriteria() const;
+
+  // Records class state and metrics before checking |counterfactual_| and then
+  // calling |DoRendererWarmpup| if |counterfactual_| is false.
+  void RecordMetricsAndMaybeDoWarmup();
+
+  Profile* profile_;
+
+  // Whether we are in a counterfactual experiment and so the renderer warmup
+  // should not be done.
+  const bool counterfactual_;
+
+  // The minimum amount of memory the devices is required to have to enable
+  // renderer warmup.
+  const int mem_threshold_mb_;
+
+  // The tick clock used within this class.
+  const base::TickClock* tick_clock_;
+
+  // The timestamp of the last renderer warmup.
+  base::TimeTicks last_warmup_time_;
+
+  // The amount of time to wait in-between doing a renderer warmup.
+  const base::TimeDelta cooldown_duration_;
+
+  DISALLOW_COPY_AND_ASSIGN(NavigationPredictorRendererWarmupClient);
+};
+
+#endif  // CHROME_BROWSER_NAVIGATION_PREDICTOR_NAVIGATION_PREDICTOR_RENDERER_WARMUP_CLIENT_H_

chrome/browser/navigation_predictor/navigation_predictor_renderer_warmup_client_browsertest.cc

+// Copyright 2020 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/test/scoped_feature_list.h"
+#include "build/build_config.h"
+#include "chrome/browser/navigation_predictor/navigation_predictor_keyed_service.h"
+#include "chrome/browser/navigation_predictor/navigation_predictor_keyed_service_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/test/browser_test.h"
+#include "content/public/test/browser_test_base.h"
+#include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_utils.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace {
+const base::Feature kNavigationPredictorRendererWarmup{
+    "NavigationPredictorRendererWarmup", base::FEATURE_DISABLED_BY_DEFAULT};
+}
+
+// Occasional flakes on Windows (https://crbug.com/1045971).
+#if defined(OS_WIN) || defined(OS_MAC) || defined(OS_CHROMEOS)
+#define DISABLE_ON_WIN_MAC_CHROMEOS(x) DISABLED_##x
+#else
+#define DISABLE_ON_WIN_MAC_CHROMEOS(x) x
+#endif
+
+class NavigationPredictorRendererWarmupClientBrowserTest
+    : public InProcessBrowserTest {
+ public:
+  NavigationPredictorRendererWarmupClientBrowserTest() = default;
+  ~NavigationPredictorRendererWarmupClientBrowserTest() override = default;
+
+  void SetUp() override {
+    scoped_feature_list_.InitAndEnableFeature(
+        kNavigationPredictorRendererWarmup);
+    InProcessBrowserTest::SetUp();
+  }
+
+  size_t SpareRendererCount() const {
+    size_t count = 0;
+    for (content::RenderProcessHost::iterator iter(
+             content::RenderProcessHost::AllHostsIterator());
+         !iter.IsAtEnd(); iter.Advance()) {
+      if (iter.GetCurrentValue()->IsUnused()) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  void MakeSpareRenderer() {
+    content::RenderProcessHost::WarmupSpareRenderProcessHost(
+        browser()->profile());
+  }
+
+  content::WebContents* GetWebContents() const {
+    return browser()->tab_strip_model()->GetActiveWebContents();
+  }
+
+  void MakeEligibleNavigationPrediction() {
+    NavigationPredictorKeyedServiceFactory::GetForProfile(browser()->profile())
+        ->OnPredictionUpdated(
+            GetWebContents(), GURL("https://www.google.com/search?q=test"),
+            NavigationPredictorKeyedService::PredictionSource::
+                kAnchorElementsParsedFromWebPage,
+            {});
+  }
+
+ private:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+IN_PROC_BROWSER_TEST_F(NavigationPredictorRendererWarmupClientBrowserTest,
+                       DISABLE_ON_WIN_MAC_CHROMEOS(StartsSpareRenderer)) {
+  // Navigate to a site so that the default renderer is used.
+  embedded_test_server()->ServeFilesFromSourceDirectory("chrome/test/data");
+  ASSERT_TRUE(embedded_test_server()->Start());
+  ui_test_utils::NavigateToURL(browser(),
+                               embedded_test_server()->GetURL("/simple.html"));
+
+  MakeEligibleNavigationPrediction();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(SpareRendererCount(), 1U);
+}
+
+IN_PROC_BROWSER_TEST_F(NavigationPredictorRendererWarmupClientBrowserTest,
+                       DISABLE_ON_WIN_MAC_CHROMEOS(PreexistingSpareRenderer)) {
+  // Navigate to a site so that the default renderer is used.
+  embedded_test_server()->ServeFilesFromSourceDirectory("chrome/test/data");
+  ASSERT_TRUE(embedded_test_server()->Start());
+  ui_test_utils::NavigateToURL(browser(),
+                               embedded_test_server()->GetURL("/simple.html"));
+
+  MakeSpareRenderer();
+  base::RunLoop().RunUntilIdle();
+  EXPECT_EQ(SpareRendererCount(), 1U);
+
+  MakeEligibleNavigationPrediction();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(SpareRendererCount(), 1U);
+}

chrome/browser/navigation_predictor/navigation_predictor_renderer_warmup_client_unittest.cc

+// Copyright 2020 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/navigation_predictor/navigation_predictor_renderer_warmup_client.h"
+
+#include <memory>
+#include <vector>
+
+#include "base/optional.h"
+#include "base/test/scoped_feature_list.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
+#include "chrome/test/base/chrome_render_view_host_test_harness.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace {
+
+constexpr char kGoogleSearchURL[] = "https://www.google.com/search?q=test";
+
+const base::Feature kNavigationPredictorRendererWarmup{
+    "NavigationPredictorRendererWarmup", base::FEATURE_DISABLED_BY_DEFAULT};
+
+NavigationPredictorKeyedService::Prediction CreateValidPrediction(
+    const GURL& src_url,
+    const std::vector<GURL>& predicted_urls) {
+  return NavigationPredictorKeyedService::Prediction(
+      nullptr, src_url, base::nullopt,
+      NavigationPredictorKeyedService::PredictionSource::
+          kAnchorElementsParsedFromWebPage,
+      predicted_urls);
+}
+
+class TestNavigationPredictorRendererWarmupClient
+    : public NavigationPredictorRendererWarmupClient {
+ public:
+  TestNavigationPredictorRendererWarmupClient(Profile* profile,
+                                              const base::TickClock* clock)
+      : NavigationPredictorRendererWarmupClient(profile, clock) {}
+  ~TestNavigationPredictorRendererWarmupClient() override = default;
+
+  bool DidDoRendererWarmup() const { return did_renderer_warmup_; }
+
+  void Reset() { did_renderer_warmup_ = false; }
+
+  void SetBrowserHasSpareRenderer(bool has_spare) { has_spare_ = has_spare; }
+
+ protected:
+  void DoRendererWarmpup() override { did_renderer_warmup_ = true; }
+  bool BrowserHasSpareRenderer() const override { return has_spare_; }
+
+ private:
+  bool did_renderer_warmup_ = false;
+  bool has_spare_ = false;
+};
+
+class NavigationPredictorRendererWarmupClientTest
+    : public ChromeRenderViewHostTestHarness {
+ public:
+  NavigationPredictorRendererWarmupClientTest() = default;
+  ~NavigationPredictorRendererWarmupClientTest() override = default;
+
+  void SetUp() override {
+    ChromeRenderViewHostTestHarness::SetUp();
+
+    TemplateURLServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+        profile(),
+        base::BindRepeating(&TemplateURLServiceFactory::BuildInstanceFor));
+
+    // Set the clock to a non-zero value.
+    clock_.SetNowTicks(base::TimeTicks::Now());
+  }
+
+  TestNavigationPredictorRendererWarmupClient* client() {
+    if (!client_) {
+      client_ = std::make_unique<TestNavigationPredictorRendererWarmupClient>(
+          profile(), &clock_);
+    }
+    return client_.get();
+  }
+
+  base::SimpleTestTickClock* clock() { return &clock_; }
+
+ private:
+  base::SimpleTestTickClock clock_;
+  std::unique_ptr<TestNavigationPredictorRendererWarmupClient> client_;
+};
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, SuccessCase) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "false"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "60000"},
+                                          });
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_TRUE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, SuccessCase_AfterCooldown) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "false"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "100"},
+                                          });
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_TRUE(client()->DidDoRendererWarmup());
+
+  client()->Reset();
+
+  clock()->Advance(base::TimeDelta::FromMilliseconds(101));
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_TRUE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, NullPrediction) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "false"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "60000"},
+                                          });
+
+  client()->OnPredictionUpdated(base::nullopt);
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, BadPredictionSrc) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "false"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "60000"},
+                                          });
+
+  client()->OnPredictionUpdated(NavigationPredictorKeyedService::Prediction(
+      nullptr, base::nullopt, std::vector<std::string>{""},
+      NavigationPredictorKeyedService::PredictionSource::kExternalAndroidApp,
+      {}));
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, CoolDown) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "false"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "60000"},
+                                          });
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_TRUE(client()->DidDoRendererWarmup());
+
+  client()->Reset();
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, HasSpareRenderer) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "false"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "60000"},
+                                          });
+
+  client()->SetBrowserHasSpareRenderer(true);
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, FeatureOff) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndDisableFeature(kNavigationPredictorRendererWarmup);
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, Counterfactual) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup, {
+                                              {"counterfactual", "true"},
+                                              {"mem_threshold_mb", "0"},
+                                              {"cooldown_duration_ms", "60000"},
+                                          });
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+TEST_F(NavigationPredictorRendererWarmupClientTest, MemThreshold) {
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeatureWithParameters(
+      kNavigationPredictorRendererWarmup,
+      {
+          {"counterfactual", "true"},
+          {"mem_threshold_mb", "99999999999"},
+          {"cooldown_duration_ms", "60000"},
+      });
+
+  client()->OnPredictionUpdated(
+      CreateValidPrediction(GURL(kGoogleSearchURL), {}));
+  EXPECT_FALSE(client()->DidDoRendererWarmup());
+}
+
+}  // namespace

chrome/test/BUILD.gn

@@ -1013,6 +1013,7 @@ if (!is_android) {
       "../browser/metrics/variations/force_field_trials_browsertest.cc",
       "../browser/navigation_predictor/navigation_predictor_browsertest.cc",
       "../browser/navigation_predictor/navigation_predictor_preconnect_client_browsertest.cc",
+      "../browser/navigation_predictor/navigation_predictor_renderer_warmup_client_browsertest.cc",
       "../browser/navigation_predictor/search_engine_preconnector_browsertest.cc",
       "../browser/net/cert_verify_proc_browsertest.cc",
       "../browser/net/chrome_accept_header_browsertest.cc",
@@ -3301,6 +3302,7 @@ test("unit_tests") {
     "../browser/metrics/thread_watcher_unittest.cc",
     "../browser/native_file_system/chrome_native_file_system_permission_context_unittest.cc",
     "../browser/native_file_system/origin_scoped_native_file_system_permission_context_unittest.cc",
+    "../browser/navigation_predictor/navigation_predictor_renderer_warmup_client_unittest.cc",
     "../browser/navigation_predictor/navigation_predictor_unittest.cc",
     "../browser/net/chrome_network_delegate_unittest.cc",
     "../browser/net/dns_probe_runner_unittest.cc",