Add a switch to allow longer shutdown timeouts, since quitting under valgrind...

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 23 matching lines @@
 #include "net/base/net_util.h"
 
 
 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.
+static const int kWaitForTerminateMsec = 5000;
 
 const wchar_t UITest::kFailedNoCrashService[] =
     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).";
 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.
 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 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 23 matching lines @@
       process_(0),  // NULL on Windows, 0 PID on POSIX.
       show_window_(false),
       clear_profile_(true),
       include_testing_id_(true),
       use_existing_browser_(default_use_existing_browser_),
       enable_file_cookies_(true),
       test_start_time_(base::Time::NowFromSystemTime()),
       command_execution_timeout_ms_(kMaxTestExecutionTime),
       action_timeout_ms_(kWaitForActionMsec),
       action_max_timeout_ms_(kWaitForActionMaxMsec),
-      sleep_timeout_ms_(kWaitForActionMsec) {
+      sleep_timeout_ms_(kWaitForActionMsec),
+      terminate_timeout_ms_(kWaitForTerminateMsec) {
   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.");
   }
 
@@ skipping 67 matching lines @@
     int max_timeout = StringToInt(WideToUTF16Hack(action_max_str));
     action_max_timeout_ms_ = std::max(kWaitForActionMaxMsec, max_timeout);
   }
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(kUiTestSleepTimeout)) {
     std::wstring sleep_timeout_str =
         CommandLine::ForCurrentProcess()->GetSwitchValue(kUiTestSleepTimeout);
     int sleep_timeout = StringToInt(WideToUTF16Hack(sleep_timeout_str));
     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);
+  }
 }
 
 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 208 matching lines @@
     }
 
     browsers.clear();
 
     // Now, drop the automation IPC channel so that the automation provider in
     // the browser notices and drops its reference to the browser process.
     server_->Disconnect();
 
     // Wait for the browser process to quit. It should quit once all tabs have
     // been closed.
-    int timeout = 5000;
+    int timeout = terminate_timeout_ms_;
 #ifdef WAIT_FOR_DEBUGGER_ON_OPEN
     timeout = 500000;
 #endif
     if (!base::WaitForSingleProcess(process_, timeout)) {
       // We need to force the browser to quit because it didn't quit fast
       // enough. Take no chance and kill every chrome processes.
       CleanupAppProcesses();
     }
   }
 
@@ skipping 433 matching lines @@
 }
 
 bool UITest::EvictFileFromSystemCacheWrapper(const FilePath& path) {
   for (int i = 0; i < 10; i++) {
     if (file_util::EvictFileFromSystemCache(path))
       return true;
     PlatformThread::Sleep(sleep_timeout_ms() / 10);
   }
   return false;
 }