Revert 80472 - GTTF: Detect browser crashes on shutdown in UI tests.Previously the automation fra...

chrome/test/ui/ui_test.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 "chrome/test/ui/ui_test.h"
 
 #if defined(OS_POSIX)
 #include <signal.h>
 #include <sys/types.h>
 #endif
@@ skipping 279 matching lines @@
   scoped_refptr<BrowserProxy> window =
     automation()->GetBrowserWindow(window_index);
   ASSERT_TRUE(window.get());
   scoped_refptr<TabProxy> tab_proxy(window->GetTab(tab_index));
   ASSERT_TRUE(tab_proxy.get());
   EXPECT_EQ(AUTOMATION_MSG_NAVIGATION_SUCCESS,
             tab_proxy->NavigateToURLBlockUntilNavigationsComplete(
                 url, number_of_navigations)) << url.spec();
 }
 
+bool UITestBase::WaitForBrowserProcessToQuit(int timeout) {
+  return launcher_->WaitForBrowserProcessToQuit(timeout);
+}
+
 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.
-    base::PlatformThread::Sleep(TestTimeouts::action_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(
+        TestTimeouts::action_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())
@@ skipping 27 matching lines @@
 
   int active_tab_index = -1;
   EXPECT_TRUE(window_proxy->GetActiveTabIndex(&active_tab_index));
   return active_tab_index;
 }
 
 bool UITestBase::IsBrowserRunning() {
   return launcher_->IsBrowserRunning();
 }
 
+bool UITestBase::CrashAwareSleep(int timeout_ms) {
+  return launcher_->CrashAwareSleep(timeout_ms);
+}
+
 int UITestBase::GetTabCount() {
   return GetTabCount(0);
 }
 
 int UITestBase::GetTabCount(int window_index) {
   scoped_refptr<BrowserProxy> window(
       automation()->GetBrowserWindow(window_index));
   EXPECT_TRUE(window.get());
   if (!window.get())
     return 0;
 
   int result = 0;
   EXPECT_TRUE(window->GetTabCount(&result));
 
   return result;
 }
 
 void UITestBase::WaitUntilTabCount(int tab_count) {
   const int kMaxIntervals = 10;
   const int kIntervalMs = TestTimeouts::action_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)
       return;
-
-    base::PlatformThread::Sleep(kIntervalMs);
   }
 
   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();
@@ skipping 310 matching lines @@
 
 bool UITest::WaitUntilJavaScriptCondition(TabProxy* tab,
                                           const std::wstring& frame_xpath,
                                           const std::wstring& jscript,
                                           int timeout_ms) {
   const int kIntervalMs = 250;
   const int kMaxIntervals = timeout_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;
-
-    base::PlatformThread::Sleep(kIntervalMs);
   }
 
   ADD_FAILURE() << "Timeout reached in WaitUntilJavaScriptCondition";
   return false;
 }
 
 bool UITest::WaitUntilCookieValue(TabProxy* tab,
                                   const GURL& url,
                                   const char* cookie_name,
                                   int timeout_ms,
                                   const char* expected_value) {
   const int kIntervalMs = 250;
   const int kMaxIntervals = timeout_ms / kIntervalMs;
 
   std::string cookie_value;
   for (int i = 0; i < kMaxIntervals; ++i) {
+    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;
-
-    base::PlatformThread::Sleep(kIntervalMs);
   }
 
   ADD_FAILURE() << "Timeout reached in WaitUntilCookieValue";
   return false;
 }
 
 std::string UITest::WaitUntilCookieNonEmpty(TabProxy* tab,
                                             const GURL& url,
                                             const char* cookie_name,
                                             int timeout_ms) {
   const int kIntervalMs = 250;
   const int kMaxIntervals = timeout_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;
-
-    base::PlatformThread::Sleep(kIntervalMs);
   }
 
   ADD_FAILURE() << "Timeout reached in WaitUntilCookieNonEmpty";
   return std::string();
 }
 
 bool UITest::WaitForDownloadShelfVisible(BrowserProxy* browser) {
   return WaitForDownloadShelfVisibilityChange(browser, true);
 }
 
 bool UITest::WaitForDownloadShelfInvisible(BrowserProxy* browser) {
   return WaitForDownloadShelfVisibilityChange(browser, false);
 }
 
 bool UITest::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.
-    base::PlatformThread::Sleep(TestTimeouts::action_timeout_ms() / kCycles);
+    bool browser_survived = CrashAwareSleep(
+        TestTimeouts::action_timeout_ms() / kCycles);
+    EXPECT_TRUE(browser_survived);
+    if (!browser_survived)
+      return false;
   }
 
   ADD_FAILURE() << "Timeout reached in WaitForFindWindowVisibilityChange";
   return false;
 }
 
 void UITest::TerminateBrowser() {
   launcher_->TerminateBrowser();
 }
 
 void UITest::NavigateToURLAsync(const GURL& url) {
   scoped_refptr<TabProxy> tab_proxy(GetActiveTab());
   ASSERT_TRUE(tab_proxy.get());
   ASSERT_TRUE(tab_proxy->NavigateToURLAsync(url));
 }
 
 bool UITest::WaitForDownloadShelfVisibilityChange(BrowserProxy* browser,
                                                   bool wait_for_open) {
   const int kCycles = 10;
   int fail_count = 0;
   int incorrect_state_count = 0;
   base::Time start = base::Time::Now();
   for (int i = 0; i < kCycles; i++) {
+    // Give it a chance to catch up.
+    bool browser_survived = CrashAwareSleep(
+        TestTimeouts::action_timeout_ms() / kCycles);
+    EXPECT_TRUE(browser_survived);
+    if (!browser_survived) {
+      LOG(INFO) << "Elapsed time: " << (base::Time::Now() - start).InSecondsF()
+                << " seconds"
+                << " call failed " << fail_count << " times"
+                << " state was incorrect " << incorrect_state_count << " times";
+      ADD_FAILURE() << "Browser failed in " << __FUNCTION__;
+      return false;
+    }
+
     bool visible = !wait_for_open;
     if (!browser->IsShelfVisible(&visible)) {
       fail_count++;
       continue;
     }
     if (visible == wait_for_open) {
       LOG(INFO) << "Elapsed time: " << (base::Time::Now() - start).InSecondsF()
                 << " seconds"
                 << " call failed " << fail_count << " times"
                 << " state was incorrect " << incorrect_state_count << " times";
       return true;  // Got the download shelf.
     }
     incorrect_state_count++;
-
-    // Give it a chance to catch up.
-    base::PlatformThread::Sleep(TestTimeouts::action_timeout_ms() / kCycles);
   }
 
   LOG(INFO) << "Elapsed time: " << (base::Time::Now() - start).InSecondsF()
             << " seconds"
             << " call failed " << fail_count << " times"
             << " state was incorrect " << incorrect_state_count << " times";
   ADD_FAILURE() << "Timeout reached in " << __FUNCTION__;
   return false;
 }