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 {

[pasko, 2016/10/05 12:35:25]

Compared to the other TimeOverride this one only adds SetTime() which I believe
will be shorter and more concise if implemented in the same class and the rest
of the code would hence avoid duplication.

Alternative to the design in this change would be to add the time override only
in tests that need it, and there the initial value of tests could be taken from
base::Time::Now() for most of the tests and for the special case of
PrerenderSilence* it would take the time from string.

I think that would be simpler overall.

[mattcary, 2016/10/10 11:54:43]

I think the use of time in prerender_browsertest.cc is confusing, because Time
and TimeTicks are treated differently: TimeTicks are always based on Now(),
whereas Time can be set to an arbitrary date. In that latter case, TimeTicks are
out of sync with the Time, which seems dangerous to me.

So I didn't want to use that same behavior in the new tests. I also don't want
to do a big change with these old tests.

Finally, since these time override classes are so short, I think it's much more
readable and maintainable to have two different classes, rather than some
inheritance which makes it difficult to read what exactly the class does by
spreading it out into two different locations.

[pasko, 2016/10/10 12:40:20]

That does not look dangerous to me. TimeTicks and Time should have discrepancies
by design. Compare on POSIX:
1. TimeTicks::Now(): https://linux.die.net/man/3/clock_gettime
2. Time::Now(): http://man7.org/linux/man-pages/man2/gettimeofday.2.html

Note that nothing stops the wall clock (i.e. (2)) to jump back in time, and it
does. When getting out of hibernation, Time jumps much more than TimeTicks.
TimeTicks is a special animal, and had interesting bugs on some old AMD CPUs for
not synchronizing clock ticks between cores. Different API, different
assumptions.
I disagree. Remembering which type of time override is which requires extra
mental load when reading the code and jumping to definitions, the names do not
logically explain the core of the difference.

[mattcary, 2016/10/10 13:56:08]

Discussed offline, added todo & task to use SimpleTestClock etc.

+   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 112 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