Enable forced prerenders on wifi

chrome/browser/prerender/prerender_manager.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 "chrome/browser/prerender/prerender_manager.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <functional>
@@ skipping 87 matching lines @@
   net::HttpRequestHeaders parsed_headers;
   parsed_headers.AddHeadersFromString(extra_headers);
   parsed_headers.RemoveHeader("upgrade-insecure-requests");
   return parsed_headers.IsEmpty();
 }
 
 // Returns true if prerendering is forced, because it is needed as a feature, as
 // opposed to a performance optimization.
 bool IsPrerenderingForced(Origin origin) {
   return origin == ORIGIN_OFFLINE ||
-         origin == ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR;
+         origin == ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER;
 }
 
 }  // namespace
 
 class PrerenderManager::OnCloseWebContentsDeleter
     : public content::WebContentsDelegate,
       public base::SupportsWeakPtr<
           PrerenderManager::OnCloseWebContentsDeleter> {
  public:
   OnCloseWebContentsDeleter(PrerenderManager* manager,
@@ skipping 151 matching lines @@
 PrerenderManager::AddPrerenderFromExternalRequest(
     const GURL& url,
     const content::Referrer& referrer,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Rect& bounds) {
   return AddPrerender(ORIGIN_EXTERNAL_REQUEST, url, referrer,
                       bounds, session_storage_namespace);
 }
 
 std::unique_ptr<PrerenderHandle>
-PrerenderManager::AddPrerenderOnCellularFromExternalRequest(
+PrerenderManager::AddForcedPrerenderFromExternalRequest(
     const GURL& url,
     const content::Referrer& referrer,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Rect& bounds) {
-  return AddPrerender(ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
-                      url,
-                      referrer,
-                      bounds,
-                      session_storage_namespace);
+  return AddPrerender(ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER, url, referrer,
+                      bounds, session_storage_namespace);
 }
 
 std::unique_ptr<PrerenderHandle> PrerenderManager::AddPrerenderForInstant(
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   return AddPrerender(ORIGIN_INSTANT, url, content::Referrer(), gfx::Rect(size),
                       session_storage_namespace);
 }
 
@@ skipping 1034 matching lines @@
   int64_t recent_profile_bytes =
       profile_network_bytes_ - last_recorded_profile_network_bytes_;
   last_recorded_profile_network_bytes_ = profile_network_bytes_;
   DCHECK_GE(recent_profile_bytes, 0);
   histograms_->RecordNetworkBytes(
       origin, used, prerender_bytes, recent_profile_bytes);
 }
 
 bool PrerenderManager::IsPrerenderSilenceExperiment(Origin origin) const {
   if (origin == ORIGIN_OFFLINE ||
-      origin == ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR) {
+      origin == ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER) {
     return false;
   }
 
   // The group name should contain expiration time formatted as:
   //   "ExperimentYes_expires_YYYY-MM-DDTHH:MM:SSZ".
   std::string group_name =
       base::FieldTrialList::FindFullName("PrerenderSilence");
   const char kExperimentPrefix[] = "ExperimentYes";
   if (!base::StartsWith(group_name, kExperimentPrefix,
                         base::CompareCase::INSENSITIVE_ASCII)) {
@@ skipping 37 matching lines @@
   if (origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN ||
       origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN ||
       origin == ORIGIN_OFFLINE) {
     return NetworkPredictionStatus::ENABLED;
   }
 
   // Prerendering forced for cellular networks still prevents navigation with
   // the DISABLED_ALWAYS selected via privacy settings.
   NetworkPredictionStatus prediction_status =
       chrome_browser_net::CanPrefetchAndPrerenderUI(profile_->GetPrefs());
-  if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR &&
+  if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_PRERENDER &&
       prediction_status == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK) {
     return NetworkPredictionStatus::ENABLED;
   }
   return prediction_status;
 }
 
 void PrerenderManager::AddProfileNetworkBytesIfEnabled(int64_t bytes) {
   DCHECK_GE(bytes, 0);
   if (GetPredictionStatus() == NetworkPredictionStatus::ENABLED &&
       IsPrerenderingPossible())
@@ skipping 29 matching lines @@
   return weak_factory_.GetWeakPtr();
 }
 
 void PrerenderManager::SetPrerenderContentsFactoryForTest(
     PrerenderContents::Factory* prerender_contents_factory) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 }  // namespace prerender