Give prerendering RVH's RenderWidgetHostViews.

chrome/browser/prerender/prerender_manager.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_manager.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
@@ skipping 116 matching lines @@
     data.contents_->set_final_status(FINAL_STATUS_MANAGER_SHUTDOWN);
     delete data.contents_;
   }
 }
 
 void PrerenderManager::SetPrerenderContentsFactory(
     PrerenderContents::Factory* prerender_contents_factory) {
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
-bool PrerenderManager::AddPreload(const GURL& url,
-                                  const std::vector<GURL>& alias_urls,
-                                  const GURL& referrer) {
+bool PrerenderManager::AddPreload(
+    const std::pair<int, int>& child_route_id_pair,
+    const GURL& url,
+    const std::vector<GURL>& alias_urls,
+    const GURL& referrer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DeleteOldEntries();
   if (FindEntry(url))
     return false;
 
   // Local copy, since we may have to add an additional entry to it.
   std::vector<GURL> all_alias_urls = alias_urls;
 
   GURL additional_alias_url;
   if (IsControlGroup() &&
@@ skipping 20 matching lines @@
   // Check if enough time has passed since the last prerender.
   if (!DoesRateLimitAllowPrerender()) {
     // Cancel the prerender. We could add it to the pending prerender list but
     // this doesn't make sense as the next prerender request will be triggered
     // by a navigation and is unlikely to be the same site.
     RecordFinalStatus(FINAL_STATUS_RATE_LIMIT_EXCEEDED);
 
     return false;
   }
 
+  RenderViewHost* source_render_view_host = NULL;
+  // This test should fail only during unit tests.
+  if (child_route_id_pair.first != -1) {
+    source_render_view_host =
+        RenderViewHost::FromID(child_route_id_pair.first,
+                               child_route_id_pair.second);
+    // Don't prerender page if parent RenderViewHost no longer exists, or it has
+    // no view.  The latter should only happen when the RenderView has closed.

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

Is it possible to add a browser test [or at least a unit test] where this case
happens? It sounds like it will be tricky to do due to tight timing, but might
be a good idea. Skipping the prerender in this case makes sense, regardless of
getting the view extents. 

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

I'm not sure about a browser test using our current framework.  Simplest way may
be to create a TestPrerenderManager and have it destroy the original
RenderViewHost in AddPreload.

I suppose we could create a prerender request for a non-existent RenderView in a
browser test, but at that point, I'm not sure how much we gain from not just
doing a unit test instead.

I've added the aforementioned unit test, and I've filed a bug for a browser
test.

Also, I added a FinalStatus for cancelling in this case, which I had forgotten
to do.

+    if (!source_render_view_host || !source_render_view_host->view())
+      return false;
+  }
+
   // TODO(cbentzel): Move invalid checks here instead of PrerenderContents?
   PrerenderContentsData data(CreatePrerenderContents(url, all_alias_urls,
                                                      referrer),
                              GetCurrentTime());
 
   prerender_list_.push_back(data);
   if (IsControlGroup()) {
     data.contents_->set_final_status(FINAL_STATUS_CONTROL_GROUP);
   } else {
     last_prerender_start_time_ = GetCurrentTimeTicks();
-    data.contents_->StartPrerendering();
+    data.contents_->StartPrerendering(source_render_view_host);
   }
   while (prerender_list_.size() > max_elements_) {
     data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->set_final_status(FINAL_STATUS_EVICTED);
     delete data.contents_;
   }
   StartSchedulingPeriodicCleanups();
   return true;
 }
 
 void PrerenderManager::AddPendingPreload(
-    const std::pair<int,int>& child_route_id_pair,
+    const std::pair<int, int>& child_route_id_pair,
     const GURL& url,
     const std::vector<GURL>& alias_urls,
     const GURL& referrer) {
   // Check if this is coming from a valid prerender rvh.
   bool is_valid_prerender = false;
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end(); ++it) {
     PrerenderContents* pc = it->contents_;
 
     int child_id;
@@ skipping 25 matching lines @@
   if (it == pending_prerender_list_.end()) {
     PendingPrerenderList::value_type el = std::make_pair(child_route_id_pair,
                                             std::vector<PendingContentsData>());
     it = pending_prerender_list_.insert(el).first;
   }
 
   it->second.push_back(PendingContentsData(url, alias_urls, referrer));
 }
 
 void PrerenderManager::DeleteOldEntries() {
-  while (!prerender_list_.empty()) {
-    PrerenderContentsData data = prerender_list_.front();
-    if (IsPrerenderElementFresh(data.start_time_))
-      return;
-    prerender_list_.pop_front();
-    data.contents_->set_final_status(FINAL_STATUS_TIMED_OUT);
-    delete data.contents_;
+  std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
+  while (it != prerender_list_.end()) {
+    if (it->contents_->pending_final_status() != FINAL_STATUS_MAX) {
+      it->contents_->set_final_status(it->contents_->pending_final_status());
+    } else if (!IsPrerenderElementFresh(it->start_time_)) {
+      it->contents_->set_final_status(FINAL_STATUS_TIMED_OUT);
+    } else {
+      ++it;
+      continue;
+    }
+    delete it->contents_;
+    it = prerender_list_.erase(it);
   }
+
   if (prerender_list_.empty())
     StopSchedulingPeriodicCleanups();
 }
 
 PrerenderContents* PrerenderManager::GetEntry(const GURL& url) {
   DeleteOldEntries();
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     PrerenderContents* pc = it->contents_;
@@ skipping 43 matching lines @@
 
   // See if we have any pending prerender requests for this routing id and start
   // the preload if we do.
   std::pair<int, int> child_route_pair = std::make_pair(child_id, route_id);
   PendingPrerenderList::iterator pending_it =
       pending_prerender_list_.find(child_route_pair);
   if (pending_it != pending_prerender_list_.end()) {
     for (std::vector<PendingContentsData>::iterator content_it =
             pending_it->second.begin();
          content_it != pending_it->second.end(); ++content_it) {
-      AddPreload(content_it->url_, content_it->alias_urls_,
+      AddPreload(pending_it->first, content_it->url_, content_it->alias_urls_,
                  content_it->referrer_);
     }
     pending_prerender_list_.erase(pending_it);
   }
 
   NotificationService::current()->Notify(
       NotificationType::PRERENDER_CONTENTS_USED,
       Source<std::pair<int, int> >(&child_route_pair),
       NotificationService::NoDetails());
 
@@ skipping 246 matching lines @@
 
 bool PrerenderManager::IsTabContentsPrerendered(TabContents* tc) const {
   return prerendered_tc_set_.count(tc) > 0;
 }
 
 bool PrerenderManager::WouldTabContentsBePrerendered(TabContents* tc) const {
   return would_be_prerendered_tc_set_.count(tc) > 0;
 }
 
 }  // namespace prerender