New link rel=prerender api, using WebKit::WebPrerenderingPlatform

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 <set>
 #include <string>
+#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 150 matching lines @@
 // static
 int PrerenderManager::prerenders_per_session_count_ = 0;
 
 // static
 PrerenderManager::PrerenderManagerMode PrerenderManager::mode_ =
     PRERENDER_MODE_ENABLED;
 
 struct PrerenderManager::PrerenderContentsData {
   PrerenderContents* contents_;
   base::Time start_time_;
+  int active_count_;
   PrerenderContentsData(PrerenderContents* contents, base::Time start_time)
       : contents_(contents),
-        start_time_(start_time) {
+        start_time_(start_time),
+        active_count_(1) {
     CHECK(contents);
   }
 };
 
 struct PrerenderManager::NavigationRecord {
   GURL url_;
   base::TimeTicks time_;
   NavigationRecord(const GURL& url, base::TimeTicks time)
       : url_(url),
         time_(time) {
@@ skipping 76 matching lines @@
 }
 
 void PrerenderManager::Shutdown() {
   DoShutdown();
 }
 
 bool PrerenderManager::AddPrerenderFromLinkRelPrerender(
     int process_id,
     int route_id,
     const GURL& url,
-    const content::Referrer& referrer) {
+    const content::Referrer& referrer,
+    const gfx::Size& size) {
 #if defined(OS_ANDROID)
   // TODO(jcivelli): http://crbug.com/113322 We should have an option to disable
   //                link-prerender and enable omnibox-prerender only.
   return false;
 #else
-  std::pair<int, int> child_route_id_pair = std::make_pair(process_id,
-                                                           route_id);
+  std::pair<int, int> child_route_id_pair(process_id, route_id);
+  PrerenderContentsDataList::iterator it =
+      FindPrerenderContentsForChildRouteIdPair(child_route_id_pair);
+  if (it != prerender_list_.end()) {
+    // Instead of prerendering from inside of a running prerender, we will defer
+    // this request until its launcher is made visible.
+    it->contents_->AddPendingPrerender(url, referrer, size);

[cbentzel, 2012/05/02 15:54:22]

This will add a pending prerender even if the PrerenderManager is not enabled -
unlikely, but could happen when a prerender is created, the user swaps the
setting for whether it is allowed, and then a <link rel="prerender"> is created
inside it.

[gavinp, 2012/05/02 16:23:42]

Yes.  The funny behaviour from this is:

1. User has prerendering on, and goes to a page that launches PrerenderPage
2. The PrerenderPage prerenders FirstPendingPrerender!
2. The user turns off prerendering.
3. The PrerenderPage prerenders SecondPendingPrerender, which gets put in the
pending list.
4. The user then goes and turns prerendering back on.
5. The user navigates to PrerenderPage, and then the pending prerenders are
added, which includes both FirstPendingPrerender and SecondPendingPrerender.

If the user didn't turn prerendering on in step (4) above, then we won't launch
the pending prerenders because of the IsEnabled check in AddPrerender.  The
behaviour previously would have been to launch only FirstPendingPrerender,
right?

[cbentzel, 2012/05/04 15:32:25]

Correct.

+    return true;
+  }
 
-  return AddPrerender(ORIGIN_LINK_REL_PRERENDER, child_route_id_pair,
-                      url, referrer, NULL);
+  // Unit tests pass in a process_id == -1.
+  RenderViewHost* source_render_view_host = NULL;
+  SessionStorageNamespace* session_storage_namespace = NULL;
+  if (process_id != -1) {
+    source_render_view_host =
+        RenderViewHost::FromID(process_id, route_id);
+    if (!source_render_view_host || !source_render_view_host->GetView())
+      return false;
+    session_storage_namespace =
+        source_render_view_host->GetSessionStorageNamespace();
+  }
+
+  return AddPrerender(ORIGIN_LINK_REL_PRERENDER,
+                      process_id, url, referrer, size,
+                      session_storage_namespace);
 #endif
 }
 
 bool PrerenderManager::AddPrerenderFromOmnibox(
     const GURL& url,
     SessionStorageNamespace* session_storage_namespace) {
   if (!IsOmniboxEnabled(profile_))
     return false;
-  return AddPrerender(ORIGIN_OMNIBOX, std::make_pair(-1, -1), url,
-                      content::Referrer(), session_storage_namespace);
+  return AddPrerender(ORIGIN_OMNIBOX, -1, url,
+                      content::Referrer(), gfx::Size(),
+                      session_storage_namespace);
+}
+
+void PrerenderManager::MaybeCancelPrerender(const GURL& url) {
+  PrerenderContentsDataList::iterator it = FindPrerenderContentsForURL(url);
+  if (it == prerender_list_.end())
+    return;
+  PrerenderContentsData& prerender_contents_data = *it;
+  if (--prerender_contents_data.active_count_ == 0)
+    prerender_contents_data.contents_->Destroy(FINAL_STATUS_CANCELLED);
 }
 
 void PrerenderManager::DestroyPrerenderForRenderView(
     int process_id, int view_id, FinalStatus final_status) {
   DCHECK(CalledOnValidThread());
   PrerenderContentsDataList::iterator it =
       FindPrerenderContentsForChildRouteIdPair(
           std::make_pair(process_id, view_id));
   if (it != prerender_list_.end()) {
     PrerenderContents* prerender_contents = it->contents_;
     prerender_contents->Destroy(final_status);
   }
 }
 
 void PrerenderManager::CancelAllPrerenders() {
   DCHECK(CalledOnValidThread());
   while (!prerender_list_.empty()) {
     PrerenderContentsData data = prerender_list_.front();
     DCHECK(data.contents_);
     data.contents_->Destroy(FINAL_STATUS_CANCELLED);
   }
 }
 
 void PrerenderManager::CancelOmniboxPrerenders() {

[cbentzel, 2012/05/02 15:54:22]

Does this need to change so the omnibox prerendering uses the MaybeCancel
instead?

   DCHECK(CalledOnValidThread());
   for (PrerenderContentsDataList::iterator it = prerender_list_.begin();
        it != prerender_list_.end(); ) {
     PrerenderContentsDataList::iterator cur = it++;
     if (cur->contents_->origin() == ORIGIN_OMNIBOX)
       cur->contents_->Destroy(FINAL_STATUS_CANCELLED);
   }
 }
 
 bool PrerenderManager::MaybeUsePrerenderedPage(WebContents* web_contents,
@@ skipping 484 matching lines @@
 void PrerenderManager::DoShutdown() {
   DestroyAllContents(FINAL_STATUS_MANAGER_SHUTDOWN);
   STLDeleteElements(&prerender_conditions_);
   on_close_tab_contents_deleters_.reset();
   profile_ = NULL;
 }
 
 // private
 bool PrerenderManager::AddPrerender(
     Origin origin,
-    const std::pair<int, int>& child_route_id_pair,
+    int process_id,
     const GURL& url_arg,
     const content::Referrer& referrer,
+    const gfx::Size& size,
     SessionStorageNamespace* session_storage_namespace) {
   DCHECK(CalledOnValidThread());
 
   if (!IsEnabled())
     return false;
 
   if (origin == ORIGIN_LINK_REL_PRERENDER &&
       IsGoogleSearchResultURL(referrer.url)) {
     origin = ORIGIN_GWS_PRERENDER;
   }
 
-  // If the referring page is prerendering, defer the prerender.
-  PrerenderContentsDataList::iterator source_prerender =
-      FindPrerenderContentsForChildRouteIdPair(child_route_id_pair);
-  if (source_prerender != prerender_list_.end()) {
-    source_prerender->contents_->AddPendingPrerender(
-        origin, url_arg, referrer);
-    return true;
-  }
-
   DeleteOldEntries();
   DeletePendingDeleteEntries();
 
   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);
 
   uint8 experiment = GetQueryStringBasedExperiment(url_arg);
 
-  if (FindEntry(url)) {
+  if (PrerenderContentsData* prerender_contents_data = FindEntryData(url)) {
+    ++prerender_contents_data->active_count_;
     RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE);
-    return false;
+    return true;
   }
 
   // Do not prerender if there are too many render processes, and we would
   // have to use an existing one.  We do not want prerendering to happen in
   // a shared process, so that we can always reliably lower the CPU
   // priority for prerendering.
   // In single-process mode, ShouldTryToUseExistingProcessHost() always returns
   // true, so that case needs to be explicitly checked for.
   // TODO(tburkard): Figure out how to cancel prerendering in the opposite
   // case, when a new tab is added to a process used for prerendering.
@@ skipping 10 matching lines @@
 
   // Check if enough time has passed since the last prerender.
   if (!DoesRateLimitAllowPrerender()) {
     // 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.
     RecordFinalStatus(origin, experiment, FINAL_STATUS_RATE_LIMIT_EXCEEDED);
     return false;
   }
 
-  RenderViewHost* source_render_view_host = NULL;
-  if (child_route_id_pair.first != -1) {
-    source_render_view_host =
-        RenderViewHost::FromID(child_route_id_pair.first,
-                               child_route_id_pair.second);
-    // Don't prerender page if parent RenderViewHost no longer exists, or it has
-    // no view.  The latter should only happen when the RenderView has closed.
-    if (!source_render_view_host || !source_render_view_host->GetView()) {
-      RecordFinalStatus(origin, experiment,
-                        FINAL_STATUS_SOURCE_RENDER_VIEW_CLOSED);
-      return false;
-    }
-  }
-
-  if (!session_storage_namespace && source_render_view_host) {
-    session_storage_namespace =
-        source_render_view_host->GetSessionStorageNamespace();
-  }
-
   PrerenderContents* prerender_contents = CreatePrerenderContents(
       url, referrer, origin, experiment);
   if (!prerender_contents || !prerender_contents->Init())
     return false;
 
   histograms_->RecordPrerenderStarted(origin);
 
   // TODO(cbentzel): Move invalid checks here instead of PrerenderContents?
   PrerenderContentsData data(prerender_contents, GetCurrentTime());
 
   prerender_list_.push_back(data);
 
   last_prerender_start_time_ = GetCurrentTimeTicks();
 
   if (!IsControlGroup()) {
-    data.contents_->StartPrerendering(source_render_view_host,
-                                      session_storage_namespace);
+    data.contents_->StartPrerendering(process_id,
+                                      size, session_storage_namespace);
   }
   while (prerender_list_.size() > config_.max_elements) {
     data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->Destroy(FINAL_STATUS_EVICTED);
   }
   StartSchedulingPeriodicCleanups();
   return true;
 }
 
@@ skipping 130 matching lines @@
 }
 
 void PrerenderManager::DeletePendingDeleteEntries() {
   while (!pending_delete_list_.empty()) {
     PrerenderContents* contents = pending_delete_list_.front();
     pending_delete_list_.pop_front();
     delete contents;
   }
 }
 
+PrerenderManager::PrerenderContentsData* PrerenderManager::FindEntryData(
+    const GURL& url) {
+  DCHECK(CalledOnValidThread());
+  PrerenderContentsDataList::iterator it = FindPrerenderContentsForURL(url);
+  if (it == prerender_list_.end())
+    return NULL;
+  PrerenderContentsData& prerender_contents_data = *it;
+  return &prerender_contents_data;
+}
+
 PrerenderContents* PrerenderManager::FindEntry(const GURL& url) const {
   DCHECK(CalledOnValidThread());
   for (PrerenderContentsDataList::const_iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     if (it->contents_->MatchesURL(url, NULL))
       return it->contents_;
   }
   // Entry not found.
   return NULL;
 }
 
-std::list<PrerenderManager::PrerenderContentsData>::iterator
+PrerenderManager::PrerenderContentsDataList::iterator
     PrerenderManager::FindPrerenderContentsForChildRouteIdPair(
         const std::pair<int, int>& child_route_id_pair) {
   PrerenderContentsDataList::iterator it = prerender_list_.begin();
   for (; it != prerender_list_.end(); ++it) {
     PrerenderContents* prerender_contents = it->contents_;
 
     int child_id;
     int route_id;
     bool has_child_id = prerender_contents->GetChildId(&child_id);
     bool has_route_id = has_child_id &&
                         prerender_contents->GetRouteId(&route_id);
 
     if (has_child_id && has_route_id &&
         child_id == child_route_id_pair.first &&
         route_id == child_route_id_pair.second) {
       break;
     }
   }
   return it;
 }
 
+PrerenderManager::PrerenderContentsDataList::iterator
+    PrerenderManager::FindPrerenderContentsForURL(const GURL& url) {
+  for (PrerenderContentsDataList::iterator it = prerender_list_.begin();
+       it != prerender_list_.end(); ++it) {
+    if (it->contents_->MatchesURL(url, NULL))
+      return it;
+  }
+  return prerender_list_.end();
+}
+
 bool PrerenderManager::DoesRateLimitAllowPrerender() const {
   DCHECK(CalledOnValidThread());
   base::TimeDelta elapsed_time =
       GetCurrentTimeTicks() - last_prerender_start_time_;
   histograms_->RecordTimeBetweenPrerenderRequests(elapsed_time);
   if (!config_.rate_limit_enabled)
     return true;
   return elapsed_time >
       base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
 }
@@ skipping 114 matching lines @@
   if (!render_process_host || !render_process_host->GetBrowserContext())
     return NULL;
   Profile* profile = Profile::FromBrowserContext(
       render_process_host->GetBrowserContext());
   if (!profile)
     return NULL;
   return PrerenderManagerFactory::GetInstance()->GetForProfile(profile);
 }
 
 }  // namespace prerender