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 add_count_;

[dominich, 2012/04/29 18:52:55]

active_count_?

[gavinp, 2012/04/30 11:43:16]

Done.

   PrerenderContentsData(PrerenderContents* contents, base::Time start_time)
       : contents_(contents),
-        start_time_(start_time) {
+        start_time_(start_time),
+        add_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,
+    SessionStorageNamespace* session_storage_namespace) {
 #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);
-
-  return AddPrerender(ORIGIN_LINK_REL_PRERENDER, child_route_id_pair,
-                      url, referrer, NULL);
+  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);
+    return true;
+  }
+  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(0, 0),
+                      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.add_count_ > 0)

[dominich, 2012/04/29 18:52:55]

why not:

if (--prerender_contents_data.add_count_ == 0)
  prerender_contents_data.contents_->Destroy(FINAL_STATUS_CANCELLED);

[gavinp, 2012/04/30 11:43:16]

Done.

+    return;
+  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_;
@@ skipping 508 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->add_count_;
     RecordFinalStatus(origin, experiment, FINAL_STATUS_DUPLICATE);

[dominich, 2012/04/29 18:52:55]

this is going to mess with the stats. If the prerender is eventually used, it
wouldn't be captured as USED. Maybe we shouldn't record a final status for
these?

[gavinp, 2012/04/30 11:43:16]

Isn't this already exactly the case on pages that launch two prerenders of the
same target?  One is OK, one fails FINAL_STATUS_DUPLICATE, and on navigation,
one gets USED?  Maybe the behaviour is broken, but I don't think this change
breaks it.

[dominich, 2012/04/30 15:52:05]

You're correct, but we do have to be careful with the refcounting here.
Currently, Omnibox calls a specific method on PrerenderManager to cancel all
Omnibox prerenders. We might want to be more surgical should we start multiple
prerenders from the Omnibox and cancel a given URL (PrerenderHandle, whatever).
When that happens, it will be tempting to minimize the API surface and remove
the Omnibox-specific cancellation method and instead use MaybeCancelPrerender.
However this will check the active count before cancelling but, in the case of
the Omnibox, this is incorrect as we can request multiple prerenders for the
same URL but from the same source, unlike the case of <link>. In that case, we
want to cancel the prerender no matter what the active count. In a way, the
active_count should actually be the number of independent sources that have
requested a particular URL.

It's fine for this CL, but would be a very simple mistake for someone (me, when
I will have forgotten about this code review in a month or two)  to make. I
wonder if we can protect against it somehow, either by specifically not
incrementing active_count for Omnibox origin, or something smarter.

-    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;
+  return address_of(*it);
+}
+
 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