clang-tidy WaitableEvent refactor (Windows side)

components/browser_watcher/window_hang_monitor_win_unittest.cc

 // Copyright 2015 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 "components/browser_watcher/window_hang_monitor_win.h"
 
 #include <memory>
 
 #include "base/base_paths.h"
 #include "base/base_switches.h"
@@ skipping 78 matching lines @@
   }
   return reinterpret_cast<HANDLE>(switch_uint);
 }
 
 // An instance of this class lives in the monitored process and receives signals
 // and executes their associated function.
 class MonitoredProcessClient {
  public:
   MonitoredProcessClient()
       : message_window_thread_("Message window thread"),
-        hang_event_(true, false) {
+        hang_event_(base::WaitableEvent::ResetPolicy::MANUAL,
+                    base::WaitableEvent::InitialState::NOT_SIGNALED) {
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
     read_pipe_.Set(GetSwitchValueHandle(command_line, kChildReadPipeSwitch));
     write_pipe_.Set(GetSwitchValueHandle(command_line, kChildWritePipeSwitch));
   }
 
   ~MonitoredProcessClient() {
     if (message_window_thread_.IsRunning()) {
       DeleteMessageWindow();
     }
@@ skipping 26 matching lines @@
       SendSignalToParent(IPC_SIGNAL_READY);
     }
   }
 
   // Creates a thread then creates the message window on it.
   void CreateMessageWindow() {
     ASSERT_TRUE(message_window_thread_.StartWithOptions(
         base::Thread::Options(base::MessageLoop::TYPE_UI, 0)));
 
     bool succeeded = false;
-    base::WaitableEvent created(true, false);
+    base::WaitableEvent created(
+        base::WaitableEvent::ResetPolicy::MANUAL,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
     ASSERT_TRUE(message_window_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MonitoredProcessClient::CreateMessageWindowInWorkerThread,
                    base::Unretained(this), &succeeded, &created)));
     created.Wait();
     ASSERT_TRUE(succeeded);
   }
 
   // Creates a thread then creates the message window on it.
   void HangMessageWindow() {
@@ skipping 28 matching lines @@
 
     message_window_.reset(new base::win::MessageWindow);
     *success = message_window_->CreateNamed(
         base::Bind(&MonitoredProcessClient::EmptyMessageCallback,
                    base::Unretained(this)),
         existing_dir.value().c_str());
     created->Signal();
   }
 
   void DeleteMessageWindow() {
-    base::WaitableEvent deleted(true, false);
+    base::WaitableEvent deleted(
+        base::WaitableEvent::ResetPolicy::MANUAL,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
     message_window_thread_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&MonitoredProcessClient::DeleteMessageWindowInWorkerThread,
                    base::Unretained(this), &deleted));
     deleted.Wait();
 
     message_window_thread_.Stop();
   }
 
   void DeleteMessageWindowInWorkerThread(base::WaitableEvent* deleted) {
@@ skipping 25 matching lines @@
 
   return 0;
 }
 
 // Manages a WindowHangMonitor that lives on a background thread.
 class HangMonitorThread {
  public:
   // Instantiates the background thread.
   HangMonitorThread()
       : event_(WindowHangMonitor::WINDOW_NOT_FOUND),
-        event_received_(false, false),
+        event_received_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                        base::WaitableEvent::InitialState::NOT_SIGNALED),
         thread_("Hang monitor thread") {}
 
   ~HangMonitorThread() {
     if (hang_monitor_.get())
       DestroyWatcher();
   }
 
   // Starts the background thread and the monitor to observe Chrome message
   // window for |process|. Blocks until the monitor has been initialized.
   bool Start(base::Process process) {
     if (!thread_.StartWithOptions(
             base::Thread::Options(base::MessageLoop::TYPE_UI, 0))) {
       return false;
     }
 
-    base::WaitableEvent complete(false, false);
+    base::WaitableEvent complete(
+        base::WaitableEvent::ResetPolicy::AUTOMATIC,
+        base::WaitableEvent::InitialState::NOT_SIGNALED);
     if (!thread_.task_runner()->PostTask(
             FROM_HERE,
             base::Bind(&HangMonitorThread::StartupOnThread,
                        base::Unretained(this), base::Passed(std::move(process)),
                        base::Unretained(&complete)))) {
       return false;
     }
 
     complete.Wait();
 
@@ skipping 192 matching lines @@
 
   ASSERT_TRUE(SendSignal(IPC_SIGNAL_HANG_MESSAGE_WINDOW));
 
   EXPECT_EQ(WindowHangMonitor::WINDOW_HUNG,
             monitor_thread().WaitForEvent());
 
   ASSERT_TRUE(SendSignal(IPC_SIGNAL_TERMINATE_PROCESS));
 }
 
 }  // namespace browser_watcher