Enable forced prerenders on wifi

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 1323 matching lines @@
 // forced-cellular prerendering.
 TEST_F(PrerenderTest, PrerenderSilenceAllowsForcedCellular) {
   // 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(OverridePrerenderManagerTime("2016-12-20T00:00:30Z",
                                            prerender_manager()));
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
-          url, ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
+          url, ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER,
           FINAL_STATUS_MANAGER_SHUTDOWN);
   std::unique_ptr<PrerenderHandle> prerender_handle =
-      prerender_manager()->AddPrerenderOnCellularFromExternalRequest(
+      prerender_manager()->AddForcedPrerenderFromExternalRequest(
           url, content::Referrer(), nullptr, gfx::Rect(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_EXTERNAL_REQUEST_FORCED_CELLULAR,
+  EXPECT_EQ(ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER,
             prerender_handle->contents()->origin());
 }
 
 // Checks that the "PrerenderSilence" experiment disables prerendering and
 // re-enables it after expiration.
 TEST_F(PrerenderTest, PrerenderSilenceDisallowsNonOffline) {
   ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial(
       "PrerenderSilence", "ExperimentYes_expires_2016-12-20T00:02:00Z"));
   Origin prerender_silence_origins[] = {
       ORIGIN_GWS_PRERENDER,
@@ skipping 35 matching lines @@
       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,
+      ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER, ORIGIN_OFFLINE,
   };
 
   EnablePrerender();
   std::unique_ptr<net::NetworkChangeNotifier> mock(
       new MockNetworkChangeNotifier4G);
   EXPECT_TRUE(net::NetworkChangeNotifier::IsConnectionCellular(
       net::NetworkChangeNotifier::GetConnectionType()));
   GURL url("http://www.google.com/");
   for (const Origin& origin : origins) {
     DummyPrerenderContents* prerender_contents = nullptr;
     std::unique_ptr<PrerenderHandle> prerender_handle;
     if (origin == ORIGIN_OFFLINE) {
       prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, origin, FINAL_STATUS_MANAGER_SHUTDOWN);
       prerender_handle =
           prerender_manager()->AddPrerenderForOffline(url, nullptr, kSize);
     } else {
       prerender_contents = prerender_manager()->CreateNextPrerenderContents(
           url, origin, FINAL_STATUS_USED);
       prerender_handle =
-          prerender_manager()->AddPrerenderOnCellularFromExternalRequest(
+          prerender_manager()->AddForcedPrerenderFromExternalRequest(
               url, content::Referrer(), nullptr, gfx::Rect(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, prerender_handle->contents()->origin());
     if (origin != ORIGIN_OFFLINE) {
       std::unique_ptr<PrerenderContents> entry =
           prerender_manager()->FindAndUseEntry(url);
@@ skipping 552 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