Convert ProcessSingleton ui_test to browser_test.

chrome/browser/process_singleton_browsertest.cc

 // Copyright (c) 2012 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 run on Windows and Posix(non-Mac) platforms.
 // Mac uses system services and ProcessSingletonMac is a noop.  (Maybe it still
 // makes sense to test that the system services are giving the behavior we
 // want?)
 
-#include <list>
-
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/test_launcher_utils.h"
-#include "chrome/test/ui/ui_test.h"
-#include "testing/gtest/include/gtest/gtest.h"
+#include "chrome/test/base/in_process_browser_test.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
 // base::Bind to run the StartChrome methods in many threads.
 class ChromeStarter : public base::RefCountedThreadSafe<ChromeStarter> {
  public:
   ChromeStarter(int timeout_ms, const FilePath& user_data_dir)
@@ skipping 12 matching lines @@
     done_event_.Reset();
     if (process_handle_ != base::kNullProcessHandle)
       base::CloseProcessHandle(process_handle_);
     process_handle_ = base::kNullProcessHandle;
     process_terminated_ = false;
   }
 
   void StartChrome(base::WaitableEvent* start_event, bool first_run) {
     // TODO(mattm): maybe stuff should be refactored to use
     // UITest::LaunchBrowserHelper somehow?
-    FilePath browser_directory;
-    PathService::Get(chrome::DIR_APP, &browser_directory);
-    CommandLine command_line(browser_directory.Append(
-        chrome::kBrowserProcessExecutablePath));
-
+    FilePath program;
+    ASSERT_TRUE(PathService::Get(base::FILE_EXE, &program));
+    CommandLine command_line(program);
     command_line.AppendSwitchPath(switches::kUserDataDir, user_data_dir_);
 
     if (first_run)
       command_line.AppendSwitch(switches::kFirstRun);
     else
       command_line.AppendSwitch(switches::kNoFirstRun);
 
     // Add the normal test-mode switches, except for the ones we're adding
     // ourselves.
     CommandLine standard_switches(CommandLine::NO_PROGRAM);
@@ skipping 45 matching lines @@
     if (process_handle_ != base::kNullProcessHandle)
       base::CloseProcessHandle(process_handle_);
   }
 
   int timeout_ms_;
   FilePath user_data_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeStarter);
 };
 
+}  // namespace
+
 // Our test fixture that initializes and holds onto a few global vars.
-class ProcessSingletonTest : public UITest {
+class ProcessSingletonTest : public InProcessBrowserTest {
  public:
   ProcessSingletonTest()
       // 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 */) {
     EXPECT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
   }
 
   void SetUp() {
     // Start the threads and create the starters.
@@ skipping 38 matching lines @@
     } process_tree_filter(base::GetProcId(process_handle));
 
     // Start by explicitly killing the main process we know about...
     static const int kExitCode = 42;
     EXPECT_TRUE(base::KillProcess(process_handle, kExitCode, true /* wait */));
 
     // Then loop until we can't find any of its descendant.
     // But don't try more than kNbTries times...
     static const int kNbTries = 10;
     int num_tries = 0;
-    while (base::GetProcessCount(chrome::kBrowserProcessExecutablePath,
-        &process_tree_filter) > 0 && num_tries++ < kNbTries) {
-      base::KillProcesses(chrome::kBrowserProcessExecutablePath,
-                          kExitCode, &process_tree_filter);
+    FilePath program;
+    ASSERT_TRUE(PathService::Get(base::FILE_EXE, &program));
+    FilePath::StringType exe_name = program.BaseName().value();
+    while (base::GetProcessCount(exe_name, &process_tree_filter) > 0 &&
+           num_tries++ < kNbTries) {
+      base::KillProcesses(exe_name, kExitCode, &process_tree_filter);
     }
     DLOG_IF(ERROR, num_tries >= kNbTries) << "Failed to kill all processes!";
   }
 
   // Since this is a hard to reproduce problem, we make a few attempts.
   // We stop the attempts at the first error, and when there are no errors,
   // we don't time-out of any wait, so it executes quite fast anyway.
   static const size_t kNbAttempts = 5;
 
   // The idea is to start chrome from multiple threads all at once.
   static const size_t kNbThreads = 5;
   scoped_refptr<ChromeStarter> chrome_starters_[kNbThreads];
   scoped_ptr<base::Thread> chrome_starter_threads_[kNbThreads];
 
   // The event that will get all threads to wake up simultaneously and try
   // to start a chrome process at the same time.
   base::WaitableEvent threads_waker_;
 
   // We don't want to use the default profile, but can't use UITest's since we
   // don't use UITest::LaunchBrowser.
   ScopedTempDir temp_profile_dir_;
 };
 
 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
 // http://crbug.com/58219
 #define MAYBE_StartupRaceCondition FAILS_StartupRaceCondition
 #else
 #define MAYBE_StartupRaceCondition StartupRaceCondition
 #endif
-TEST_F(ProcessSingletonTest, MAYBE_StartupRaceCondition) {
+IN_PROC_BROWSER_TEST_F(ProcessSingletonTest, MAYBE_StartupRaceCondition) {
   // We use this to stop the attempts loop on the first failure.
   bool failed = false;
   for (size_t attempt = 0; attempt < kNbAttempts && !failed; ++attempt) {
     SCOPED_TRACE(testing::Message() << "Attempt: " << attempt << ".");
     // We use a single event to get all threads to do the AppLaunch at the same
     // time...
     threads_waker_.Reset();
 
     // Test both with and without the first-run dialog, since they exercise
     // different paths.
@@ skipping 79 matching lines @@
     ASSERT_EQ(static_cast<size_t>(1), pending_starters.size());
     size_t last_index = pending_starters.front();
     pending_starters.clear();
     if (chrome_starters_[last_index]->process_handle_ !=
         base::kNullProcessHandle) {
       KillProcessTree(chrome_starters_[last_index]->process_handle_);
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }
-
-}  // namespace