Disable No-State prefetch for offline origins.

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 82 matching lines @@
 // Because of this, it is okay to show prerendered contents even if
 // |extra_headers| contains "Upgrade-Insecure-Requests" header.
 bool AreExtraHeadersCompatibleWithPrerenderContents(
     const std::string& extra_headers) {
   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;
+}
+
 }  // namespace
 
 class PrerenderManager::OnCloseWebContentsDeleter
     : public content::WebContentsDelegate,
       public base::SupportsWeakPtr<
           PrerenderManager::OnCloseWebContentsDeleter> {
  public:
   OnCloseWebContentsDeleter(PrerenderManager* manager,
                             std::unique_ptr<WebContents> tab)
       : manager_(manager), tab_(std::move(tab)), suppressed_dialog_(false) {
@@ skipping 489 matching lines @@
 void PrerenderManager::SetMode(PrerenderManagerMode mode) {
   mode_ = mode;
 }
 
 // static
 bool PrerenderManager::IsPrerenderingPossible() {
   return GetMode() != PRERENDER_MODE_DISABLED;
 }
 
 // static
-bool PrerenderManager::IsNoStatePrefetch() {
-  return GetMode() == PRERENDER_MODE_NOSTATE_PREFETCH;
+bool PrerenderManager::IsNoStatePrefetch(Origin origin) {
+  return !IsPrerenderingForced(origin) &&
+         GetMode() == PRERENDER_MODE_NOSTATE_PREFETCH;
 }
 
 // static
-bool PrerenderManager::IsSimpleLoadExperiment() {
-  return GetMode() == PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT;
+bool PrerenderManager::IsSimpleLoadExperiment(Origin origin) {
+  return !IsPrerenderingForced(origin) &&
+         GetMode() == PRERENDER_MODE_SIMPLE_LOAD_EXPERIMENT;
 }
 
 bool PrerenderManager::IsWebContentsPrerendering(
     const WebContents* web_contents,
     Origin* origin) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrerenderContents* prerender_contents = GetPrerenderContents(web_contents);
   if (!prerender_contents)
     return false;
 
@@ skipping 314 matching lines @@
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
     RecordFinalStatusWithoutCreatingPrerenderContents(
         url, origin, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return nullptr;
   }
 
   // Record the URL in the prefetch list, even when in full prerender mode, to
   // enable metrics comparisons.
   prefetches_.emplace_back(url, GetCurrentTimeTicks(), origin);

[pasko, 2016/12/16 17:23:00]

Just to double-check that I understand: modifying the prefetches_ is OK here
because they are used only for histograms, and we would just ignore the
prefetches_-based histograms for these two origins?

[droger, 2016/12/16 18:35:47]

Yes, exactly.

This messes up our metrics a bit but luckily most (all?) our histograms are
split by origin and we can easily exclude these.

 
-  if (IsSimpleLoadExperiment()) {
+  if (IsSimpleLoadExperiment(origin)) {
     // Exit after adding the url to prefetches_, so that no prefetching occurs
     // but the page is still tracked as "would have been prefetched".
     return nullptr;
   }
 
   std::unique_ptr<PrerenderContents> prerender_contents =
       CreatePrerenderContents(url, referrer, origin);
   DCHECK(prerender_contents);
   PrerenderContents* prerender_contents_ptr = prerender_contents.get();
-  if (IsNoStatePrefetch())
+  if (IsNoStatePrefetch(origin))
     prerender_contents_ptr->SetPrerenderMode(PREFETCH_ONLY);
   active_prerenders_.push_back(
       base::MakeUnique<PrerenderData>(this, std::move(prerender_contents),
                                       GetExpiryTimeForNewPrerender(origin)));
   if (!prerender_contents_ptr->Init()) {
     DCHECK(active_prerenders_.end() ==
            FindIteratorForPrerenderContents(prerender_contents_ptr));
     return nullptr;
   }
 
@@ skipping 385 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