Move pending prerender logic into PrerenderLinkManager.

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 <map>
+#include <utility>
+
 #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"
@@ skipping 21 matching lines @@
 namespace {
 
 class DummyPrerenderContents : public PrerenderContents {
  public:
   DummyPrerenderContents(UnitTestPrerenderManager* test_prerender_manager,
                          PrerenderTracker* prerender_tracker,
                          const GURL& url,
                          Origin origin,
                          FinalStatus expected_final_status);
 
-  virtual ~DummyPrerenderContents() {
-    EXPECT_EQ(expected_final_status_, final_status());
-  }
+  virtual ~DummyPrerenderContents();
 
   virtual void StartPrerendering(
       int ALLOW_UNUSED creator_child_id,
       const gfx::Size& ALLOW_UNUSED size,
       content::SessionStorageNamespace* ALLOW_UNUSED session_storage_namespace)
       OVERRIDE;
 
   virtual bool GetChildId(int* child_id) const OVERRIDE {
     // Having a default child_id of -1 forces pending prerenders not to fail
     // on session storage and cross domain checking.
@@ skipping 69 matching lines @@
   PrerenderContents* FindAndUseEntry(const GURL& url) {
     PrerenderData* prerender_data = FindPrerenderData(url, NULL);
     if (!prerender_data)
       return NULL;
     ScopedVector<PrerenderData>::iterator to_erase =
         FindIteratorForPrerenderContents(prerender_data->contents());
     CHECK(to_erase != active_prerenders_.end());
     PrerenderContents* prerender_contents = prerender_data->ReleaseContents();
     active_prerenders_.erase(to_erase);
 
-    prerender_contents->SetFinalStatus(FINAL_STATUS_USED);
     prerender_contents->PrepareForUse();
     return prerender_contents;
   }
 
   void AdvanceTime(TimeDelta delta) {
     time_ += delta;
   }
 
   void AdvanceTimeTicks(TimeDelta delta) {
     time_ticks_ += delta;
@@ skipping 48 matching lines @@
 
   // from PrerenderManager
   virtual Time GetCurrentTime() const OVERRIDE {
     return time_;
   }
 
   virtual TimeTicks GetCurrentTimeTicks() const OVERRIDE {
     return time_ticks_;
   }
 
+  virtual PrerenderContents* GetPrerenderContentsForRoute(
+      int child_id, int route_id) const OVERRIDE {
+    // Overridden for the PrerenderLinkManager's pending prerender logic.
+    PrerenderContentsMap::const_iterator iter = prerender_contents_map_.find(
+        std::make_pair(child_id, route_id));
+    if (iter == prerender_contents_map_.end())
+      return NULL;
+    return iter->second;
+  }
+
+  void DummyPrerenderContentsStarted(int child_id,
+                                     int route_id,
+                                     PrerenderContents* prerender_contents) {
+    prerender_contents_map_[std::make_pair(child_id, route_id)] =
+        prerender_contents;
+  }
+
+  void DummyPrerenderContentsDestroyed(int child_id,
+                                       int route_id) {
+    prerender_contents_map_.erase(std::make_pair(child_id, route_id));
+  }
+
  private:
   void SetNextPrerenderContents(DummyPrerenderContents* prerender_contents) {
     CHECK(!next_prerender_contents_.get());
     next_prerender_contents_.reset(prerender_contents);
     if (prerender_contents->expected_final_status() == FINAL_STATUS_USED)
       used_prerender_contents_.push_back(prerender_contents);
   }
 
 
   virtual PrerenderContents* CreatePrerenderContents(
       const GURL& url,
       const Referrer& referrer,
       Origin origin,
       uint8 experiment_id) OVERRIDE {
     CHECK(next_prerender_contents_.get());
     EXPECT_EQ(url, next_prerender_contents_->prerender_url());
     EXPECT_EQ(origin, next_prerender_contents_->origin());
     return next_prerender_contents_.release();
   }
 
+  // Maintain a map from route pairs to PrerenderContents for
+  // GetPrerenderContentsForRoute.
+  typedef std::map<std::pair<int,int>, PrerenderContents*> PrerenderContentsMap;
+  PrerenderContentsMap prerender_contents_map_;
+
   Time time_;
   TimeTicks time_ticks_;
   scoped_ptr<PrerenderContents> next_prerender_contents_;
   // PrerenderContents with an |expected_final_status| of FINAL_STATUS_USED,
   // tracked so they will be automatically deleted.
   ScopedVector<PrerenderContents> used_prerender_contents_;
 
   PrerenderTracker* prerender_tracker_;
 };
 
@@ skipping 14 matching lines @@
     Origin origin,
     FinalStatus expected_final_status)
     : PrerenderContents(test_prerender_manager,
                         NULL, url, Referrer(), origin,
                         PrerenderManager::kNoExperiment),
       route_id_(g_next_route_id_++),
       test_prerender_manager_(test_prerender_manager),
       expected_final_status_(expected_final_status) {
 }
 
+DummyPrerenderContents::~DummyPrerenderContents() {
+  EXPECT_EQ(expected_final_status_, final_status());
+  test_prerender_manager_->DummyPrerenderContentsDestroyed(-1, route_id_);
+}
+
 void DummyPrerenderContents::StartPrerendering(
     int ALLOW_UNUSED creator_child_id,
     const gfx::Size& ALLOW_UNUSED size,
     content::SessionStorageNamespace* ALLOW_UNUSED session_storage_namespace) {
   // In the base PrerenderContents implementation, StartPrerendering will
   // be called even when the PrerenderManager is part of the control group,
   // but it will early exit before actually creating a new RenderView if
   // |is_control_group| is true;
   load_start_time_ = test_prerender_manager_->GetCurrentTimeTicks();
   if (!test_prerender_manager_->IsControlGroup(experiment_id())) {
     prerendering_has_started_ = true;
+    test_prerender_manager_->DummyPrerenderContentsStarted(-1, route_id_, this);
     NotifyPrerenderStart();
   }
 }
 
 class PrerenderTest : public testing::Test {
  public:
   static const int kDefaultChildId = -1;
   static const int kDefaultRenderViewRouteId = -1;
 
   PrerenderTest() : ui_thread_(BrowserThread::UI, &message_loop_),
@@ skipping 43 matching lines @@
     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;
   }
 
+  bool LauncherHasScheduledPrerender(int child_id, int prerender_id) {
+    PrerenderLinkManager::LinkPrerender* prerender =
+        prerender_link_manager()->FindByLauncherChildIdAndPrerenderId(
+            child_id, prerender_id);
+    return prerender != NULL;
+  }
+
   // 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);
     return LauncherHasRunningPrerender(kDefaultChildId, last_prerender_id());
   }
@@ skipping 235 matching lines @@
           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());
     }
 
     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));
-
+      // the default launcher.
       GURL extra_url("http://google.com/extraurl");
-      prerender_link_manager()->OnAddPrerender(child_id,
-                                               GetNextPrerenderID(),
-                                               extra_url, content::Referrer(),
-                                               kSize, route_id);
+      EXPECT_FALSE(AddSimplePrerender(extra_url));
       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));
+      EXPECT_TRUE(LauncherHasScheduledPrerender(kDefaultChildId,
+                                                prerender_id));
+      prerender_link_manager()->OnCancelPrerender(kDefaultChildId,
+                                                  prerender_id);
+      EXPECT_FALSE(LauncherHasScheduledPrerender(kDefaultChildId,
+                                                 prerender_id));
     }
 
     DummyPrerenderContents* prerender_contents_to_delay =
         prerender_manager()->CreateNextPrerenderContents(url_to_delay,
                                                          FINAL_STATUS_USED);
     EXPECT_FALSE(AddSimplePrerender(url_to_delay));
     EXPECT_FALSE(prerender_contents_to_delay->prerendering_has_started());
     EXPECT_NE(null, prerender_manager()->next_prerender_contents());
     EXPECT_EQ(null, prerender_manager()->FindEntry(url_to_delay));
     for (size_t j = 0; j < effective_max_link_concurrency; ++j) {
@@ skipping 55 matching lines @@
           FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
 
   int child_id;
   int route_id;
   ASSERT_TRUE(prerender_contents->GetChildId(&child_id));
   ASSERT_TRUE(prerender_contents->GetRouteId(&route_id));
 
   GURL pending_url("http://news.google.com/");
 
+  // Schedule a pending prerender launched from the prerender.
   DummyPrerenderContents* pending_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           pending_url,
           ORIGIN_GWS_PRERENDER,
           FINAL_STATUS_USED);
-  scoped_ptr<PrerenderHandle> pending_prerender_handle(
-      prerender_manager()->AddPrerenderFromLinkRelPrerender(
-          child_id, route_id, pending_url,
-          Referrer(url, blink::WebReferrerPolicyDefault), kSize));
-  CHECK(pending_prerender_handle.get());
-  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
+  prerender_link_manager()->OnAddPrerender(
+      child_id, GetNextPrerenderID(), pending_url,
+      Referrer(url, blink::WebReferrerPolicyDefault),
+      kSize, route_id);
+  EXPECT_FALSE(LauncherHasRunningPrerender(child_id, last_prerender_id()));
+  EXPECT_FALSE(pending_prerender_contents->prerendering_has_started());
 
+  // Use the referring prerender.
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 
-  EXPECT_TRUE(pending_prerender_handle->IsPrerendering());
+  // The pending prerender should start now.
+  EXPECT_TRUE(LauncherHasRunningPrerender(child_id, last_prerender_id()));
+  EXPECT_TRUE(pending_prerender_contents->prerendering_has_started());
   ASSERT_EQ(pending_prerender_contents,
             prerender_manager()->FindAndUseEntry(pending_url));
-  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
 }
 
 TEST_F(PrerenderTest, InvalidPendingPrerenderTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
 
   int child_id;
   int route_id;
   ASSERT_TRUE(prerender_contents->GetChildId(&child_id));
   ASSERT_TRUE(prerender_contents->GetRouteId(&route_id));
 
   // This pending URL has an unsupported scheme, and won't be able
   // to start.
   GURL pending_url("ftp://news.google.com/");
 
-  prerender_manager()->CreateNextPrerenderContents(
-      pending_url,
-      ORIGIN_GWS_PRERENDER,
-      FINAL_STATUS_UNSUPPORTED_SCHEME);
-  scoped_ptr<PrerenderHandle> pending_prerender_handle(
-      prerender_manager()->AddPrerenderFromLinkRelPrerender(
-          child_id, route_id, pending_url,
-          Referrer(url, blink::WebReferrerPolicyDefault), kSize));
-  DCHECK(pending_prerender_handle.get());
-  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
+  // Schedule a pending prerender launched from the prerender.
+  DummyPrerenderContents* pending_prerender_contents =
+      prerender_manager()->CreateNextPrerenderContents(
+          pending_url,
+          ORIGIN_GWS_PRERENDER,
+          FINAL_STATUS_UNSUPPORTED_SCHEME);
+  prerender_link_manager()->OnAddPrerender(

[gavinp, 2014/01/30 19:58:49]

Nice. I like that these tests are going through the prerender_link_manager()
more.

[davidben, 2014/01/30 21:01:51]

They have to anyway; the logic has moved to PrerenderLinkManager.

+      child_id, GetNextPrerenderID(), pending_url,
+      Referrer(url, blink::WebReferrerPolicyDefault),
+      kSize, route_id);
+  EXPECT_FALSE(LauncherHasRunningPrerender(child_id, last_prerender_id()));
+  EXPECT_FALSE(pending_prerender_contents->prerendering_has_started());
 
+  // Use the referring prerender.
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 
-  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
+  // The pending prerender still doesn't start.
+  EXPECT_FALSE(LauncherHasRunningPrerender(child_id, last_prerender_id()));
+  EXPECT_FALSE(pending_prerender_contents->prerendering_has_started());
 }
 
 TEST_F(PrerenderTest, CancelPendingPrerenderTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
 
   int child_id;
   int route_id;
   ASSERT_TRUE(prerender_contents->GetChildId(&child_id));
   ASSERT_TRUE(prerender_contents->GetRouteId(&route_id));
 
   GURL pending_url("http://news.google.com/");
 
-  scoped_ptr<PrerenderHandle> pending_prerender_handle(
-      prerender_manager()->AddPrerenderFromLinkRelPrerender(
-          child_id, route_id, pending_url,
-          Referrer(url, blink::WebReferrerPolicyDefault), kSize));
-  CHECK(pending_prerender_handle.get());
-  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
+  // Schedule a pending prerender launched from the prerender.
+  prerender_link_manager()->OnAddPrerender(
+      child_id, GetNextPrerenderID(), pending_url,
+      Referrer(url, blink::WebReferrerPolicyDefault),
+      kSize, route_id);
+  EXPECT_FALSE(LauncherHasRunningPrerender(child_id, last_prerender_id()));
 
+  // Cancel the pending prerender.
+  prerender_link_manager()->OnCancelPrerender(child_id, last_prerender_id());
+
+  // Use the referring prerender.
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
+  ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 
-  pending_prerender_handle.reset();
-
-  ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
+  // The pending prerender doesn't start.
+  EXPECT_FALSE(LauncherHasRunningPrerender(child_id, last_prerender_id()));
 }
 
 // Tests that a PrerenderManager created for a browser session in the control
 // group works as expected.
 TEST_F(PrerenderTest, ControlGroup) {
   RestorePrerenderMode restore_prerender_mode;
   PrerenderManager::SetMode(
       PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
@@ skipping 705 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