Migrate WaitableEvent to enum-based constructor in sync/

sync/internal_api/public/base/cancelation_signal_unittest.cc

 // Copyright 2013 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 "sync/internal_api/public/base/cancelation_signal.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/platform_thread.h"
@@ skipping 30 matching lines @@
   bool WasStarted();
 
  private:
   base::WaitableEvent event_;
   base::Thread exec_thread_;
   CancelationSignal* cancel_signal_;
   bool was_started_;
 };
 
 BlockingTask::BlockingTask(CancelationSignal* cancel_signal)
-  : event_(true, false),
-    exec_thread_("BlockingTaskBackgroundThread"),
-    cancel_signal_(cancel_signal),
-    was_started_(false) { }
+    : event_(base::WaitableEvent::ResetPolicy::MANUAL,
+             base::WaitableEvent::InitialState::NOT_SIGNALED),
+      exec_thread_("BlockingTaskBackgroundThread"),
+      cancel_signal_(cancel_signal),
+      was_started_(false) {}
 
 BlockingTask::~BlockingTask() {
   if (was_started_) {
     cancel_signal_->UnregisterHandler(this);
   }
 }
 
 void BlockingTask::RunAsync(base::WaitableEvent* task_start_signal,
                             base::WaitableEvent* task_done_signal) {
   exec_thread_.Start();
@@ skipping 50 matching lines @@
  private:
   base::MessageLoop main_loop_;
 
   CancelationSignal signal_;
   base::WaitableEvent task_start_event_;
   base::WaitableEvent task_done_event_;
   BlockingTask blocking_task_;
 };
 
 CancelationSignalTest::CancelationSignalTest()
-  : task_start_event_(false, false),
-    task_done_event_(false, false),
-    blocking_task_(&signal_) {}
+    : task_start_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED),
+      task_done_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                       base::WaitableEvent::InitialState::NOT_SIGNALED),
+      blocking_task_(&signal_) {}
 
 CancelationSignalTest::~CancelationSignalTest() {}
 
 void CancelationSignalTest::StartBlockingTaskAsync() {
   blocking_task_.RunAsync(&task_start_event_, &task_done_event_);
 }
 
 void CancelationSignalTest::StartBlockingTaskAndWaitForItToStart() {
   blocking_task_.RunAsync(&task_start_event_, &task_done_event_);
   task_start_event_.Wait();
@@ skipping 39 matching lines @@
 // progress.
 TEST_F(CancelationSignalTest, Cancel) {
   StartBlockingTaskAndWaitForItToStart();
 
   // Wait for the task to finish and let verify it has been started.
   CancelBlocking();
   EXPECT_FALSE(VerifyTaskNotStarted());
 }
 
 }  // namespace syncer