Output some error text if one of these Wait functions should timeout....

chrome/test/ui/ui_test.cc

 // Copyright (c) 2010 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 "chrome/test/ui/ui_test.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #endif
@@ skipping 602 matching lines @@
 
 bool UITestBase::WaitForDownloadShelfInvisible(BrowserProxy* browser) {
   return WaitForDownloadShelfVisibilityChange(browser, false);
 }
 
 bool UITestBase::WaitForDownloadShelfVisibilityChange(BrowserProxy* browser,
                                                       bool wait_for_open) {
   const int kCycles = 10;
   for (int i = 0; i < kCycles; i++) {
     // Give it a chance to catch up.
-    PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(sleep_timeout_ms() / kCycles);
+    EXPECT_TRUE(browser_survived);
+    if (!browser_survived)
+      return false;
 
     bool visible = !wait_for_open;
     if (!browser->IsShelfVisible(&visible))
       continue;
     if (visible == wait_for_open)
       return true;  // Got the download shelf.
   }
+
+  ADD_FAILURE() << "Timeout reached in WaitForDownloadShelfVisibilityChange";

[Paweł Hajdan Jr., 2010/07/14 00:16:58]

You might want to add another log message in the other failure case. Like
"Browser crashed in WaitFor...". Similar comment applies to other places in this
file.

   return false;
 }
 
 bool UITestBase::WaitForFindWindowVisibilityChange(BrowserProxy* browser,
                                                    bool wait_for_open) {
   const int kCycles = 10;
   for (int i = 0; i < kCycles; i++) {
     bool visible = false;
     if (!browser->IsFindWindowFullyVisible(&visible))
       return false;  // Some error.
     if (visible == wait_for_open)
       return true;  // Find window visibility change complete.
 
     // Give it a chance to catch up.
-    PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(sleep_timeout_ms() / kCycles);
+    EXPECT_TRUE(browser_survived);
+    if (!browser_survived)
+      return false;
   }
+
+  ADD_FAILURE() << "Timeout reached in WaitForFindWindowVisibilityChange";
   return false;
 }
 
 bool UITestBase::WaitForBookmarkBarVisibilityChange(BrowserProxy* browser,
                                                     bool wait_for_open) {
   const int kCycles = 10;
   for (int i = 0; i < kCycles; i++) {
     bool visible = false;
     bool animating = true;
     if (!browser->GetBookmarkBarVisibility(&visible, &animating))
       return false;  // Some error.
     if (visible == wait_for_open && !animating)
       return true;  // Bookmark bar visibility change complete.
 
     // Give it a chance to catch up.
-    PlatformThread::Sleep(sleep_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(sleep_timeout_ms() / kCycles);
+    EXPECT_TRUE(browser_survived);
+    if (!browser_survived)
+      return false;
   }
+
+  ADD_FAILURE() << "Timeout reached in WaitForBookmarkBarVisibilityChange";
   return false;
 }
 
 GURL UITestBase::GetActiveTabURL(int window_index) {
   scoped_refptr<TabProxy> tab_proxy(GetActiveTab(window_index));
   EXPECT_TRUE(tab_proxy.get());
   if (!tab_proxy.get())
     return GURL();
 
   GURL url;
@@ skipping 94 matching lines @@
     bool browser_survived = CrashAwareSleep(kIntervalMs);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived)
       return false;
 
     EXPECT_TRUE(tab->GetCookieByName(url, cookie_name, &cookie_value));
     if (cookie_value == expected_value)
       return true;
   }
 
+  ADD_FAILURE() << "Timeout reached in WaitUntilCookieValue";
   return false;
 }
 
 std::string UITestBase::WaitUntilCookieNonEmpty(TabProxy* tab,
                                                 const GURL& url,
                                                 const char* cookie_name,
                                                 int time_out_ms) {
   const int kIntervalMs = 250;
   const int kMaxIntervals = time_out_ms / kIntervalMs;
 
   for (int i = 0; i < kMaxIntervals; ++i) {
     bool browser_survived = CrashAwareSleep(kIntervalMs);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived)
       return std::string();
 
     std::string cookie_value;
     EXPECT_TRUE(tab->GetCookieByName(url, cookie_name, &cookie_value));
     if (!cookie_value.empty())
       return cookie_value;
   }
 
+  ADD_FAILURE() << "Timeout reached in WaitUntilCookieNonEmpty";
   return std::string();
 }
 
 bool UITestBase::WaitUntilJavaScriptCondition(TabProxy* tab,
                                               const std::wstring& frame_xpath,
                                               const std::wstring& jscript,
                                               int time_out_ms) {
   const int kIntervalMs = 250;
   const int kMaxIntervals = time_out_ms / kIntervalMs;
 
   // Wait until the test signals it has completed.
   for (int i = 0; i < kMaxIntervals; ++i) {
     bool browser_survived = CrashAwareSleep(kIntervalMs);
     EXPECT_TRUE(browser_survived);
     if (!browser_survived)
       return false;
 
     bool done_value = false;
     bool success = tab->ExecuteAndExtractBool(frame_xpath, jscript,
                                               &done_value);
     EXPECT_TRUE(success);
     if (!success)
       return false;
     if (done_value)
       return true;
   }
 
+  ADD_FAILURE() << "Timeout reached in WaitUntilJavaScriptCondition";
   return false;
 }
 
 void UITestBase::WaitUntilTabCount(int tab_count) {
-  for (int i = 0; i < 10; ++i) {
-    PlatformThread::Sleep(sleep_timeout_ms() / 10);
+  const int kMaxIntervals = 10;
+  const int kIntervalMs = sleep_timeout_ms() / kMaxIntervals;
+
+  for (int i = 0; i < kMaxIntervals; ++i) {
+    bool browser_survived = CrashAwareSleep(kIntervalMs);
+    EXPECT_TRUE(browser_survived);
+    if (!browser_survived)
+      return;
     if (GetTabCount() == tab_count)
-      break;
+      return;
   }
-  EXPECT_EQ(tab_count, GetTabCount());
+
+  ADD_FAILURE() << "Timeout reached in WaitUntilTabCount";
 }
 
 FilePath UITestBase::GetDownloadDirectory() {
   scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
   EXPECT_TRUE(tab_proxy.get());
   if (!tab_proxy.get())
     return FilePath();
 
   FilePath download_directory;
   EXPECT_TRUE(tab_proxy->GetDownloadDirectory(&download_directory));
@@ skipping 651 matching lines @@
     set_ui_test_name(ASCIIToWide(test_name));
   }
   UITestBase::SetUp();
   PlatformTest::SetUp();
 }
 
 void UITest::TearDown() {
   UITestBase::TearDown();
   PlatformTest::TearDown();
 }