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

chrome/browser/prerender/prerender_manager_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 "base/time.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "content/browser/browser_thread.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 34 matching lines @@
  private:
   bool has_started_;
   FinalStatus expected_final_status_;
 };
 
 class TestPrerenderManager : public PrerenderManager {
  public:
   TestPrerenderManager()
       : PrerenderManager(NULL),
         time_(base::Time::Now()),
+        time_ticks_(base::TimeTicks::Now()),
         next_pc_(NULL) {
+    rate_limit_enabled_ = false;
   }
 
   void AdvanceTime(base::TimeDelta delta) {
     time_ += delta;
   }
 
+  void AdvanceTimeTicks(base::TimeDelta delta) {
+    time_ticks_ += delta;
+  }
+
   void SetNextPrerenderContents(PrerenderContents* pc) {
     next_pc_.reset(pc);
   }
 
   // Shorthand to add a simple preload with no aliases.
   bool AddSimplePreload(const GURL& url) {
     return AddPreload(url, std::vector<GURL>(), GURL());
   }
 
+  void set_rate_limit_enabled(bool enabled) { rate_limit_enabled_ = true; }
+
   PrerenderContents* next_pc() { return next_pc_.get(); }
 
  protected:
   virtual ~TestPrerenderManager() {
     if (next_pc()) {
       next_pc()->set_final_status(
           FINAL_STATUS_MANAGER_SHUTDOWN);
     }
   }
 
  private:
   virtual base::Time GetCurrentTime() const OVERRIDE {
     return time_;
   }
 
+  virtual base::TimeTicks GetCurrentTimeTicks() const OVERRIDE {
+    return time_ticks_;
+  }
+
   virtual PrerenderContents* CreatePrerenderContents(
       const GURL& url,
       const std::vector<GURL>& alias_urls,
       const GURL& referrer) OVERRIDE {
     DCHECK(next_pc_.get());
     return next_pc_.release();
   }
 
   base::Time time_;
+  base::TimeTicks time_ticks_;
   scoped_ptr<PrerenderContents> next_pc_;
 };
 
 }  // namespace
 
 class PrerenderManagerTest : public testing::Test {
  public:
   PrerenderManagerTest() : prerender_manager_(new TestPrerenderManager()),
                            ui_thread_(BrowserThread::UI, &message_loop_) {
   }
@@ skipping 159 matching lines @@
   EXPECT_TRUE(prerender_manager_->AddPreload(url, alias_urls, GURL()));
   EXPECT_FALSE(prerender_manager_->AddSimplePreload(url));
   EXPECT_FALSE(prerender_manager_->AddSimplePreload(alias_url1));
   EXPECT_FALSE(prerender_manager_->AddSimplePreload(alias_url2));
   ASSERT_EQ(pc, prerender_manager_->GetEntry(url));
 
   pc->set_final_status(FINAL_STATUS_USED);
   delete pc;
 }
 
-}  // naemspace prerender
+// Ensure that we ignore prerender requests within the rate limit.
+TEST_F(PrerenderManagerTest, RateLimitInWindowTest) {
+  GURL url("http://www.google.com/");
+  DummyPrerenderContents* pc =
+      new DummyPrerenderContents(prerender_manager_.get(), url,
+                                 FINAL_STATUS_MANAGER_SHUTDOWN);
+  DummyPrerenderContents* null = NULL;
+  prerender_manager_->SetNextPrerenderContents(pc);
+  EXPECT_TRUE(prerender_manager_->AddSimplePreload(url));
+  EXPECT_EQ(null, prerender_manager_->next_pc());
+  EXPECT_TRUE(pc->has_started());
+
+  prerender_manager_->set_rate_limit_enabled(true);
+  prerender_manager_->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(1));
+
+  GURL url1("http://news.google.com/");
+  DummyPrerenderContents* rate_limit_pc =
+      new DummyPrerenderContents(prerender_manager_.get(), url1,
+                                 FINAL_STATUS_MANAGER_SHUTDOWN);
+  prerender_manager_->SetNextPrerenderContents(rate_limit_pc);
+  EXPECT_FALSE(prerender_manager_->AddSimplePreload(url1));
+  prerender_manager_->set_rate_limit_enabled(false);
+}
+
+// Ensure that we don't ignore prerender requests outside the rate limit.
+TEST_F(PrerenderManagerTest, RateLimitOutsideWindowTest) {
+  GURL url("http://www.google.com/");
+  DummyPrerenderContents* pc =
+      new DummyPrerenderContents(prerender_manager_.get(), url,
+                                 FINAL_STATUS_EVICTED);
+  DummyPrerenderContents* null = NULL;
+  prerender_manager_->SetNextPrerenderContents(pc);
+  EXPECT_TRUE(prerender_manager_->AddSimplePreload(url));
+  EXPECT_EQ(null, prerender_manager_->next_pc());
+  EXPECT_TRUE(pc->has_started());
+
+  prerender_manager_->set_rate_limit_enabled(true);
+  prerender_manager_->AdvanceTimeTicks(base::TimeDelta::FromMilliseconds(2000));
+
+  GURL url1("http://news.google.com/");
+  DummyPrerenderContents* rate_limit_pc =
+      new DummyPrerenderContents(prerender_manager_.get(), url1,
+                                 FINAL_STATUS_MANAGER_SHUTDOWN);
+  prerender_manager_->SetNextPrerenderContents(rate_limit_pc);
+  EXPECT_TRUE(prerender_manager_->AddSimplePreload(url1));
+  EXPECT_EQ(null, prerender_manager_->next_pc());
+  EXPECT_TRUE(rate_limit_pc->has_started());
+  prerender_manager_->set_rate_limit_enabled(false);
+}
+
+}  // namespace prerender