Implement PrerenderManager::AddPrerenderForOffline()

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 307 matching lines @@
 
 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);
 }
 
+PrerenderHandle* PrerenderManager::AddPrerenderForOffline(
+    const GURL& url,
+    content::SessionStorageNamespace* session_storage_namespace,
+    const gfx::Size& size) {
+  return AddPrerender(ORIGIN_OFFLINE, url, content::Referrer(), size,
+                      session_storage_namespace);
+}
+
 void PrerenderManager::CancelAllPrerenders() {
   DCHECK(CalledOnValidThread());
   while (!active_prerenders_.empty()) {
     PrerenderContents* prerender_contents =
         active_prerenders_.front()->contents();
     prerender_contents->Destroy(FINAL_STATUS_CANCELLED);
   }
 }
 
 bool PrerenderManager::MaybeUsePrerenderedPage(const GURL& url,
@@ skipping 187 matching lines @@
     // Schedule the delete to occur after the tab has run its unload handlers.
     // TODO(davidben): Honor the beforeunload event. http://crbug.com/304932
     on_close_web_contents_deleters_.push_back(
         new OnCloseWebContentsDeleter(this, old_web_contents));
     old_web_contents->DispatchBeforeUnload(false);
   } else {
     // No unload handler to run, so delete asap.
     ScheduleDeleteOldWebContents(old_web_contents, NULL);
   }
 
+  // Offline originated prerenders should never ever be swapped-in.
+  CHECK_NE(ORIGIN_OFFLINE, prerender_contents->origin());

[pasko, 2016/04/25 11:29:11]

This comment does not propose to change anything, just thoughts and sharing
common hopefully-wisdom:

Just as mmenke@ I am not a fan of CHECKs, so FindPrerenderData() not returning
stuff with offline origin would be safer, though it'd look 

If we see a CHECK in crash reports, we do not have much context with it. I think
what we would do is patch FindPrerenderData() when/if this happens. Let's see.

[gabadie, 2016/04/25 12:35:11]

I have uploaded a new CL that removed that CHECK, but added a test that
FindPrerenderData() no longer find offline originated prerenders.

+
   // TODO(cbentzel): Should prerender_contents move to the pending delete
   //                 list, instead of deleting directly here?
   AddToHistory(prerender_contents.get());
   RecordNavigation(url);
   return new_web_contents;
 }
 
 void PrerenderManager::MoveEntryToPendingDelete(PrerenderContents* entry,
                                                 FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
@@ skipping 404 matching lines @@
 
   GURL url = url_arg;
   GURL alias_url;
   if (IsControlGroup() && MaybeGetQueryStringBasedAliasURL(url, &alias_url))
     url = alias_url;
 
   // 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)) {
+  if (profile_->GetPrefs()->GetBoolean(prefs::kBlockThirdPartyCookies) &&
+      origin != ORIGIN_OFFLINE) {
     RecordFinalStatusWithoutCreatingPrerenderContents(
         url, origin, FINAL_STATUS_BLOCK_THIRD_PARTY_COOKIES);
     return nullptr;
   }
 
   NetworkPredictionStatus prerendering_status =
       GetPredictionStatusForOrigin(origin);
   if (prerendering_status != NetworkPredictionStatus::ENABLED) {
     FinalStatus final_status =
         prerendering_status == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK
@@ skipping 197 matching lines @@
       return it;
   }
   return active_prerenders_.end();
 }
 
 bool PrerenderManager::DoesRateLimitAllowPrerender(Origin origin) const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
   histograms_->RecordTimeBetweenPrerenderRequests(origin, elapsed_time);
+  // TODO(gabadie,pasko): Re-implement missing tests for
+  // FINAL_STATUS_RATE_LIMIT_EXCEEDED that where removed by:
+  //    http://crrev.com/a2439eeab37f7cb7a118493fb55ec0cb07f93b49.
+  if (origin == ORIGIN_OFFLINE)
+    return true;
   if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >=
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 }
 
 void PrerenderManager::DeleteOldWebContents() {
   while (!old_web_contents_list_.empty()) {
     WebContents* web_contents = old_web_contents_list_.front();
     old_web_contents_list_.pop_front();
@@ skipping 122 matching lines @@
 
 NetworkPredictionStatus PrerenderManager::GetPredictionStatus() const {
   DCHECK(CalledOnValidThread());
   return CanPrefetchAndPrerenderUI(profile_->GetPrefs());
 }
 
 NetworkPredictionStatus PrerenderManager::GetPredictionStatusForOrigin(
     Origin origin) const {
   DCHECK(CalledOnValidThread());
 
-  // LINK rel=prerender origins ignore the network state and the privacy
-  // settings.
+  // <link rel=prerender> origins ignore the network state and the privacy
+  // settings. Web developers should be able prefetch with all possible privacy
+  // settings and with all possible network types. This would avoid web devs
+  // coming up with creative ways to prefetch in cases they are not allowed to
+  // do so.
+  //
+  // Offline originated prerenders also ignore the network state and privacy
+  // settings because they are controlled by the offliner logic via
+  // PrerenderHandle.
   if (origin == ORIGIN_LINK_REL_PRERENDER_SAMEDOMAIN ||
-      origin == ORIGIN_LINK_REL_PRERENDER_CROSSDOMAIN) {
+      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 =
       CanPrefetchAndPrerenderUI(profile_->GetPrefs());
   if (origin == ORIGIN_EXTERNAL_REQUEST_FORCED_CELLULAR &&
       prediction_status == NetworkPredictionStatus::DISABLED_DUE_TO_NETWORK) {
     return NetworkPredictionStatus::ENABLED;
@@ skipping 27 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