Update prerender policy for custom tabs

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 282 matching lines @@
     return NULL;
   return AddPrerender(ORIGIN_OMNIBOX, url, content::Referrer(), size,
                       session_storage_namespace);
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderFromExternalRequest(
     const GURL& url,
     const content::Referrer& referrer,
     SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
-  return AddPrerender(ORIGIN_EXTERNAL_REQUEST, url, referrer, size,
+  return AddPrerender(
+      ORIGIN_EXTERNAL_REQUEST, url, referrer, size, session_storage_namespace);
+}
+
+PrerenderHandle* PrerenderManager::AddPrerenderOnCellularFromExternalRequest(
+    const GURL& url,
+    const content::Referrer& referrer,
+    SessionStorageNamespace* session_storage_namespace,
+    const gfx::Size& size) {
+  return AddPrerender(ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR,
+                      url,
+                      referrer,
+                      size,
                       session_storage_namespace);
 }
 
 PrerenderHandle* PrerenderManager::AddPrerenderForInstant(
     const GURL& url,
     content::SessionStorageNamespace* session_storage_namespace,
     const gfx::Size& size) {
   DCHECK(search::ShouldPrefetchSearchResults());
   return AddPrerender(ORIGIN_INSTANT, url, content::Referrer(), size,
                       session_storage_namespace);
@@ skipping 256 matching lines @@
   histograms_->RecordPageLoadTimeNotSwappedIn(origin, page_load_time, url);
 }
 
 void PrerenderManager::RecordPerceivedPageLoadTime(
     Origin origin,
     NavigationType navigation_type,
     base::TimeDelta perceived_page_load_time,
     double fraction_plt_elapsed_at_swap_in,
     const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (GetPredictionStatus() != NetworkPredictionStatus::ENABLED)
+  if (GetPredictionStatusForOrigin(origin)
+      != NetworkPredictionStatus::ENABLED) {
     return;
+  }
 
   histograms_->RecordPerceivedPageLoadTime(
       origin, perceived_page_load_time, navigation_type, url);
 
   if (navigation_type == NAVIGATION_TYPE_PRERENDERED) {
     histograms_->RecordPercentLoadDoneAtSwapin(
         origin, fraction_plt_elapsed_at_swap_in);
   }
 }
 
@@ skipping 192 matching lines @@
   return DoesURLHaveValidScheme(url) || url == GURL(url::kAboutBlankURL);
 }
 
 base::DictionaryValue* PrerenderManager::GetAsValue() const {
   DCHECK(CalledOnValidThread());
   base::DictionaryValue* dict_value = new base::DictionaryValue();
   dict_value->Set("history", prerender_history_->GetEntriesAsValue());
   dict_value->Set("active", GetActivePrerendersAsValue());
   dict_value->SetBoolean("enabled",
       GetPredictionStatus() == NetworkPredictionStatus::ENABLED);
+  std::string disabled_note;
+  if (GetPredictionStatus() == NetworkPredictionStatus::DISABLED_ALWAYS)
+    disabled_note = "Disabled by user setting";
+  if (GetPredictionStatus() == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK)
+    disabled_note = "Disabled on cellular connection by default";
+  dict_value->SetString("disabled_note", disabled_note);
   dict_value->SetBoolean("omnibox_enabled", IsOmniboxEnabled(profile_));
   // If prerender is disabled via a flag this method is not even called.
   std::string enabled_note;
   if (IsControlGroup())
     enabled_note += "(Control group: Not actually prerendering) ";
   if (IsNoUseGroup())
     enabled_note += "(No-use group: Not swapping in prerendered pages) ";
   if (GetMode() == PRERENDER_MODE_EXPERIMENT_15MIN_TTL_GROUP)
     enabled_note +=
         "(15 min TTL group: Extended prerender eviction to 15 mins) ";
@@ skipping 131 matching lines @@
   // From here on, we will record a FinalStatus so we need to register with the
   // histogram tracking.
   histograms_->RecordPrerender(origin, url_arg);
 
   if (profile_->GetPrefs()->GetBoolean(prefs::kBlockThirdPartyCookies)) {
     RecordFinalStatusWithoutCreatingPrerenderContents(
         url, origin, FINAL_STATUS_BLOCK_THIRD_PARTY_COOKIES);
     return nullptr;
   }
 
-  NetworkPredictionStatus prerendering_status = GetPredictionStatus();
+  NetworkPredictionStatus prerendering_status =
+      GetPredictionStatusForOrigin(origin);
   if (prerendering_status != NetworkPredictionStatus::ENABLED) {
     FinalStatus final_status =
         prerendering_status == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK
             ? FINAL_STATUS_CELLULAR_NETWORK
             : FINAL_STATUS_PRERENDERING_DISABLED;
     RecordFinalStatusWithoutCreatingPrerenderContents(url, origin,
                                                       final_status);
     return nullptr;
   }
 
@@ skipping 328 matching lines @@
   DCHECK_GE(recent_profile_bytes, 0);
   histograms_->RecordNetworkBytes(
       origin, used, prerender_bytes, recent_profile_bytes);
 }
 
 NetworkPredictionStatus PrerenderManager::GetPredictionStatus() const {
   DCHECK(CalledOnValidThread());
   return CanPrefetchAndPrerenderUI(profile_->GetPrefs());
 }
 
+NetworkPredictionStatus PrerenderManager::GetPredictionStatusForOrigin(
+    Origin origin) const {
+  DCHECK(CalledOnValidThread());
+  NetworkPredictionStatus prediction_status =
+      CanPrefetchAndPrerenderUI(profile_->GetPrefs());
+  if (prediction_status == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK
+      && origin == ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR) {
+    prediction_status = NetworkPredictionStatus::ENABLED;
+  }
+  return prediction_status;
+}
+
 void PrerenderManager::AddProfileNetworkBytesIfEnabled(int64_t bytes) {
   DCHECK_GE(bytes, 0);
   if (GetPredictionStatus() == NetworkPredictionStatus::ENABLED &&
       ActuallyPrerendering())
     profile_network_bytes_ += bytes;
 }
 
 void PrerenderManager::AddPrerenderProcessHost(
     content::RenderProcessHost* process_host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 13 matching lines @@
 }
 
 void PrerenderManager::RenderProcessHostDestroyed(
     content::RenderProcessHost* host) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   size_t erased = prerender_process_hosts_.erase(host);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace prerender