process_singleton_browsertest.cc 13.7 KB
Newer Older
1
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 3 4 5 6 7
// 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.
//
8 9 10 11
// 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?)
12

13 14
#include <stddef.h>

15 16
#include <memory>

17
#include "base/bind.h"
18
#include "base/command_line.h"
19
#include "base/files/file_path.h"
20
#include "base/files/scoped_temp_dir.h"
21
#include "base/location.h"
22
#include "base/macros.h"
23
#include "base/memory/ref_counted.h"
24
#include "base/path_service.h"
25
#include "base/process/launch.h"
26
#include "base/process/process.h"
27
#include "base/process/process_iterator.h"
28
#include "base/single_thread_task_runner.h"
29
#include "base/synchronization/waitable_event.h"
30 31
#include "base/test/test_timeouts.h"
#include "base/threading/thread.h"
32
#include "build/build_config.h"
33
#include "chrome/common/chrome_constants.h"
34
#include "chrome/common/chrome_paths.h"
35
#include "chrome/common/chrome_result_codes.h"
36
#include "chrome/common/chrome_switches.h"
37
#include "chrome/test/base/in_process_browser_test.h"
38
#include "chrome/test/base/test_launcher_utils.h"
39 40 41 42
#include "testing/gmock/include/gmock/gmock.h"

using ::testing::AnyOf;
using ::testing::Eq;
43 44 45 46 47 48

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
49
// base::Bind to run the StartChrome methods in many threads.
50 51
class ChromeStarter : public base::RefCountedThreadSafe<ChromeStarter> {
 public:
52 53 54
  ChromeStarter(base::TimeDelta timeout,
                const base::FilePath& user_data_dir,
                const base::CommandLine& initial_command_line_for_relaunch)
55 56 57 58
      : ready_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                     base::WaitableEvent::InitialState::NOT_SIGNALED),
        done_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                    base::WaitableEvent::InitialState::NOT_SIGNALED),
59
        process_terminated_(false),
60
        timeout_(timeout),
61 62
        user_data_dir_(user_data_dir),
        initial_command_line_for_relaunch_(initial_command_line_for_relaunch) {}
63 64 65 66 67 68

  // 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();
69 70
    if (process_.IsValid())
      process_.Close();
71 72 73
    process_terminated_ = false;
  }

74
  void StartChrome(base::WaitableEvent* start_event, bool first_run) {
75 76 77 78 79 80 81 82 83 84 85 86 87
    base::CommandLine command_line_for_relaunch(
        initial_command_line_for_relaunch_.GetProgram());
    test_launcher_utils::RemoveCommandLineSwitch(
        initial_command_line_for_relaunch_, switches::kUserDataDir,
        &command_line_for_relaunch);
    command_line_for_relaunch.AppendSwitchPath(switches::kUserDataDir,
                                               user_data_dir_);

    if (first_run) {
      base::CommandLine tmp_command_line = command_line_for_relaunch;
      test_launcher_utils::RemoveCommandLineSwitch(
          tmp_command_line, switches::kNoFirstRun, &command_line_for_relaunch);
      command_line_for_relaunch.AppendSwitch(switches::kForceFirstRun);
88 89
    }

90 91 92 93
    // 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!
94
    ASSERT_NE(nullptr, start_event);
95
    start_event->Wait();
96 97 98 99

    // 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...
100 101
    process_ =
        base::LaunchProcess(command_line_for_relaunch, base::LaunchOptions());
102
    ASSERT_TRUE(process_.IsValid());
103 104 105 106

    // 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.
107 108
    process_terminated_ =
        process_.WaitForExitWithTimeout(timeout_, &exit_code_);
109 110 111 112 113 114 115
    // 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_;
116
  base::Process process_;
117
  bool process_terminated_;
118 119
  // Process exit code. Only meaningful if |process_terminated_| is true.
  int exit_code_;
120 121 122

 private:
  friend class base::RefCountedThreadSafe<ChromeStarter>;
123

124
  ~ChromeStarter() {}
125

126
  base::TimeDelta timeout_;
127
  base::FilePath user_data_dir_;
128
  base::CommandLine initial_command_line_for_relaunch_;
129

130 131 132
  DISALLOW_COPY_AND_ASSIGN(ChromeStarter);
};

133 134
}  // namespace

135
// Our test fixture that initializes and holds onto a few global vars.
136
class ProcessSingletonTest : public InProcessBrowserTest {
137
 public:
138
  ProcessSingletonTest()
139 140
      // 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.
141 142
      : threads_waker_(base::WaitableEvent::ResetPolicy::MANUAL,
                       base::WaitableEvent::InitialState::NOT_SIGNALED) {
143
    EXPECT_TRUE(temp_profile_dir_.CreateUniqueTempDir());
144 145
  }

146
  void TearDown() override {
147
    InProcessBrowserTest::TearDown();
148 149 150 151 152 153 154 155 156 157 158 159 160
    // 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
  // all of its child processes have successfully attached to it. This was added
  // when we realized that if we just kill the parent process right away, we
  // sometimes end up with dangling child processes. If we Sleep for a certain
  // amount of time, we are OK... So we introduced this method to avoid a
  // flaky wait. Instead, we kill all descendants of the main process after we
  // killed it, relying on the fact that we can still get the parent id of a
  // child process, even when the parent dies.
rvargas's avatar
rvargas committed
161
  void KillProcessTree(const base::Process& process) {
162 163 164 165 166
    class ProcessTreeFilter : public base::ProcessFilter {
     public:
      explicit ProcessTreeFilter(base::ProcessId parent_pid) {
        ancestor_pids_.insert(parent_pid);
      }
167
      bool Includes(const base::ProcessEntry& entry) const override {
168 169
        if (ancestor_pids_.find(entry.parent_pid()) != ancestor_pids_.end()) {
          ancestor_pids_.insert(entry.pid());
170 171 172 173 174 175 176
          return true;
        } else {
          return false;
        }
      }
     private:
      mutable std::set<base::ProcessId> ancestor_pids_;
rvargas's avatar
rvargas committed
177
    } process_tree_filter(process.Pid());
178 179 180

    // Start by explicitly killing the main process we know about...
    static const int kExitCode = 42;
rvargas's avatar
rvargas committed
181
    EXPECT_TRUE(process.Terminate(kExitCode, true /* wait */));
182 183 184 185 186

    // 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;
187
    base::FilePath program;
188
    ASSERT_TRUE(PathService::Get(base::FILE_EXE, &program));
189
    base::FilePath::StringType exe_name = program.BaseName().value();
190 191 192
    while (base::GetProcessCount(exe_name, &process_tree_filter) > 0 &&
           num_tries++ < kNbTries) {
      base::KillProcesses(exe_name, kExitCode, &process_tree_filter);
193 194 195 196 197 198 199 200 201 202 203 204
    }
    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];
205
  std::unique_ptr<base::Thread> chrome_starter_threads_[kNbThreads];
206 207 208 209

  // 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_;
210 211 212

  // We don't want to use the default profile, but can't use UITest's since we
  // don't use UITest::LaunchBrowser.
213
  base::ScopedTempDir temp_profile_dir_;
214 215
};

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233
// ChromeOS hits DCHECKS on ProcessSingleton rendezvous: crbug.com/782487
#if defined(OS_CHROMEOS)
#define MAYBE_StartupRaceCondition DISABLED_StartupRaceCondition
#else
#define MAYBE_StartupRaceCondition StartupRaceCondition
#endif
IN_PROC_BROWSER_TEST_F(ProcessSingletonTest, MAYBE_StartupRaceCondition) {
  // Start the threads and create the starters.
  for (size_t i = 0; i < kNbThreads; ++i) {
    chrome_starter_threads_[i] =
        std::make_unique<base::Thread>("ChromeStarter");
    ASSERT_TRUE(chrome_starter_threads_[i]->Start());
    chrome_starters_[i] = base::MakeRefCounted<ChromeStarter>(
        TestTimeouts::action_max_timeout(), temp_profile_dir_.GetPath(),
        GetCommandLineForRelaunch());
  }

  for (size_t attempt = 0; attempt < kNbAttempts && !HasFailure(); ++attempt) {
234
    SCOPED_TRACE(testing::Message() << "Attempt: " << attempt << ".");
235 236
    // We use a single event to get all threads to do the AppLaunch at the
    // same time...
237 238
    threads_waker_.Reset();

239 240 241 242 243 244 245 246 247 248 249 250 251 252
    // Test both with and without the first-run dialog, since they exercise
    // different paths.
#if defined(OS_POSIX)
    // TODO(mattm): test first run dialog singleton handling on linux too.
    // On posix if we test the first run dialog, GracefulShutdownHandler gets
    // the TERM signal, but since the message loop isn't running during the gtk
    // first run dialog, the ShutdownDetector never handles it, and KillProcess
    // has to time out (60 sec!) and SIGKILL.
    bool first_run = false;
#else
    // Test for races in both regular start up and first run start up cases.
    bool first_run = attempt % 2;
#endif

253 254 255 256 257 258 259
    // Here we prime all the threads with a ChromeStarter that will wait for
    // our signal to launch its chrome process.
    for (size_t i = 0; i < kNbThreads; ++i) {
      ASSERT_NE(static_cast<ChromeStarter*>(NULL), chrome_starters_[i].get());
      chrome_starters_[i]->Reset();

      ASSERT_TRUE(chrome_starter_threads_[i]->IsRunning());
260
      ASSERT_NE(static_cast<base::MessageLoop*>(NULL),
261 262
                chrome_starter_threads_[i]->message_loop());

263 264
      chrome_starter_threads_[i]->task_runner()->PostTask(
          FROM_HERE,
265 266
          base::BindOnce(&ChromeStarter::StartChrome, chrome_starters_[i],
                         &threads_waker_, first_run));
267 268 269 270 271 272
    }

    // Wait for all the starters to be ready.
    // We could replace this loop if we ever implement a WaitAll().
    for (size_t i = 0; i < kNbThreads; ++i) {
      SCOPED_TRACE(testing::Message() << "Waiting on thread: " << i << ".");
273
      chrome_starters_[i]->ready_event_.Wait();
274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
    }
    // GO!
    threads_waker_.Signal();

    // As we wait for all threads to signal that they are done, we remove their
    // index from this vector so that we get left with only the index of
    // the thread that started the main process.
    std::vector<size_t> pending_starters(kNbThreads);
    for (size_t i = 0; i < kNbThreads; ++i)
      pending_starters[i] = i;

    // We use a local array of starter's done events we must wait on...
    // These are collected from the starters that we have not yet been removed
    // from the pending_starters vector.
    base::WaitableEvent* starters_done_events[kNbThreads];
    // At the end, "There can be only one" main browser process alive.
    while (pending_starters.size() > 1) {
      SCOPED_TRACE(testing::Message() << pending_starters.size() <<
                   " starters left.");
      for (size_t i = 0; i < pending_starters.size(); ++i) {
        starters_done_events[i] =
            &chrome_starters_[pending_starters[i]]->done_event_;
      }
      size_t done_index = base::WaitableEvent::WaitMany(
          starters_done_events, pending_starters.size());
      size_t starter_index = pending_starters[done_index];
      // If the starter is done but has not marked itself as terminated,
rvargas's avatar
rvargas committed
301 302
      // it is because it timed out of its WaitForExitCodeWithTimeout(). Only
      // the last one standing should be left waiting... So we failed...
303 304 305 306 307 308 309 310 311 312 313 314 315
      EXPECT_TRUE(chrome_starters_[starter_index]->process_terminated_)
          << "There is more than one main process.";
      if (chrome_starters_[starter_index]->process_terminated_) {
        // Generally PROCESS_NOTIFIED would be the expected exit code. In some
        // rare cases the ProcessSingleton race can result in PROFILE_IN_USE
        // exit code, which we also allow, though it would be ideal if that
        // never happened.
        // TODO(mattm): investigate why PROFILE_IN_USE occurs sometimes.
        EXPECT_THAT(
            chrome_starters_[starter_index]->exit_code_,
            AnyOf(Eq(chrome::RESULT_CODE_PROFILE_IN_USE),
                  Eq(chrome::RESULT_CODE_NORMAL_EXIT_PROCESS_NOTIFIED)));
      } else {
316 317
        // But we let the last loop turn finish so that we can properly
        // kill all remaining processes. Starting with this one...
318
        if (chrome_starters_[starter_index]->process_.IsValid()) {
rvargas's avatar
rvargas committed
319
          KillProcessTree(chrome_starters_[starter_index]->process_);
320 321 322 323 324 325 326 327
        }
      }
      pending_starters.erase(pending_starters.begin() + done_index);
    }

    // "There can be only one!" :-)
    ASSERT_EQ(static_cast<size_t>(1), pending_starters.size());
    size_t last_index = pending_starters.front();
328
    pending_starters.clear();
329
    if (chrome_starters_[last_index]->process_.IsValid()) {
rvargas's avatar
rvargas committed
330
      KillProcessTree(chrome_starters_[last_index]->process_);
331 332 333 334
      chrome_starters_[last_index]->done_event_.Wait();
    }
  }
}