Upstreaming prerendering changes for Android.

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 202 matching lines @@
     const content::Referrer& referrer,
     Origin origin,
     uint8 experiment_id)
     : 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),
       prerendering_has_started_(false),
       match_complete_status_(MATCH_COMPLETE_DEFAULT),
       prerendering_has_been_cancelled_(false),
       child_id_(-1),
       route_id_(-1),
       origin_(origin),
       experiment_id_(experiment_id) {
   DCHECK(prerender_manager != NULL);
 }
@@ skipping 13 matching lines @@
   DCHECK(profile_ != NULL);
   DCHECK(!prerendering_has_started_);
   DCHECK(prerender_contents_.get() == NULL);
 
   prerendering_has_started_ = true;
   WebContents* new_contents = WebContents::Create(
       profile_, NULL, MSG_ROUTING_NONE, NULL, session_storage_namespace);
   prerender_contents_.reset(new TabContentsWrapper(new_contents));
   content::WebContentsObserver::Observe(new_contents);
 
   gfx::Rect tab_bounds(640, 480);

[dominich, 2012/02/14 01:11:20]

This is a recent change, but a default is set here for the case that there's no
active browser and no source render view host (which is the case sometimes on
OSX).

   if (source_render_view_host) {
     DCHECK(source_render_view_host->view() != NULL);
     WebContents* source_wc =
         source_render_view_host->delegate()->GetAsWebContents();
     if (source_wc) {
       // Set the size of the new TC to that of the old TC.
       source_wc->GetView()->GetContainerBounds(&tab_bounds);
     }
   } else {
     // 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.
     Browser* active_browser = BrowserList::GetLastActiveWithProfile(profile_);
     if (active_browser) {
       WebContents* active_web_contents = active_browser->GetWebContentsAt(
           active_browser->active_index());
       if (active_web_contents)
         active_web_contents->GetView()->GetContainerBounds(&tab_bounds);
+    } else {
+      gfx::Rect default_tab_bounds = prerender_manager_->default_tab_bounds();

[dominich, 2012/02/14 01:11:20]

So you don't need this unless you want to override the default set above per
platform.

[Jay Civelli, 2012/02/14 03:13:51]

Moved to the config, as you suggested later on.

+      if (!default_tab_bounds.IsEmpty())
+        tab_bounds = default_tab_bounds;
     }
   }
 
   tab_contents_delegate_.reset(new TabContentsDelegateImpl(this));
   new_contents->SetDelegate(tab_contents_delegate_.get());
 
   // Set the size of the prerender TabContents.
   prerender_contents_->web_contents()->GetView()->SizeContents(
       tab_bounds.size());
 
@@ skipping 220 matching lines @@
 
 void PrerenderContents::OnJSOutOfMemory() {
   Destroy(FINAL_STATUS_JS_OUT_OF_MEMORY);
 }
 
 void PrerenderContents::RenderViewGone(base::TerminationStatus status) {
   Destroy(FINAL_STATUS_RENDERER_CRASHED);
 }
 
 void PrerenderContents::DidStopLoading() {
   has_stopped_loading_ = true;

[dominich, 2012/02/14 01:11:20]

Do you need to set has_finished_loading_ = false explicitly here?

[Jay Civelli, 2012/02/14 03:13:51]

Do you mean has_finished_loading_ = true?
I don't think I do, we should always get a DidFinishLoad for the main frame.

 }
 
 void PrerenderContents::DidStartProvisionalLoadForFrame(
     int64 frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     RenderViewHost* render_view_host) {
   if (is_main_frame) {
     if (!AddAliasURL(validated_url))
       return;
 
     // Usually, this event fires if the user clicks or enters a new URL.
     // Neither of these can happen in the case of an invisible prerender.
     // So the cause is: Some JavaScript caused a new URL to be loaded.  In that
     // case, the spinner would start again in the browser, so we must reset
     // has_stopped_loading_ so that the spinner won't be stopped.
     has_stopped_loading_ = false;
+    has_finished_loading_ = false;
   }
 }
 
+void PrerenderContents::DidFinishLoad(int64 frame_id,
+                                      const GURL& validated_url,
+                                      bool is_main_frame) {
+  if (is_main_frame)
+    has_finished_loading_ = true;
+}
+
 bool PrerenderContents::ShouldSuppressDialogs() {
   // Always suppress JavaScript messages if they're triggered by a page being
   // prerendered.
   // We still want to show the user the message when they navigate to this
   // page, so cancel this prerender.
   Destroy(FINAL_STATUS_JAVASCRIPT_ALERT);
   return true;
 }
 
 void PrerenderContents::Destroy(FinalStatus final_status) {
@@ skipping 104 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