Additional logging for LoginPromptBrowserTest.IncorrectConfirmation

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 "chrome/browser/browser_thread.h"
 #include "chrome/browser/ui/browser.h"
@@ skipping 258 matching lines @@
 
   EXPECT_EQ(kMultiRealmTestRealmCount, n_handlers);
   EXPECT_LT(0, observer.auth_needed_count_);
   EXPECT_LT(0, observer.auth_supplied_count_);
   EXPECT_EQ(0, observer.auth_cancelled_count_);
   EXPECT_TRUE(test_server()->Stop());
 }
 
 // Testing for recovery from an incorrect password for the case where
 // there are multiple authenticated resources.
-// Marked as flaky.  See crbug.com/68860
+// Marked as flaky.  See crbug.com/69266 and http://crbug.com/68860

[cbentzel, 2011/01/12 15:04:25]

Nit: use full URL for 69266. 

+// TODO(asanka): Remove logging when timeout issues are resolved.
 IN_PROC_BROWSER_TEST_F(LoginPromptBrowserTest, FLAKY_IncorrectConfirmation) {
   ASSERT_TRUE(test_server()->Start());
   GURL test_page = test_server()->GetURL(kSingleRealmTestPage);
 
   TabContentsWrapper* contents =
       browser()->GetSelectedTabContentsWrapper();
   ASSERT_TRUE(contents);
 
   NavigationController* controller = &contents->controller();
   LoginPromptBrowserTestObserver observer;
 
   observer.Register(Source<NavigationController>(controller));
 
   WindowedLoadStopObserver load_stop_waiter(controller);
 
+  LOG(INFO) << "Begin";
   {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     browser()->OpenURL(test_page, GURL(), CURRENT_TAB, PageTransition::TYPED);
+    LOG(INFO) << "Waiting for initial AUTH_NEEDED";
     auth_needed_waiter.Wait();
   }
 
   EXPECT_FALSE(observer.handlers_.empty());
 
   if (!observer.handlers_.empty()) {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
     WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
     LoginHandler* handler = *observer.handlers_.begin();
 
     ASSERT_TRUE(handler);
     handler->SetAuth(bad_username_, bad_password_);
+    LOG(INFO) << "Waiting for initial AUTH_SUPPLIED";
     auth_supplied_waiter.Wait();
 
     // The request should be retried after the incorrect password is
     // supplied.  This should result in a new AUTH_NEEDED notification
     // for the same realm.
+    LOG(INFO) << "Waiting for secondary AUTH_NEEDED";
     auth_needed_waiter.Wait();
   }
 
   int n_handlers = 0;
 
   while (n_handlers < 1) {
     WindowedAuthNeededObserver auth_needed_waiter(controller);
 
     while (!observer.handlers_.empty()) {
       WindowedAuthSuppliedObserver auth_supplied_waiter(controller);
       LoginHandler* handler = *observer.handlers_.begin();
 
       ASSERT_TRUE(handler);
       n_handlers++;
       SetAuthFor(handler);
+      LOG(INFO) << "Waiting for secondary AUTH_SUPPLIED";
       auth_supplied_waiter.Wait();
     }
 
-    if (n_handlers < 1)
+    if (n_handlers < 1) {
+      LOG(INFO) << "Waiting for additional AUTH_NEEDED";
       auth_needed_waiter.Wait();
+    }
   }
 
+  LOG(INFO) << "Waiting for LOAD_STOP";
   load_stop_waiter.Wait();
 
   // The single realm test has only one realm, and thus only one login
   // prompt.
   EXPECT_EQ(1, n_handlers);
   EXPECT_LT(0, observer.auth_needed_count_);
-  EXPECT_LT(0, observer.auth_supplied_count_);
   EXPECT_EQ(0, observer.auth_cancelled_count_);
+  EXPECT_EQ(observer.auth_needed_count_, observer.auth_supplied_count_);

[cbentzel, 2011/01/11 19:40:34]

Was this added for a stronger test?

[asanka, 2011/01/11 21:58:05]

Yeah.  With the current state of the code, we should see an equal number of
AUTH_NEEDED and AUTH_SUPPLIED notifications for this test.  The exact number may
change based on how many concurrent requests are issued for the same target, but
the two counts should be the same.

   EXPECT_TRUE(test_server()->Stop());
+  LOG(INFO) << "Done";
 }
-} // namespace
+}  // namespace