Limit prerender by only allowing one every X ms (X currently set to 500).

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 36 matching lines @@
 struct PrerenderManager::PrerenderContentsData {
   PrerenderContents* contents_;
   base::Time start_time_;
   PrerenderContentsData(PrerenderContents* contents, base::Time start_time)
       : contents_(contents),
         start_time_(start_time) {
   }
 };
 
 PrerenderManager::PrerenderManager(Profile* profile)
-    : profile_(profile),
+    : rate_limit_enabled_(true),
+      profile_(profile),
       max_prerender_age_(base::TimeDelta::FromSeconds(
           kDefaultMaxPrerenderAgeSeconds)),
       max_elements_(kDefaultMaxPrerenderElements),
-      prerender_contents_factory_(PrerenderContents::CreateFactory()) {
+      prerender_contents_factory_(PrerenderContents::CreateFactory()),
+      last_prerender_start_time_(base::TimeTicks::Now() -
+              base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs)) {

[cbentzel, 2011/03/15 18:51:03]

Nit: should indentation be only four from previous line? Not sure in this case.

[dominich, 2011/03/15 21:05:37]

I'm not sure either, and I couldn't find anything clear for this case. Down to 4
anyway.

 }
 
 PrerenderManager::~PrerenderManager() {
   while (!prerender_list_.empty()) {
     PrerenderContentsData data = prerender_list_.front();
     prerender_list_.pop_front();
     data.contents_->set_final_status(FINAL_STATUS_MANAGER_SHUTDOWN);
     delete data.contents_;
   }
 }
@@ skipping 13 matching lines @@
   // 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()) {
     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);
+  last_prerender_start_time_ = base::TimeTicks::Now();
   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;
 }
@@ skipping 161 matching lines @@
 // 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);
 }
 
+bool PrerenderManager::DoesRateLimitAllowPrerender() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  base::TimeDelta elapsed_time =
+      base::TimeTicks::Now() - last_prerender_start_time_;
+  UMA_HISTOGRAM_TIMES("Prerender.TimeBetweenPrerenderRequests",
+                      elapsed_time);
+  if (!rate_limit_enabled_)
+    return true;
+  return elapsed_time >
+      base::TimeDelta::FromMilliseconds(kMinTimeBetweenPrerendersMs);
+}
+
 void PrerenderManager::StartSchedulingPeriodicCleanups() {
   if (repeating_timer_.IsRunning())
     return;
   repeating_timer_.Start(
       base::TimeDelta::FromMilliseconds(kPeriodicCleanupIntervalMs),
       this,
       &PrerenderManager::PeriodicCleanup);
 }
 
 void PrerenderManager::StopSchedulingPeriodicCleanups() {
@@ skipping 24 matching lines @@
 
 void PrerenderManager::MarkTabContentsAsNotPrerendered(TabContents* tc) {
   prerendered_tc_set_.erase(tc);
 }
 
 bool PrerenderManager::IsTabContentsPrerendered(TabContents* tc) const {
   return prerendered_tc_set_.count(tc) > 0;
 }
 
 }  // namespace prerender