Deflake PrerenderExcessiveMemory, fix race

chrome/browser/prerender/prerender_browsertest.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/test/test_timeouts.h"
@@ skipping 84 matching lines @@
 
 // PrerenderContents that stops the UI message loop on DidStopLoading().
 class TestPrerenderContents : public PrerenderContents {
  public:
   TestPrerenderContents(
       PrerenderManager* prerender_manager,
       PrerenderTracker* prerender_tracker,
       Profile* profile,
       const GURL& url,
       const GURL& referrer,
-      int number_of_loads,
+      int expected_number_of_loads,
       FinalStatus expected_final_status)
       : PrerenderContents(prerender_manager, prerender_tracker, profile,
                           url, referrer, ORIGIN_LINK_REL_PRERENDER,
                           PrerenderManager::kNoExperiment),
         number_of_loads_(0),
-        expected_number_of_loads_(number_of_loads),
+        expected_number_of_loads_(expected_number_of_loads),
         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),
         quit_message_loop_on_destruction_(true) {
+    if (expected_number_of_loads == 0)
+      MessageLoopForUI::current()->Quit();
   }
 
   virtual ~TestPrerenderContents() {
     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.
-    if (new_render_view_host_) {
+    if (new_render_view_host_)
       EXPECT_TRUE(was_hidden_);
-    }
 
     // A used PrerenderContents will only be destroyed when we swap out
     // TabContents, at the end of a navigation caused by a call to
     // NavigateToURLImpl().
     if (final_status() == FINAL_STATUS_USED)
       EXPECT_TRUE(new_render_view_host_);
 
     EXPECT_EQ(should_be_shown_, was_shown_);
 
     // When the PrerenderContents is destroyed, quit the UI message loop.
@@ skipping 36 matching lines @@
   // even though it is used.
   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 
   // Some of the ui_test_utils calls that we use assume that no one will quit
   // the message loop that they run internally. So we dont quit the message
   // loop in the destructor so as not to interfere.
   void set_quit_message_loop_on_destruction(bool value) {
     quit_message_loop_on_destruction_ = value;
   }
 
+  int number_of_loads() { return number_of_loads_; }
+
  private:
   virtual void OnRenderViewHostCreated(
       RenderViewHost* new_render_view_host) OVERRIDE {
     // Used to make sure the RenderViewHost is hidden and, if used,
     // subsequently shown.
     notification_registrar().Add(
         this,
         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
         Source<RenderWidgetHost>(new_render_view_host));
 
@@ skipping 40 matching lines @@
 
   bool quit_message_loop_on_destruction_;
 };
 
 // PrerenderManager that uses TestPrerenderContents.
 class WaitForLoadPrerenderContentsFactory : public PrerenderContents::Factory {
  public:
   WaitForLoadPrerenderContentsFactory(
       int number_of_loads,
       const std::deque<FinalStatus>& expected_final_status_queue)
-      : number_of_loads_(number_of_loads) {
-    expected_final_status_queue_.resize(expected_final_status_queue.size());
-    std::copy(expected_final_status_queue.begin(),
-              expected_final_status_queue.end(),
-              expected_final_status_queue_.begin());
+      : number_of_loads_(number_of_loads),

[cbentzel, 2011/08/29 12:26:18]

Nit: should this change to expected_number_of_loads_

+        expected_final_status_queue_(expected_final_status_queue) {
     VLOG(1) << "Factory created with queue length " <<
                expected_final_status_queue_.size();
   }
 
   virtual PrerenderContents* CreatePrerenderContents(
       PrerenderManager* prerender_manager,
       PrerenderTracker* prerender_tracker,
       Profile* profile,
       const GURL& url,
       const GURL& referrer,
@@ skipping 345 matching lines @@
     browser()->OpenURL(src_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
 
     ui_test_utils::RunMessageLoop();
 
     TestPrerenderContents* prerender_contents = GetPrerenderContents();
 
     if (ShouldRenderPrerenderedPageCorrectly(expected_final_status)) {
       ASSERT_TRUE(prerender_contents != NULL);
       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
 
-      if (call_javascript_) {
+      if (call_javascript_ && total_navigations > 0) {
         // Check if page behaves as expected while in prerendered state.
         bool prerender_test_result = false;
         ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
             prerender_contents->render_view_host_mutable(), L"",
             L"window.domAutomationController.send(DidPrerenderPass())",
             &prerender_test_result));
         EXPECT_TRUE(prerender_test_result);
       }
     } else {
-      // In the failure case, we should have removed dest_url_ from the
+      // In the failure case, we should have removed |dest_url_| from the
       // prerender_manager.
       EXPECT_TRUE(prerender_contents == NULL);
     }
   }
 
   void NavigateToURLImpl(const GURL& dest_url,
                          WindowOpenDisposition disposition) const {
     // Make sure in navigating we have a URL to use in the PrerenderManager.
     ASSERT_TRUE(GetPrerenderContents() != NULL);
 
     // If opening the page in a background tab, it won't be shown when swapped
     // in.
     if (disposition == NEW_BACKGROUND_TAB)
       GetPrerenderContents()->set_should_be_shown(false);
 
+    // In the case of zero loads, need to wait for the page load to complete
+    // before running any Javascript.
+    scoped_ptr<ui_test_utils::WindowedNotificationObserver> page_load_observer;
+    TabContents* tab_contents =
+        GetPrerenderContents()->prerender_contents()->tab_contents();
+    if (GetPrerenderContents()->number_of_loads() == 0) {
+      page_load_observer.reset(
+          new ui_test_utils::WindowedNotificationObserver(
+              content::NOTIFICATION_LOAD_STOP,
+              Source<NavigationController>(&tab_contents->controller())));
+    }
+
     // ui_test_utils::NavigateToURL waits until DidStopLoading is called on
     // the current tab.  As that tab is going to end up deleted, and may never
     // finish loading before that happens, exit the message loop on the deletion
     // of the used prerender contents instead.
     //
     // As PrerenderTestURL waits until the prerendered page has completely
     // loaded, there is no race between loading |dest_url| and swapping the
     // prerendered TabContents into the tab.
     ui_test_utils::NavigateToURLWithDisposition(
         browser(), dest_url, disposition, ui_test_utils::BROWSER_TEST_NONE);
     ui_test_utils::RunMessageLoop();
 
     // Make sure the PrerenderContents found earlier was used or removed.
     EXPECT_TRUE(GetPrerenderContents() == NULL);
 
     if (call_javascript_) {
-      // Check if page behaved as expected when actually displayed.
-
-      // Locate the navigated TabContents.
-      TabContents* tab_contents = NULL;
-      switch (disposition) {
-        case CURRENT_TAB:
-        case NEW_FOREGROUND_TAB:
-          tab_contents = browser()->GetSelectedTabContents();
-          break;
-        case NEW_BACKGROUND_TAB:
-          tab_contents =
-              browser()->GetTabContentsAt(browser()->active_index() + 1);
-          break;
-        default:
-          ASSERT_TRUE(false) << "Unsupported creation disposition";
-      }
-      ASSERT_TRUE(tab_contents);
+      if (page_load_observer.get())
+        page_load_observer->Wait();
 
       bool display_test_result = false;
       ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
           tab_contents->render_view_host(), L"",
           L"window.domAutomationController.send(DidDisplayPass())",
           &display_test_result));
       EXPECT_TRUE(display_test_result);
     }
   }
 
@@ skipping 16 matching lines @@
 }
 
 // Checks that the visibility API works.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibility) {
   PrerenderTestURL("files/prerender/prerender_visibility.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURL();
 }
 
+// Checks that the visibility API works when the prerender is quickly opened
+// in a new tab before it stops loading.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibilityQuickSwitch) {
+  PrerenderTestURL("files/prerender/prerender_visibility_quick.html",
+                   FINAL_STATUS_USED, 0);
+  NavigateToDestURL();
+}
+
 // Checks that the visibility API works when opening a page in a new hidden
 // tab.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibilityBackgroundTab) {
   PrerenderTestURL("files/prerender/prerender_visibility_hidden.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURLWithDisposition(NEW_BACKGROUND_TAB);
 }
 
+// Checks that the visibility API works when opening a page in a new hidden
+// tab, which is switched to before it stops loading.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       PrerenderVisibilityBackgroundTabQuickSwitch) {
+  PrerenderTestURL("files/prerender/prerender_visibility_hidden_quick.html",
+                   FINAL_STATUS_USED, 0);
+  NavigateToDestURLWithDisposition(NEW_BACKGROUND_TAB);
+}
+
 // Checks that the visibility API works when opening a page in a new foreground
 // tab.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibilityForegroundTab) {
   PrerenderTestURL("files/prerender/prerender_visibility.html",
                    FINAL_STATUS_USED,
                    1);
   NavigateToDestURLWithDisposition(NEW_FOREGROUND_TAB);
 }
 
+// Checks that the visibility API works when the prerender is quickly opened
+// in a new tab foreground before it stops loading.
+IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
+                       PrerenderVisibilityForegroundTabQuickSwitch) {
+  PrerenderTestURL("files/prerender/prerender_visibility_quick.html",
+                   FINAL_STATUS_USED, 0);
+  NavigateToDestURL();
+}
+
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
   PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
                    FINAL_STATUS_JAVASCRIPT_ALERT,
                    1);
 }
 
 // Checks that the prerendering of a page is canceled correctly when a
 // Javascript alert is called.
@@ skipping 934 matching lines @@
     bool original_prerender_page = false;
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
         browser()->GetSelectedTabContents()->render_view_host(), L"",
         L"window.domAutomationController.send(IsOriginalPrerenderPage())",
         &original_prerender_page));
     EXPECT_TRUE(original_prerender_page);
   }
 }
 
 }  // namespace prerender