[NoStatePrefetch] Cancel repeated prefetches with FINAL_STATUS_DUPLICATE

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 <stddef.h>
 #include <stdint.h>
 
 #include <map>
 #include <utility>
 
@@ skipping 20 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/prerender_types.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/network_change_notifier.h"
+#include "net/http/http_cache.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/size.h"
 #include "url/gurl.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using content::BrowserThread;
 using content::Referrer;
@@ skipping 723 matching lines @@
 
   GURL second_url("http://example2.com");
   DummyPrerenderContents* second_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           second_url, FINAL_STATUS_MANAGER_SHUTDOWN);
   EXPECT_TRUE(AddSimplePrerender(second_url));
   EXPECT_EQ(second_prerender_contents,
             prerender_manager()->FindEntry(second_url));
 }
 
+// Prefetching the same URL twice during |time_to_live| results in a duplicate
+// and is aborted.
+TEST_F(PrerenderTest, NoStatePrefetchDuplicate) {
+  const GURL kUrl("http://www.google.com/");
+
+  RestorePrerenderMode restore_prerender_mode;
+  prerender_manager()->SetMode(
+      PrerenderManager::PRERENDER_MODE_NOSTATE_PREFETCH);
+  base::SimpleTestTickClock* tick_clock =
+      OverridePrerenderManagerTimeTicks(prerender_manager());
+
+  // Prefetch the url once.
+  prerender_manager()->CreateNextPrerenderContents(
+      kUrl, ORIGIN_OMNIBOX, FINAL_STATUS_MANAGER_SHUTDOWN);
+  EXPECT_TRUE(
+      prerender_manager()->AddPrerenderFromOmnibox(kUrl, nullptr, gfx::Size()));
+
+  prerender_manager()->CreateNextPrerenderContents(
+      kUrl, ORIGIN_OMNIBOX, FINAL_STATUS_MANAGER_SHUTDOWN);
+
+  // Prefetching again before time_to_live aborts, because it is a duplicate.
+  tick_clock->Advance(base::TimeDelta::FromSeconds(1));
+  EXPECT_FALSE(
+      prerender_manager()->AddPrerenderFromOmnibox(kUrl, nullptr, gfx::Size()));
+
+  // Prefetching after time_to_live succeeds.
+  tick_clock->Advance(
+      base::TimeDelta::FromMinutes(net::HttpCache::kPrefetchReuseMins));
+  EXPECT_TRUE(
+      prerender_manager()->AddPrerenderFromOmnibox(kUrl, nullptr, gfx::Size()));
+}
 
 // Make sure that if we prerender more requests than we support, that we launch
 // them in the order given up until we reach MaxConcurrency, at which point we
 // queue them and launch them in the order given. As well, insure that limits
 // are enforced for the system as a whole and on a per launcher basis.
 TEST_F(PrerenderTest, MaxConcurrencyTest) {
   struct TestConcurrency {
     size_t max_link_concurrency;
     size_t max_link_concurrency_per_launcher;
   };
@@ skipping 1122 matching lines @@
   prerender_contents->SetPrerenderMode(PREFETCH_ONLY);
   EXPECT_TRUE(prerender_contents->IsValidHttpMethod("GET"));
   EXPECT_TRUE(prerender_contents->IsValidHttpMethod("HEAD"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("OPTIONS"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("POST"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("TRACE"));
   EXPECT_FALSE(prerender_contents->IsValidHttpMethod("WHATEVER"));
 }
 
 }  // namespace prerender