Migrate WaitableEvent to enum-based constructor in ppapi/

ppapi/proxy/ppapi_proxy_test.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 "ppapi/proxy/ppapi_proxy_test.h"
 
 #include <sstream>
 #include <tuple>
 
 #include "base/bind.h"
@@ skipping 509 matching lines @@
 // TwoWayTest ---------------------------------------------------------------
 
 TwoWayTest::TwoWayTest(TwoWayTest::TwoWayTestMode test_mode)
     : test_mode_(test_mode),
       host_(ProxyTestHarnessBase::PER_THREAD_GLOBALS),
       plugin_(ProxyTestHarnessBase::PER_THREAD_GLOBALS),
       io_thread_("TwoWayTest_IOThread"),
       plugin_thread_("TwoWayTest_PluginThread"),
       remote_harness_(NULL),
       local_harness_(NULL),
-      channel_created_(true, false),
-      shutdown_event_(true, false) {
+      channel_created_(base::WaitableEvent::ResetPolicy::MANUAL,
+                       base::WaitableEvent::InitialState::NOT_SIGNALED),
+      shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL,
+                      base::WaitableEvent::InitialState::NOT_SIGNALED) {
   if (test_mode == TEST_PPP_INTERFACE) {
     remote_harness_ = &plugin_;
     local_harness_ = &host_;
   } else {
     remote_harness_ = &host_;
     local_harness_ = &plugin_;
   }
 }
 
 TwoWayTest::~TwoWayTest() {
   shutdown_event_.Signal();
 }
 
 void TwoWayTest::SetUp() {
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
   io_thread_.StartWithOptions(options);
   plugin_thread_.Start();
 
   // Construct the IPC handle name using the process ID so we can safely run
   // multiple |TwoWayTest|s concurrently.
   std::ostringstream handle_name;
   handle_name << "TwoWayTestChannel" << base::GetCurrentProcId();
   IPC::ChannelHandle handle(handle_name.str());
-  base::WaitableEvent remote_harness_set_up(true, false);
+  base::WaitableEvent remote_harness_set_up(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
   plugin_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&SetUpRemoteHarness, remote_harness_, handle,
                             base::RetainedRef(io_thread_.task_runner()),
                             &shutdown_event_, &remote_harness_set_up));
   remote_harness_set_up.Wait();
   local_harness_->SetUpHarnessWithChannel(
       handle, io_thread_.task_runner().get(), &shutdown_event_,
       true);  // is_client
 }
 
 void TwoWayTest::TearDown() {
-  base::WaitableEvent remote_harness_torn_down(true, false);
+  base::WaitableEvent remote_harness_torn_down(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
   plugin_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&TearDownRemoteHarness, remote_harness_,
                             &remote_harness_torn_down));
   remote_harness_torn_down.Wait();
 
   local_harness_->TearDownHarness();
 
   io_thread_.Stop();
 }
 
 void TwoWayTest::PostTaskOnRemoteHarness(const base::Closure& task) {
-  base::WaitableEvent task_complete(true, false);
+  base::WaitableEvent task_complete(
+      base::WaitableEvent::ResetPolicy::MANUAL,
+      base::WaitableEvent::InitialState::NOT_SIGNALED);
   plugin_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&RunTaskOnRemoteHarness, task, &task_complete));
   task_complete.Wait();
 }
 
 
 }  // namespace proxy
 }  // namespace ppapi