Add pending preloads indexed by routing id. Start preloading once we navigate.

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/histogram.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
@@ skipping 89 matching lines @@
   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(int route_id,
+                                         const GURL& url,
+                                         const std::vector<GURL>& alias_urls,
+                                         const GURL& referrer) {
+  DCHECK(pending_prerender_map_.find(route_id) == pending_prerender_map_.end());

[cbentzel, 2011/03/14 14:32:26]

What if there are two <link rel="prefetch"> elements on the page that is
prerendered? This will trigger then.

[dominich, 2011/03/14 17:47:15]

Good catch. I can remove the DCHECK, but perhaps it is better to also change the
container from a map to something like a vector of pairs. Then on navigation I
can trigger all of the prerenders for the page in the right order and let the
existing logic take care of which start. What do you think?

+
+  pending_prerender_map_.insert(
+        std::make_pair<int, PendingContentsData>(route_id,
+                              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_;
   }
   if (prerender_list_.empty())
@@ skipping 28 matching lines @@
 
   RenderViewHost* rvh = pc->render_view_host();
   // RenderViewHosts in PrerenderContents start out hidden.
   // Since we are actually using it now, restore it.
   rvh->WasRestored();
   pc->set_render_view_host(NULL);
   rvh->Send(new ViewMsg_DisplayPrerenderedPage(rvh->routing_id()));
   tc->SwapInRenderViewHost(rvh);
   tc->set_was_prerendered(true);
 
+  // See if we have any pending prerender requests for this routing id and start
+  // the preload if we do.
+  std::map<int, PendingContentsData>::iterator pending_it =
+      pending_prerender_map_.find(rvh->routing_id());
+  if (pending_it != pending_prerender_map_.end()) {
+    const PendingContentsData& data = pending_it->second;
+    AddPreload(data.url_, data.alias_urls_, data.referrer_);
+    pending_prerender_map_.erase(pending_it);
+  }
+
   ViewHostMsg_FrameNavigate_Params* p = pc->navigate_params();
   if (p != NULL)
     tc->DidNavigate(rvh, *p);
 
   string16 title = pc->title();
   if (!title.empty())
     tc->UpdateTitle(rvh, pc->page_id(), UTF16ToWideHack(title));
 
   GURL icon_url = pc->icon_url();
   if (!icon_url.is_empty())
     tc->fav_icon_helper().OnUpdateFavIconURL(pc->page_id(), icon_url);
 
   if (pc->has_stopped_loading())
     tc->DidStopLoading();
 
   return true;
 }
 
 void PrerenderManager::RemoveEntry(PrerenderContents* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     if (it->contents_ == entry) {
+      RemovePendingPreload(entry);
       prerender_list_.erase(it);
       break;
     }
   }
   DeleteOldEntries();
 }
 
 base::Time PrerenderManager::GetCurrentTime() const {
   return base::Time::Now();
 }
@@ skipping 68 matching lines @@
 void PrerenderManager::RecordPrefetchTagObservedOnUIThread() {
   // Once we get here, we have to be on the UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If we observe multiple tags within the 30 second window, we will still
   // reset the window to begin at the most recent occurrence, so that we will
   // always be in a window in the 30 seconds from each occurrence.
   last_prefetch_seen_time_ = base::TimeTicks::Now();
 }
 
+void PrerenderManager::RemovePendingPreload(PrerenderContents* entry) {
+  RenderViewHost* rvh = entry->render_view_host();
+
+  // If the entry doesn't have a RenderViewHost then it didn't start
+  // prerendering and there shouldn't be any pending preloads to remove.
+  if (rvh == NULL)
+    return;
+
+  int route_id = rvh->routing_id();
+  std::map<int, PendingContentsData>::iterator it =
+      pending_prerender_map_.find(route_id);
+  if (it != pending_prerender_map_.end())
+    pending_prerender_map_.erase(it);
+}
+
 // static
 bool PrerenderManager::ShouldRecordWindowedPPLT() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (last_prefetch_seen_time_.is_null())
     return false;
   base::TimeDelta elapsed_time =
       base::TimeTicks::Now() - last_prefetch_seen_time_;
   return elapsed_time <= base::TimeDelta::FromSeconds(kWindowedPPLTSeconds);
 }
 
@@ skipping 22 matching lines @@
   }
   for (std::vector<PrerenderContents*>::iterator it =
            prerender_contents.begin();
        it != prerender_contents.end();
        ++it) {
     (*it)->DestroyWhenUsingTooManyResources();
   }
 }
 
 }  // namespace prerender