Migrate WaitableEvent to enum-based constructor in base/

base/task_scheduler/scheduler_service_thread_unittest.cc

 // Copyright 2016 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/task_scheduler/scheduler_service_thread.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 80 matching lines @@
   std::unique_ptr<SchedulerThreadPoolImpl> scheduler_thread_pool_;
   std::unique_ptr<SchedulerServiceThread> service_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskSchedulerServiceThreadTest);
 };
 
 }  // namespace
 
 // Tests that the service thread can handle a single delayed task.
 TEST_F(TaskSchedulerServiceThreadTest, RunSingleDelayedTask) {
-  WaitableEvent event(true, false);
+  WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
+                      WaitableEvent::InitialState::NOT_SIGNALED);
   delayed_task_manager().AddDelayedTask(
       WrapUnique(new Task(FROM_HERE,
                           Bind(&WaitableEvent::Signal, Unretained(&event)),
                           TaskTraits(), TimeDelta::FromMilliseconds(100))),
       make_scoped_refptr(new Sequence), nullptr, thread_pool());
   // Waking the service thread shouldn't cause the task to be executed per its
   // delay not having expired (racy in theory, see test-fixture meta-comment).
   service_thread()->WakeUp();
   // Yield to increase the likelihood of catching a bug where these tasks would
   // be released before their delay is passed.
   PlatformThread::YieldCurrentThread();
   EXPECT_FALSE(event.IsSignaled());
   // When the delay expires, the delayed task is posted, signaling |event|.
   event.Wait();
 }
 
 // Tests that the service thread can handle more than one delayed task with
 // different delays.
 TEST_F(TaskSchedulerServiceThreadTest, RunMultipleDelayedTasks) {
   const TimeTicks test_begin_time = TimeTicks::Now();
   const TimeDelta delay1 = TimeDelta::FromMilliseconds(100);
   const TimeDelta delay2 = TimeDelta::FromMilliseconds(200);
 
-  WaitableEvent event1(true, false);
+  WaitableEvent event1(WaitableEvent::ResetPolicy::MANUAL,
+                       WaitableEvent::InitialState::NOT_SIGNALED);
   delayed_task_manager().AddDelayedTask(
       WrapUnique(new Task(FROM_HERE,
                           Bind(&WaitableEvent::Signal, Unretained(&event1)),
                           TaskTraits(), delay1)),
       make_scoped_refptr(new Sequence), nullptr, thread_pool());
 
-  WaitableEvent event2(true, false);
+  WaitableEvent event2(WaitableEvent::ResetPolicy::MANUAL,
+                       WaitableEvent::InitialState::NOT_SIGNALED);
   delayed_task_manager().AddDelayedTask(
       WrapUnique(new Task(FROM_HERE,
                           Bind(&WaitableEvent::Signal, Unretained(&event2)),
                           TaskTraits(), delay2)),
       make_scoped_refptr(new Sequence), nullptr, thread_pool());
 
   // Adding the task shouldn't have caused them to be executed.
   EXPECT_FALSE(event1.IsSignaled());
   EXPECT_FALSE(event2.IsSignaled());
 
@@ skipping 28 matching lines @@
 
   // Now wait for the second task to be fired.
   event2.Wait();
 
   // Which should only have fired after |delay2| was expired.
   EXPECT_GE(TimeTicks::Now() - test_begin_time, delay2);
 }
 
 }  // namespace internal
 }  // namespace base