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 45 matching lines @@
 
 struct PrerenderManager::PrerenderContentsData {
   PrerenderContents* contents_;
   base::Time start_time_;
   PrerenderContentsData(PrerenderContents* contents, base::Time start_time)
       : contents_(contents),
         start_time_(start_time) {
   }
 };
 
+struct PrerenderManager::PendingContentsData {
+  PendingContentsData(const GURL& url, const std::vector<GURL>& alias_urls,
+                      const GURL& referrer)
+      : url_(url), alias_urls_(alias_urls), referrer_(referrer) { }
+  ~PendingContentsData() {}
+  GURL url_;
+  std::vector<GURL> alias_urls_;
+  GURL referrer_;
+};
+
+
 PrerenderManager::PrerenderManager(Profile* profile)
     : rate_limit_enabled_(true),
       profile_(profile),
       max_prerender_age_(base::TimeDelta::FromSeconds(
           kDefaultMaxPrerenderAgeSeconds)),
       max_elements_(kDefaultMaxPrerenderElements),
       prerender_contents_factory_(PrerenderContents::CreateFactory()),
       last_prerender_start_time_(GetCurrentTimeTicks() -
           base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)) {
 }
@@ skipping 12 matching lines @@
   prerender_contents_factory_.reset(prerender_contents_factory);
 }
 
 bool PrerenderManager::AddPreload(const GURL& url,
                                   const std::vector<GURL>& alias_urls,
                                   const GURL& referrer) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DeleteOldEntries();
   if (FindEntry(url))
     return false;
+
   // Do not prerender if there are too many render processes, and we would
   // have to use an existing one.  We do not want prerendering to happen in
   // a shared process, so that we can always reliably lower the CPU
   // priority for prerendering.
   // TODO(tburkard): Figure out how to cancel prerendering in the opposite
   // case, when a new tab is added to a process used for prerendering.
   if (RenderProcessHost::ShouldTryToUseExistingProcessHost()) {
     // Only record the status if we are not in the control group.
     if (!IsControlGroup())
       RecordFinalStatus(FINAL_STATUS_TOO_MANY_PROCESSES);
     return false;
   }
 
   // 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;
   }
 
   // TODO(cbentzel): Move invalid checks here instead of PrerenderContents?
   PrerenderContentsData data(CreatePrerenderContents(url, alias_urls, referrer),
                              GetCurrentTime());
   prerender_list_.push_back(data);
   if (!IsControlGroup()) {
     last_prerender_start_time_ = GetCurrentTimeTicks();
     data.contents_->StartPrerendering();
   }
   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 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;
+    int route_id;
+    bool has_child_id = pc->GetChildId(&child_id);
+    bool has_route_id = has_child_id && pc->GetRouteId(&route_id);
+
+    if (has_child_id && has_route_id &&
+        child_id == child_route_id_pair.first &&
+        route_id == child_route_id_pair.second) {
+      is_valid_prerender = true;
+      break;
+    }
+  }
+
+  // If not, we could check to see if the RenderViewHost specified by the
+  // child_route_id_pair exists and if so just start prerendering, as this
+  // suggests that the link was clicked, though this might prerender something
+  // that the user has already navigated away from. For now, we'll be
+  // conservative and skip the prerender which will mean some prerender requests
+  // from prerendered pages will be missed if the user navigates quickly.
+  if (!is_valid_prerender) {
+    RecordFinalStatus(FINAL_STATUS_PENDING_SKIPPED);
+    return;
+  }
+
+  PendingPrerenderList::iterator it =
+      pending_prerender_list_.find(child_route_id_pair);
+  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_;
   }
   if (prerender_list_.empty())
@@ skipping 30 matching lines @@
     return false;
   }
 
   if (!pc->load_start_time().is_null())
     RecordTimeUntilUsed(GetCurrentTimeTicks() - pc->load_start_time());
 
   UMA_HISTOGRAM_COUNTS("Prerender.PrerendersPerSessionCount",
                        ++prerenders_per_session_count_);
   pc->set_final_status(FINAL_STATUS_USED);
 
+  int child_id;
+  int route_id;
+  CHECK(pc->GetChildId(&child_id));
+  CHECK(pc->GetRouteId(&route_id));
+
   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);
   MarkTabContentsAsPrerendered(tc);
 
+  // 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_,
+                 content_it->referrer_);
+    }
+    pending_prerender_list_.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->favicon_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 67 matching lines @@
   for (std::list<PrerenderContentsData>::iterator it = prerender_list_.begin();
        it != prerender_list_.end();
        ++it) {
     if (it->contents_->MatchesURL(url))
       return it->contents_;
   }
   // Entry not found.
   return NULL;
 }
 
+PrerenderManager::PendingContentsData*
+    PrerenderManager::FindPendingEntry(const GURL& url) {
+  for (PendingPrerenderList::iterator map_it = pending_prerender_list_.begin();
+       map_it != pending_prerender_list_.end();
+       ++map_it) {
+    for (std::vector<PendingContentsData>::iterator content_it =
+            map_it->second.begin();
+         content_it != map_it->second.end();
+         ++content_it) {
+      if (content_it->url_ == url) {
+        return &(*content_it);
+      }
+    }
+  }
+
+  return NULL;
+}
+
 // static
 void PrerenderManager::RecordPrefetchTagObserved() {
   // Ensure that we are in the UI thread, and post to the UI thread if
   // necessary.
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         NewRunnableFunction(
             &PrerenderManager::RecordPrefetchTagObservedOnUIThread));
   } else {
     RecordPrefetchTagObservedOnUIThread();
   }
 }
 
 // static
 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) {
+  int child_id;
+  int route_id;
+  bool has_child_id = entry->GetChildId(&child_id);
+  bool has_route_id = has_child_id && entry->GetRouteId(&route_id);
+
+  // 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 (has_child_id && has_route_id) {
+    std::pair<int, int> child_route_pair = std::make_pair(child_id, route_id);
+    pending_prerender_list_.erase(child_route_pair);
+  }
+}
+
 // 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 55 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