Modify WaitableEvent::Wait() to return void

chrome/browser/process_singleton_uitest.cc

 // Copyright (c) 2011 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 74 matching lines @@
         continue;
 
       command_line.AppendSwitchNative(switch_name, i->second);
     }
 
     // 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!
     ASSERT_NE(static_cast<base::WaitableEvent*>(NULL), start_event);
-    ASSERT_TRUE(start_event->Wait());
+    start_event->Wait();
 
     // 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...
     base::LaunchProcess(command_line, base::LaunchOptions(), &process_handle_);
     ASSERT_NE(base::kNullProcessHandle, process_handle_);
 
     // 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.
@@ skipping 153 matching lines @@
           FROM_HERE, NewRunnableMethod(chrome_starters_[i].get(),
                                        &ChromeStarter::StartChrome,
                                        &threads_waker_,
                                        first_run));
     }
 
     // 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 << ".");
-      ASSERT_TRUE(chrome_starters_[i]->ready_event_.Wait());
+      chrome_starters_[i]->ready_event_.Wait();
     }
     // 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;
@@ skipping 37 matching lines @@
     pending_starters.empty();
     if (chrome_starters_[last_index]->process_handle_ !=
         base::kNullProcessHandle) {
       KillProcessTree(chrome_starters_[last_index]->process_handle_);
       chrome_starters_[last_index]->done_event_.Wait();
     }
   }
 }
 
 }  // namespace