Make PrerenderHandle an observer of PrerenderContents.

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"
@@ skipping 117 matching lines @@
     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->StartPendingPrerenders();
+    prerender_contents->PrepareForUse();
     return prerender_contents;
   }
 
   void AdvanceTime(TimeDelta delta) {
     time_ += delta;
   }
 
   void AdvanceTimeTicks(TimeDelta delta) {
     time_ticks_ += delta;
   }
@@ skipping 206 matching lines @@
           url,
           FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
 
   scoped_ptr<PrerenderHandle> duplicate_prerender_handle(
       prerender_manager()->AddPrerenderFromLinkRelPrerender(
           kDefaultChildId, kDefaultRenderViewRouteId, url,
           Referrer(url, WebKit::WebReferrerPolicyDefault), kSize));
 
-  EXPECT_TRUE(duplicate_prerender_handle->IsValid());
   EXPECT_TRUE(duplicate_prerender_handle->IsPrerendering());
 
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 
-  EXPECT_FALSE(duplicate_prerender_handle->IsValid());
   EXPECT_FALSE(duplicate_prerender_handle->IsPrerendering());
 }
 
 // Make sure that if queue a request, and a second prerender request for the
 // same URL comes in, that we drop the second request and keep the first one.
 TEST_F(PrerenderTest, DropSecondRequestTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
@@ skipping 261 matching lines @@
   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, WebKit::WebReferrerPolicyDefault), kSize));
   CHECK(pending_prerender_handle.get());
-  EXPECT_TRUE(pending_prerender_handle->IsValid());
-  EXPECT_TRUE(pending_prerender_handle->IsPending());
+  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
 
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 
-  EXPECT_FALSE(pending_prerender_handle->IsPending());
+  EXPECT_TRUE(pending_prerender_handle->IsPrerendering());
   ASSERT_EQ(pending_prerender_contents,
             prerender_manager()->FindAndUseEntry(pending_url));
 }
 
 TEST_F(PrerenderTest, InvalidPendingPrerenderTest) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url,
           FINAL_STATUS_USED);
@@ skipping 10 matching lines @@
 
   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, WebKit::WebReferrerPolicyDefault), kSize));
   DCHECK(pending_prerender_handle.get());
-  EXPECT_TRUE(pending_prerender_handle->IsValid());
-  EXPECT_TRUE(pending_prerender_handle->IsPending());
+  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
 
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 
-  EXPECT_FALSE(pending_prerender_handle->IsValid());
-  EXPECT_FALSE(pending_prerender_handle->IsPending());
+  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
 }
 
 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, WebKit::WebReferrerPolicyDefault), kSize));
   CHECK(pending_prerender_handle.get());
-  EXPECT_TRUE(pending_prerender_handle->IsValid());
-  EXPECT_TRUE(pending_prerender_handle->IsPending());
+  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
 
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
 
   pending_prerender_handle->OnCancel();
-  EXPECT_FALSE(pending_prerender_handle->IsValid());
+  EXPECT_FALSE(pending_prerender_handle->IsPrerendering());
 
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 }
 
 // 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);
@@ skipping 50 matching lines @@
 }
 
 // Tests that our PPLT dummy prerender gets created properly.
 TEST_F(PrerenderTest, PPLTDummy) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_UNSUPPORTED_SCHEME);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
+  EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   DummyPrerenderContents* pplt_dummy_contents =
       prerender_manager()->CreateNextPrerenderContents(url,
                                                        FINAL_STATUS_USED);
   GURL ftp_url("ftp://ftp.google.com/");
   // Adding this ftp URL will force the expected unsupported scheme error.
   prerender_contents->AddAliasURL(ftp_url);
+  EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 
   ASSERT_EQ(pplt_dummy_contents, prerender_manager()->FindAndUseEntry(url));
+  EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Tests that our PPLT dummy prerender gets created properly, even
 // when navigating to a page that has been recently navigated to.
 TEST_F(PrerenderTest, RecentlyVisitedPPLTDummy) {
   GURL url("http://www.google.com/");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_UNSUPPORTED_SCHEME);
   EXPECT_TRUE(AddSimplePrerender(url));
@@ skipping 17 matching lines @@
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   // Force the creation of a match complete dummy.
   DummyPrerenderContents* duplicate_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(url,
                                                        FINAL_STATUS_CANCELLED);
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
   prerender_contents->Destroy(FINAL_STATUS_JAVASCRIPT_ALERT);
   ASSERT_EQ(duplicate_prerender_contents, prerender_manager()->FindEntry(url));
 
+  // Make sure that events on prerender handles propogate to the match
+  // complete replacement.
+  DummyPrerenderContents* null = NULL;
   prerender_link_manager()->OnCancelPrerender(kDefaultChildId,
                                               last_prerender_id());
-  DummyPrerenderContents* null = NULL;
   ASSERT_EQ(null, prerender_manager()->FindEntry(url));
 }
 
-
 // Tests that the prerender manager matches include the fragment.
 TEST_F(PrerenderTest, FragmentMatchesTest) {
   GURL fragment_url("http://www.google.com/#test");
 
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(fragment_url,
                                                        FINAL_STATUS_USED);
   EXPECT_TRUE(AddSimplePrerender(fragment_url));
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   ASSERT_EQ(prerender_contents,
@@ skipping 120 matching lines @@
 
   EXPECT_TRUE(prerender_contents->prerendering_has_started());
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                last_prerender_id());
 
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
-  EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 TEST_F(PrerenderTest, LinkManagerCancelTwice) {
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   GURL url("http://www.myexample.com");
   DummyPrerenderContents* prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_CANCELLED);
 
   EXPECT_TRUE(AddSimplePrerender(url));
@@ skipping 109 matching lines @@
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                first_prerender_id);
 
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindEntry(url));
   prerender_link_manager()->OnAbandonPrerender(kDefaultChildId,
                                                second_prerender_id);
 
-  EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   EXPECT_FALSE(prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(prerender_contents, prerender_manager()->FindAndUseEntry(url));
 }
 
 // TODO(gavinp): After abandon shortens the expire time on a Prerender,
 // add a series of tests testing advancing the time by either the abandon
 // or normal expire, and verifying the expected behaviour with groups
 // of links.
 TEST_F(PrerenderTest, LinkManagerExpireThenCancel) {
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
@@ skipping 35 matching lines @@
       prerender_manager()->config().time_to_live + TimeDelta::FromSeconds(1));
   DummyPrerenderContents* null = NULL;
   ASSERT_EQ(null, prerender_manager()->FindEntry(url));
   DummyPrerenderContents* second_prerender_contents =
       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));
-  // The PrerenderLinkManager is not empty since we never removed the first
-  // prerender.
-  EXPECT_FALSE(IsEmptyPrerenderLinkManager());
 }
 
 TEST_F(PrerenderTest, LinkManagerCancelThenAddAgain) {
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   GURL url("http://www.myexample.com");
   DummyPrerenderContents* first_prerender_contents =
       prerender_manager()->CreateNextPrerenderContents(
           url, FINAL_STATUS_CANCELLED);
   EXPECT_TRUE(AddSimplePrerender(url));
   EXPECT_TRUE(first_prerender_contents->prerendering_has_started());
   EXPECT_FALSE(first_prerender_contents->prerendering_has_been_cancelled());
   ASSERT_EQ(first_prerender_contents, prerender_manager()->FindEntry(url));
   prerender_link_manager()->OnCancelPrerender(kDefaultChildId,
                                               last_prerender_id());
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
   EXPECT_TRUE(first_prerender_contents->prerendering_has_been_cancelled());
   DummyPrerenderContents* null = NULL;
   ASSERT_EQ(null, prerender_manager()->FindEntry(url));
   DummyPrerenderContents* second_prerender_contents =
       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