Fix up various browser tests not to use WaitForNavigation.

chrome/browser/ssl/ssl_browser_tests.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 "base/command_line.h"
 #include "base/time.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/interstitial_page.h"
 #include "content/browser/tab_contents/navigation_entry.h"
 #include "content/browser/tab_contents/tab_contents.h"
+#include "content/common/notification_service.h"
 #include "net/base/cert_status_flags.h"
 #include "net/test/test_server.h"
 
 const FilePath::CharType kDocRoot[] = FILE_PATH_LITERAL("chrome/test/data");
 
 class SSLUITest : public InProcessBrowserTest {
   typedef net::TestServer::HTTPSOptions HTTPSOptions;
 
  public:
   SSLUITest()
@@ skipping 80 matching lines @@
     ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
         tab->render_view_host(), std::wstring(),
         L"window.domAutomationController.send(IsContentLoaded());",
         &actuallyLoadedContent));
     EXPECT_EQ(expectLoaded, actuallyLoadedContent);
   }
 
   void ProceedThroughInterstitial(TabContents* tab) {
     InterstitialPage* interstitial_page = tab->interstitial_page();
     ASSERT_TRUE(interstitial_page);
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
     interstitial_page->Proceed();
-    // Wait for the navigation to be done.
-    ui_test_utils::WaitForNavigation(&(tab->controller()));
+    observer.Wait();
   }
 
   static bool GetFilePathWithHostAndPortReplacement(
       const std::string& original_file_path,
       const net::HostPortPair& host_port_pair,
       std::string* replacement_path) {
     std::vector<net::TestServer::StringPair> replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_HOST_AND_PORT", host_port_pair.ToString()));
     return net::TestServer::GetFilePathWithReplacements(
@@ skipping 265 matching lines @@
       test_server()->GetURL("files/ssl/google.html"));
   TabContents* tab = browser()->GetSelectedTabContents();
   NavigationEntry* entry1 = tab->controller().GetActiveEntry();
   ASSERT_TRUE(entry1);
   ui_test_utils::NavigateToURL(browser(),
       test_server()->GetURL("files/ssl/blank_page.html"));
   NavigationEntry* entry2 = tab->controller().GetActiveEntry();
   ASSERT_TRUE(entry2);
 
   // Now go back so that a page is in the forward history.
-  tab->controller().GoBack();
-  ui_test_utils::WaitForNavigation(&(tab->controller()));
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    tab->controller().GoBack();
+    observer.Wait();
+  }
   ASSERT_TRUE(tab->controller().CanGoForward());
   NavigationEntry* entry3 = tab->controller().GetActiveEntry();
   ASSERT_TRUE(entry1 == entry3);
 
   // Now go to a bad HTTPS page that shows an interstitial.
   ui_test_utils::NavigateToURL(browser(),
       https_server_expired_.GetURL("files/ssl/google.html"));
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  true);  // Interstitial showing
 
   // Simulate user clicking and holding on forward button.
-  tab->controller().GoToOffset(1);
-  ui_test_utils::WaitForNavigation(&(tab->controller()));
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    tab->controller().GoToOffset(1);
+    observer.Wait();
+  }
 
   // We should be showing the second good page.
   EXPECT_FALSE(browser()->GetSelectedTabContents()->interstitial_page());
   CheckUnauthenticatedState(tab);
   EXPECT_FALSE(tab->controller().CanGoForward());
   NavigationEntry* entry4 = tab->controller().GetActiveEntry();
   EXPECT_TRUE(entry2 == entry4);
 }
 
 // Open a page with a HTTPS error in a tab with no prior navigation (through a
@@ skipping 143 matching lines @@
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_displays_insecure_content.html",
       test_server()->host_port_pair(),
       &replacement_path));
 
   GURL url = https_server_.GetURL(replacement_path);
   browser::NavigateParams params(browser(), url, PageTransition::TYPED);
   params.disposition = NEW_FOREGROUND_TAB;
   params.tabstrip_index = 0;
   params.source_contents = tab1;
+  ui_test_utils::WindowedNotificationObserver observer(
+      content::NOTIFICATION_LOAD_STOP, NotificationService::AllSources());
   browser::Navigate(&params);
   TabContentsWrapper* tab2 = params.target_contents;
-  ui_test_utils::WaitForNavigation(&(tab2->controller()));
+  observer.Wait();
 
   // The new tab has insecure content.
   CheckAuthenticatedState(tab2->tab_contents(), true);
 
   // The original tab should not be contaminated.
   CheckAuthenticatedState(tab1->tab_contents(), false);
 }
 
 // Visits two pages from the same origin: one that runs insecure content and one
 // that doesn't.  The test checks that we propagate the insecure content state
@@ skipping 14 matching lines @@
   ASSERT_TRUE(GetFilePathWithHostAndPortReplacement(
       "files/ssl/page_runs_insecure_content.html",
       test_server()->host_port_pair(),
       &replacement_path));
 
   // Create a new tab.
   GURL url = https_server_.GetURL(replacement_path);
   browser::NavigateParams params(browser(), url, PageTransition::TYPED);
   params.disposition = NEW_FOREGROUND_TAB;
   params.source_contents = tab1;
+  ui_test_utils::WindowedNotificationObserver observer(
+      content::NOTIFICATION_LOAD_STOP, NotificationService::AllSources());
   browser::Navigate(&params);
   TabContentsWrapper* tab2 = params.target_contents;
-  ui_test_utils::WaitForNavigation(&(tab2->controller()));
+  observer.Wait();
 
   // The new tab has insecure content.
   CheckAuthenticationBrokenState(tab2->tab_contents(), 0, true, false);
 
   // Which means the origin for the first tab has also been contaminated with
   // insecure content.
   CheckAuthenticationBrokenState(tab1->tab_contents(), 0, true, false);
 }
 
 // Visits a page with an image over http.  Visits another page over https
@@ skipping 150 matching lines @@
       break;
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
                                             new MessageLoop::QuitTask(), 1000);
     ui_test_utils::RunMessageLoop();
   }
   ASSERT_EQ(1, static_cast<int>(tab1->constrained_window_count()));
 
   // Let's add another tab to make sure the browser does not exit when we close
   // the first tab.
   GURL url = test_server()->GetURL("files/ssl/google.html");
-  TabContentsWrapper* tab2 =
-      browser()->AddSelectedTabWithURL(url, PageTransition::TYPED);
-  ui_test_utils::WaitForNavigation(&(tab2->controller()));
+  ui_test_utils::WindowedNotificationObserver observer(
+      content::NOTIFICATION_LOAD_STOP, NotificationService::AllSources());
+  browser()->AddSelectedTabWithURL(url, PageTransition::TYPED);
+  observer.Wait();
 
   // Close the first tab.
   browser()->CloseTabContents(tab1);
 }
 
 // Visit a page over bad https that is a redirect to a page with good https.
 // Crashes: http://crbug.com/77374
 // Previously marked as flaky: http://crbug.com/40932
 IN_PROC_BROWSER_TEST_F(SSLUITest, DISABLED_TestRedirectBadToGoodHTTPS) {
   ASSERT_TRUE(https_server_.Start());
@@ skipping 122 matching lines @@
                               &top_frame_path));
 
   TabContents* tab = browser()->GetSelectedTabContents();
   ui_test_utils::NavigateToURL(browser(),
                                https_server_.GetURL(top_frame_path));
 
   CheckAuthenticatedState(tab, false);
 
   bool success = false;
   // Now navigate inside the frame.
-  EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      tab->render_view_host(), std::wstring(),
-      L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
-      &success));
-  EXPECT_TRUE(success);
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        tab->render_view_host(), std::wstring(),
+        L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
+        &success));
+    ASSERT_TRUE(success);
+    observer.Wait();
+  }
 
   // We should still be fine.
   CheckAuthenticatedState(tab, false);
 
   // Now let's hit a bad page.
-  EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      tab->render_view_host(), std::wstring(),
-      L"window.domAutomationController.send(clickLink('badHTTPSLink'));",
-      &success));
-  EXPECT_TRUE(success);
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        tab->render_view_host(), std::wstring(),
+        L"window.domAutomationController.send(clickLink('badHTTPSLink'));",
+        &success));
+    ASSERT_TRUE(success);
+    observer.Wait();
+  }
 
   // The security style should still be secure.
   CheckAuthenticatedState(tab, false);
 
   // And the frame should be blocked.
   bool is_content_evil = true;
   std::wstring content_frame_xpath(L"html/frameset/frame[2]");
   std::wstring is_evil_js(L"window.domAutomationController.send("
                           L"document.getElementById('evilDiv') != null);");
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), content_frame_xpath, is_evil_js,
       &is_content_evil));
   EXPECT_FALSE(is_content_evil);
 
   // Now go back, our state should still be OK.
-  tab->controller().GoBack();
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    tab->controller().GoBack();
+    observer.Wait();
+  }
   CheckAuthenticatedState(tab, false);
 
   // Navigate to a page served over HTTP.
-  EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      tab->render_view_host(), std::wstring(),
-      L"window.domAutomationController.send(clickLink('HTTPLink'));",
-      &success));
-  EXPECT_TRUE(success);
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        tab->render_view_host(), std::wstring(),
+        L"window.domAutomationController.send(clickLink('HTTPLink'));",
+        &success));
+    ASSERT_TRUE(success);
+    observer.Wait();
+  }
 
   // Our state should be insecure.
   CheckAuthenticatedState(tab, true);
 
   // Go back, our state should be unchanged.
-  tab->controller().GoBack();
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    tab->controller().GoBack();
+    observer.Wait();
+  }
   CheckAuthenticatedState(tab, true);
 }
 
 // From a bad HTTPS top frame:
 // - navigate to an OK HTTPS frame (expected to be still authentication broken).
 // Marked as flaky, see bug 40932.
 IN_PROC_BROWSER_TEST_F(SSLUITest, FLAKY_TestBadFrameNavigation) {
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   std::string top_frame_path;
   ASSERT_TRUE(GetTopFramePath(*test_server(),
                               https_server_,
                               https_server_expired_,
                               &top_frame_path));
 
   TabContents* tab = browser()->GetSelectedTabContents();
   ui_test_utils::NavigateToURL(browser(),
                                https_server_expired_.GetURL(top_frame_path));
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  true);  // Interstitial showing
 
   ProceedThroughInterstitial(tab);
 
   // Navigate to a good frame.
   bool success = false;
+  ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
       tab->render_view_host(), std::wstring(),
       L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
       &success));
-  EXPECT_TRUE(success);
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  ASSERT_TRUE(success);
+  observer.Wait();
 
   // We should still be authentication broken.
   CheckAuthenticationBrokenState(tab, net::CERT_STATUS_DATE_INVALID, false,
                                  false);
 }
 
 // From an HTTP top frame, navigate to good and bad HTTPS (security state should
 // stay unauthenticated).
 // Disabled, flakily exceeds test timeout, http://crbug.com/43437.
 IN_PROC_BROWSER_TEST_F(SSLUITest, DISABLED_TestUnauthenticatedFrameNavigation) {
   ASSERT_TRUE(test_server()->Start());
   ASSERT_TRUE(https_server_.Start());
   ASSERT_TRUE(https_server_expired_.Start());
 
   std::string top_frame_path;
   ASSERT_TRUE(GetTopFramePath(*test_server(),
                               https_server_,
                               https_server_expired_,
                               &top_frame_path));
 
   TabContents* tab = browser()->GetSelectedTabContents();
   ui_test_utils::NavigateToURL(browser(),
                                test_server()->GetURL(top_frame_path));
   CheckUnauthenticatedState(tab);
 
   // Now navigate inside the frame to a secure HTTPS frame.
-  bool success = false;
-  EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      tab->render_view_host(), std::wstring(),
-      L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
-      &success));
-  EXPECT_TRUE(success);
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    bool success = false;
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        tab->render_view_host(), std::wstring(),
+        L"window.domAutomationController.send(clickLink('goodHTTPSLink'));",
+        &success));
+    ASSERT_TRUE(success);
+    observer.Wait();
+  }
 
   // We should still be unauthenticated.
   CheckUnauthenticatedState(tab);
 
   // Now navigate to a bad HTTPS frame.
-  EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
-      tab->render_view_host(), std::wstring(),
-      L"window.domAutomationController.send(clickLink('badHTTPSLink'));",
-      &success));
-  EXPECT_TRUE(success);
-  ui_test_utils::WaitForNavigation(&tab->controller());
+  {
+    bool success = false;
+    ui_test_utils::WindowedNotificationObserver observer(
+        content::NOTIFICATION_LOAD_STOP,
+        Source<NavigationController>(&tab->controller()));
+    EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
+        tab->render_view_host(), std::wstring(),
+        L"window.domAutomationController.send(clickLink('badHTTPSLink'));",
+        &success));
+    ASSERT_TRUE(success);
+    observer.Wait();
+  }
 
   // State should not have changed.
   CheckUnauthenticatedState(tab);
 
   // And the frame should have been blocked (see bug #2316).
   bool is_content_evil = true;
   std::wstring content_frame_xpath(L"html/frameset/frame[2]");
   std::wstring is_evil_js(L"window.domAutomationController.send("
                           L"document.getElementById('evilDiv') != null);");
   EXPECT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
@@ skipping 92 matching lines @@
 
 // Visit a page over https that contains a frame with a redirect.
 
 // XMLHttpRequest insecure content in synchronous mode.
 
 // XMLHttpRequest insecure content in asynchronous mode.
 
 // XMLHttpRequest over bad ssl in synchronous mode.
 
 // XMLHttpRequest over OK ssl in synchronous mode.