Prerender: omnibox and instant field trial parameters.

chrome/browser/prerender/prerender_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/field_trial_param_associator.h"
+#include "base/metrics/field_trial_params.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/simple_test_clock.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/net/prediction_options.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_origin.h"
+#include "chrome/browser/prerender/prerender_test_utils.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/prerender_types.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/prefs/pref_service.h"
-#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/network_change_notifier.h"
 #include "net/http/http_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 
 using base::Time;
@@ skipping 231 matching lines @@
   // Maintain a map from route pairs to PrerenderContents for
   // GetPrerenderContentsForRoute.
   using PrerenderContentsMap =
       std::map<std::pair<int, int>, PrerenderContents*>;
   PrerenderContentsMap prerender_contents_map_;
 
   std::unique_ptr<PrerenderContents> next_prerender_contents_;
   bool is_low_end_device_;
 };
 
-class RestorePrerenderMode {
- public:
-  RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
-  }
-
-  ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
-
- private:
-  PrerenderManager::PrerenderManagerMode prev_mode_;
-};
-
 class MockNetworkChangeNotifier4G : public net::NetworkChangeNotifier {
  public:
   ConnectionType GetCurrentConnectionType() const override {
     return NetworkChangeNotifier::CONNECTION_4G;
   }
 };
 
 DummyPrerenderContents::DummyPrerenderContents(
     UnitTestPrerenderManager* test_prerender_manager,
     const GURL& url,
@@ skipping 41 matching lines @@
         switches::kPrerenderFromOmnibox,
         switches::kPrerenderFromOmniboxSwitchValueEnabled);
   }
 
   ~PrerenderTest() override {
     prerender_link_manager_->OnChannelClosing(kDefaultChildId);
     prerender_link_manager_->Shutdown();
     prerender_manager_->Shutdown();
   }
 
+  void TearDown() override {
+    base::FieldTrialParamAssociator::GetInstance()->ClearAllParamsForTesting();
+  }
+
   UnitTestPrerenderManager* prerender_manager() {
     return prerender_manager_.get();
   }
 
   PrerenderLinkManager* prerender_link_manager() {
     return prerender_link_manager_.get();
   }
 
   Profile* profile() { return &profile_; }
 
@@ skipping 46 matching lines @@
         prefs::kNetworkPredictionOptions,
         chrome_browser_net::NETWORK_PREDICTION_NEVER);
   }
 
   void EnablePrerender() {
     profile_.GetPrefs()->SetInteger(
         prefs::kNetworkPredictionOptions,
         chrome_browser_net::NETWORK_PREDICTION_ALWAYS);
   }
 
+  void SetUpFieldTrial(const std::map<std::string, std::string>& params,
+                       base::test::ScopedFeatureList* scoped_feature_list) {
+    // Set up the prerender mode through a field trial.
+    std::string kTrialName = "name";
+    std::string kTrialGroup = "group";
+    base::FieldTrial* trial =
+        base::FieldTrialList::CreateFieldTrial(kTrialName, kTrialGroup);
+    ASSERT_TRUE(

[pasko, 2017/03/17 17:33:33]

this would return from the function if the condition does not hold, do we really
want it? do we care?

[mattcary, 2017/03/20 10:20:31]

This returns false if, for example, one tries to associate multiple params with
a single trial group. This is why I had to add the tearDown() method. It was a
lot easier seeing this assert fail than to have the params for a test not get
applied and have a tricky test failure to debug.

[pasko, 2017/03/20 13:24:55]

Let me rephrase: ASSERT_* returns from the subroutine, we should use
ASSERT_NO_FATAL_FAILURE with them if we want exception-like propagation of
assertions in tests.

See:
https://github.com/google/googletest/blob/master/googletest/docs/AdvancedGuid...

+        base::FieldTrialParamAssociator::GetInstance()
+            ->AssociateFieldTrialParams(kTrialName, kTrialGroup, params));
+
+    std::unique_ptr<base::FeatureList> feature_list =
+        base::MakeUnique<base::FeatureList>();
+    feature_list->RegisterFieldTrialOverride(
+        kNoStatePrefetchFeature.name,
+        base::FeatureList::OVERRIDE_ENABLE_FEATURE, trial);
+
+    scoped_feature_list->InitWithFeatureList(std::move(feature_list));
+
+    EXPECT_EQ(base::FeatureList::GetFieldTrial(kNoStatePrefetchFeature), trial);

[pasko, 2017/03/17 17:33:33]

This is a utility function, not a test, I think it would be more readable to
perform these EXPECT_* checks in one of the tests
(PrerenderRespectsFieldTrialParameters?) and assume it always works.

[mattcary, 2017/03/20 10:20:31]

Changed to an assert, see previous comment.

+
+    std::map<std::string, std::string> actual_params;
+    EXPECT_TRUE(base::GetFieldTrialParamsByFeature(kNoStatePrefetchFeature,
+                                                   &actual_params));
+    EXPECT_EQ(params, actual_params);
+  }
+
   const base::HistogramTester& histogram_tester() { return histogram_tester_; }
 
  private:
   // Needed to pass PrerenderManager's DCHECKs.
   base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
 
   TestingProfile profile_;
   std::unique_ptr<UnitTestPrerenderManager> prerender_manager_;
   std::unique_ptr<PrerenderLinkManager> prerender_link_manager_;
   int last_prerender_id_;
+  base::HistogramTester histogram_tester_;
+
+  // An instance of base::FieldTrialList is necessary in order to initialize
+  // global state.
   base::FieldTrialList field_trial_list_;
-  base::HistogramTester histogram_tester_;
 };
 
 TEST_F(PrerenderTest, PrerenderRespectsDisableFlag) {
   RestorePrerenderMode restore_prerender_mode;
-  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  ASSERT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
   ASSERT_EQ(PrerenderManager::PRERENDER_MODE_ENABLED,
-            PrerenderManager::GetMode());
+            PrerenderManager::GetMode(ORIGIN_NONE));
 
   {
     base::test::ScopedFeatureList scoped_feature_list;
     scoped_feature_list.InitAndDisableFeature(kNoStatePrefetchFeature);
     prerender::ConfigurePrerender();
+    EXPECT_FALSE(PrerenderManager::IsAnyPrerenderingPossible());
     EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
-              PrerenderManager::GetMode());
-    EXPECT_FALSE(PrerenderManager::IsPrerenderingPossible());
+              PrerenderManager::GetMode(ORIGIN_NONE));
+    EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+              PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+    EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+              PrerenderManager::GetMode(ORIGIN_INSTANT));
   }
 }
 
 TEST_F(PrerenderTest, PrerenderRespectsFieldTrialParameters) {
   RestorePrerenderMode restore_prerender_mode;
 
-  // Set up the prerender mode through a field trial.
-  std::string kTrialName = "name";
-  std::string kTrialGroup = "group";
-  base::FieldTrial* trial =
-      base::FieldTrialList::CreateFieldTrial(kTrialName, kTrialGroup);
-  std::map<std::string, std::string> params = {
-      {kNoStatePrefetchFeatureModeParameterName,
-       kNoStatePrefetchFeatureModeParameterSimpleLoad}};
-  ASSERT_TRUE(
-      variations::AssociateVariationParams(kTrialName, kTrialGroup, params));
+  base::test::ScopedFeatureList scoped_feature_list;
+  SetUpFieldTrial({{kNoStatePrefetchFeatureModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterSimpleLoad}},
+                  &scoped_feature_list);
 
-  std::unique_ptr<base::FeatureList> feature_list =
-      base::MakeUnique<base::FeatureList>();
-  feature_list->RegisterFieldTrialOverride(
-      kNoStatePrefetchFeature.name, base::FeatureList::OVERRIDE_ENABLE_FEATURE,
-      trial);
+  prerender::ConfigurePrerender();
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
+            PrerenderManager::GetMode(ORIGIN_NONE));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
+            PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
+            PrerenderManager::GetMode(ORIGIN_INSTANT));
+}
+
+TEST_F(PrerenderTest, PrerenderRespectsFieldTrialParametersPrefetchInstant) {
+  RestorePrerenderMode restore_prerender_mode;
 
   base::test::ScopedFeatureList scoped_feature_list;
-  scoped_feature_list.InitWithFeatureList(std::move(feature_list));
-
-  EXPECT_EQ(base::FeatureList::GetFieldTrial(kNoStatePrefetchFeature), trial);
-
-  std::map<std::string, std::string> actual_params;
-  EXPECT_TRUE(variations::GetVariationParamsByFeature(kNoStatePrefetchFeature,
-                                                      &actual_params));
-  EXPECT_EQ(params, actual_params);
+  SetUpFieldTrial({{kNoStatePrefetchFeatureModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterSimpleLoad},
+                   {kNoStatePrefetchFeatureInstantModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterPrefetch}},
+                  &scoped_feature_list);
 
   prerender::ConfigurePrerender();
-  EXPECT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
   EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
-            PrerenderManager::GetMode());
+            PrerenderManager::GetMode(ORIGIN_NONE));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
+            PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH,
+            PrerenderManager::GetMode(ORIGIN_INSTANT));
+}
+
+TEST_F(PrerenderTest, PrerenderRespectsFieldTrialParametersPrefetchOmnibox) {
+  RestorePrerenderMode restore_prerender_mode;
+
+  base::test::ScopedFeatureList scoped_feature_list;
+  SetUpFieldTrial({{kNoStatePrefetchFeatureModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterSimpleLoad},
+                   {kNoStatePrefetchFeatureOmniboxModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterPrefetch}},
+                  &scoped_feature_list);
+
+  prerender::ConfigurePrerender();
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
+            PrerenderManager::GetMode(ORIGIN_NONE));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH,
+            PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT,
+            PrerenderManager::GetMode(ORIGIN_INSTANT));
+}
+
+TEST_F(PrerenderTest, PrerenderRespectsFieldTrialParametersNoneButInstant) {
+  RestorePrerenderMode restore_prerender_mode;
+
+  base::test::ScopedFeatureList scoped_feature_list;
+  SetUpFieldTrial({{kNoStatePrefetchFeatureModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterDisabled},
+                   {kNoStatePrefetchFeatureInstantModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterPrerender},
+                   {kNoStatePrefetchFeatureOmniboxModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterDisabled}},
+                  &scoped_feature_list);
+
+  prerender::ConfigurePrerender();
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_NONE));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_ENABLED,
+            PrerenderManager::GetMode(ORIGIN_INSTANT));
+}
+
+TEST_F(PrerenderTest, PrerenderRespectsFieldTrialParametersNoneAtAll) {
+  RestorePrerenderMode restore_prerender_mode;
+
+  base::test::ScopedFeatureList scoped_feature_list;
+  SetUpFieldTrial({{kNoStatePrefetchFeatureModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterDisabled},
+                   {kNoStatePrefetchFeatureOmniboxModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterDisabled},
+                   {kNoStatePrefetchFeatureInstantModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterDisabled}},
+                  &scoped_feature_list);
+
+  prerender::ConfigurePrerender();
+  EXPECT_FALSE(PrerenderManager::IsAnyPrerenderingPossible());
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_NONE));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_INSTANT));
+}
+
+TEST_F(PrerenderTest, PrerenderRespectsFieldTrialParametersDefaultNone) {
+  RestorePrerenderMode restore_prerender_mode;
+
+  base::test::ScopedFeatureList scoped_feature_list;
+  SetUpFieldTrial({{kNoStatePrefetchFeatureModeParameterName,
+                    kNoStatePrefetchFeatureModeParameterDisabled}},
+                  &scoped_feature_list);
+
+  prerender::ConfigurePrerender();
+  EXPECT_FALSE(PrerenderManager::IsAnyPrerenderingPossible());
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_NONE));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_OMNIBOX));
+  EXPECT_EQ(PrerenderManager::PRERENDER_MODE_DISABLED,
+            PrerenderManager::GetMode(ORIGIN_INSTANT));
 }
 
 TEST_F(PrerenderTest, PrerenderRespectsThirdPartyCookiesPref) {
   GURL url("http://www.google.com/");
   RestorePrerenderMode restore_prerender_mode;
-  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  ASSERT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
 
   profile()->GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, true);
   EXPECT_FALSE(AddSimplePrerender(url));
   histogram_tester().ExpectUniqueSample(
       "Prerender.FinalStatus", FINAL_STATUS_BLOCK_THIRD_PARTY_COOKIES, 1);
 }
 
 TEST_F(PrerenderTest, OfflinePrerenderIgnoresThirdPartyCookiesPref) {
   GURL url("http://www.google.com/");
   RestorePrerenderMode restore_prerender_mode;
-  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  ASSERT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
 
   profile()->GetPrefs()->SetBoolean(prefs::kBlockThirdPartyCookies, true);
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, ORIGIN_OFFLINE, FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle(
       prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize));
   EXPECT_TRUE(prerender_handle);
   EXPECT_TRUE(prerender_handle->IsPrerendering());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_OFFLINE, prerender_handle->contents()->origin());
 }
 
 // Checks that the prerender mode affects "normal" origins such as omnibox, but
 // not offline origin.
 TEST_F(PrerenderTest, PrerenderModePerOrigin) {
   RestorePrerenderMode restore_prerender_mode;
 
   prerender_manager()->SetMode(
       PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
-  EXPECT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  prerender_manager()->SetOmniboxMode(
+      PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
+  EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OFFLINE));
+  EXPECT_TRUE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OMNIBOX));
+  EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_INSTANT));
+  EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OFFLINE));
+  EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OMNIBOX));
+
+  prerender_manager()->SetMode(PrerenderManager::PRERENDER_MODE_ENABLED);
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
   EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OFFLINE));
   EXPECT_TRUE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OMNIBOX));
   EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OFFLINE));
   EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OMNIBOX));
 
-  prerender_manager()->SetMode(PrerenderManager::PRERENDER_MODE_ENABLED);
-  EXPECT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  prerender_manager()->SetMode(PrerenderManager::PRERENDER_MODE_DISABLED);
+  prerender_manager()->SetInstantMode(
+      PrerenderManager::PRERENDER_MODE_DISABLED);
+  prerender_manager()->SetOmniboxMode(
+      PrerenderManager::PRERENDER_MODE_DISABLED);
+  EXPECT_FALSE(PrerenderManager::IsAnyPrerenderingPossible());
+
+  prerender_manager()->SetMode(
+      PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT);
+  prerender_manager()->SetInstantMode(
+      PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT);
+  EXPECT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
   EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OFFLINE));
   EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OMNIBOX));
   EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OFFLINE));
   EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OMNIBOX));
-
-  prerender_manager()->SetMode(PrerenderManager::PRERENDER_MODE_DISABLED);
-  EXPECT_FALSE(PrerenderManager::IsPrerenderingPossible());
-
-  prerender_manager()->SetMode(
-      PrerenderManager::PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT);
-  EXPECT_TRUE(PrerenderManager::IsPrerenderingPossible());
-  EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OFFLINE));
-  EXPECT_FALSE(PrerenderManager::IsNoStatePrefetch(ORIGIN_OMNIBOX));
-  EXPECT_FALSE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OFFLINE));
-  EXPECT_TRUE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_OMNIBOX));
+  EXPECT_TRUE(PrerenderManager::IsSimpleLoadExperiment(ORIGIN_INSTANT));
 }
 
 TEST_F(PrerenderTest, PrerenderRespectsPrerenderModeNoStatePrefetch) {
   GURL url("http://www.google.com/");
   RestorePrerenderMode restore_prerender_mode;
 
   prerender_manager()->SetMode(
       PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
 
   DummyPrerenderContents* prerender_contents =
@@ skipping 14 matching lines @@
 
 // Checks that a full prerender happens in offline mode, even if no-state
 // prefetch is enabled.
 TEST_F(PrerenderTest, OfflinePrerenderIgnoresPrerenderMode) {
   GURL url("http://www.google.com/");
   RestorePrerenderMode restore_prerender_mode;
 
   prerender_manager()->SetMode(
       PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
 
-  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  ASSERT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
 
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, ORIGIN_OFFLINE, FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle(
       prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize));
   EXPECT_EQ(FULL_PRERENDER, prerender_contents->prerender_mode());
 }
 
 TEST_F(PrerenderTest, PrerenderDisabledOnLowEndDevice) {
   GURL url("http://www.google.com/");
-  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  ASSERT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
   prerender_manager()->SetIsLowEndDevice(true);
   EXPECT_FALSE(AddSimplePrerender(url));
   histogram_tester().ExpectUniqueSample("Prerender.FinalStatus",
                                         FINAL_STATUS_LOW_END_DEVICE, 1);
 }
 
 TEST_F(PrerenderTest, OfflinePrerenderPossibleOnLowEndDevice) {
   GURL url("http://www.google.com/");
-  ASSERT_TRUE(PrerenderManager::IsPrerenderingPossible());
+  ASSERT_TRUE(PrerenderManager::IsAnyPrerenderingPossible());
 
   prerender_manager()->SetIsLowEndDevice(true);
 
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, ORIGIN_OFFLINE, FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle(
       prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize));
   EXPECT_TRUE(prerender_handle);
   EXPECT_TRUE(prerender_handle->IsPrerendering());
@@ skipping 225 matching lines @@
 }
 
 // Prefetching the same URL twice during |time_to_live| results in a duplicate
 // and is aborted.
 TEST_F(PrerenderTest, NoStatePrefetchDuplicate) {
   const GURL kUrl("http://www.google.com/");
 
   RestorePrerenderMode restore_prerender_mode;
   prerender_manager()->SetMode(
       PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
+  prerender_manager()->SetOmniboxMode(
+      PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
   base::SimpleTestTickClock* tick_clock =
       OverridePrerenderManagerTimeTicks(prerender_manager());
 
   // Prefetch the url once.
   prerender_manager()->CreateNextPrerenderContents(kUrl, ORIGIN_OMNIBOX,
                                                    FINAL_STATUS_CANCELLED);
   EXPECT_TRUE(
       prerender_manager()->AddPrerenderFromOmnibox(kUrl, nullptr, gfx::Size()));
   // Cancel the prerender so that it is not reused.
   prerender_manager()->CancelAllPrerenders();
@@ skipping 1168 matching lines @@
 
   TestNetworkBytesChangedObserver observer;
   prerender_handle->SetObserver(&observer);
 
   prerender_contents->AddNetworkBytes(12);
   EXPECT_TRUE(observer.network_bytes_changed());
   EXPECT_EQ(12, prerender_contents->network_bytes());
 }
 
 }  // namespace prerender