Move pending prerender logic into PrerenderLinkManager.

chrome/browser/prerender/prerender_browsertest.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 <deque>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 306 matching lines @@
       const GURL& url,
       const content::Referrer& referrer,
       Origin origin,
       FinalStatus expected_final_status)
       : PrerenderContents(prerender_manager, profile, url,
                           referrer, origin, PrerenderManager::kNoExperiment),
         expected_final_status_(expected_final_status),
         new_render_view_host_(NULL),
         was_hidden_(false),
         was_shown_(false),
-        should_be_shown_(expected_final_status == FINAL_STATUS_USED),
-        expected_pending_prerenders_(0) {
+        should_be_shown_(expected_final_status == FINAL_STATUS_USED) {
   }
 
   virtual ~TestPrerenderContents() {
     if (expected_final_status_ == FINAL_STATUS_MAX) {
-      EXPECT_EQ(match_complete_status(), MATCH_COMPLETE_REPLACEMENT);
+      EXPECT_EQ(MATCH_COMPLETE_REPLACEMENT, match_complete_status());
     } else {
       EXPECT_EQ(expected_final_status_, final_status()) <<
           " when testing URL " << prerender_url().path() <<
           " (Expected: " << NameFromFinalStatus(expected_final_status_) <<
           ", Actual: " << NameFromFinalStatus(final_status()) << ")";
     }
     // Prerendering RenderViewHosts should be hidden before the first
     // navigation, so this should be happen for every PrerenderContents for
     // which a RenderViewHost is created, regardless of whether or not it's
     // used.
@@ skipping 27 matching lines @@
   }
 
   virtual bool CheckURL(const GURL& url) OVERRIDE {
     // Prevent FINAL_STATUS_UNSUPPORTED_SCHEME when navigating to about:crash in
     // the PrerenderRendererCrash test.
     if (url.spec() != content::kChromeUICrashURL)
       return PrerenderContents::CheckURL(url);
     return true;
   }
 
-  virtual void AddPendingPrerender(
-      scoped_ptr<PendingPrerenderInfo> pending_prerender_info) OVERRIDE {
-    PrerenderContents::AddPendingPrerender(pending_prerender_info.Pass());
-    if (expected_pending_prerenders_ > 0 &&
-        pending_prerender_count() == expected_pending_prerenders_) {
-      base::MessageLoop::current()->Quit();
-    }
-  }
-
-  // Waits until the prerender has |expected_pending_prerenders| pending
-  // prerenders.
-  void WaitForPendingPrerenders(size_t expected_pending_prerenders) {
-    if (pending_prerender_count() < expected_pending_prerenders) {
-      expected_pending_prerenders_ = expected_pending_prerenders;
-      content::RunMessageLoop();
-      expected_pending_prerenders_ = 0;
-    }
-
-    EXPECT_EQ(expected_pending_prerenders, pending_prerender_count());
-  }
-
   // For tests that open the prerender in a new background tab, the RenderView
   // will not have been made visible when the PrerenderContents is destroyed
   // even though it is used.
   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 
   FinalStatus expected_final_status() const { return expected_final_status_; }
 
  private:
   virtual void OnRenderViewHostCreated(
       RenderViewHost* new_render_view_host) OVERRIDE {
@@ skipping 36 matching lines @@
   // The RenderViewHost created for the prerender, if any.
   RenderViewHost* new_render_view_host_;
   // Set to true when the prerendering RenderWidget is hidden.
   bool was_hidden_;
   // Set to true when the prerendering RenderWidget is shown, after having been
   // hidden.
   bool was_shown_;
   // Expected final value of was_shown_.  Defaults to true for
   // FINAL_STATUS_USED, and false otherwise.
   bool should_be_shown_;
-
-  // Total number of pending prerenders we're currently waiting for.  Zero
-  // indicates we currently aren't waiting for any.
-  size_t expected_pending_prerenders_;
 };
 
 // A handle to a TestPrerenderContents whose lifetime is under the caller's
 // control. A PrerenderContents may be destroyed at any point. This allows
 // tracking the final status, etc.
 class TestPrerender : public PrerenderContents::Observer,
                       public base::SupportsWeakPtr<TestPrerender> {
  public:
   TestPrerender()
       : contents_(NULL),
@@ skipping 818 matching lines @@
   // removed from the PrerenderLinkManager when the prerender is canceled from
   // the browser, when the prerenders are cancelled from the renderer process,
   // or the channel for the renderer process is closed on the IO thread.  In the
   // last case, the code must be careful to wait for the channel to close, as it
   // is done asynchronously after swapping out the old process.  See
   // ChannelDestructionWatcher.
   bool IsEmptyPrerenderLinkManager() const {
     return GetPrerenderLinkManager()->IsEmpty();
   }
 
+  size_t GetLinkPrerenderCount() const {
+    return GetPrerenderLinkManager()->prerenders_.size();
+  }
+
+  size_t GetRunningLinkPrerenderCount() const {
+    return GetPrerenderLinkManager()->CountRunningPrerenders();
+  }
+
   // Returns length of |prerender_manager_|'s history, or -1 on failure.
   int GetHistoryLength() const {
     scoped_ptr<base::DictionaryValue> prerender_dict(
         static_cast<base::DictionaryValue*>(
             GetPrerenderManager()->GetAsValue()));
     if (!prerender_dict.get())
       return -1;
     base::ListValue* history_list;
     if (!prerender_dict->GetList("history", &history_list))
       return -1;
@@ skipping 66 matching lines @@
   bool DidDisplayPass(WebContents* web_contents) const {
     bool display_test_result = false;
     if (!content::ExecuteScriptAndExtractBool(
             web_contents,
             "window.domAutomationController.send(DidDisplayPass())",
             &display_test_result))
       return false;
     return display_test_result;
   }
 
+  scoped_ptr<TestPrerender> ExpectPrerender(FinalStatus expected_final_status) {
+    return prerender_contents_factory_->ExpectPrerenderContents(
+        expected_final_status);
+  }
+
  protected:
   bool autostart_test_server_;
 
  private:
   // TODO(davidben): Remove this altogether so the tests don't globally assume
   // only one prerender.
   TestPrerenderContents* GetPrerenderContents() const {
     return GetPrerenderContentsFor(dest_url_);
   }
 
@@ skipping 142 matching lines @@
   ChannelDestructionWatcher channel_close_watcher;
   channel_close_watcher.WatchChannel(
       GetActiveWebContents()->GetRenderProcessHost());
   NavigateToDestURL();
   channel_close_watcher.WaitForChannelClose();
 
   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that pending prerenders launch and receive proper event treatment.
-// Disabled due to http://crbug.com/167792
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderPagePending) {
-  std::vector<FinalStatus> expected_final_status_queue;
-  expected_final_status_queue.push_back(FINAL_STATUS_USED);
-  expected_final_status_queue.push_back(FINAL_STATUS_USED);
-  PrerenderTestURL("files/prerender/prerender_page_pending.html",
-                   expected_final_status_queue, 1);
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPagePending) {
+  scoped_ptr<TestPrerender> prerender =
+      PrerenderTestURL("files/prerender/prerender_page_pending.html",
+                       FINAL_STATUS_USED, 1);
 
-  ChannelDestructionWatcher first_channel_close_watcher;
+  // Navigate to the prerender.
+  scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
+  NavigateToDestURL();
+  // Abort early if the original prerender didn't swap, so as not to hang.
+  ASSERT_FALSE(prerender->contents());
 
-  first_channel_close_watcher.WatchChannel(
-      GetActiveWebContents()->GetRenderProcessHost());
-  NavigateToDestURL();
-  // NavigateToDestURL doesn't run a message loop. Normally that's fine, but in
-  // this case, we need the pending prerenders to start.
-  content::RunMessageLoop();
-  first_channel_close_watcher.WaitForChannelClose();
+  // Wait for the new prerender to be ready.
+  prerender2->WaitForStart();
+  prerender2->WaitForLoads(1);
 
   const GURL prerender_page_url =
       test_server()->GetURL("files/prerender/prerender_page.html");
   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
   EXPECT_NE(static_cast<TestPrerenderContents*>(NULL),
             GetPrerenderContentsFor(prerender_page_url));
 
   // Now navigate to our target page.
-  ChannelDestructionWatcher second_channel_close_watcher;
-  second_channel_close_watcher.WatchChannel(
-      GetActiveWebContents()->GetRenderProcessHost());
+  NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
+                                         GetActiveWebContents());
   ui_test_utils::NavigateToURLWithDisposition(
       current_browser(), prerender_page_url, CURRENT_TAB,
       ui_test_utils::BROWSER_TEST_NONE);
-  second_channel_close_watcher.WaitForChannelClose();
+  swap_observer.Wait();
 
   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // Checks that pending prerenders which are canceled before they are launched
 // never get started.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovesPending) {
   PrerenderTestURL("files/prerender/prerender_page_removes_pending.html",
                    FINAL_STATUS_USED, 1);
 
@@ skipping 574 matching lines @@
 
 // Checks shutdown code while a prerender is active.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderQuickQuit) {
   DisableJavascriptCalls();
   DisableLoadEventCheck();
   PrerenderTestURL("files/prerender/prerender_page.html",
                    FINAL_STATUS_APP_TERMINATING,
                    0);
 }
 
-// TODO(gavinp,sreeram): Fix http://crbug.com/145248 and deflake this test.
 // Checks that we don't prerender in an infinite loop.
-IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderInfiniteLoop) {
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderInfiniteLoop) {
   const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
   const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
   ScopedVector<TestPrerender> prerenders =
       PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
   ASSERT_TRUE(prerenders[0]->contents());
-  prerenders[0]->contents()->WaitForPendingPrerenders(1u);
+  // Assert that the pending prerender is in there already. This relies on the
+  // fact that the renderer sends out the AddLinkRelPrerender IPC before sending
+  // the page load one.

[davidben, 2014/01/24 17:50:43]

Not entirely thrilled by these "this relies on the fact that [...]" bits, but I
believe it is not racy right now. We can perhaps add some test-only observers to
PrerenderLinkManager if this ends up changing. (x5 or so)

+  EXPECT_EQ(2U, GetLinkPrerenderCount());
+  EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
 
   // Next url should be in pending list but not an active entry.
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
 
   NavigateToDestURL();
 
-  // Make sure the PrerenderContents for the next url is now in the manager
-  // and not pending.
+  // Make sure the PrerenderContents for the next url is now in the manager and
+  // not pending. This relies on pending prerenders being resolved in the same
+  // event loop iteration as OnPrerenderStop.
   EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
+  EXPECT_EQ(1U, GetLinkPrerenderCount());
+  EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
 }
 
-// TODO(gavinp,sreeram): Fix http://crbug.com/145248 and deflake this test.
 // Checks that we don't prerender in an infinite loop and multiple links are
 // handled correctly.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
-                       DISABLED_PrerenderInfiniteLoopMultiple) {
+                       PrerenderInfiniteLoopMultiple) {
   const char* const kHtmlFileA =
       "files/prerender/prerender_infinite_a_multiple.html";
   const char* const kHtmlFileB =
       "files/prerender/prerender_infinite_b_multiple.html";
   const char* const kHtmlFileC =
       "files/prerender/prerender_infinite_c_multiple.html";
 
   // This test is conceptually simplest if concurrency is at two, since we
   // don't have to worry about which of kHtmlFileB or kHtmlFileC gets evicted.
   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
 
   std::vector<FinalStatus> expected_final_status_queue;
   expected_final_status_queue.push_back(FINAL_STATUS_USED);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
 
   ScopedVector<TestPrerender> prerenders =
       PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
   ASSERT_TRUE(prerenders[0]->contents());
-  prerenders[0]->contents()->WaitForPendingPrerenders(2u);
 
-  // Next url should be in pending list but not an active entry.
+  // Next url should be in pending list but not an active entry. This relies on
+  // the fact that the renderer sends out the AddLinkRelPrerender IPC before
+  // sending the page load one.
+  EXPECT_EQ(3U, GetLinkPrerenderCount());
+  EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileC));
 
   NavigateToDestURL();
 
   // Make sure the PrerenderContents for the next urls are now in the manager
   // and not pending. One and only one of the URLs (the last seen) should be the
-  // active entry.
+  // active entry. This relies on pending prerenders being resolved in the same
+  // event loop iteration as OnPrerenderStop.
   bool url_b_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileB);
   bool url_c_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileC);
   EXPECT_TRUE(url_b_is_active_prerender && url_c_is_active_prerender);
+  EXPECT_EQ(2U, GetLinkPrerenderCount());
+  EXPECT_EQ(2U, GetRunningLinkPrerenderCount());
+}
+
+// Checks that pending prerenders are aborted (and never launched) when launched
+// by a prerender that itself gets aborted.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAbortPendingOnCancel) {
+  const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
+  const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
+
+  scoped_ptr<TestPrerender> prerender =
+      PrerenderTestURL(kHtmlFileA, FINAL_STATUS_CANCELLED, 1);
+  ASSERT_TRUE(prerender->contents());
+  // Assert that the pending prerender is in there already. This relies on the
+  // fact that the renderer sends out the AddLinkRelPrerender IPC before sending
+  // the page load one.
+  EXPECT_EQ(2U, GetLinkPrerenderCount());
+  EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
+
+  // Next url should be in pending list but not an active entry.
+  EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
+
+  // Cancel the prerender.
+  GetPrerenderManager()->CancelAllPrerenders();
+  prerender->WaitForStop();
+
+  // All prerenders are now gone.
+  EXPECT_TRUE(IsEmptyPrerenderLinkManager());
 }
 
 // See crbug.com/131836.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderTaskManager) {
   // Show the task manager. This populates the model.
   chrome::OpenTaskManager(current_browser());
   // Wait for the model of task manager to start.
   TaskManagerBrowserTestUtil::WaitForWebResourceChange(1);
 
   // Start with two resources.
@@ skipping 1468 matching lines @@
   }
 };
 
 // Checks that prerendering works in incognito mode.
 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
   NavigateToDestURL();
 }
 
 }  // namespace prerender