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 } 327
