Fix ProcessSingletonTest.StartupRaceCondition using default profile again.

chrome/browser/process_singleton_uitest.cc

 // Copyright (c) 2010 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/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/ref_counted.h"
+#include "base/scoped_temp_dir.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/test/test_launcher_utils.h"
 #include "chrome/test/ui/ui_test.h"
 #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:
-  explicit ChromeStarter(int timeout_ms)
+  explicit ChromeStarter(int timeout_ms, const FilePath& user_data_dir)
       : ready_event_(false /* manual */, false /* signaled */),
         done_event_(false /* manual */, false /* signaled */),
         process_handle_(NULL),
         process_terminated_(false),
-        timeout_ms_(timeout_ms) {
+        timeout_ms_(timeout_ms),
+        user_data_dir_(user_data_dir) {
   }
 
   // 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_ != 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(
         FilePath::FromWStringHack(chrome::kBrowserProcessExecutablePath)));
 
-    FilePath user_data_directory;
-    PathService::Get(chrome::DIR_USER_DATA, &user_data_directory);
-    command_line.AppendSwitchPath(switches::kUserDataDir, user_data_directory);
+    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::ARGUMENTS_ONLY);
+    test_launcher_utils::PrepareBrowserCommandLineForTests(&standard_switches);
+    const CommandLine::SwitchMap& switch_map = standard_switches.GetSwitches();
+    for (CommandLine::SwitchMap::const_iterator i = switch_map.begin();
+         i != switch_map.end(); ++i) {
+      const std::string& switch_name = i->first;
+      if (switch_name == switches::kUserDataDir ||
+          switch_name == switches::kFirstRun ||
+          switch_name == switches::kNoFirstRun)
+        continue;
+
+      command_line.AppendSwitchNative(switch_name, i->second);
+    }
+
     // Try to get all threads to launch the app at the same time.
     // So let the test know we are ready.
     ready_event_.Signal();
     // And then wait for the test to tell us to GO!
     ASSERT_NE(static_cast<base::WaitableEvent*>(NULL), start_event);
     ASSERT_TRUE(start_event->Wait());
 
     // 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...
@@ skipping 18 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<ChromeStarter>;
 
   ~ChromeStarter() {
     if (process_handle_ != base::kNullProcessHandle)
       base::CloseProcessHandle(process_handle_);
   }
 
   int timeout_ms_;
+  FilePath user_data_dir_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeStarter);
 };
 
 // Our test fixture that initializes and holds onto a few global vars.
 class ProcessSingletonTest : public UITest {
  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 */) {
+    temp_profile_dir_.CreateUniqueTempDir();
   }
 
   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(action_max_timeout_ms());
+      chrome_starters_[i] = new ChromeStarter(action_max_timeout_ms(),
+                                              temp_profile_dir_.path());
     }
   }
 
   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 44 matching lines @@
   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)
 // http://crbug.com/47979
 #define MAYBE_StartupRaceCondition FAILS_StartupRaceCondition
 #else
 #define MAYBE_StartupRaceCondition StartupRaceCondition
 #endif
 TEST_F(ProcessSingletonTest, MAYBE_StartupRaceCondition) {
   // We use this to stop the attempts loop on the first failure.
@@ skipping 90 matching lines @@
     pending_starters.empty();
     if (chrome_starters_[last_index]->process_handle_ !=
         base::kNullProcessHandle) {
       KillProcessTree(chrome_starters_[last_index]->process_handle_);
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }
 
 }  // namespace