Experiment to disable Prerendering with fast wind-down

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 130 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,
@@ skipping 936 matching lines @@
           url,
           ORIGIN_EXTERNAL_REQUEST,
           FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle(
       prerender_manager()->AddPrerenderFromExternalRequest(
           url, content::Referrer(), nullptr, gfx::Rect(kSize)));
   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"));
+  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"));
+  GURL url("http://www.google.com/");
+  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"));
+  for (const Origin& origin : origins) {
+    std::unique_ptr<PrerenderHandle> prerender_handle(
+        prerender_manager()->AddPrerender(origin, url, content::Referrer(),
+                                          gfx::Rect(kSize), nullptr));
+    EXPECT_FALSE(prerender_handle);
+  }
+}
+
+// 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));
+  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) {
   const Origin origins[] = {
     ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
     ORIGIN_OFFLINE,
   };
 
   EnablePrerender();
   std::unique_ptr<net::NetworkChangeNotifier> mock(
       new MockNetworkChangeNotifier4G);
   EXPECT_TRUE(net::NetworkChangeNotifier::IsConnectionCellular(
@@ skipping 544 matching lines @@
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_INSTANT, prerender_handle->contents()->origin());
   std::unique_ptr<PrerenderContents> entry =
       prerender_manager()->FindAndUseEntry(url);
   ASSERT_EQ(prerender_contents, entry.get());
   EXPECT_FALSE(prerender_handle->IsPrerendering());
 }
 
 }  // namespace prerender