Move LoginPromptTest.TestCancelAuth to a browsertest.

chrome/browser/ui/login/login_prompt_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 <algorithm>
 #include <list>
 #include <map>
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/prerender/prerender_manager.h"
@@ skipping 139 matching lines @@
 
 template <int T>
 class WindowedNavigationObserver
     : public ui_test_utils::WindowedNotificationObserver {
  public:
   explicit WindowedNavigationObserver(NavigationController* controller)
       : ui_test_utils::WindowedNotificationObserver(
           T, content::Source<NavigationController>(controller)) {}
 };
 
-typedef WindowedNavigationObserver<content::NOTIFICATION_LOAD_STOP>
-    WindowedLoadStopObserver;
+// LOAD_STOP observer is special since we want to be able to wait for
+// multiple LOAD_STOP events.
+class WindowedLoadStopObserver

[Paweł Hajdan Jr., 2011/10/21 08:49:04]

Could you please generalize it to chrome/test?

+    : public WindowedNavigationObserver<content::NOTIFICATION_LOAD_STOP> {
+ public:
+  WindowedLoadStopObserver(NavigationController* controller,
+                           int notification_count)
+      : WindowedNavigationObserver<content::NOTIFICATION_LOAD_STOP>(controller),
+        remaining_notification_count_(notification_count) {}

[cbentzel, 2011/10/19 19:03:12]

Do you need notification count? Is the sequence of LOAD_STOPs consistent enough
that you could just use two of the old-style WindowedLoadStopObserver's? Or is
this simpler?

[asanka, 2011/10/19 19:21:17]

In the TestCancelAuth test, when we initiate a navigation to an unauthenticated
page while an auth prompt is being displayed, we will see AUTH_CANCELLED,
LOAD_STOP (for the previous page), LOAD_START (for the new page) and a LOAD_STOP
(for the new page).  We don't have a good synchronization point between the
LOAD_STOP events to register for the next LOAD_STOP.  So I elected to wait for
both together.

+ protected:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+ private:
+  int remaining_notification_count_;  // Number of notifications remaining.
+};
+
+void WindowedLoadStopObserver::Observe(
+    int type,
+    const content::NotificationSource& source,
+    const content::NotificationDetails& details) {
+  if (--remaining_notification_count_ == 0)
+    WindowedNotificationObserver::Observe(type, source, details);
+}
 
 typedef WindowedNavigationObserver<chrome::NOTIFICATION_AUTH_NEEDED>
     WindowedAuthNeededObserver;
 
 typedef WindowedNavigationObserver<chrome::NOTIFICATION_AUTH_CANCELLED>
     WindowedAuthCancelledObserver;
 
 typedef WindowedNavigationObserver<chrome::NOTIFICATION_AUTH_SUPPLIED>
     WindowedAuthSuppliedObserver;
 
 const char* kPrefetchAuthPage = "files/login/prefetch.html";
 
 const char* kMultiRealmTestPage = "files/login/multi_realm.html";
 const int   kMultiRealmTestRealmCount = 2;
 const int   kMultiRealmTestResourceCount = 4;
 
 const char* kSingleRealmTestPage = "files/login/single_realm.html";
 const int   kSingleRealmTestResourceCount = 6;
 
+const char* kAuthBasicPage = "auth-basic";
+
 // Confirm that <link rel="prefetch"> targetting an auth required
 // resource does not provide a login dialog.  These types of requests
 // should instead just cancel the auth.
 
 // Unfortunately, this test doesn't assert on anything for its
 // correctness.  Instead, it relies on the auth dialog blocking the
 // browser, and triggering a timeout to cause failure when the
 // prefetch resource requires authorization.
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, PrefetchAuthCancels) {
   ASSERT_TRUE(test_server()->Start());
@@ skipping 21 matching lines @@
   } set_prefetch_for_test(true);
 
   TabContentsWrapper* contents =
       browser()->GetSelectedTabContentsWrapper();
   ASSERT_TRUE(contents);
   NavigationController* controller = &contents->controller();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
-  WindowedLoadStopObserver load_stop_waiter(controller);
+  WindowedLoadStopObserver load_stop_waiter(controller, 1);
   browser()->OpenURL(
       test_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
 
   load_stop_waiter.Wait();
   EXPECT_TRUE(observer.handlers_.empty());
   EXPECT_TRUE(test_server()->Stop());
 }
 
+// Test login prompt cancellation.
+IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, TestCancelAuth) {
+  ASSERT_TRUE(test_server()->Start());
+  GURL auth_page = test_server()->GetURL(kAuthBasicPage);
+  GURL no_auth_page_1 = test_server()->GetURL("a");
+  GURL no_auth_page_2 = test_server()->GetURL("b");
+  GURL no_auth_page_3 = test_server()->GetURL("c");
+
+  TabContentsWrapper* contents =
+      browser()->GetSelectedTabContentsWrapper();
+  ASSERT_TRUE(contents);
+
+  NavigationController* controller = &contents->controller();
+
+  LoginPromptBrowserTestObserver observer;
+  observer.Register(content::Source<NavigationController>(controller));
+
+  // First navigate to an unauthenticated page so we have something to
+  // go back to.
+  ui_test_utils::NavigateToURL(browser(), no_auth_page_1);
+
+  // Navigating while auth is requested is the same as cancelling.
+  {
+    // We need to wait for two LOAD_STOP events.  One for auth_page and one for
+    // no_auth_page_2.
+    WindowedLoadStopObserver load_stop_waiter(controller, 2);
+    WindowedAuthNeededObserver auth_needed_waiter(controller);
+    browser()->OpenURL(
+        auth_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
+    auth_needed_waiter.Wait();
+    WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
+    browser()->OpenURL(
+        no_auth_page_2, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
+    auth_cancelled_waiter.Wait();
+    load_stop_waiter.Wait();
+    EXPECT_TRUE(observer.handlers_.empty());
+  }
+
+  // Try navigating backwards.
+  {
+    // As above, we wait for two LOAD_STOP events; one for each navigation.
+    WindowedLoadStopObserver load_stop_waiter(controller, 2);
+    WindowedAuthNeededObserver auth_needed_waiter(controller);
+    browser()->OpenURL(
+        auth_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
+    auth_needed_waiter.Wait();
+    WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
+    ASSERT_TRUE(browser()->CanGoBack());
+    browser()->GoBack(CURRENT_TAB);
+    auth_cancelled_waiter.Wait();
+    load_stop_waiter.Wait();
+    EXPECT_TRUE(observer.handlers_.empty());
+  }
+
+  // Now add a page and go back, so we have something to go forward to.
+  ui_test_utils::NavigateToURL(browser(), no_auth_page_3);
+  {
+    WindowedLoadStopObserver load_stop_waiter(controller, 1);
+    browser()->GoBack(CURRENT_TAB);  // Should take us to page 1
+    load_stop_waiter.Wait();
+  }
+
+  {
+    // We wait for two LOAD_STOP events; one for each navigation.
+    WindowedLoadStopObserver load_stop_waiter(controller, 2);
+    WindowedAuthNeededObserver auth_needed_waiter(controller);
+    browser()->OpenURL(
+        auth_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
+    auth_needed_waiter.Wait();
+    WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
+    ASSERT_TRUE(browser()->CanGoForward());
+    browser()->GoForward(CURRENT_TAB);  // Should take us to page 3
+    auth_cancelled_waiter.Wait();
+    load_stop_waiter.Wait();
+    EXPECT_TRUE(observer.handlers_.empty());
+  }
+
+  // Now test that cancelling works as expected.
+  {
+    WindowedLoadStopObserver load_stop_waiter(controller, 1);
+    WindowedAuthNeededObserver auth_needed_waiter(controller);
+    browser()->OpenURL(
+        auth_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
+    auth_needed_waiter.Wait();
+    WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
+    LoginHandler* handler = *observer.handlers_.begin();
+    ASSERT_TRUE(handler);
+    handler->CancelAuth();
+    auth_cancelled_waiter.Wait();
+    load_stop_waiter.Wait();
+    EXPECT_TRUE(observer.handlers_.empty());
+  }
+}
+
 // Test handling of resources that require authentication even though
 // the page they are included on doesn't.  In this case we should only
 // present the minimal number of prompts necessary for successfully
 // displaying the page.  First we check whether cancelling works as
 // expected.
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, MultipleRealmCancellation) {
   ASSERT_TRUE(test_server()->Start());
   GURL test_page = test_server()->GetURL(kMultiRealmTestPage);
 
   TabContentsWrapper* contents =
       browser()->GetSelectedTabContentsWrapper();
   ASSERT_TRUE(contents);
 
   NavigationController* controller = &contents->controller();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
-  WindowedLoadStopObserver load_stop_waiter(controller);
+  WindowedLoadStopObserver load_stop_waiter(controller, 1);
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     browser()->OpenURL(
         test_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
     auth_needed_waiter.Wait();
   }
 
   int n_handlers = 0;
 
@@ skipping 38 matching lines @@
 
   TabContentsWrapper* contents =
       browser()->GetSelectedTabContentsWrapper();
   ASSERT_TRUE(contents);
 
   NavigationController* controller = &contents->controller();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
-  WindowedLoadStopObserver load_stop_waiter(controller);
+  WindowedLoadStopObserver load_stop_waiter(controller, 1);
   int n_handlers = 0;
 
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
 
     browser()->OpenURL(
         test_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
     auth_needed_waiter.Wait();
   }
 
@@ skipping 106 matching lines @@
 
   NavigationController* controller = &contents->controller();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(content::Source<NavigationController>(controller));
 
   // First load a page that has a favicon that requires
   // authentication.  There should be no login prompt.
   {
     GURL test_page = test_server()->GetURL(kFaviconTestPage);
-    WindowedLoadStopObserver load_stop_waiter(controller);
+    WindowedLoadStopObserver load_stop_waiter(controller, 1);
     browser()->OpenURL(
         test_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
     load_stop_waiter.Wait();
   }
 
   // Now request the same favicon, but directly as the document.
   // There should be one login prompt.
   {
     GURL test_page = test_server()->GetURL(kFaviconResource);
-    WindowedLoadStopObserver load_stop_waiter(controller);
+    WindowedLoadStopObserver load_stop_waiter(controller, 1);
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     browser()->OpenURL(
         test_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
     auth_needed_waiter.Wait();
     ASSERT_EQ(1u, observer.handlers_.size());
 
     while (!observer.handlers_.empty()) {
       WindowedAuthCancelledObserver auth_cancelled_waiter(controller);
       LoginHandler* handler = *observer.handlers_.begin();
 
@@ skipping 32 matching lines @@
     GURL test_page = test_server()->GetURL(kTestPage);
     ASSERT_EQ("127.0.0.1", test_page.host());
 
     // Change the host from 127.0.0.1 to www.a.com so that when the
     // page tries to load from b, it will be cross-origin.
     std::string new_host("www.a.com");
     GURL::Replacements replacements;
     replacements.SetHostStr(new_host);
     test_page = test_page.ReplaceComponents(replacements);
 
-    WindowedLoadStopObserver load_stop_waiter(controller);
+    WindowedLoadStopObserver load_stop_waiter(controller, 1);
     browser()->OpenURL(
         test_page, GURL(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED);
     load_stop_waiter.Wait();
   }
 
   EXPECT_EQ(0, observer.auth_needed_count_);
 
   // Now request the same page, but from the same origin.
   // There should be one login prompt.
   {
@@ skipping 21 matching lines @@
       handler->CancelAuth();
       auth_cancelled_waiter.Wait();
     }
   }
 
   EXPECT_EQ(1, observer.auth_needed_count_);
   EXPECT_TRUE(test_server()->Stop());
 }
 
 }  // namespace