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 <utility>
 
 #include "base/process_util.h"
@@ skipping 25 matching lines @@
 using content::DownloadItem;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::ResourceRedirectDetails;
 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) {
-  }
+// A prerender handle that embeds another prerender and acts as a pass-through.
+class PendingPrerender : public PrerenderHandleInterface {

[dominich, 2012/06/18 15:32:44]

I think you're conflating two things here. There's no reason for a
PendingPrerender to be related to a PrerenderHandle. They're related but not the
same thing and I don't see what this adds that wasn't already captured by the
PendingPrerenderInfo struct and list.

[gavinp, 2012/06/18 16:40:48]

This class is gone in the next upload. The question is: if
AddPrerenderFromLinkRelPrerender is always going to returna  PrerenderHandle,
how's that go?

This was one approach; but a better one is to return a real one that just
doesn't have its prerendercontents yet. That's where I'm leaning now.


On 2012/06/18 15:32:44, dominich wrote:

+ public:
+  PendingPrerender();
 
-  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_;
+  bool is_destroyed() const { return is_destroyed_; }
+  void set_prerender(PrerenderHandle prerender) { prerender_ = prerender; }
+
+  virtual bool DidFinishLoading() const OVERRIDE;
+  virtual bool IsPending() const OVERRIDE;
+  
+ private:
+  virtual ~PendingPrerender() OVERRIDE;
+  virtual void Destroy() OVERRIDE;
+
+  bool is_destroyed_;
+  PrerenderHandle prerender_;
 };
 
+PendingPrerender::PendingPrerender() : is_destroyed_(false) { }
+
+bool PendingPrerender::DidFinishLoading() const {
+  if (!prerender_)
+    return false;
+  return prerender_->DidFinishLoading();
+}
+
+bool PendingPrerender::IsPending() const {
+  if (!prerender_)
+    return true;
+  return prerender_->IsPending();
+}
+
+PendingPrerender::~PendingPrerender() {
+  Destroy();
+}
+
+void PendingPrerender::Destroy() {
+  is_destroyed_ = true;
+}
+
 // 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 17 matching lines @@
   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,
+  PendingPrerenderInfo(scoped_refptr<PendingPrerender> prerender,
+                       const GURL& url,
                        const content::Referrer& referrer,
                        const gfx::Size& size);
+  scoped_refptr<PendingPrerender> prerender;
   const GURL url;
   const content::Referrer referrer;
   const gfx::Size size;
 };
 
 PrerenderContents::PendingPrerenderInfo::PendingPrerenderInfo(
+    scoped_refptr<PendingPrerender> prerender,
     const GURL& url,
     const content::Referrer& referrer,
     const gfx::Size& size)
-    : url(url),
+    : prerender(prerender),
+      url(url),
       referrer(referrer),
       size(size) {
 }
 
 // TabContentsDelegateImpl -----------------------------------------------------
 
 class PrerenderContents::TabContentsDelegateImpl
     : public content::WebContentsDelegate {
  public:
   explicit TabContentsDelegateImpl(PrerenderContents* prerender_contents) :
@@ skipping 76 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));
+PrerenderHandle PrerenderContents::AddPendingPrerender(
+    const GURL& url,
+    const content::Referrer& referrer,
+    const gfx::Size& size) {
+  scoped_refptr<PendingPrerender> pending_prerender(new PendingPrerender);
+  pending_prerender_list_.push_back(
+      PendingPrerenderInfo(pending_prerender, url, referrer, size));
+  return pending_prerender;
 }
 
 bool PrerenderContents::IsPendingEntry(const GURL& url) const {
   for (PendingPrerenderList::const_iterator it =
            pending_prerender_list_.begin();
        it != pending_prerender_list_.end();
        ++it) {
     if (it->url == url)
       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();
-       it != pending_prerender_list.end();
-       ++it) {
-    prerender_manager_->AddPrerenderFromLinkRelPrerender(
-        child_id_, route_id_, it->url, it->referrer, it->size);
+       it != pending_prerender_list.end(); ++it) {
+    if (it->prerender->is_destroyed()) continue;
+    it->prerender->set_prerender(

[dominich, 2012/06/18 15:32:44]

Why don't we clear the list of pending prerenders after starting them? Is that a
bug?

[gavinp, 2012/06/18 16:40:48]

Also gone in the new approach.

+        prerender_manager_->AddPrerenderFromLinkRelPrerender(
+            child_id_, route_id_, it->url, it->referrer, it->size));
   }
 }
 
 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),
       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);
+  DVLOG(2) << "PrerenderContents constructor\n";
+  DVLOG(3) << "   url = " << url.spec();
 }
 
-bool PrerenderContents::Init() {
+bool PrerenderContents::Init(WeakPrerenderHandle prerender) {
+  prerender_ = prerender;
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
     int creator_child_id,
@@ skipping 109 matching lines @@
 }
 
 bool PrerenderContents::GetRouteId(int* route_id) const {
   CHECK(route_id);
   DCHECK_GE(route_id_, -1);
   *route_id = route_id_;
   return route_id_ != -1;
 }
 
 void PrerenderContents::set_final_status(FinalStatus final_status) {
-  DCHECK(final_status >= FINAL_STATUS_USED && final_status < FINAL_STATUS_MAX);
-  DCHECK(final_status_ == FINAL_STATUS_MAX);
+  DCHECK_LE(FINAL_STATUS_USED, final_status);
+  DCHECK_GT(FINAL_STATUS_MAX, final_status);
+
+  DCHECK_EQ(FINAL_STATUS_MAX, final_status_);
 
   final_status_ = final_status;
 }
 
 PrerenderContents::~PrerenderContents() {
-  DCHECK(final_status_ != FINAL_STATUS_MAX);
+  DVLOG(4) << "PrerenderContents::~PrerenderContents()";
+  DCHECK_NE(FINAL_STATUS_MAX, final_status_);
   DCHECK(prerendering_has_been_cancelled_ ||
          final_status_ == FINAL_STATUS_USED);
-  DCHECK(origin_ != ORIGIN_MAX);
+  DCHECK_NE(ORIGIN_MAX, origin_);
 
   prerender_manager_->RecordFinalStatusWithMatchCompleteStatus(
       origin_,
       experiment_id_,
       match_complete_status_,
       final_status_);
 
   if (child_id_ != -1 && route_id_ != -1) {
     prerender_tracker_->OnPrerenderingFinished(child_id_, route_id_);
     for (std::vector<GURL>::const_iterator it = alias_urls_.begin();
@@ skipping 125 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;
+bool PrerenderContents::Matches(
+    const GURL& url,
+    const content::SessionStorageNamespace* session_storage_namespace) const {
+  DVLOG(4) << "PrerenderContents::Matches";
+  if (child_id_ != -1) {
+    RenderViewHost* render_view_host =
+        RenderViewHost::FromID(child_id_, route_id_);
+    if (!render_view_host || !render_view_host->GetView() ||
+        session_storage_namespace !=
+            render_view_host->GetSessionStorageNamespace()) {
+      return false;
+    }
   }
-  return false;
+  DCHECK_LE(1, std::count(alias_urls_.begin(), alias_urls_.end(), url));
+  std::vector<GURL>::const_iterator it = std::find(alias_urls_.begin(),
+                                                   alias_urls_.end(), url);
+  return it != alias_urls_.end();
 }
 
 void PrerenderContents::OnJSOutOfMemory() {
   Destroy(FINAL_STATUS_JS_OUT_OF_MEMORY);
 }
 
 void PrerenderContents::RenderViewGone(base::TerminationStatus status) {
   Destroy(FINAL_STATUS_RENDERER_CRASHED);
 }
 
@@ skipping 55 matching lines @@
     if (!prerender_tracker_->GetFinalStatus(child_id_, route_id_,
                                             &final_status)) {
       NOTREACHED();
     }
   }
   set_final_status(final_status);
 
   prerendering_has_been_cancelled_ = true;
   // This has to be done after setting the final status, as it adds the
   // prerender to the history.
-  prerender_manager_->MoveEntryToPendingDelete(this, final_status);
+  if (prerendering_has_started_ && prerender_) {
+    prerender_manager_->MoveEntryToPendingDelete(prerender_, final_status);
+  }
 
   // We may destroy the PrerenderContents before we have initialized the
   // RenderViewHost. Otherwise set the Observer's PrerenderContents to NULL to
   // avoid any more messages being sent.
   if (render_view_host_observer_.get())
     render_view_host_observer_->set_prerender_contents(NULL);
 }
 
 base::ProcessMetrics* PrerenderContents::MaybeGetProcessMetrics() {
   if (process_metrics_.get() == NULL) {
@@ skipping 67 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