New link rel=prerender api, using WebKit::WebPrerenderingPlatform

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 78 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);
   }
 };
 
-PrerenderContents::PendingPrerenderData::PendingPrerenderData(
-    Origin origin,
-    const GURL& url,
-    const content::Referrer& referrer)
-    : origin(origin),
-      url(url),
-      referrer(referrer) {
-}
-
 // TabContentsDelegateImpl -----------------------------------------------------
 
 class PrerenderContents::TabContentsDelegateImpl
     : public content::WebContentsDelegate {
  public:
   explicit TabContentsDelegateImpl(PrerenderContents* prerender_contents) :
       prerender_contents_(prerender_contents) {
   }
 
  virtual WebContents* OpenURLFromTab(WebContents* source,
@@ skipping 72 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(Origin origin,
-                                            const GURL& url,
+void PrerenderContents::AddPendingPrerender(const GURL& url,

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

I was worried about the loss of Origin here, but it's absolutely valid that you
can't have pending Omnibox prerenders. However, with other prerender origins
potentially coming down the pike it might be premature to remove it.

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

I'll ping Timo, who's writing the history navigator.  Otherwise I can't think of
any other origins that would require this delay.  Can you?

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

None that are in active development, and it would be reasonably trivial to add
it back if necessary. I agree that the reduction in API complexity given the
current state of the implementation is worth it.

                                             const content::Referrer& referrer) {
   pending_prerender_list_.push_back(

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

nit: this line should be merged with the one below

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

Done.

-      PendingPrerenderData(origin, url, referrer));
+      PendingPrerenderData(url, referrer));
 }
 
 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)
+    if (it->first == 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_->AddPrerender(it->origin,
-                                     std::make_pair(child_id_, route_id_),
-                                     it->url,
-                                     it->referrer,
-                                     NULL);
+    RenderViewHost* render_view_host = RenderViewHost::FromID(child_id_,
+                                                              route_id_);
+    prerender_manager_->AddPrerenderFromLinkRelPrerender(

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

as above, this assumption makes me nervous.

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

I think it's easy enough to add back if we need to.

+        child_id_, route_id_, it->first, it->second, size_,

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

is it possible that the WebView size has changed since the pending prerender was
added? Maybe get the size again from the RenderViewHost here?

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

I believe that the prerender can't change size while it's not visible and
prerendering, but mmenke will know better.  It would be a shame if it could,
since then in this case we'd be back to using the less reliable sizes from the
RenderViewHost in the delayed prerendering case.

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

It sounds like we already have an issue that we might prerender at one size and
then resize on swap. In which case this should work the same as the existing
code, which is reasonable.

[mmenke, 2012/04/30 18:35:22]

It's currently not possible for a hidden WebView to be resized, but I would be
happier using the size passed along with the prerender request, rather than
depend on that.

+        render_view_host->GetSessionStorageNamespace());
   }
 }
 
 PrerenderContents::PrerenderContents(
     PrerenderManager* prerender_manager,
     PrerenderTracker* prerender_tracker,
     Profile* profile,
     const GURL& url,
     const content::Referrer& referrer,
     Origin origin,
@@ skipping 21 matching lines @@
 bool PrerenderContents::Init() {
   return AddAliasURL(prerender_url_);
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
 void PrerenderContents::StartPrerendering(
-    const RenderViewHost* source_render_view_host,
+    int creator_child_id,
+    const gfx::Size& size,
     content::SessionStorageNamespace* session_storage_namespace) {
   DCHECK(profile_ != NULL);
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
+  DCHECK_EQ(-1, creator_child_id_);
+  DCHECK(size_.IsEmpty());
+
+  creator_child_id_ = creator_child_id;
+  size_ = size;
 
   prerendering_has_started_ = true;
-  DCHECK(creator_child_id_ == -1);
-  DCHECK(alias_urls_.size() == 1);
-  if (source_render_view_host)
-    creator_child_id_ = source_render_view_host->GetProcess()->GetID();
+  DCHECK_EQ(1U, alias_urls_.size());
   InformRenderProcessAboutPrerender(prerender_url_, true,
                                     creator_child_id_);
 
   WebContents* new_contents = CreateWebContents(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->GetView() != NULL);
-    WebContents* source_wc =
-        source_render_view_host->GetDelegate()->GetAsWebContents();
-    if (source_wc) {
-      // Set the size of the new TC to that of the old TC.
-      source_wc->GetView()->GetContainerBounds(&tab_bounds);
-    }
-  } else {
+  if (size_.IsEmpty()) {

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

will this ever happen now the size is coming from the WebView directly?

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

Yes.  Omnibox prerendering is probably the biggest cause.

+    size_ = prerender_manager_->config().default_tab_bounds.size();
 #if !defined(OS_ANDROID)
     // Try to get the active tab of the active browser and use that for tab
     // bounds. If the browser has never been active, we will fail to get a size
     // but we shouldn't be prerendering in that case anyway.
     //
     // This code is unneeded on Android as we do not have a Browser object so we
     // can't get the size, and |default_tab_bounds| will be set to the right
     // value.
-    Browser* active_browser = BrowserList::GetLastActiveWithProfile(profile_);
-    if (active_browser) {
+    if (Browser* active_browser =
+            BrowserList::GetLastActiveWithProfile(profile_)) {
       WebContents* active_web_contents = active_browser->GetWebContentsAt(
           active_browser->active_index());
+      gfx::Rect container_bounds;
       if (active_web_contents)
-        active_web_contents->GetView()->GetContainerBounds(&tab_bounds);
+        active_web_contents->GetView()->GetContainerBounds(&container_bounds);
+      size_ = container_bounds.size();
     }
 #endif  // !defined(OS_ANDROID)
   }
 
   tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   new_contents->SetDelegate(tab_contents_delegate_.get());
 
   // Set the size of the prerender WebContents.
-  prerender_contents_->web_contents()->GetView()->SizeContents(
-      tab_bounds.size());
+  prerender_contents_->web_contents()->GetView()->SizeContents(size_);
 
   // Register as an observer of the RenderViewHost so we get messages.
   render_view_host_observer_.reset(
       new PrerenderRenderViewHostObserver(this, GetRenderViewHostMutable()));
 
   child_id_ = GetRenderViewHost()->GetProcess()->GetID();
   route_id_ = GetRenderViewHost()->GetRoutingID();
 
   // Register this with the ResourceDispatcherHost as a prerender
   // RenderViewHost. This must be done before the Navigate message to catch all
@@ skipping 373 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