Migrate WaitableEvent enum-based constructor in templated EventPerfTest

base/threading/thread_perftest.cc

 // Copyright 2014 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 <stddef.h>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
@@ skipping 162 matching lines @@
   RunPingPongTest("1_Task_Threads_With_Observer", 1);
   RunPingPongTest("4_Task_Threads_With_Observer", 4);
 }
 
 // Class to test our WaitableEvent performance by signaling back and fort.
 // WaitableEvent is templated so we can also compare with other versions.
 template <typename WaitableEventType>
 class EventPerfTest : public ThreadPerfTest {
  public:
   void Init() override {
-    for (size_t i = 0; i < threads_.size(); i++)
-      events_.push_back(new WaitableEventType(false, false));
+    for (size_t i = 0; i < threads_.size(); i++) {
+      events_.push_back(
+          new WaitableEventType(WaitableEvent::ResetPolicy::AUTOMATIC,
+                                WaitableEvent::InitialState::NOT_SIGNALED));
+    }
   }
 
   void Reset() override { events_.clear(); }
 
   void WaitAndSignalOnThread(size_t event) {
     size_t next_event = (event + 1) % events_.size();
     int my_hops = 0;
     do {
       events_[event]->Wait();
       my_hops = --remaining_hops_;  // We own 'hops' between Wait and Signal.
@@ skipping 26 matching lines @@
 // might want to craft a way to test the best-case (where the thread doesn't
 // end up blocking because the event is already signalled).
 typedef EventPerfTest<base::WaitableEvent> WaitableEventPerfTest;
 TEST_F(WaitableEventPerfTest, EventPingPong) {
   RunPingPongTest("4_WaitableEvent_Threads", 4);
 }
 
 // Build a minimal event using ConditionVariable.
 class ConditionVariableEvent {
  public:
-  ConditionVariableEvent(bool manual_reset, bool initially_signaled)
+  ConditionVariableEvent(WaitableEvent::ResetPolicy reset_policy,
+                         WaitableEvent::InitialState initial_state)
       : cond_(&lock_), signaled_(false) {
-    DCHECK(!manual_reset);
-    DCHECK(!initially_signaled);
+    DCHECK_EQ(WaitableEvent::ResetPolicy::AUTOMATIC, reset_policy);
+    DCHECK_EQ(WaitableEvent::InitialState::NOT_SIGNALED, initial_state);
   }
 
   void Signal() {
     {
       base::AutoLock scoped_lock(lock_);
       signaled_ = true;
     }
     cond_.Signal();
   }
 
@@ skipping 15 matching lines @@
 typedef EventPerfTest<ConditionVariableEvent> ConditionVariablePerfTest;
 TEST_F(ConditionVariablePerfTest, EventPingPong) {
   RunPingPongTest("4_ConditionVariable_Threads", 4);
 }
 #if defined(OS_POSIX)
 
 // Absolutely 100% minimal posix waitable event. If there is a better/faster
 // way to force a context switch, we should use that instead.
 class PthreadEvent {
  public:
-  PthreadEvent(bool manual_reset, bool initially_signaled) {
-    DCHECK(!manual_reset);
-    DCHECK(!initially_signaled);
+  PthreadEvent(WaitableEvent::ResetPolicy reset_policy,
+               WaitableEvent::InitialState initial_state) {
+    DCHECK_EQ(WaitableEvent::ResetPolicy::AUTOMATIC, reset_policy);
+    DCHECK_EQ(WaitableEvent::InitialState::NOT_SIGNALED, initial_state);
     pthread_mutex_init(&mutex_, 0);
     pthread_cond_init(&cond_, 0);
     signaled_ = false;
   }
 
   ~PthreadEvent() {
     pthread_cond_destroy(&cond_);
     pthread_mutex_destroy(&mutex_);
   }
 
@@ skipping 23 matching lines @@
 typedef EventPerfTest<PthreadEvent> PthreadEventPerfTest;
 TEST_F(PthreadEventPerfTest, EventPingPong) {
   RunPingPongTest("4_PthreadCondVar_Threads", 4);
 }
 
 #endif
 
 }  // namespace
 
 }  // namespace base