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,
                                             const content::Referrer& referrer) {
-  pending_prerender_list_.push_back(
-      PendingPrerenderData(origin, url, referrer));
+  pending_prerender_list_.push_back(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(
+        child_id_, route_id_, it->first, it->second, size_,
+        render_view_host->GetSessionStorageNamespace());

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

I just noticed this fix. Thank you!

   }
 }
 
 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()) {
+    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, render_view_host_mutable()));
+      new PrerenderRenderViewHostObserver(this, GetRenderViewHostMutable()));
 
-  child_id_ = render_view_host()->GetProcess()->GetID();
-  route_id_ = render_view_host()->GetRoutingID();
+  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
   // resource requests, but as it is on the same thread as the Navigate message
   // (IO) there is no race condition.
   prerender_tracker_->OnPrerenderingStarted(
       child_id_,
       route_id_,
       prerender_manager_);
 
@@ skipping 288 matching lines @@
   // 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) {
     // If a PrenderContents hasn't started prerending, don't be fully formed.
-    if (!render_view_host() || !render_view_host()->GetProcess())
+    if (!GetRenderViewHost() || !GetRenderViewHost()->GetProcess())
       return NULL;
-    base::ProcessHandle handle = render_view_host()->GetProcess()->GetHandle();
+    base::ProcessHandle handle = GetRenderViewHost()->GetProcess()->GetHandle();
     if (handle == base::kNullProcessHandle)
       return NULL;
 #if !defined(OS_MACOSX)
     process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(handle));
 #else
     process_metrics_.reset(base::ProcessMetrics::CreateProcessMetrics(
         handle,
         content::BrowserChildProcessHost::GetPortProvider()));
 #endif
   }
@@ skipping 19 matching lines @@
   content::WebContentsObserver::Observe(NULL);
   return prerender_contents_.release();
 }
 
 WebContents* PrerenderContents::GetWebContents() {
   if (!prerender_contents_.get())
     return NULL;
   return prerender_contents_->web_contents();
 }
 
-RenderViewHost* PrerenderContents::render_view_host_mutable() {
-  return const_cast<RenderViewHost*>(render_view_host());
+RenderViewHost* PrerenderContents::GetRenderViewHostMutable() {
+  return const_cast<RenderViewHost*>(GetRenderViewHost());
 }
 
-const RenderViewHost* PrerenderContents::render_view_host() const {
+const RenderViewHost* PrerenderContents::GetRenderViewHost() const {
   if (!prerender_contents_.get())
     return NULL;
   return prerender_contents_->web_contents()->GetRenderViewHost();
 }
 
 void PrerenderContents::CommitHistory(TabContentsWrapper* tab) {
   if (tab_contents_delegate_.get())
     tab_contents_delegate_->CommitHistory(tab);
 }
 
@@ skipping 11 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