NoState Prefetch: nostate prefetch browser tests.

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>
 
@@ skipping 81 matching lines @@
 int DummyPrerenderContents::g_next_route_id_ = 0;
 
 const gfx::Size kSize(640, 480);
 
 const uint32_t kDefaultRelTypes = PrerenderRelTypePrerender;
 
 }  // namespace
 
 class UnitTestPrerenderManager : public PrerenderManager {
  public:
+  class UnittestTime : public TimeOverride {
+   public:
+    UnittestTime() : time_(Time::Now()), time_ticks_(TimeTicks::Now()) {}
+
+    base::Time GetCurrentTime() const override { return time_; }
+    base::TimeTicks GetCurrentTimeTicks() const override { return time_ticks_; }
+
+    bool SetTime(const std::string& time_string) {
+      return base::Time::FromString(time_string.c_str(), &time_);
+    }
+
+    void AdvanceTime(TimeDelta delta) { time_ += delta; }
+
+    void AdvanceTimeTicks(TimeDelta delta) { time_ticks_ += delta; }
+
+   private:
+    base::Time time_;
+    base::TimeTicks time_ticks_;
+  };
+
   using PrerenderManager::kMinTimeBetweenPrerendersMs;
   using PrerenderManager::kNavigationRecordWindowMs;
 
   explicit UnitTestPrerenderManager(Profile* profile)
-      : PrerenderManager(profile),
-        time_(Time::Now()),
-        time_ticks_(TimeTicks::Now()) {
+      : PrerenderManager(profile) {
     set_rate_limit_enabled(false);
+    std::unique_ptr<UnittestTime> unittest_time =
+        base::MakeUnique<UnittestTime>();
+    unittest_time_ptr_ = unittest_time.get();
+    SetTimeOverride(std::move(unittest_time));
   }
 
   ~UnitTestPrerenderManager() override {}
 
   // From KeyedService, via PrererenderManager:
   void Shutdown() override {
     if (next_prerender_contents())
       next_prerender_contents_->Destroy(FINAL_STATUS_MANAGER_SHUTDOWN);
     PrerenderManager::Shutdown();
   }
@@ skipping 21 matching lines @@
         FindIteratorForPrerenderContents(prerender_data->contents());
     CHECK(to_erase != active_prerenders_.end());
     std::unique_ptr<PrerenderContents> prerender_contents =
         prerender_data->ReleaseContents();
     active_prerenders_.erase(to_erase);
 
     prerender_contents->PrepareForUse();
     return prerender_contents;
   }
 
-  bool SetTime(const std::string& time_string) {
-    return base::Time::FromString(time_string.c_str(), &time_);
-  }
-
-  void AdvanceTime(TimeDelta delta) {
-    time_ += delta;
-  }
-
-  void AdvanceTimeTicks(TimeDelta delta) {
-    time_ticks_ += delta;
-  }
-
   DummyPrerenderContents* CreateNextPrerenderContents(
       const GURL& url,
       FinalStatus expected_final_status) {
     return SetNextPrerenderContents(base::MakeUnique<DummyPrerenderContents>(
         this, url, ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN,
         expected_final_status));
   }
 
   DummyPrerenderContents* CreateNextPrerenderContents(
       const GURL& url,
@@ skipping 16 matching lines @@
   }
 
   void set_rate_limit_enabled(bool enabled) {
     mutable_config().rate_limit_enabled = enabled;
   }
 
   PrerenderContents* next_prerender_contents() {
     return next_prerender_contents_.get();
   }
 
-  // from PrerenderManager
-  Time GetCurrentTime() const override { return time_; }
-
-  TimeTicks GetCurrentTimeTicks() const override { return time_ticks_; }
-
   PrerenderContents* GetPrerenderContentsForRoute(int child_id,
                                                   int route_id) const override {
     // Overridden for the PrerenderLinkManager's pending prerender logic.
     PrerenderContentsMap::const_iterator it =
         prerender_contents_map_.find(std::make_pair(child_id, route_id));
     return it != prerender_contents_map_.end() ? it->second : nullptr;
   }
 
   void DummyPrerenderContentsStarted(int child_id,
                                      int route_id,
                                      PrerenderContents* prerender_contents) {
     prerender_contents_map_[std::make_pair(child_id, route_id)] =
         prerender_contents;
   }
 
   void DummyPrerenderContentsDestroyed(int child_id,
                                        int route_id) {
     prerender_contents_map_.erase(std::make_pair(child_id, route_id));
   }
 
   void SetIsLowEndDevice(bool is_low_end_device) {
     is_low_end_device_ = is_low_end_device;
   }
 
+  UnittestTime* unittest_time() const { return unittest_time_ptr_; }
+
  private:
   bool IsLowEndDevice() const override { return is_low_end_device_; }
 
   DummyPrerenderContents* SetNextPrerenderContents(
       std::unique_ptr<DummyPrerenderContents> prerender_contents) {
     CHECK(!next_prerender_contents_);
     DummyPrerenderContents* contents_ptr = prerender_contents.get();
     next_prerender_contents_ = std::move(prerender_contents);
     return contents_ptr;
   }
 
   std::unique_ptr<PrerenderContents> CreatePrerenderContents(
       const GURL& url,
       const Referrer& referrer,
       Origin origin) override {
     CHECK(next_prerender_contents_);
     EXPECT_EQ(url, next_prerender_contents_->prerender_url());
     EXPECT_EQ(origin, next_prerender_contents_->origin());
     return std::move(next_prerender_contents_);
   }
 
   // Maintain a map from route pairs to PrerenderContents for
   // GetPrerenderContentsForRoute.
   using PrerenderContentsMap =
       std::map<std::pair<int, int>, PrerenderContents*>;
   PrerenderContentsMap prerender_contents_map_;
 
-  Time time_;
-  TimeTicks time_ticks_;
+  UnittestTime* unittest_time_ptr_;
   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_); }
@@ skipping 264 matching lines @@
 // Ensure that we expire a prerendered page after the max. permitted time.
 TEST_F(PrerenderTest, ExpireTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_TIMED_OUT);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_FALSE(prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().time_to_live + TimeDelta::FromSeconds(1));
   ASSERT_FALSE(prerender_manager()->FindEntry(url));
 }
 
 // Ensure that we don't launch prerenders of bad urls (in this case, a mailto:
 // url)
 TEST_F(PrerenderTest, BadURLTest) {
   GURL url("mailto:test@gmail.com");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
@@ skipping 23 matching lines @@
       prerender_manager()->CreateNextPrerenderContents(url,
                                                        FINAL_STATUS_TIMED_OUT);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                last_prerender_id());
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
   EXPECT_FALSE(prerender_manager()->next_prerender_contents());
-  prerender_manager()->AdvanceTimeTicks(test_advance);
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(test_advance);
 
   EXPECT_FALSE(prerender_manager()->FindEntry(url));
 }
 
 // But when we navigate away very close to the original expiry of a prerender,
 // we shouldn't expect it to be extended.
 TEST_F(PrerenderTest, LinkManagerNavigateAwayNearExpiry) {
   const TimeDelta time_to_live = TimeDelta::FromSeconds(300);
   const TimeDelta abandon_time_to_live = TimeDelta::FromSeconds(20);
 
@@ skipping 13 matching lines @@
 
   GURL url("http://example2.com");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(url,
                                                        FINAL_STATUS_TIMED_OUT);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
 
-  prerender_manager()->AdvanceTimeTicks(first_advance);
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(first_advance);
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
 
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                last_prerender_id());
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
 
   EXPECT_FALSE(prerender_manager()->next_prerender_contents());
 
-  prerender_manager()->AdvanceTimeTicks(second_advance);
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(second_advance);
   EXPECT_FALSE(prerender_manager()->FindEntry(url));
 }
 
 // When the user navigates away from a page, and then launches a new prerender,
 // the new prerender should preempt the abandoned prerender even if the
 // abandoned prerender hasn't expired.
 TEST_F(PrerenderTest, LinkManagerNavigateAwayLaunchAnother) {
   const TimeDelta time_to_live = TimeDelta::FromSeconds(300);
   const TimeDelta abandon_time_to_live = TimeDelta::FromSeconds(20);
   const TimeDelta test_advance = TimeDelta::FromSeconds(5);
   ASSERT_LT(test_advance, time_to_live);
   ASSERT_GT(abandon_time_to_live, test_advance);
 
   prerender_manager()->mutable_config().time_to_live = time_to_live;
   prerender_manager()->mutable_config().abandon_time_to_live =
       abandon_time_to_live;
 
   GURL url("http://example.com");
   prerender_manager()->CreateNextPrerenderContents(url, FINAL_STATUS_CANCELLED);
   EXPECT_TRUE(AddSimplePrerender(url));
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                last_prerender_id());
 
-  prerender_manager()->AdvanceTimeTicks(test_advance);
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(test_advance);
 
   GURL second_url("http://example2.com");
   DummyPrerenderContents* second_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           second_url, FINAL_STATUS_MANAGER_SHUTDOWN);
   EXPECT_TRUE(AddSimplePrerender(second_url));
   EXPECT_EQ(second_prerender_contents,
             prerender_manager()->FindEntry(second_url));
 }
 
@@ skipping 311 matching lines @@
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_RECENTLY_VISITED);
   EXPECT_FALSE(AddSimplePrerender(url));
   EXPECT_FALSE(prerender_contents->prerendering_has_started());
 }
 
 TEST_F(PrerenderTest, NotSoRecentlyVisited) {
   GURL url("http://www.google.com/");
 
   prerender_manager()->RecordNavigation(url);
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       TimeDelta::FromMilliseconds(
           UnitTestPrerenderManager::kNavigationRecordWindowMs + 500));
 
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
@@ skipping 128 matching lines @@
   EXPECT_FALSE(prerender_handle);
   EXPECT_FALSE(prerender_contents->prerendering_has_started());
 }
 
 // Checks that the "PrerenderSilence experiment does not disable offline
 // prerendering.
 TEST_F(PrerenderTest, PrerenderSilenceAllowsOffline) {
   // Set the time to 30 seconds before the experiment expires.
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "PrerenderSilence", "ExperimentYes_expires_2016-12-20T00:01:00Z"));
-  ASSERT_TRUE(prerender_manager()->SetTime("2016-12-20T00:00:30Z"));
+  ASSERT_TRUE(
+      prerender_manager()->unittest_time()->SetTime("2016-12-20T00:00:30Z"));
   GURL url("http://www.google.com/");
   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 "PrerenderSilence" experiment disables prerendering.
 TEST_F(PrerenderTest, PrerenderSilenceDisallowsNonOffline) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "PrerenderSilence", "ExperimentYes_expires_2016-12-20T00:02:00Z"));
   const Origin origins[] = {
       ORIGIN_GWS_PRERENDER,
       ORIGIN_OMNIBOX,
       ORIGIN_NONE,
       ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN,
       ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN,
       ORIGIN_EXTERNAL_REQUEST,
       ORIGIN_INSTANT,
       ORIGIN_LINK_REL_NEXT,
       ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
   };
-  ASSERT_TRUE(prerender_manager()->SetTime("2016-12-20T00:01:00Z"));
+  ASSERT_TRUE(
+      prerender_manager()->unittest_time()->SetTime("2016-12-20T00:01:00Z"));
   for (const Origin& origin : origins) {
     EXPECT_TRUE(
         prerender_manager()->IsPrerenderSilenceExperimentForTesting(origin));
   }
 }
 
 // Checks that prerendering is enabled after expiration of the
 // "PrerenderSilence" experiment.
 TEST_F(PrerenderTest, PrerenderSilenceAllowsAfterExpiration) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "PrerenderSilence", "ExperimentYes_expires_2016-12-20T00:02:00Z"));
   GURL url("http://www.google.com/");
-  ASSERT_TRUE(prerender_manager()->SetTime("2016-12-20T00:01:00Z"));
-  prerender_manager()->AdvanceTime(TimeDelta::FromSeconds(60));
+  ASSERT_TRUE(
+      prerender_manager()->unittest_time()->SetTime("2016-12-20T00:01:00Z"));
+  prerender_manager()->unittest_time()->AdvanceTime(TimeDelta::FromSeconds(60));
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(url, FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
   ASSERT_EQ(prerender_contents, entry.get());
 }
 
 TEST_F(PrerenderTest, PrerenderAllowedForOfflineAndForcedCellular) {
@@ skipping 274 matching lines @@
   GURL url("http://www.myexample.com");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_TIMED_OUT);
 
   EXPECT_TRUE(AddSimplePrerender(url));
 
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().time_to_live + TimeDelta::FromSeconds(1));
 
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
   ASSERT_FALSE(prerender_manager()->FindEntry(url));
   prerender_link_manager()->OnCancelPrerender(kDefaultChildId,
                                               last_prerender_id());
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   ASSERT_FALSE(prerender_manager()->FindEntry(url));
 }
 
 TEST_F(PrerenderTest, LinkManagerExpireThenAddAgain) {
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   GURL url("http://www.myexample.com");
   DummyPrerenderContents* first_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_TIMED_OUT);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(first_prerender_contents->prerendering_has_started());
   EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(first_prerender_contents,
             prerender_manager()->FindEntry(url));
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().time_to_live + TimeDelta::FromSeconds(1));
   ASSERT_FALSE(prerender_manager()->FindEntry(url));
   DummyPrerenderContents* second_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(second_prerender_contents->prerendering_has_started());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
   ASSERT_EQ(second_prerender_contents, entry.get());
@@ skipping 31 matching lines @@
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_TIMED_OUT);
 
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
 
   prerender_link_manager()->OnChannelClosing(kDefaultChildId);
 
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().abandon_time_to_live +
       TimeDelta::FromSeconds(1));
 
   EXPECT_FALSE(prerender_manager()->FindEntry(url));
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Creates two prerenders, one of which should be blocked by the
 // max_link_concurrency; abandons both of them and waits to make sure both
 // are cleared from the PrerenderLinkManager.
@@ skipping 15 matching lines @@
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(second_url));
 
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                first_prerender_id);
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                second_prerender_id);
 
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().abandon_time_to_live +
       TimeDelta::FromSeconds(1));
   EXPECT_FALSE(prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(second_url));
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Creates two prerenders, the second one started by the first, both of which
 // should be blocked by max_concurrency; abandons both of them and waits to make
 // sure both are cleared from the PrerenderLinkManager.
@@ skipping 22 matching lines @@
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(pending_url));
 
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                first_prerender_id);
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                second_prerender_id);
 
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().abandon_time_to_live +
       TimeDelta::FromSeconds(1));
   EXPECT_FALSE(prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(pending_url));
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Creates two prerenders, one of which should be blocked by the
 // max_link_concurrency; uses one after the max wait to launch, and
 // ensures the second prerender does not start.
 TEST_F(PrerenderTest, LinkManagerWaitToLaunchNotLaunched) {
   SetConcurrency(1);
   ASSERT_LT(prerender_manager()->config().max_wait_to_launch,
             prerender_manager()->config().time_to_live);
   GURL first_url("http://www.myexample.com");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           first_url, FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(first_url));
 
   GURL second_url("http://www.neverlaunched.com");
   EXPECT_FALSE(AddSimplePrerender(second_url));
 
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(second_url));
 
-  prerender_manager()->AdvanceTimeTicks(
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
       prerender_manager()->config().max_wait_to_launch +
       TimeDelta::FromSeconds(1));
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(second_url));
 
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(first_url);
   EXPECT_EQ(prerender_contents, entry.get());
 
   EXPECT_FALSE(prerender_manager()->FindEntry(first_url));
@@ skipping 24 matching lines @@
   const TimeDelta wait_for_first_prerender_to_expire =
       prerender_manager()->config().time_to_live -
       wait_to_launch_second_prerender +
       TimeDelta::FromSeconds(1);
   ASSERT_LT(prerender_manager()->config().time_to_live,
             wait_to_launch_second_prerender +
             wait_for_first_prerender_to_expire);
   ASSERT_GT(prerender_manager()->config().max_wait_to_launch.InSeconds(),
             wait_for_first_prerender_to_expire.InSeconds());
 
-  prerender_manager()->AdvanceTimeTicks(wait_to_launch_second_prerender);
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
+      wait_to_launch_second_prerender);
   GURL second_url("http://www.willlaunch.com");
   DummyPrerenderContents* second_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           second_url, FINAL_STATUS_USED);
   EXPECT_FALSE(AddSimplePrerender(second_url));
 
   // The first prerender is still running, but the second has not yet launched.
   EXPECT_EQ(first_prerender_contents,
             prerender_manager()->FindEntry(first_url));
   EXPECT_FALSE(prerender_manager()->FindEntry(second_url));
 
   // The first prerender should have died, giving life to the second one.
-  prerender_manager()->AdvanceTimeTicks(wait_for_first_prerender_to_expire);
+  prerender_manager()->unittest_time()->AdvanceTimeTicks(
+      wait_for_first_prerender_to_expire);
   EXPECT_FALSE(prerender_manager()->FindEntry(first_url));
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(second_url);
   EXPECT_EQ(second_prerender_contents, entry.get());
 }
 
 TEST_F(PrerenderTest, InstantSearchNotAllowedWhenDisabled) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "EmbeddedSearch",
       "Group82 espv:8 use_cacheable_ntp:1 prefetch_results:1"));
@@ skipping 39 matching lines @@
   prerender_contents->SetPrerenderMode(PREFETCH_ONLY);
   EXPECT_TRUE(prerender_contents->IsValidHttpMethod("GET"));
   EXPECT_TRUE(prerender_contents->IsValidHttpMethod("HEAD"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("OPTIONS"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("POST"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("TRACE"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("WHATEVER"));
 }
 
 }  // namespace prerender