Implement per-test timeout for UI tests.

chrome/test/ui/ui_test.cc

 // Copyright (c) 2006-2009 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"
 
 #include <set>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 26 matching lines @@
 
 using base::TimeTicks;
 
 // Delay to let browser complete a requested action.
 static const int kWaitForActionMsec = 2000;
 static const int kWaitForActionMaxMsec = 10000;
 // Delay to let the browser complete the test.
 static const int kMaxTestExecutionTime = 30000;
 // Delay to let the browser shut down before trying more brutal methods.
 static const int kWaitForTerminateMsec = 30000;
+// Timeout after which the test will be aborted.
+static const int kPerTestTimeoutMsec = 360000;
 
 const wchar_t UITest::kFailedNoCrashService[] =
 #if defined(OS_WIN)
     L"NOTE: This test is expected to fail if crash_service.exe is not "
     L"running. Start it manually before running this test (see the build "
     L"output directory).";
 #elif defined(OS_LINUX)
     L"NOTE: This test is expected to fail if breakpad is not built in "
     L"or if chromium is not running headless (try CHROME_HEADLESS=1).";
 #else
     L"NOTE: Crash service not ported to this platform!";
 #endif
 bool UITest::in_process_renderer_ = false;
 bool UITest::no_sandbox_ = false;
 bool UITest::full_memory_dump_ = false;
 bool UITest::safe_plugins_ = false;
 bool UITest::show_error_dialogs_ = true;
 bool UITest::default_use_existing_browser_ = false;
 bool UITest::dump_histograms_on_exit_ = false;
 bool UITest::enable_dcheck_ = false;
 bool UITest::silent_dump_on_dcheck_ = false;
 bool UITest::disable_breakpad_ = false;
 int UITest::timeout_ms_ = 20 * 60 * 1000;
 std::wstring UITest::js_flags_ = L"";
 std::wstring UITest::log_level_ = L"";
 
 // Specify the time (in milliseconds) that the ui_tests should wait before
 // timing out. This is used to specify longer timeouts when running under Purify
 // which requires much more time.
+// TODO(phajdan.jr): ui-test-timeout is misleading name, rename it.
 const wchar_t kUiTestTimeout[] = L"ui-test-timeout";
 const wchar_t kUiTestActionTimeout[] = L"ui-test-action-timeout";
 const wchar_t kUiTestActionMaxTimeout[] = L"ui-test-action-max-timeout";
 const wchar_t kUiTestSleepTimeout[] = L"ui-test-sleep-timeout";
 const wchar_t kUiTestTerminateTimeout[] = L"ui-test-terminate-timeout";
+const wchar_t kUiTestPerTestTimeout[] = L"ui-test-per-test-timeout";
 
 const wchar_t kExtraChromeFlagsSwitch[] = L"extra-chrome-flags";
 
 // By default error dialogs are hidden, which makes debugging failures in the
 // slave process frustrating. By passing this in error dialogs are enabled.
 const wchar_t kEnableErrorDialogs[] = L"enable-errdialogs";
 
 // Uncomment this line to have the spawned process wait for the debugger to
 // attach.  This only works on Windows.  On posix systems, you can set the
 // BROWSER_WRAPPER env variable to wrap the browser process.
@@ skipping 13 matching lines @@
       clear_profile_(true),
       include_testing_id_(true),
       use_existing_browser_(default_use_existing_browser_),
       enable_file_cookies_(true),
       profile_type_(UITest::DEFAULT_THEME),
       test_start_time_(base::Time::NowFromSystemTime()),
       command_execution_timeout_ms_(kMaxTestExecutionTime),
       action_timeout_ms_(kWaitForActionMsec),
       action_max_timeout_ms_(kWaitForActionMaxMsec),
       sleep_timeout_ms_(kWaitForActionMsec),
-      terminate_timeout_ms_(kWaitForTerminateMsec) {
+      terminate_timeout_ms_(kWaitForTerminateMsec),
+      per_test_timeout_ms_(kPerTestTimeoutMsec) {
   PathService::Get(chrome::DIR_APP, &browser_directory_);
   PathService::Get(chrome::DIR_TEST_DATA, &test_data_directory_);
 }
 
 void UITest::SetUp() {
   if (!use_existing_browser_) {
     AssertAppNotRunning(L"Please close any other instances "
                         L"of the app before testing.");
   }
 
   // Pass the test case name to chrome.exe on the command line to help with
   // parsing Purify output.
   const testing::TestInfo* const test_info =
       testing::UnitTest::GetInstance()->current_test_info();
   if (test_info) {
     std::string test_name = test_info->test_case_name();
     test_name += ".";
     test_name += test_info->name();
     ui_test_name_ = ASCIIToWide(test_name);
   }
 
   InitializeTimeouts();
   LaunchBrowserAndServer();
+
+  automation()->QuitAfterTimeout(per_test_timeout_ms_);
 }
 
 void UITest::TearDown() {
   CloseBrowserAndServer();
 
   // Make sure that we didn't encounter any assertion failures
   logging::AssertionList assertions;
   logging::GetFatalAssertions(&assertions);
 
   // If there were errors, get all the error strings for display.
@@ skipping 52 matching lines @@
     sleep_timeout_ms_ = std::max(kWaitForActionMsec, sleep_timeout);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestTerminateTimeout)) {
     std::wstring terminate_timeout_str =
         CommandLine::ForCurrentProcess()->GetSwitchValue(
             kUiTestTerminateTimeout);
     int terminate_timeout = StringToInt(WideToUTF16Hack(terminate_timeout_str));
     terminate_timeout_ms_ = std::max(kWaitForActionMsec, terminate_timeout);
   }
+
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestPerTestTimeout)) {
+    std::wstring per_test_timeout_str =
+        CommandLine::ForCurrentProcess()->GetSwitchValue(
+            kUiTestPerTestTimeout);
+    int per_test_timeout = StringToInt(WideToUTF16Hack(per_test_timeout_str));
+    per_test_timeout_ms_ = std::max(kPerTestTimeoutMsec, per_test_timeout);
+  }
 }
 
 AutomationProxy* UITest::CreateAutomationProxy(int execution_timeout) {
   // By default we create a plain vanilla AutomationProxy.
   return new AutomationProxy(execution_timeout);
 }
 
 void UITest::LaunchBrowserAndServer() {
   // Set up IPC testing interface server.
   server_.reset(CreateAutomationProxy(command_execution_timeout_ms_));
@@ skipping 903 matching lines @@
 #else
   // TODO(port): above code is very Windows-specific; we need to
   // figure out and abstract out how we'll handle finding any existing
   // running process, etc. on other platforms.
   NOTIMPLEMENTED();
 #endif
   }
 
   return true;
 }