Add <link rel=next> support to prerender.

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/format_macros.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/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/common/prerender_types.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/size.h"
 #include "url/gurl.h"
 
 using base::Time;
 using base::TimeDelta;
@@ skipping 48 matching lines @@
   int route_id_;
 
   UnitTestPrerenderManager* test_prerender_manager_;
   FinalStatus expected_final_status_;
 };
 
 int DummyPrerenderContents::g_next_route_id_ = 0;
 
 const gfx::Size kSize(640, 480);
 
+const uint32 kDefaultRelTypes = PrerenderRelTypePrerender;
+
 }  // namespace
 
 class UnitTestPrerenderManager : public PrerenderManager {
  public:
   using PrerenderManager::kMinTimeBetweenPrerendersMs;
   using PrerenderManager::kNavigationRecordWindowMs;
 
   explicit UnitTestPrerenderManager(Profile* profile,
                                     PrerenderTracker* prerender_tracker)
       : PrerenderManager(profile, prerender_tracker),
@@ skipping 176 matching lines @@
     NotifyPrerenderStart();
   }
 }
 
 class PrerenderTest : public testing::Test {
  public:
   static const int kDefaultChildId = -1;
   static const int kDefaultRenderViewRouteId = -1;
 
   PrerenderTest() : ui_thread_(BrowserThread::UI, &message_loop_),
-                    prerender_manager_(new UnitTestPrerenderManager(
-                        &profile_, prerender_tracker())),
-                    prerender_link_manager_(
-                        new PrerenderLinkManager(prerender_manager_.get())),
                     last_prerender_id_(0),
                     field_trial_list_(NULL) {
     // Enable omnibox prerendering.
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kPrerenderFromOmnibox,
         switches::kPrerenderFromOmniboxSwitchValueEnabled);
   }
 
   virtual ~PrerenderTest() {
-    prerender_link_manager_->OnChannelClosing(kDefaultChildId);
-    prerender_link_manager_->Shutdown();
-    prerender_manager_->Shutdown();
+    prerender_link_manager()->OnChannelClosing(kDefaultChildId);
+    prerender_link_manager()->Shutdown();
+    prerender_manager()->Shutdown();
   }
 
   UnitTestPrerenderManager* prerender_manager() {
+    if (!prerender_manager_) {
+      prerender_manager_.reset(
+          new UnitTestPrerenderManager(&profile_, prerender_tracker()));
+    }
     return prerender_manager_.get();
   }
 
   PrerenderLinkManager* prerender_link_manager() {
+    if (!prerender_link_manager_) {
+      prerender_link_manager_.reset(
+          new PrerenderLinkManager(prerender_manager()));
+    }
     return prerender_link_manager_.get();
   }
 
   void SetConcurrency(size_t concurrency) {
     prerender_manager()->mutable_config().max_link_concurrency_per_launcher =
         concurrency;
     prerender_manager()->mutable_config().max_link_concurrency =
         std::max(prerender_manager()->mutable_config().max_link_concurrency,
                  concurrency);
   }
 
-  bool IsEmptyPrerenderLinkManager() const {
-    return prerender_link_manager_->IsEmpty();
+  bool IsEmptyPrerenderLinkManager() {
+    return prerender_link_manager()->IsEmpty();
   }
 
   int last_prerender_id() const {
     return last_prerender_id_;
   }
 
   int GetNextPrerenderID() {
     return ++last_prerender_id_;
   }
 
   bool LauncherHasRunningPrerender(int child_id, int prerender_id) {
     PrerenderLinkManager::LinkPrerender* prerender =
         prerender_link_manager()->FindByLauncherChildIdAndPrerenderId(
             child_id, prerender_id);
     return prerender && prerender->handle;
   }
 
   // Shorthand to add a simple prerender with a reasonable source. Returns
   // true iff the prerender has been added to the PrerenderManager by the
   // PrerenderLinkManager and the PrerenderManager returned a handle.
   bool AddSimplePrerender(const GURL& url) {
-    prerender_link_manager()->OnAddPrerender(kDefaultChildId,
-                                             GetNextPrerenderID(),
-                                             url, content::Referrer(),
-                                             kSize, kDefaultRenderViewRouteId);
+    prerender_link_manager()->OnAddPrerender(
+        kDefaultChildId, GetNextPrerenderID(), url, kDefaultRelTypes,
+        content::Referrer(), kSize, kDefaultRenderViewRouteId);
     return LauncherHasRunningPrerender(kDefaultChildId, last_prerender_id());
   }
 
  private:
   PrerenderTracker* prerender_tracker() {
     return g_browser_process->prerender_tracker();
   }
 
   // Needed to pass PrerenderManager's DCHECKs.
   TestingProfile profile_;
@@ skipping 234 matching lines @@
     if (concurrencies_to_test[i].max_link_concurrency >
             effective_max_link_concurrency) {
       // We should be able to launch more prerenders on this system, but not for
       // our current launcher.
       int child_id;
       int route_id;
       ASSERT_TRUE(prerender_contentses.back()->GetChildId(&child_id));
       ASSERT_TRUE(prerender_contentses.back()->GetRouteId(&route_id));
 
       GURL extra_url("http://google.com/extraurl");
-      prerender_link_manager()->OnAddPrerender(child_id,
-                                               GetNextPrerenderID(),
-                                               extra_url, content::Referrer(),
-                                               kSize, route_id);
+      prerender_link_manager()->OnAddPrerender(
+          child_id, GetNextPrerenderID(), extra_url, kDefaultRelTypes,
+          content::Referrer(), kSize, route_id);
       const int prerender_id = last_prerender_id();
       EXPECT_TRUE(LauncherHasRunningPrerender(child_id, prerender_id));
       prerender_link_manager()->OnCancelPrerender(child_id, prerender_id);
       EXPECT_FALSE(LauncherHasRunningPrerender(child_id, prerender_id));
     }
 
     DummyPrerenderContents* prerender_contents_to_delay =
         prerender_manager()->CreateNextPrerenderContents(url_to_delay,
                                                          FINAL_STATUS_USED);
     EXPECT_FALSE(AddSimplePrerender(url_to_delay));
@@ skipping 166 matching lines @@
 }
 
 // Tests that prerendering is cancelled when the source render view does not
 // exist.  On failure, the DCHECK in CreatePrerenderContents() above should be
 // triggered.
 TEST_F(PrerenderTest, SourceRenderViewClosed) {
   GURL url("http://www.google.com/");
   prerender_manager()->CreateNextPrerenderContents(
       url,
       FINAL_STATUS_MANAGER_SHUTDOWN);
-  prerender_link_manager()->OnAddPrerender(100, GetNextPrerenderID(), url,
-                                           Referrer(), kSize, 200);
+  prerender_link_manager()->OnAddPrerender(
+      100, GetNextPrerenderID(), url, kDefaultRelTypes, Referrer(), kSize, 200);
   EXPECT_FALSE(LauncherHasRunningPrerender(100, last_prerender_id()));
 }
 
+// Tests that prerendering doesn't launch rel=next prerenders without the field
+// trial.
+TEST_F(PrerenderTest, NoRelNextByDefault) {
+  GURL url("http://www.google.com/");
+  prerender_manager()->CreateNextPrerenderContents(
+      url, FINAL_STATUS_MANAGER_SHUTDOWN);
+  DummyPrerenderContents* null = NULL;
+
+  prerender_link_manager()->OnAddPrerender(
+      kDefaultChildId, GetNextPrerenderID(), url, PrerenderRelTypeNext,
+      Referrer(), kSize, kDefaultRenderViewRouteId);
+  EXPECT_EQ(null, prerender_manager()->FindEntry(url));
+}
+
+// Tests that prerendering does launch rel=next prerenders with the field trial.
+TEST_F(PrerenderTest, RelNextByFieldTrial) {
+  ASSERT_TRUE(base::FieldTrialList::CreateFieldTrial("PrerenderRelNextTrial",
+                                                     "Yes"));
+  GURL url("http://www.google.com/");
+  DummyPrerenderContents* prerender_contents =
+      prerender_manager()->CreateNextPrerenderContents(
+          url, FINAL_STATUS_MANAGER_SHUTDOWN);
+
+  prerender_link_manager()->OnAddPrerender(
+      kDefaultChildId, GetNextPrerenderID(), url, PrerenderRelTypeNext,
+      Referrer(), kSize, kDefaultRenderViewRouteId);
+  EXPECT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
+}
+
 // Tests that prerendering is cancelled when we launch a second prerender of
 // the same target within a short time interval.
 TEST_F(PrerenderTest, RecentlyVisited) {
   GURL url("http://www.google.com/");
 
   prerender_manager()->RecordNavigation(url);
 
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_RECENTLY_VISITED);
@@ skipping 535 matching lines @@
           first_url, FINAL_STATUS_TIMED_OUT);
   EXPECT_TRUE(AddSimplePrerender(first_url));
   const int first_prerender_id = last_prerender_id();
 
   int child_id;
   int route_id;
   ASSERT_TRUE(prerender_contents->GetChildId(&child_id));
   ASSERT_TRUE(prerender_contents->GetRouteId(&route_id));
 
   GURL pending_url("http://www.neverlaunched.com");
-  prerender_link_manager()->OnAddPrerender(child_id,
-                                           GetNextPrerenderID(),
-                                           pending_url, content::Referrer(),
-                                           kSize, route_id);
+  prerender_link_manager()->OnAddPrerender(
+      child_id, GetNextPrerenderID(), pending_url, kDefaultRelTypes,
+      content::Referrer(), kSize, route_id);
   const int second_prerender_id = last_prerender_id();
 
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   DummyPrerenderContents* null = NULL;
   EXPECT_EQ(prerender_contents, prerender_manager()->FindEntry(first_url));
   EXPECT_EQ(null, prerender_manager()->FindEntry(pending_url));
 
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                first_prerender_id);
@@ skipping 116 matching lines @@
   CHECK(prerender_handle.get());
   EXPECT_TRUE(prerender_handle->IsPrerendering());
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_EQ(prerender_contents, prerender_handle->contents());
   EXPECT_EQ(ORIGIN_INSTANT, prerender_handle->contents()->origin());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
   EXPECT_FALSE(prerender_handle->IsPrerendering());
 }
 
 }  // namespace prerender