Prerendered pages are swapped in at browser::Navigate time.

chrome/browser/prerender/prerender_contents.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_contents.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/process_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/history/history_tab_helper.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_render_view_host_observer.h"
 #include "chrome/browser/prerender/prerender_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/icon_messages.h"
-#include "chrome/common/render_messages.h"
+#include "chrome/common/prerender_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/browser/web_contents_view.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 19 matching lines @@
   bool operator()(const GURL& url) const {
     return url.scheme() == url_.scheme() &&
            url.host() == url_.host() &&
            url.port() == url_.port() &&
            url.path() == url_.path() &&
            url.query() == url_.query();
   }
   GURL url_;
 };
 
+// Tells the render process at |child_id| whether |url| is a new prerendered
+// page, or whether |url| is being removed as a prerendered page. Currently
+// this will only inform the render process that created the prerendered page
+// with <link rel="prerender"> tags about it. This means that if the user
+// clicks on a link for a prerendered URL in a different page, the prerender
+// will not be swapped in.

[Charlie Reis, 2012/03/01 19:06:03]

I think this is the right call.  For reference, we may eventually have renderers
check in with the browser on every navigation (e.g., if we enforce strict site
isolation).  In that case the browser would be able to make a more informed
decision.

+void InformRenderProcessAboutPrerender(const GURL& url,
+                                       bool is_add,
+                                       int child_id) {
+  if (child_id < 0)
+    return;
+  content::RenderProcessHost* render_process_host =
+      content::RenderProcessHost::FromID(child_id);
+  if (!render_process_host)
+    return;
+  IPC::Message* message = NULL;
+  if (is_add)
+    message = new PrerenderMsg_AddPrerenderURL(url);
+  else
+    message = new PrerenderMsg_RemovePrerenderURL(url);

[Charlie Reis, 2012/03/01 19:06:03]

Just as a sanity check, we don't need to be concerned about races here, right? 
If a renderer thinks we can prerender it and we've since deleted, we'll just
load it from scratch.  And if it thinks we can't prerender it but we can, it's
just some wasted effort.  Seems ok to me.

[cbentzel, 2012/03/01 22:18:53]

You are correct - there is not a race here.

I commented about the impact of a delayed RemovePrerenderURL case in ShouldFork
- would it help to copy here as well?

[Charlie Reis, 2012/03/01 22:24:38]

That comment is sufficient, thanks.  This file just came up earlier in my
review.

+  render_process_host->Send(message);
+}
+
 }  // end namespace
 
 class PrerenderContentsFactoryImpl : public PrerenderContents::Factory {
  public:
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager, PrerenderTracker* prerender_tracker,
       Profile* profile, const GURL& url, const content::Referrer& referrer,
       Origin origin, uint8 experiment_id) OVERRIDE {
     return new PrerenderContents(prerender_manager, prerender_tracker, profile,
                                  url, referrer, origin, experiment_id);
@@ skipping 146 matching lines @@
       page_id_(0),
       has_stopped_loading_(false),
       has_finished_loading_(false),
       final_status_(FINAL_STATUS_MAX),
       prerendering_has_started_(false),
       match_complete_status_(MATCH_COMPLETE_DEFAULT),
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
       origin_(origin),
-      experiment_id_(experiment_id) {
+      experiment_id_(experiment_id),
+      creator_child_id_(-1) {
   DCHECK(prerender_manager != NULL);
 }
 
 bool PrerenderContents::Init() {
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     const RenderViewHost* source_render_view_host,
     content::SessionStorageNamespace* session_storage_namespace) {
   DCHECK(profile_ != NULL);
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
 
   prerendering_has_started_ = true;
+  DCHECK(creator_child_id_ == -1);
+  if (source_render_view_host)
+    creator_child_id_ = source_render_view_host->process()->GetID();
+  InformRenderProcessAboutPrerender(prerender_url_, true,
+                                    creator_child_id_);
+
   WebContents* new_contents = WebContents::Create(
       profile_, NULL, MSG_ROUTING_NONE, NULL, session_storage_namespace);
   prerender_contents_.reset(new TabContentsWrapper(new_contents));
   content::WebContentsObserver::Observe(new_contents);
 
   gfx::Rect tab_bounds = prerender_manager_->config().default_tab_bounds;
   if (source_render_view_host) {
     DCHECK(source_render_view_host->view() != NULL);
     WebContents* source_wc =
         source_render_view_host->delegate()->GetAsWebContents();
@@ skipping 95 matching lines @@
   DCHECK(prerendering_has_been_cancelled_ ||
          final_status_ == FINAL_STATUS_USED);
   DCHECK(origin_ != ORIGIN_MAX);
 
   prerender_manager_->RecordFinalStatusWithMatchCompleteStatus(
       origin_,
       experiment_id_,
       match_complete_status_,
       final_status_);
 
-  if (child_id_ != -1 && route_id_ != -1)
+  if (child_id_ != -1 && route_id_ != -1) {
     prerender_tracker_->OnPrerenderingFinished(child_id_, route_id_);
+    InformRenderProcessAboutPrerender(prerender_url_, false, creator_child_id_);
+  }
 
   // If we still have a TabContents, clean up anything we need to and then
   // destroy it.
   if (prerender_contents_.get())
     delete ReleasePrerenderContents();
 
   // The following URLs are no longer rendering.
   prerender_tracker_->RemovePrerenderURLsOnUIThread(alias_urls_);
 }
 
@@ skipping 34 matching lines @@
 
         content::Details<RenderViewHost> new_render_view_host(details);
         OnRenderViewHostCreated(new_render_view_host.ptr());
 
         // When a new RenderView is created for a prerendering TabContents,
         // tell the new RenderView it's being used for prerendering before any
         // navigations occur.  Note that this is always triggered before the
         // first navigation, so there's no need to send the message just after
         // the TabContents is created.
         new_render_view_host->Send(
-            new ChromeViewMsg_SetIsPrerendering(
+            new PrerenderMsg_SetIsPrerendering(
                 new_render_view_host->routing_id(),
                 true));
 
         // Make sure the size of the RenderViewHost has been passed to the new
         // RenderView.  Otherwise, the size may not be sent until the
         // RenderViewReady event makes it from the render process to the UI
         // thread of the browser process.  When the RenderView receives its
         // size, is also sets itself to be visible, which would then break the
         // visibility API.
         new_render_view_host->WasResized();
@@ skipping 226 matching lines @@
 bool PrerenderContents::IsCrossSiteNavigationPending() const {
   if (!prerender_contents_.get() || !prerender_contents_->web_contents())
     return false;
   const WebContents* web_contents = prerender_contents_->web_contents();
   return (web_contents->GetSiteInstance() !=
           web_contents->GetPendingSiteInstance());
 }
 
 
 }  // namespace prerender