More WaitableEvent stragglers migrated to enum-based constructor

chromecast/media/cma/ipc/media_message_fifo_unittest.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 "chromecast/media/cma/ipc/media_message_fifo.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 36 matching lines @@
     uint32_t msg_type = 0x2 + (k % 5);
     uint32_t max_msg_content_size = k % 64;
     do {
       std::unique_ptr<MediaMessage> msg1(MediaMessage::CreateMessage(
           msg_type, base::Bind(&MediaMessageFifo::ReserveMemory,
                                base::Unretained(fifo.get())),
           max_msg_content_size));
       if (msg1)
         break;
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
-    } while(true);
+    } while (true);
   }
 
   fifo.reset();
 
   event->Signal();
 }
 
 void MsgConsumer(std::unique_ptr<MediaMessageFifo> fifo,
                  int msg_count,
                  base::WaitableEvent* event) {
   int k = 0;
   while (k < msg_count) {
     uint32_t msg_type = 0x2 + (k % 5);
     do {
       std::unique_ptr<MediaMessage> msg2(fifo->Pop());
       if (msg2) {
         if (msg2->type() != PaddingMediaMsg) {
           EXPECT_EQ(msg2->type(), msg_type);
           k++;
         }
         break;
       }
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
-    } while(true);
+    } while (true);
   }
 
   fifo.reset();
 
   event->Signal();
 }
 
 void MsgProducerConsumer(std::unique_ptr<MediaMessageFifo> producer_fifo,
                          std::unique_ptr<MediaMessageFifo> consumer_fifo,
                          base::WaitableEvent* event) {
@@ skipping 34 matching lines @@
 
   std::unique_ptr<MediaMessageFifo> producer_fifo(
       new MediaMessageFifo(std::unique_ptr<MediaMemoryChunk>(
                                new FifoMemoryChunk(&buffer[0], buffer_size)),
                            true));
   std::unique_ptr<MediaMessageFifo> consumer_fifo(
       new MediaMessageFifo(std::unique_ptr<MediaMemoryChunk>(
                                new FifoMemoryChunk(&buffer[0], buffer_size)),
                            false));
 
-  base::WaitableEvent event(false, false);
+  base::WaitableEvent event(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                            base::WaitableEvent::InitialState::NOT_SIGNALED);
   thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&MsgProducerConsumer, base::Passed(&producer_fifo),
                             base::Passed(&consumer_fifo), &event));
   event.Wait();
 
   thread.reset();
 }
 
 TEST(MediaMessageFifoTest, MultiThreaded) {
   size_t buffer_size = 64 * 1024;
   std::unique_ptr<uint64_t[]> buffer(
       new uint64_t[buffer_size / sizeof(uint64_t)]);
 
   std::unique_ptr<base::Thread> producer_thread(
       new base::Thread("FeederThread"));
   std::unique_ptr<base::Thread> consumer_thread(
       new base::Thread("ConsumerThread"));
   producer_thread->Start();
   consumer_thread->Start();
 
   std::unique_ptr<MediaMessageFifo> producer_fifo(
       new MediaMessageFifo(std::unique_ptr<MediaMemoryChunk>(
                                new FifoMemoryChunk(&buffer[0], buffer_size)),
                            true));
   std::unique_ptr<MediaMessageFifo> consumer_fifo(
       new MediaMessageFifo(std::unique_ptr<MediaMemoryChunk>(
                                new FifoMemoryChunk(&buffer[0], buffer_size)),
                            false));
 
-  base::WaitableEvent producer_event_done(false, false);
-  base::WaitableEvent consumer_event_done(false, false);
+  base::WaitableEvent producer_event_done(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
+  base::WaitableEvent consumer_event_done(
+      base::WaitableEvent::ResetPolicy::AUTOMATIC,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
 
   const int msg_count = 2048;
   producer_thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&MsgProducer, base::Passed(&producer_fifo),
                             msg_count, &producer_event_done));
   consumer_thread->task_runner()->PostTask(
       FROM_HERE, base::Bind(&MsgConsumer, base::Passed(&consumer_fifo),
                             msg_count, &consumer_event_done));
 
   producer_event_done.Wait();
   consumer_event_done.Wait();
 
   producer_thread.reset();
   consumer_thread.reset();
 }
 
 }  // namespace media
 }  // namespace chromecast