Migrate WaitableEvent to enum-based constructor in base/

base/threading/worker_pool_unittest.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.
 
 #include "base/threading/worker_pool.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread_checker_impl.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 typedef PlatformTest WorkerPoolTest;
 
 namespace base {
 
 namespace {
 
 class PostTaskAndReplyTester
     : public base::RefCountedThreadSafe<PostTaskAndReplyTester> {
  public:
-  PostTaskAndReplyTester() : finished_(false), test_event_(false, false) {}
+  PostTaskAndReplyTester()
+      : finished_(false),
+        test_event_(WaitableEvent::ResetPolicy::AUTOMATIC,
+                    WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   void RunTest() {
     ASSERT_TRUE(thread_checker_.CalledOnValidThread());
     WorkerPool::PostTaskAndReply(
       FROM_HERE,
       base::Bind(&PostTaskAndReplyTester::OnWorkerThread, this),
       base::Bind(&PostTaskAndReplyTester::OnOriginalThread, this),
       false);
 
     test_event_.Wait();
@@ skipping 22 matching lines @@
   bool finished_;
   WaitableEvent test_event_;
 
   // The Impl version performs its checks even in release builds.
   ThreadCheckerImpl thread_checker_;
 };
 
 }  // namespace
 
 TEST_F(WorkerPoolTest, PostTask) {
-  WaitableEvent test_event(false, false);
-  WaitableEvent long_test_event(false, false);
+  WaitableEvent test_event(WaitableEvent::ResetPolicy::AUTOMATIC,
+                           WaitableEvent::InitialState::NOT_SIGNALED);
+  WaitableEvent long_test_event(WaitableEvent::ResetPolicy::AUTOMATIC,
+                                WaitableEvent::InitialState::NOT_SIGNALED);
 
   WorkerPool::PostTask(FROM_HERE,
                        base::Bind(&WaitableEvent::Signal,
                                   base::Unretained(&test_event)),
                        false);
   WorkerPool::PostTask(FROM_HERE,
                        base::Bind(&WaitableEvent::Signal,
                                   base::Unretained(&long_test_event)),
                        true);
 
@@ skipping 20 matching lines @@
     // Ensure that the other thread has a chance to run even on a single-core
     // device.
     pthread_yield_np();
 #endif
     RunLoop().RunUntilIdle();
   }
   EXPECT_TRUE(tester->finished());
 }
 
 }  // namespace base