Make three simultanious prerenders the default maximum in Canary and Dev only.

chrome/browser/prerender/prerender_unittest.cc

 // Copyright (c) 2012 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/command_line.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
+#include "base/stringprintf.h"
 #include "base/time.h"
 #include "chrome/browser/prerender/prerender_contents.h"
 #include "chrome/browser/prerender/prerender_handle.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
 #include "chrome/browser/prerender/prerender_manager.h"
 #include "chrome/browser/prerender/prerender_origin.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 49 matching lines @@
   UnitTestPrerenderManager* test_prerender_manager_;
   FinalStatus expected_final_status_;
 };
 
 const gfx::Size kSize(640, 480);
 
 }  // namespace
 
 class UnitTestPrerenderManager : public PrerenderManager {
  public:
+  using PrerenderManager::kMinTimeBetweenPrerendersMs;
   using PrerenderManager::kNavigationRecordWindowMs;
   using PrerenderManager::GetMaxAge;
 
   explicit UnitTestPrerenderManager(PrerenderTracker* prerender_tracker)
       : PrerenderManager(&profile_, prerender_tracker),
         time_(base::Time::Now()),
         time_ticks_(base::TimeTicks::Now()),
         next_prerender_contents_(NULL),
         prerender_tracker_(prerender_tracker) {
     set_rate_limit_enabled(false);
@@ skipping 292 matching lines @@
           FINAL_STATUS_TIMED_OUT);
   DummyPrerenderContents* null = NULL;
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   prerender_manager()->AdvanceTimeTicks(prerender_manager()->GetMaxAge() +
                                         base::TimeDelta::FromSeconds(1));
   ASSERT_EQ(null, prerender_manager()->FindEntry(url));
 }
 
-// LRU Test.  Make sure that if we prerender more than one request, that
+// LRU Test. Make sure that if we prerender more requests than we support, that
 // the oldest one will be dropped.
 TEST_F(PrerenderTest, DropOldestRequestTest) {
-  GURL url("http://www.google.com/");
-  DummyPrerenderContents* prerender_contents =
-      prerender_manager()->CreateNextPrerenderContents(
-          url,
-          FINAL_STATUS_EVICTED);
+  std::vector<int> concurrencies_to_test;
+  concurrencies_to_test.push_back(
+      prerender_manager()->config().max_concurrency);
+  concurrencies_to_test.push_back(1);
+  concurrencies_to_test.push_back(2);
+
   DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(AddSimplePrerender(url));
-  EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
-  EXPECT_TRUE(prerender_contents->prerendering_has_started());
+  GURL url_to_evict("http://www.google.com/evictme");
 
-  GURL url1("http://news.google.com/");
-  DummyPrerenderContents* prerender_contents1 =
-      prerender_manager()->CreateNextPrerenderContents(
-          url1,
-          FINAL_STATUS_USED);
-  EXPECT_TRUE(AddSimplePrerender(url1));
-  EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
-  EXPECT_TRUE(prerender_contents1->prerendering_has_started());
+  for (std::vector<int>::const_iterator i = concurrencies_to_test.begin();
+       i != concurrencies_to_test.end();
+       ++i) {
+    const int max_concurrency = *i;
+    prerender_manager()->mutable_config().max_concurrency = max_concurrency;
 
-  ASSERT_EQ(null, prerender_manager()->FindEntry(url));
-  ASSERT_EQ(prerender_contents1, prerender_manager()->FindAndUseEntry(url1));
-}
+    DummyPrerenderContents* prerender_contents_to_evict =
+        prerender_manager()->CreateNextPrerenderContents(
+            url_to_evict, FINAL_STATUS_EVICTED);
+    EXPECT_TRUE(AddSimplePrerender(url_to_evict));
+    EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
+    EXPECT_TRUE(prerender_contents_to_evict->prerendering_has_started());
 
-// Two element prerender test.  Ensure that the LRU operates correctly if we
-// permit 2 elements to be kept prerendered.
-TEST_F(PrerenderTest, TwoElementPrerenderTest) {
-  prerender_manager()->mutable_config().max_elements = 2;
-  GURL url("http://www.google.com/");
-  DummyPrerenderContents* prerender_contents =
-      prerender_manager()->CreateNextPrerenderContents(
-          url,
-          FINAL_STATUS_EVICTED);
-  DummyPrerenderContents* null = NULL;
-  EXPECT_TRUE(AddSimplePrerender(url));
-  EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
-  EXPECT_TRUE(prerender_contents->prerendering_has_started());
+    std::vector<GURL> urls;
+    std::vector<PrerenderContents*> prerender_contentses;
 
-  GURL url1("http://news.google.com/");
-  DummyPrerenderContents* prerender_contents1 =
-      prerender_manager()->CreateNextPrerenderContents(
-          url1,
-          FINAL_STATUS_USED);
-  EXPECT_TRUE(AddSimplePrerender(url1));
-  EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
-  EXPECT_TRUE(prerender_contents1->prerendering_has_started());
+    for (int j = 0; j < max_concurrency; ++j) {
+      urls.push_back(GURL(base::StringPrintf("http://google.com/use#%d", j)));
+      prerender_contentses.push_back(
+          prerender_manager()->CreateNextPrerenderContents(urls.back(),
+                                                           FINAL_STATUS_USED));
+      EXPECT_TRUE(AddSimplePrerender(urls.back()));
+      EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
+      EXPECT_TRUE(prerender_contentses.back()->prerendering_has_started());
+    }
 
-  GURL url2("http://images.google.com/");
-  DummyPrerenderContents* prerender_contents2 =
-      prerender_manager()->CreateNextPrerenderContents(
-          url2,
-          FINAL_STATUS_USED);
-  EXPECT_TRUE(AddSimplePrerender(url2));
-  EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
-  EXPECT_TRUE(prerender_contents2->prerendering_has_started());
-
-  ASSERT_EQ(null, prerender_manager()->FindEntry(url));
-  ASSERT_EQ(prerender_contents1, prerender_manager()->FindAndUseEntry(url1));
-  ASSERT_EQ(prerender_contents2, prerender_manager()->FindAndUseEntry(url2));
+    ASSERT_EQ(null, prerender_manager()->FindEntry(url_to_evict));
+    for (int j = 0; j < max_concurrency; ++j) {
+      ASSERT_EQ(prerender_contentses[j],
+                prerender_manager()->FindAndUseEntry(urls[j]));
+    }
+  }
 }
 
 TEST_F(PrerenderTest, AliasURLTest) {
   GURL url("http://www.google.com/");
   GURL alias_url1("http://www.google.com/index.html");
   GURL alias_url2("http://google.com/");
   GURL not_an_alias_url("http://google.com/index.html");
   std::vector<GURL> alias_urls;
   alias_urls.push_back(alias_url1);
   alias_urls.push_back(alias_url2);
@@ skipping 44 matching lines @@
   GURL url1("http://news.google.com/");
   prerender_manager()->CreateNextPrerenderContents(
       url,
       FINAL_STATUS_MANAGER_SHUTDOWN);
   EXPECT_FALSE(AddSimplePrerender(url1));
   prerender_manager()->set_rate_limit_enabled(false);
 }
 
 // Ensure that we don't ignore prerender requests outside the rate limit.
 TEST_F(PrerenderTest, RateLimitOutsideWindowTest) {
+  // Setting concurrency to one lets us force eviction by adding only one more
+  // prerender.
+  prerender_manager()->mutable_config().max_concurrency = 1;
+
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_EVICTED);
   DummyPrerenderContents* null = NULL;
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
 
   prerender_manager()->set_rate_limit_enabled(true);
   prerender_manager()->AdvanceTimeTicks(
-      base::TimeDelta::FromMilliseconds(2000));
+      base::TimeDelta::FromMilliseconds(
+          UnitTestPrerenderManager::kMinTimeBetweenPrerendersMs + 500));
 
   GURL url1("http://news.google.com/");
   DummyPrerenderContents* rate_limit_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url1,
           FINAL_STATUS_MANAGER_SHUTDOWN);
   EXPECT_TRUE(AddSimplePrerender(url1));
   EXPECT_EQ(null, prerender_manager()->next_prerender_contents());
   EXPECT_TRUE(rate_limit_prerender_contents->prerendering_has_started());
   prerender_manager()->set_rate_limit_enabled(false);
@@ skipping 550 matching lines @@
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(second_prerender_contents->prerendering_has_started());
   ASSERT_EQ(second_prerender_contents,
             prerender_manager()->FindAndUseEntry(url));
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 }
 
 }  // namespace prerender