GTTF: Detect browser crashes on shutdown in UI tests.

chrome/test/automation/proxy_launcher.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/automation/proxy_launcher.h"
 
 #include "app/sql/connection.h"
 #include "base/file_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
@@ skipping 188 matching lines @@
   return LaunchBrowserHelper(state, true, NULL);
 }
 #endif
 
 void ProxyLauncher::QuitBrowser() {
   if (SESSION_ENDING == shutdown_type_) {
     TerminateBrowser();
     return;
   }
 
+  base::TimeTicks quit_start = base::TimeTicks::Now();
+
   // There's nothing to do here if the browser is not running.
   // WARNING: There is a race condition here where the browser may shut down
   // after this check but before some later automation call. Your test should
   // use WaitForBrowserProcessToQuit() if it intentionally
   // causes the browser to shut down.
   if (IsBrowserRunning()) {
-    base::TimeTicks quit_start = base::TimeTicks::Now();
     EXPECT_TRUE(automation()->SetFilteredInet(false));
 
     if (WINDOW_CLOSE == shutdown_type_) {
       int window_count = 0;
       EXPECT_TRUE(automation()->GetBrowserWindowCount(&window_count));
 
       // Synchronously close all but the last browser window. Closing them
       // one-by-one may help with stability.
       while (window_count > 1) {
         scoped_refptr<BrowserProxy> browser_proxy =
@@ skipping 20 matching lines @@
     } else if (USER_QUIT == shutdown_type_) {
       scoped_refptr<BrowserProxy> browser_proxy =
           automation()->GetBrowserWindow(0);
       EXPECT_TRUE(browser_proxy.get());
       if (browser_proxy.get()) {
         EXPECT_TRUE(browser_proxy->RunCommandAsync(IDC_EXIT));
       }
     } else {
       NOTREACHED() << "Invalid shutdown type " << shutdown_type_;
     }
+  }
 
-    // Now, drop the automation IPC channel so that the automation provider in
-    // the browser notices and drops its reference to the browser process.
-    automation()->Disconnect();
+  // Now, drop the automation IPC channel so that the automation provider in
+  // the browser notices and drops its reference to the browser process.
+  if (automation_proxy_.get())
+    automation_proxy_->Disconnect();
 
-    // Wait for the browser process to quit. It should quit once all tabs have
-    // been closed.
-    if (!WaitForBrowserProcessToQuit(
-        TestTimeouts::wait_for_terminate_timeout_ms())) {
-      // We need to force the browser to quit because it didn't quit fast
-      // enough. Take no chance and kill every chrome processes.
-      CleanupAppProcesses();
-    }
-    browser_quit_time_ = base::TimeTicks::Now() - quit_start;
+  // Wait for the browser process to quit. It should quit once all tabs have
+  // been closed.
+  int exit_code = -1;
+  if (WaitForBrowserProcessToQuit(
+          TestTimeouts::wait_for_terminate_timeout_ms(), &exit_code)) {
+    EXPECT_EQ(0, exit_code);  // Expect a clean shutdown.
+  } else {
+    // We need to force the browser to quit because it didn't quit fast
+    // enough. Take no chance and kill every chrome processes.
+    CleanupAppProcesses();
   }
+  browser_quit_time_ = base::TimeTicks::Now() - quit_start;
 
   // Don't forget to close the handle
   base::CloseProcessHandle(process_);
   process_ = base::kNullProcessHandle;
   process_id_ = -1;
 }
 
 void ProxyLauncher::TerminateBrowser() {
+  base::TimeTicks quit_start = base::TimeTicks::Now();
+
   if (IsBrowserRunning()) {
-    base::TimeTicks quit_start = base::TimeTicks::Now();
     EXPECT_TRUE(automation()->SetFilteredInet(false));
 #if defined(OS_WIN)
     scoped_refptr<BrowserProxy> browser(automation()->GetBrowserWindow(0));
     ASSERT_TRUE(browser.get());
     ASSERT_TRUE(browser->TerminateSession());
 #endif  // defined(OS_WIN)
 
     // Now, drop the automation IPC channel so that the automation provider in
     // the browser notices and drops its reference to the browser process.
     automation()->Disconnect();
 
 #if defined(OS_POSIX)
     EXPECT_EQ(kill(process_, SIGTERM), 0);
 #endif  // OS_POSIX
+  }
 
-    if (!WaitForBrowserProcessToQuit(
-        TestTimeouts::wait_for_terminate_timeout_ms())) {
-      // We need to force the browser to quit because it didn't quit fast
-      // enough. Take no chance and kill every chrome processes.
-      CleanupAppProcesses();
-    }
-    browser_quit_time_ = base::TimeTicks::Now() - quit_start;
+  int exit_code = 0;
+  if (WaitForBrowserProcessToQuit(
+          TestTimeouts::wait_for_terminate_timeout_ms(), &exit_code)) {
+    EXPECT_EQ(0, exit_code);  // Expect a clean shutdown.
+  } else {
+    // We need to force the browser to quit because it didn't quit fast
+    // enough. Take no chance and kill every chrome processes.
+    CleanupAppProcesses();
   }
+  browser_quit_time_ = base::TimeTicks::Now() - quit_start;
 
   // Don't forget to close the handle
   base::CloseProcessHandle(process_);
   process_ = base::kNullProcessHandle;
   process_id_ = -1;
 }
 
 void ProxyLauncher::AssertAppNotRunning(const std::wstring& error_message) {
   std::wstring final_error_message(error_message);
 
   ChromeProcessList processes = GetRunningChromeProcesses(process_id_);
   if (!processes.empty()) {
     final_error_message += L" Leftover PIDs: [";
     for (ChromeProcessList::const_iterator it = processes.begin();
          it != processes.end(); ++it) {
       final_error_message += StringPrintf(L" %d", *it);
     }
     final_error_message += L" ]";
   }
   ASSERT_TRUE(processes.empty()) << final_error_message;
 }
 
 void ProxyLauncher::CleanupAppProcesses() {
   TerminateAllChromeProcesses(process_id_);
 }
 
-bool ProxyLauncher::WaitForBrowserProcessToQuit(int timeout) {
+bool ProxyLauncher::WaitForBrowserProcessToQuit(int timeout, int* exit_code) {
 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
   timeout = 500000;
 #endif
-  return base::WaitForSingleProcess(process_, timeout);
+  return base::WaitForExitCodeWithTimeout(process_, exit_code, timeout);
 }
 
 bool ProxyLauncher::IsBrowserRunning() {
-  return CrashAwareSleep(0);
-}
+  // If there is no active AutomationProxy the browser shouldn't be running.
+  if (!automation_proxy_.get())
+    return false;
 
-bool ProxyLauncher::CrashAwareSleep(int timeout_ms) {
-  return base::CrashAwareSleep(process_, timeout_ms);
+  // Send a simple message to the browser. If it comes back, the browser
+  // must be alive.
+  int window_count;
+  return automation_proxy_->GetBrowserWindowCount(&window_count);
 }
 
 void ProxyLauncher::PrepareTestCommandline(CommandLine* command_line,
                                            bool include_testing_id) {
   // Propagate commandline settings from test_launcher_utils.
   test_launcher_utils::PrepareBrowserCommandLineForTests(command_line);
 
   // Add any explicit command line flags passed to the process.
   CommandLine::StringType extra_chrome_flags =
       CommandLine::ForCurrentProcess()->GetSwitchValueNative(
@@ skipping 222 matching lines @@
   LaunchBrowserAndServer(state, wait_for_initial_loads);
 }
 
 void AnonymousProxyLauncher::TerminateConnection() {
   CloseBrowserAndServer();
 }
 
 std::string AnonymousProxyLauncher::PrefixedChannelID() const {
   return channel_id_;
 }