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
31namespace {
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.
37class 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.
133class 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
227IN_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}
327