Migrate WaitableEvent to enum-based constructor in ipc/

ipc/ipc_sync_channel.cc

 // Copyright (c) 2012 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 "ipc/ipc_sync_channel.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 172 matching lines @@
 
   void set_top_send_done_watcher(base::WaitableEventWatcher* watcher) {
     top_send_done_watcher_ = watcher;
   }
 
  private:
   friend class base::RefCountedThreadSafe<ReceivedSyncMsgQueue>;
 
   // See the comment in SyncChannel::SyncChannel for why this event is created
   // as manual reset.
-  ReceivedSyncMsgQueue() :
-      message_queue_version_(0),
-      dispatch_event_(true, false),
-      listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      task_pending_(false),
-      listener_count_(0),
-      top_send_done_watcher_(NULL) {
-  }
+  ReceivedSyncMsgQueue()
+      : message_queue_version_(0),
+        dispatch_event_(base::WaitableEvent::ResetPolicy::MANUAL,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED),
+        listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+        task_pending_(false),
+        listener_count_(0),
+        top_send_done_watcher_(NULL) {}
 
   ~ReceivedSyncMsgQueue() {}
 
   // Holds information about a queued synchronous message or reply.
   struct QueuedMessage {
     QueuedMessage(Message* m, SyncContext* c) : message(m), context(c) { }
     Message* message;
     scoped_refptr<SyncChannel::SyncContext> context;
   };
 
@@ skipping 42 matching lines @@
 // the reply has arrived.
 void SyncChannel::SyncContext::Push(SyncMessage* sync_msg) {
   // Create the tracking information for this message. This object is stored
   // by value since all members are pointers that are cheap to copy. These
   // pointers are cleaned up in the Pop() function.
   //
   // The event is created as manual reset because in between Signal and
   // OnObjectSignalled, another Send can happen which would stop the watcher
   // from being called.  The event would get watched later, when the nested
   // Send completes, so the event will need to remain set.
-  PendingSyncMsg pending(SyncMessage::GetMessageId(*sync_msg),
-                         sync_msg->GetReplyDeserializer(),
-                         new WaitableEvent(true, false));
+  PendingSyncMsg pending(
+      SyncMessage::GetMessageId(*sync_msg), sync_msg->GetReplyDeserializer(),
+      new WaitableEvent(base::WaitableEvent::ResetPolicy::MANUAL,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED));
   base::AutoLock auto_lock(deserializers_lock_);
   deserializers_.push_back(pending);
 }
 
 bool SyncChannel::SyncContext::Pop() {
   bool result;
   {
     base::AutoLock auto_lock(deserializers_lock_);
     PendingSyncMsg msg = deserializers_.back();
     delete msg.deserializer;
@@ skipping 355 matching lines @@
   TRACE_EVENT2("ipc", "SyncChannel::SendOnIPCThread",
                "class", IPC_MESSAGE_ID_CLASS(message->type()),
                "line", IPC_MESSAGE_ID_LINE(message->type()));
 #endif
   if (!message->is_sync())
     return ChannelProxy::SendOnIPCThread(std::move(message));
   return Send(message.release());
 }
 
 }  // namespace IPC