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>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/elapsed_timer.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/net/prediction_options.h"
+#include "chrome/browser/prerender/prerender_constants.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_histograms.h"
 #include "chrome/browser/prerender/prerender_history.h"
 #include "chrome/browser/prerender/prerender_manager_factory.h"
 #include "chrome/browser/prerender/prerender_tab_helper.h"
 #include "chrome/browser/prerender/prerender_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 280 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.
+  DCHECK(prerender_contents->origin() != ORIGIN_OFFLINE);

[mmenke, 2016/04/05 18:48:26]

You don't seem to be enforcing this anywhere?  Site instances shouldn't match, I
guess, but I'm really no authority on that.

[gabadie, 2016/04/14 18:28:51]

We rely on the assemption that the offline should have its own namespace storage
not shared with any tabs. Therefore this should never ever be happening.

+
   // 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 552 matching lines @@
 }
 
 void PrerenderManager::PostCleanupTask() {
   DCHECK(CalledOnValidThread());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&PrerenderManager::PeriodicCleanup, AsWeakPtr()));
 }
 
 base::TimeTicks PrerenderManager::GetExpiryTimeForNewPrerender(
     Origin origin) const {
+  if (origin == ORIGIN_OFFLINE)
+    return GetCurrentTimeTicks() + base::TimeDelta::FromMinutes(
+        kOfflinePrerenderLifeExpectancyMinutes);
   return GetCurrentTimeTicks() + config_.time_to_live;
 }
 
 base::TimeTicks PrerenderManager::GetExpiryTimeForNavigatedAwayPrerender()
     const {
   return GetCurrentTimeTicks() + config_.abandon_time_to_live;
 }
 
 void PrerenderManager::DeleteOldEntries() {
   DCHECK(CalledOnValidThread());
@@ skipping 50 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);
+  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