src/chrome/browser/process_singleton_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This test validates that the ProcessSingleton class properly makes sure
   6 // that there is only one main browser process.
   7 //
   8 // It is currently compiled and run on Windows and Posix(non-Mac) platforms.
   9 // Mac uses system services and ProcessSingletonMac is a noop.  (Maybe it still
  10 // makes sense to test that the system services are giving the behavior we
  11 // want?)
  12
  13 #include "base/bind.h"
  14 #include "base/command_line.h"
  15 #include "base/files/file_path.h"
  16 #include "base/files/scoped_temp_dir.h"
  17 #include "base/memory/ref_counted.h"
  18 #include "base/path_service.h"
  19 #include "base/process/kill.h"
  20 #include "base/process/launch.h"
  21 #include "base/process/process_iterator.h"
  22 #include "base/synchronization/waitable_event.h"
  23 #include "base/test/test_timeouts.h"
  24 #include "base/threading/thread.h"
  25 #include "chrome/common/chrome_constants.h"
  26 #include "chrome/common/chrome_paths.h"
  27 #include "chrome/common/chrome_switches.h"
  28 #include "chrome/test/base/in_process_browser_test.h"
  29 #include "chrome/test/base/test_launcher_utils.h"
  30
  31 namespace {
  32
  33 // This is for the code that is to be ran in multiple threads at once,
  34 // to stress a race condition on first process start.
  35 // We use the thread safe ref counted base class so that we can use the
  36 // base::Bind to run the StartChrome methods in many threads.
  37 class ChromeStarter : public base::RefCountedThreadSafe<ChromeStarter> {
  38  public:
  39   ChromeStarter(base::TimeDelta timeout, const base::FilePath& user_data_dir)
  40       : ready_event_(false /* manual */, false /* signaled */),
  41         done_event_(false /* manual */, false /* signaled */),
  42         process_handle_(base::kNullProcessHandle),
  43         process_terminated_(false),
  44         timeout_(timeout),
  45         user_data_dir_(user_data_dir) {
  46   }
  47
  48   // We must reset some data members since we reuse the same ChromeStarter
  49   // object and start/stop it a few times. We must start fresh! :-)
  50   void Reset() {
  51     ready_event_.Reset();
  52     done_event_.Reset();
  53     if (process_handle_ != base::kNullProcessHandle)
  54       base::CloseProcessHandle(process_handle_);
  55     process_handle_ = base::kNullProcessHandle;
  56     process_terminated_ = false;
  57   }
  58
  59   void StartChrome(base::WaitableEvent* start_event, bool first_run) {
  60     // TODO(mattm): maybe stuff should be refactored to use
  61     // UITest::LaunchBrowserHelper somehow?
  62     base::FilePath program;
  63     ASSERT_TRUE(PathService::Get(base::FILE_EXE, &program));
  64     CommandLine command_line(program);
  65     command_line.AppendSwitchPath(switches::kUserDataDir, user_data_dir_);
  66
  67     if (first_run)
  68       command_line.AppendSwitch(switches::kForceFirstRun);
  69     else
  70       command_line.AppendSwitch(switches::kNoFirstRun);
  71
  72     // Add the normal test-mode switches, except for the ones we're adding
  73     // ourselves.
  74     CommandLine standard_switches(CommandLine::NO_PROGRAM);
  75     test_launcher_utils::PrepareBrowserCommandLineForTests(&standard_switches);
  76     const CommandLine::SwitchMap& switch_map = standard_switches.GetSwitches();
  77     for (CommandLine::SwitchMap::const_iterator i = switch_map.begin();
  78          i != switch_map.end(); ++i) {
  79       const std::string& switch_name = i->first;
  80       if (switch_name == switches::kUserDataDir ||
  81           switch_name == switches::kForceFirstRun ||
  82           switch_name == switches::kNoFirstRun)
  83         continue;
  84
  85       command_line.AppendSwitchNative(switch_name, i->second);
  86     }
  87
  88     // Try to get all threads to launch the app at the same time.
  89     // So let the test know we are ready.
  90     ready_event_.Signal();
  91     // And then wait for the test to tell us to GO!
  92     ASSERT_NE(static_cast<base::WaitableEvent*>(NULL), start_event);
  93     start_event->Wait();
  94
  95     // Here we don't wait for the app to be terminated because one of the
  96     // process will stay alive while the others will be restarted. If we would
  97     // wait here, we would never get a handle to the main process...
  98     base::LaunchProcess(command_line, base::LaunchOptions(), &process_handle_);
  99     ASSERT_NE(base::kNullProcessHandle, process_handle_);
 100
 101     // We can wait on the handle here, we should get stuck on one and only
 102     // one process. The test below will take care of killing that process
 103     // to unstuck us once it confirms there is only one.
 104     process_terminated_ = base::WaitForSingleProcess(process_handle_,
 105                                                      timeout_);
 106     // Let the test know we are done.
 107     done_event_.Signal();
 108   }
 109
 110   // Public access to simplify the test code using them.
 111   base::WaitableEvent ready_event_;
 112   base::WaitableEvent done_event_;
 113   base::ProcessHandle process_handle_;
 114   bool process_terminated_;
 115
 116  private:
 117   friend class base::RefCountedThreadSafe<ChromeStarter>;
 118
 119   ~ChromeStarter() {
 120     if (process_handle_ != base::kNullProcessHandle)
 121       base::CloseProcessHandle(process_handle_);
 122   }
 123
 124   base::TimeDelta timeout_;
 125   base::FilePath user_data_dir_;
 126
 127   DISALLOW_COPY_AND_ASSIGN(ChromeStarter);
 128 };
 129
 130 }  // namespace
 131
 132 // Our test fixture that initializes and holds onto a few global vars.
 133 class ProcessSingletonTest : public InProcessBrowserTest {
 134  public:
 135   ProcessSingletonTest()
 136       // We use a manual reset so that all threads wake up at once when signaled
 137       // and thus we must manually reset it for each attempt.
 138       : threads_waker_(true /* manual */, false /* signaled */) {
 139     EXPECT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
 140   }
 141
 142   virtual void SetUp() {
 143     // Start the threads and create the starters.
 144     for (size_t i = 0; i < kNbThreads; ++i) {
 145       chrome_starter_threads_[i].reset(new base::Thread("ChromeStarter"));
 146       ASSERT_TRUE(chrome_starter_threads_[i]->Start());
 147       chrome_starters_[i] = new ChromeStarter(
 148           TestTimeouts::action_max_timeout(), temp_profile_dir_.path());
 149     }
 150   }
 151
 152   virtual void TearDown() {
 153     // Stop the threads.
 154     for (size_t i = 0; i < kNbThreads; ++i)
 155       chrome_starter_threads_[i]->Stop();
 156   }
 157
 158   // This method is used to make sure we kill the main browser process after
 159   // all of its child processes have successfully attached to it. This was added
 160   // when we realized that if we just kill the parent process right away, we
 161   // sometimes end up with dangling child processes. If we Sleep for a certain
 162   // amount of time, we are OK... So we introduced this method to avoid a
 163   // flaky wait. Instead, we kill all descendants of the main process after we
 164   // killed it, relying on the fact that we can still get the parent id of a
 165   // child process, even when the parent dies.
 166   void KillProcessTree(base::ProcessHandle process_handle) {
 167     class ProcessTreeFilter : public base::ProcessFilter {
 168      public:
 169       explicit ProcessTreeFilter(base::ProcessId parent_pid) {
 170         ancestor_pids_.insert(parent_pid);
 171       }
 172       virtual bool Includes(const base::ProcessEntry & entry) const OVERRIDE {
 173         if (ancestor_pids_.find(entry.parent_pid()) != ancestor_pids_.end()) {
 174           ancestor_pids_.insert(entry.pid());
 175           return true;
 176         } else {
 177           return false;
 178         }
 179       }
 180      private:
 181       mutable std::set<base::ProcessId> ancestor_pids_;
 182     } process_tree_filter(base::GetProcId(process_handle));
 183
 184     // Start by explicitly killing the main process we know about...
 185     static const int kExitCode = 42;
 186     EXPECT_TRUE(base::KillProcess(process_handle, kExitCode, true /* wait */));
 187
 188     // Then loop until we can't find any of its descendant.
 189     // But don't try more than kNbTries times...
 190     static const int kNbTries = 10;
 191     int num_tries = 0;
 192     base::FilePath program;
 193     ASSERT_TRUE(PathService::Get(base::FILE_EXE, &program));
 194     base::FilePath::StringType exe_name = program.BaseName().value();
 195     while (base::GetProcessCount(exe_name, &process_tree_filter) > 0 &&
 196            num_tries++ < kNbTries) {
 197       base::KillProcesses(exe_name, kExitCode, &process_tree_filter);
 198     }
 199     DLOG_IF(ERROR, num_tries >= kNbTries) << "Failed to kill all processes!";
 200   }
 201
 202   // Since this is a hard to reproduce problem, we make a few attempts.
 203   // We stop the attempts at the first error, and when there are no errors,
 204   // we don't time-out of any wait, so it executes quite fast anyway.
 205   static const size_t kNbAttempts = 5;
 206
 207   // The idea is to start chrome from multiple threads all at once.
 208   static const size_t kNbThreads = 5;
 209   scoped_refptr<ChromeStarter> chrome_starters_[kNbThreads];
 210   scoped_ptr<base::Thread> chrome_starter_threads_[kNbThreads];
 211
 212   // The event that will get all threads to wake up simultaneously and try
 213   // to start a chrome process at the same time.
 214   base::WaitableEvent threads_waker_;
 215
 216   // We don't want to use the default profile, but can't use UITest's since we
 217   // don't use UITest::LaunchBrowser.
 218   base::ScopedTempDir temp_profile_dir_;
 219 };
 220
 221 #if defined(OS_LINUX) && defined(TOOLKIT_VIEWS)
 222 // http://crbug.com/58219
 223 #define MAYBE_StartupRaceCondition DISABLED_StartupRaceCondition
 224 #else
 225 #define MAYBE_StartupRaceCondition StartupRaceCondition
 226 #endif
 227 IN_PROC_BROWSER_TEST_F(ProcessSingletonTest, MAYBE_StartupRaceCondition) {
 228   // We use this to stop the attempts loop on the first failure.
 229   bool failed = false;
 230   for (size_t attempt = 0; attempt < kNbAttempts && !failed; ++attempt) {
 231     SCOPED_TRACE(testing::Message() << "Attempt: " << attempt << ".");
 232     // We use a single event to get all threads to do the AppLaunch at the same
 233     // time...
 234     threads_waker_.Reset();
 235
 236     // Test both with and without the first-run dialog, since they exercise
 237     // different paths.
 238 #if defined(OS_POSIX)
 239     // TODO(mattm): test first run dialog singleton handling on linux too.
 240     // On posix if we test the first run dialog, GracefulShutdownHandler gets
 241     // the TERM signal, but since the message loop isn't running during the gtk
 242     // first run dialog, the ShutdownDetector never handles it, and KillProcess
 243     // has to time out (60 sec!) and SIGKILL.
 244     bool first_run = false;
 245 #else
 246     // Test for races in both regular start up and first run start up cases.
 247     bool first_run = attempt % 2;
 248 #endif
 249
 250     // Here we prime all the threads with a ChromeStarter that will wait for
 251     // our signal to launch its chrome process.
 252     for (size_t i = 0; i < kNbThreads; ++i) {
 253       ASSERT_NE(static_cast<ChromeStarter*>(NULL), chrome_starters_[i].get());
 254       chrome_starters_[i]->Reset();
 255
 256       ASSERT_TRUE(chrome_starter_threads_[i]->IsRunning());
 257       ASSERT_NE(static_cast<base::MessageLoop*>(NULL),
 258                 chrome_starter_threads_[i]->message_loop());
 259
 260       chrome_starter_threads_[i]->message_loop()->PostTask(
 261           FROM_HERE, base::Bind(&ChromeStarter::StartChrome,
 262                                 chrome_starters_[i].get(),
 263                                 &threads_waker_,
 264                                 first_run));
 265     }
 266
 267     // Wait for all the starters to be ready.
 268     // We could replace this loop if we ever implement a WaitAll().
 269     for (size_t i = 0; i < kNbThreads; ++i) {
 270       SCOPED_TRACE(testing::Message() << "Waiting on thread: " << i << ".");
 271       chrome_starters_[i]->ready_event_.Wait();
 272     }
 273     // GO!
 274     threads_waker_.Signal();
 275
 276     // As we wait for all threads to signal that they are done, we remove their
 277     // index from this vector so that we get left with only the index of
 278     // the thread that started the main process.
 279     std::vector<size_t> pending_starters(kNbThreads);
 280     for (size_t i = 0; i < kNbThreads; ++i)
 281       pending_starters[i] = i;
 282
 283     // We use a local array of starter's done events we must wait on...
 284     // These are collected from the starters that we have not yet been removed
 285     // from the pending_starters vector.
 286     base::WaitableEvent* starters_done_events[kNbThreads];
 287     // At the end, "There can be only one" main browser process alive.
 288     while (pending_starters.size() > 1) {
 289       SCOPED_TRACE(testing::Message() << pending_starters.size() <<
 290                    " starters left.");
 291       for (size_t i = 0; i < pending_starters.size(); ++i) {
 292         starters_done_events[i] =
 293             &chrome_starters_[pending_starters[i]]->done_event_;
 294       }
 295       size_t done_index = base::WaitableEvent::WaitMany(
 296           starters_done_events, pending_starters.size());
 297       size_t starter_index = pending_starters[done_index];
 298       // If the starter is done but has not marked itself as terminated,
 299       // it is because it timed out of its WaitForSingleProcess(). Only the
 300       // last one standing should be left waiting... So we failed...
 301       EXPECT_TRUE(chrome_starters_[starter_index]->process_terminated_ ||
 302                   failed) << "There is more than one main process.";
 303       if (!chrome_starters_[starter_index]->process_terminated_) {
 304         // This will stop the "for kNbAttempts" loop.
 305         failed = true;
 306         // But we let the last loop turn finish so that we can properly
 307         // kill all remaining processes. Starting with this one...
 308         if (chrome_starters_[starter_index]->process_handle_ !=
 309             base::kNullProcessHandle) {
 310           KillProcessTree(chrome_starters_[starter_index]->process_handle_);
 311         }
 312       }
 313       pending_starters.erase(pending_starters.begin() + done_index);
 314     }
 315
 316     // "There can be only one!" :-)
 317     ASSERT_EQ(static_cast<size_t>(1), pending_starters.size());
 318     size_t last_index = pending_starters.front();
 319     pending_starters.clear();
 320     if (chrome_starters_[last_index]->process_handle_ !=
 321         base::kNullProcessHandle) {
 322       KillProcessTree(chrome_starters_[last_index]->process_handle_);
 323       chrome_starters_[last_index]->done_event_.Wait();
 324     }
 325   }
 326 }