Remove base::WaitForSingleProcess

chrome/browser/process_singleton_browsertest.cc

 // Copyright (c) 2012 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
@@ skipping 83 matching lines @@
 
     // 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...
     process_ = base::LaunchProcess(command_line, base::LaunchOptions());
     ASSERT_TRUE(process_.IsValid());
 
     // 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.
-    process_terminated_ = base::WaitForSingleProcess(process_.Handle(),
-                                                     timeout_);
+    int exit_code;
+    process_terminated_ = process_.WaitForExitWithTimeout(timeout_, &exit_code);
     // 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_;
   base::Process process_;
   bool process_terminated_;
 
@@ skipping 170 matching lines @@
       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,
-      // it is because it timed out of its WaitForSingleProcess(). Only the
-      // last one standing should be left waiting... So we failed...
+      // it is because it timed out of its WaitForExitCodeWithTimeout(). Only
+      // the last one standing should be left waiting... So we failed...
       EXPECT_TRUE(chrome_starters_[starter_index]->process_terminated_ ||
                   failed) << "There is more than one main process.";
       if (!chrome_starters_[starter_index]->process_terminated_) {
         // This will stop the "for kNbAttempts" loop.
         failed = true;
         // But we let the last loop turn finish so that we can properly
         // kill all remaining processes. Starting with this one...
         if (chrome_starters_[starter_index]->process_.IsValid()) {
           KillProcessTree(chrome_starters_[starter_index]->process_.Handle());
         }
       }
       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();
     pending_starters.clear();
     if (chrome_starters_[last_index]->process_.IsValid()) {
       KillProcessTree(chrome_starters_[last_index]->process_.Handle());
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }