Handle interface to prerenders.

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 <functional>
 #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_handle.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/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/icon_messages.h"
 #include "chrome/common/prerender_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/browser_child_process_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_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"
 
 using content::DownloadItem;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::ResourceRedirectDetails;
+using content::SessionStorageNamespace;
 using content::WebContents;
 
 namespace prerender {
 
 namespace {
 
-// Compares URLs ignoring any ref for the purposes of matching URLs when
-// prerendering.
-struct PrerenderURLPredicate {
-  explicit PrerenderURLPredicate(const GURL& url)
-      : url_(url) {
-  }
-
-  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.
 void InformRenderProcessAboutPrerender(const GURL& url,
                                        bool is_add,
                                        int child_id) {
   if (child_id < 0)
@@ skipping 16 matching lines @@
  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);
   }
 };
 
-struct PrerenderContents::PendingPrerenderInfo {
-  PendingPrerenderInfo(const GURL& url,
-                       const content::Referrer& referrer,
-                       const gfx::Size& size);
-  const GURL url;
-  const content::Referrer referrer;
-  const gfx::Size size;
-};
-
-PrerenderContents::PendingPrerenderInfo::PendingPrerenderInfo(
-    const GURL& url,
-    const content::Referrer& referrer,
-    const gfx::Size& size)
-    : url(url),
-      referrer(referrer),
-      size(size) {
-}
-
 // TabContentsDelegateImpl -----------------------------------------------------
 
 class PrerenderContents::TabContentsDelegateImpl
     : public content::WebContentsDelegate {
  public:
   explicit TabContentsDelegateImpl(PrerenderContents* prerender_contents) :
       prerender_contents_(prerender_contents) {
   }
 
   // content::WebContentsDelegate implementation:
   virtual WebContents* OpenURLFromTab(WebContents* source,
-                                     const OpenURLParams& params) OVERRIDE {
+                                      const OpenURLParams& params) OVERRIDE {
     // |OpenURLFromTab| is typically called when a frame performs a navigation
     // that requires the browser to perform the transition instead of WebKit.
     // Examples include prerendering a site that redirects to an app URL,
     // or if --enable-strict-site-isolation is specified and the prerendered
     // frame redirects to a different origin.
     // TODO(cbentzel): Consider supporting this if it is a common case during
     // prerenders.
     prerender_contents_->Destroy(FINAL_STATUS_OPEN_URL);
     return NULL;
   }
@@ skipping 75 matching lines @@
  private:
   typedef std::vector<scoped_refptr<history::HistoryAddPageArgs> >
       AddPageVector;
 
   // Caches pages to be added to the history.
   AddPageVector add_page_vector_;
 
   PrerenderContents* prerender_contents_;
 };
 
-void PrerenderContents::AddPendingPrerender(const GURL& url,
-                                            const content::Referrer& referrer,
-                                            const gfx::Size& size) {
-  pending_prerender_list_.push_back(PendingPrerenderInfo(url, referrer, size));
+void PrerenderContents::AddPendingPrerender(
+    const base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+    const GURL& url,
+    const content::Referrer& referrer,
+    const gfx::Size& size) {
+  pending_prerender_list_.push_back(
+      PendingPrerenderInfo(weak_prerender_handle, url, referrer, size));
 }
 
-bool PrerenderContents::IsPendingEntry(const GURL& url) const {
-  for (PendingPrerenderList::const_iterator it =
+bool PrerenderContents::IsPendingEntry(
+    const PrerenderHandle* prerender_handle) const {
+  for (std::vector<PendingPrerenderInfo>::const_iterator it =

[dominich, 2012/07/03 17:08:39]

Another reason to not remove the typedef - you would have only had to change the
type in one place.

            pending_prerender_list_.begin();
        it != pending_prerender_list_.end();
        ++it) {
-    if (it->url == url)
+    if (it->weak_prerender_handle.get() == prerender_handle)

[dominich, 2012/07/03 17:08:39]

i'm curious how this compiled before. it /should/ be ok to compare a weak_ptr to
a raw pointer, but I don't know exactly what code the compiler would have
inserted to do that, given there's no overloaded operator== that I can see.

[gavinp, 2012/07/03 18:45:41]

See base::WeakPtr<T>::operator T*() { return get(); }

The language allows one implicit conversion when searching for a function, so it
was calling that conversion to get a PrerenderHandle*, then using the default
bool ::operator==(PrerenderHandle*, PrerenderHandle*).

[dominich, 2012/07/03 20:02:41]

Aha!

I do not like that one bit. However, it is not something to tackle here.

[gavinp, 2012/07/04 03:01:17]

I concur that it's out of scope. You might be surprised to see how distinct
std::weak_ptr is from base::WeakPtr. Short answer? Very distinct.

       return true;
   }
   return false;
 }
 
 void PrerenderContents::StartPendingPrerenders() {
-  PendingPrerenderList pending_prerender_list;
+  SessionStorageNamespace* session_storage_namespace = NULL;
+  if (RenderViewHost* render_view_host = GetRenderViewHostMutable()) {
+    session_storage_namespace = render_view_host->GetSessionStorageNamespace();
+  } else {
+    DCHECK_EQ(-1, child_id_)
+        << "session_storage_namespace != NULL, except in tests";
+  }
+
+  std::vector<PendingPrerenderInfo> pending_prerender_list;
   pending_prerender_list.swap(pending_prerender_list_);
-  for (PendingPrerenderList::iterator it = pending_prerender_list.begin();
+  for (std::vector<PendingPrerenderInfo>::iterator it =
+           pending_prerender_list.begin();
        it != pending_prerender_list.end();
        ++it) {
-    prerender_manager_->AddPrerenderFromLinkRelPrerender(
-        child_id_, route_id_, it->url, it->referrer, it->size);
+    if (it->weak_prerender_handle && it->weak_prerender_handle->IsValid()) {
+      prerender_manager_->StartPendingPrerender(
+          it->weak_prerender_handle.get(), ORIGIN_LINK_REL_PRERENDER, child_id_,

[dominich, 2012/07/03 17:08:39]

and again - how did this compile?

[mmenke, 2012/07/09 18:06:57]

It's actually pretty common to rely on the weak pointer to pointer cast operator
in the Chromium code base.  I think relying on it in a comparison is a *very*
bad idea because of the NULL case, however.

+          it->url, it->referrer, it->size, session_storage_namespace);
+    }
   }
 }
 
+PrerenderContents::PendingPrerenderInfo::PendingPrerenderInfo(
+    const base::WeakPtr<PrerenderHandle> weak_prerender_handle,
+    const GURL& url,
+    const content::Referrer& referrer,
+    const gfx::Size& size)
+    : weak_prerender_handle(weak_prerender_handle),
+      url(url),
+      referrer(referrer),
+      size(size) {
+}
+
+PrerenderContents::PendingPrerenderInfo::~PendingPrerenderInfo() {
+}
+
 PrerenderContents::PrerenderContents(
     PrerenderManager* prerender_manager,
     PrerenderTracker* prerender_tracker,
     Profile* profile,
     const GURL& url,
     const content::Referrer& referrer,
     Origin origin,
     uint8 experiment_id)
     : prerendering_has_started_(false),
       prerender_manager_(prerender_manager),
       prerender_tracker_(prerender_tracker),
       prerender_url_(url),
       referrer_(referrer),
       profile_(profile),
       page_id_(0),
+      session_storage_namespace_(NULL),
       has_stopped_loading_(false),
       has_finished_loading_(false),
       final_status_(FINAL_STATUS_MAX),
       match_complete_status_(MATCH_COMPLETE_DEFAULT),
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
       origin_(origin),
       experiment_id_(experiment_id),
       creator_child_id_(-1) {
   DCHECK(prerender_manager != NULL);
 }
 
+void PrerenderContents::MakeIntoDummyReplacementOf(
+    const PrerenderContents* original_prerender_contents) {
+  load_start_time_ = original_prerender_contents->load_start_time_;
+  session_storage_namespace_ =
+      original_prerender_contents->session_storage_namespace_;
+}
+
 bool PrerenderContents::Init() {
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     int creator_child_id,
     const gfx::Size& size,
-    content::SessionStorageNamespace* session_storage_namespace,
+    SessionStorageNamespace* session_storage_namespace,
     bool is_control_group) {
   DCHECK(profile_ != NULL);
   DCHECK(!size.IsEmpty());
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
   DCHECK_EQ(-1, creator_child_id_);
   DCHECK(size_.IsEmpty());
   DCHECK_EQ(1U, alias_urls_.size());
 
   creator_child_id_ = creator_child_id;
+  session_storage_namespace_ = session_storage_namespace;
   size_ = size;
 
   InformRenderProcessAboutPrerender(prerender_url_, true,
                                     creator_child_id_);
 
+  DCHECK(load_start_time_.is_null());
+  load_start_time_ = base::TimeTicks::Now();
+
   // Everything after this point sets up the WebContents object and associated
   // RenderView for the prerender page. Don't do this for members of the
   // control group.
   if (is_control_group)
     return;
 
   prerendering_has_started_ = true;
 
   WebContents* new_contents = CreateWebContents(session_storage_namespace);
   prerender_contents_.reset(new TabContents(new_contents));
@@ skipping 35 matching lines @@
   // Register to inform new RenderViews that we're prerendering.
   notification_registrar_.Add(
       this, content::NOTIFICATION_RENDER_VIEW_HOST_CREATED_FOR_TAB,
       content::Source<WebContents>(new_contents));
 
   // Register for redirect notifications sourced from |this|.
   notification_registrar_.Add(
       this, content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
       content::Source<WebContents>(GetWebContents()));
 
-  DCHECK(load_start_time_.is_null());
-  load_start_time_ = base::TimeTicks::Now();
-
   // Transfer over the user agent override.
   new_contents->SetUserAgentOverride(
       prerender_manager_->config().user_agent_override);
 
   new_contents->GetController().LoadURLWithUserAgentOverride(
       prerender_url_,
       referrer_,
       (origin_ == ORIGIN_OMNIBOX ? content::PAGE_TRANSITION_TYPED :
                                    content::PAGE_TRANSITION_LINK),
       false,
@@ skipping 113 matching lines @@
       NOTREACHED() << "Unexpected notification sent.";
       break;
   }
 }
 
 void PrerenderContents::OnRenderViewHostCreated(
     RenderViewHost* new_render_view_host) {
 }
 
 WebContents* PrerenderContents::CreateWebContents(
-    content::SessionStorageNamespace* session_storage_namespace) {
+    SessionStorageNamespace* session_storage_namespace) {
   return  WebContents::Create(profile_, NULL, MSG_ROUTING_NONE, NULL,
                               session_storage_namespace);
 }
 
 void PrerenderContents::OnUpdateFaviconURL(
     int32 page_id,
     const std::vector<FaviconURL>& urls) {
   VLOG(1) << "PrerenderContents::OnUpdateFaviconURL" << icon_url_;
   for (std::vector<FaviconURL>::const_iterator it = urls.begin();
        it != urls.end(); ++it) {
@@ skipping 31 matching lines @@
 
 void PrerenderContents::AddAliasURLsFromOtherPrerenderContents(
     PrerenderContents* other_pc) {
   for (std::vector<GURL>::const_iterator it = other_pc->alias_urls_.begin();
        it != other_pc->alias_urls_.end();
        ++it) {
     alias_urls_.push_back(*it);
   }
 }
 
-bool PrerenderContents::MatchesURL(const GURL& url, GURL* matching_url) const {
-  std::vector<GURL>::const_iterator matching_url_iterator =
-      std::find_if(alias_urls_.begin(),
-                   alias_urls_.end(),
-                   PrerenderURLPredicate(url));
-  if (matching_url_iterator != alias_urls_.end()) {
-    if (matching_url)
-      *matching_url = *matching_url_iterator;
-    return true;
-  }
-  return false;
+bool PrerenderContents::Matches(
+    const GURL& url,
+    const SessionStorageNamespace* session_storage_namespace) {
+  if (session_storage_namespace_ != session_storage_namespace)
+    return false;
+  return std::count_if(alias_urls_.begin(), alias_urls_.end(),
+                       std::bind2nd(std::equal_to<GURL>(), url)) != 0;
 }
 
 void PrerenderContents::RenderViewGone(base::TerminationStatus status) {
   Destroy(FINAL_STATUS_RENDERER_CRASHED);
 }
 
 void PrerenderContents::DidStopLoading() {
   has_stopped_loading_ = true;
 }
 
@@ skipping 132 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