[GTTF] Miscellanous UI tests cleanups:

chrome/browser/process_singleton_win_uitest.cc

 // Copyright (c) 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.
 
 // This test validates that the ProcessSingleton class properly makes sure
 // that there is only one main browser process.
 //
 // It is currently compiled and ran on the windows platform only but has been
 // written in a platform independent way (using the process/threads/sync
 // routines from base). So it does compile fine on Mac and Linux but fails to
@@ skipping 15 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // This is for the code that is to be ran in multiple threads at once,
 // to stress a race condition on first process start.
 // We use the thread safe ref counted base class so that we can use the
 // NewRunnableMethod class to run the StartChrome methods in many threads.
 class ChromeStarter : public base::RefCountedThreadSafe<ChromeStarter> {
  public:
-  ChromeStarter()
+  explicit ChromeStarter(int timeout_ms)
       : ready_event_(false /* manual */, false /* signaled */),
         done_event_(false /* manual */, false /* signaled */),
         process_handle_(NULL),
-        process_terminated_(false) {
+        process_terminated_(false),
+        timeout_ms_(timeout_ms) {
   }
 
   // We must reset some data members since we reuse the same ChromeStarter
   // object and start/stop it a few times. We must start fresh! :-)
   void Reset() {
     ready_event_.Reset();
     done_event_.Reset();
     if (process_handle_ != NULL)
       base::CloseProcessHandle(process_handle_);
     process_handle_ = NULL;
@@ skipping 17 matching lines @@
     // Here we don't wait for the app to be terminated because one of the
     // process will stay alive while the others will be restarted. If we would
     // wait here, we would never get a handle to the main process...
     base::LaunchApp(command_line, false /* wait */,
                     false /* hidden */, &process_handle_);
     ASSERT_NE(static_cast<base::ProcessHandle>(NULL), process_handle_);
 
     // We can wait on the handle here, we should get stuck on one and only
     // one process. The test below will take care of killing that process
     // to unstuck us once it confirms there is only one.
-    static const int64 kWaitForProcessDeath = 5000;
     process_terminated_ = base::WaitForSingleProcess(process_handle_,
-                                                     kWaitForProcessDeath);
+                                                     timeout_ms_);
     // Let the test know we are done.
     done_event_.Signal();
   }
 
   // Public access to simplify the test code using them.
   base::WaitableEvent ready_event_;
   base::WaitableEvent done_event_;
   base::ProcessHandle process_handle_;
   bool process_terminated_;
 
  private:
   friend class base::RefCountedThreadSafe<ChromeStarter>;
+
   ~ChromeStarter() {
     if (process_handle_ != NULL)
       base::CloseProcessHandle(process_handle_);
   }
+
+  int timeout_ms_;
+
   DISALLOW_COPY_AND_ASSIGN(ChromeStarter);
 };
 
 // Our test fixture that initializes and holds onto a few global vars.
 class ProcessSingletonWinTest : public UITest {
  public:
   ProcessSingletonWinTest()
       // We use a manual reset so that all threads wake up at once when signaled
       // and thus we must manually reset it for each attempt.
       : threads_waker_(true /* manual */, false /* signaled */) {
   }
 
   void SetUp() {
     // Start the threads and create the starters.
     for (size_t i = 0; i < kNbThreads; ++i) {
       chrome_starter_threads_[i].reset(new base::Thread("ChromeStarter"));
       ASSERT_TRUE(chrome_starter_threads_[i]->Start());
-      chrome_starters_[i] = new ChromeStarter;
+      chrome_starters_[i] = new ChromeStarter(action_max_timeout_ms());
     }
   }
 
   void TearDown() {
     // Stop the threads.
     for (size_t i = 0; i < kNbThreads; ++i)
       chrome_starter_threads_[i]->Stop();
   }
 
   // This method is used to make sure we kill the main browser process after
@@ skipping 133 matching lines @@
     size_t last_index = pending_starters.front();
     pending_starters.empty();
     if (chrome_starters_[last_index]->process_handle_ != NULL) {
       KillProcessTree(chrome_starters_[last_index]->process_handle_);
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }
 
 }  // namespace