Give prerendering RVH's RenderWidgetHostViews.

chrome/browser/prerender/prerender_contents.cc

 // Copyright (c) 2011 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 "base/process_util.h"
 #include "base/task.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/background_contents_service.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prerender/prerender_final_status.h"
 #include "chrome/browser/prerender/prerender_manager.h"
+#include "chrome/browser/prerender/prerender_render_widget_host_view.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/ui/login/login_prompt.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/icon_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/view_types.h"
 #include "content/browser/browsing_instance.h"
@@ skipping 39 matching lines @@
                                      const std::vector<GURL>& alias_urls,
                                      const GURL& referrer)
     : prerender_manager_(prerender_manager),
       render_view_host_(NULL),
       prerender_url_(url),
       referrer_(referrer),
       profile_(profile),
       page_id_(0),
       has_stopped_loading_(false),
       final_status_(FINAL_STATUS_MAX),
+      pending_final_status_(FINAL_STATUS_MAX),
       prerendering_has_started_(false) {
   DCHECK(prerender_manager != NULL);
   if (!AddAliasURL(prerender_url_))
     LOG(DFATAL) << "PrerenderContents given invalid URL " << prerender_url_;
   for (std::vector<GURL>::const_iterator it = alias_urls.begin();
        it != alias_urls.end();
        ++it) {
     if (!AddAliasURL(*it))
       LOG(DFATAL) << "PrerenderContents given invalid URL " << prerender_url_;
   }
 }
 
 // static
 PrerenderContents::Factory* PrerenderContents::CreateFactory() {
   return new PrerenderContentsFactoryImpl();
 }
 
-void PrerenderContents::StartPrerendering() {
+void PrerenderContents::StartPrerendering(
+    const RenderViewHost* source_render_view_host) {
   DCHECK(profile_ != NULL);
   DCHECK(!prerendering_has_started_);
+  DCHECK(source_render_view_host != NULL);
+  DCHECK(source_render_view_host->view() != NULL);
   prerendering_has_started_ = true;
   SiteInstance* site_instance = SiteInstance::CreateSiteInstance(profile_);
   render_view_host_ = new RenderViewHost(site_instance, this, MSG_ROUTING_NONE,
                                          NULL);
 
   int process_id = render_view_host_->process()->id();
   int view_id = render_view_host_->routing_id();
   std::pair<int, int> process_view_pair = std::make_pair(process_id, view_id);
   NotificationService::current()->Notify(
       NotificationType::PRERENDER_CONTENTS_STARTED,
       Source<std::pair<int, int> >(&process_view_pair),
       NotificationService::NoDetails());
 
   // Create the RenderView, so it can receive messages.
   render_view_host_->CreateRenderView(string16());
 
-  // Hide the RVH, so that we will run at a lower CPU priority.
-  // Once the RVH is being swapped into a tab, we will Restore it again.
-  render_view_host_->WasHidden();
+  // Give the RVH a PrerenderRenderWidgetHostView, both so its size can be set
+  // and so that the prerender can be cancelled under certain circumstances.
+  PrerenderRenderWidgetHostView* view =
+      new PrerenderRenderWidgetHostView(render_view_host_, this);
+  view->Init(source_render_view_host->view());
+
 
   // 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.
   ResourceDispatcherHost* rdh = g_browser_process->resource_dispatcher_host();
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           NewRunnableFunction(&AddChildRoutePair, rdh,
                                               process_id, view_id));
 
@@ skipping 62 matching lines @@
   DCHECK(final_status >= FINAL_STATUS_USED && final_status < FINAL_STATUS_MAX);
   DCHECK_EQ(FINAL_STATUS_MAX, final_status_);
 
   final_status_ = final_status;
 }
 
 FinalStatus PrerenderContents::final_status() const {
   return final_status_;
 }
 
+void PrerenderContents::set_pending_final_status(
+    FinalStatus pending_final_status) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(pending_final_status >= FINAL_STATUS_USED &&
+         pending_final_status < FINAL_STATUS_MAX);

[cbentzel, 2011/04/19 17:42:41]

Do you want to DCHECK_EQ(FINAL_STATUS_MAX, pending_final_status_)? Or can it be
done multiple times?

[mmenke, 2011/04/19 20:00:01]

It can be done multiple times.  I just wait for the next call to
DeleteOldEntries() before actual deletion, and anything can happen in the
meantime.  There's no way to prevent this, though I could keep the first "final"
status we get, instead of the final one.  I don't think it really matters,
either way.

+
+  pending_final_status_ = pending_final_status;
+}
+
+FinalStatus PrerenderContents::pending_final_status() const {
+  return pending_final_status_;
+}
+
 PrerenderContents::~PrerenderContents() {
   DCHECK(final_status_ != FINAL_STATUS_MAX);
 
   // If we haven't even started prerendering, we were just in the control
   // group, which means we do not want to record the status.
   if (prerendering_has_started())
     RecordFinalStatus(final_status_);
 
   if (!render_view_host_)   // Will be null for unit tests.
     return;
@@ skipping 337 matching lines @@
     return;
 
   size_t private_bytes, shared_bytes;
   if (metrics->GetMemoryBytes(&private_bytes, &shared_bytes)) {
     if (private_bytes > kMaxPrerenderPrivateMB * 1024 * 1024)
       Destroy(FINAL_STATUS_MEMORY_LIMIT_EXCEEDED);
   }
 }
 
 }  // namespace prerender