Migrate WaitableEvent to enum-based constructor in base/

base/allocator/allocator_shim_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/allocator/allocator_shim.h"
 
 #include <malloc.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
@@ skipping 283 matching lines @@
 // paths of allocator_shim.cc and smoke-test its thread safey.
 // The test creates kNumThreads threads. Each of them does just a realloc(0x42).
 // The shim intercepts such realloc and makes it fail only once on each thread.
 // We expect to see excactly kNumThreads invocations of the new_handler.
 TEST_F(AllocatorShimTest, NewHandlerConcurrency) {
   const int kNumThreads = 32;
   PlatformThreadHandle threads[kNumThreads];
 
   // The WaitableEvent here is used to attempt to trigger all the threads at
   // the same time, after they have been initialized.
-  WaitableEvent event(/*manual_reset=*/true, /*initially_signaled=*/false);
+  WaitableEvent event(WaitableEvent::ResetPolicy::MANUAL,
+                      WaitableEvent::InitialState::NOT_SIGNALED);
 
   ThreadDelegateForNewHandlerTest mock_thread_main(&event);
 
   for (int i = 0; i < kNumThreads; ++i)
     PlatformThread::Create(0, &mock_thread_main, &threads[i]);
 
   std::set_new_handler(&AllocatorShimTest::NewHandler);
   SetCallNewHandlerOnMallocFailure(true);  // It's going to fail on realloc().
   InsertAllocatorDispatch(&g_mock_dispatch);
   event.Signal();
   for (int i = 0; i < kNumThreads; ++i)
     PlatformThread::Join(threads[i]);
   RemoveAllocatorDispatchForTesting(&g_mock_dispatch);
   ASSERT_EQ(kNumThreads, GetNumberOfNewHandlerCalls());
 }
 
 }  // namespace
 }  // namespace allocator
 }  // namespace base