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_prerenders_.push_back(
+      PendingPrerenderInfo(weak_prerender_handle, url, referrer, size));
 }
 
-bool PrerenderContents::IsPendingEntry(const GURL& url) const {
-  for (PendingPrerenderList::const_iterator it =
-           pending_prerender_list_.begin();
-       it != pending_prerender_list_.end();
+bool PrerenderContents::IsPendingEntry(
+    const PrerenderHandle& prerender_handle) const {
+  for (std::vector<PendingPrerenderInfo>::const_iterator it =
+           pending_prerenders_.begin();
+       it != pending_prerenders_.end();
        ++it) {
-    if (it->url == url)
+    if (it->weak_prerender_handle.get() == &prerender_handle)
       return true;
   }
   return false;
 }
 
 void PrerenderContents::StartPendingPrerenders() {
-  PendingPrerenderList pending_prerender_list;
-  pending_prerender_list.swap(pending_prerender_list_);
-  for (PendingPrerenderList::iterator it = pending_prerender_list.begin();
+  SessionStorageNamespace* session_storage_namespace = NULL;
+  if (RenderViewHost* render_view_host = GetRenderViewHostMutable())
+    session_storage_namespace = render_view_host->GetSessionStorageNamespace();
+  DCHECK(child_id_ == -1 || session_storage_namespace);
+
+  std::vector<PendingPrerenderInfo> pending_prerender_list;
+  pending_prerender_list.swap(pending_prerenders_);
+  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_,
+          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;

[mmenke, 2012/07/11 18:40:05]

I'm still concerned about this, since it makes the code incorrect.  It looks
like there's a session_storage_namespace_.id() field that we can use instead,
and then we won't have to worry about lifetime issues.  It's unique across the
process, and will never be reused until Chrome is restarted (Well, at least it
will be millenia before the field overflows...).

[gavinp, 2012/07/11 21:19:30]

Done. This was one of your most important comments in your previous review, and
I should have remediated to it then. Thanks for repeating it.

   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