clang-tidy WaitableEvent refactor (Windows side)

media/gpu/video_decode_accelerator_unittest.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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 221 matching lines @@
 // Initialize the GPU thread for rendering. We only need to setup once
 // for all test cases.
 class VideoDecodeAcceleratorTestEnvironment : public ::testing::Environment {
  public:
   VideoDecodeAcceleratorTestEnvironment()
       : rendering_thread_("GLRenderingVDAClientThread") {}
 
   void SetUp() override {
     rendering_thread_.Start();
 
-    base::WaitableEvent done(false, false);
+    base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED);
     rendering_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&RenderingHelper::InitializeOneOff, &done));
     done.Wait();
 
 #if defined(USE_OZONE)
     gpu_helper_.reset(new ui::OzoneGpuTestHelper());
     // Need to initialize after the rendering side since the rendering side
     // initializes the "GPU" parts of Ozone.
     //
     // This also needs to be done in the test environment since this shouldn't
@@ skipping 403 matching lines @@
   if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
     pixel_format = media::PIXEL_FORMAT_ARGB;
 
   LOG_ASSERT((pixel_format_ == PIXEL_FORMAT_UNKNOWN) ||
              (pixel_format_ == pixel_format));
   pixel_format_ = pixel_format;
 
   texture_target_ = texture_target;
   for (uint32_t i = 0; i < requested_num_of_buffers; ++i) {
     uint32_t texture_id;
-    base::WaitableEvent done(false, false);
+    base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED);
     rendering_helper_->CreateTexture(texture_target_, &texture_id, dimensions,
                                      &done);
     done.Wait();
 
     scoped_refptr<TextureRef> texture_ref;
     base::Closure delete_texture_cb =
         base::Bind(&RenderingHelper::DeleteTexture,
                    base::Unretained(rendering_helper_), texture_id);
 
     if (g_test_import) {
@@ skipping 434 matching lines @@
 
 void VideoDecodeAcceleratorTest::SetUp() {
   ParseAndReadTestVideoData(g_test_video_data, &test_video_files_);
 }
 
 void VideoDecodeAcceleratorTest::TearDown() {
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&STLDeleteElements<std::vector<TestVideoFile*>>,
                             &test_video_files_));
 
-  base::WaitableEvent done(false, false);
+  base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                           base::WaitableEvent::InitialState::NOT_SIGNALED);
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&RenderingHelper::UnInitialize,
                             base::Unretained(&rendering_helper_), &done));
   done.Wait();
 
   rendering_helper_.TearDown();
 }
 
 void VideoDecodeAcceleratorTest::ParseAndReadTestVideoData(
     base::FilePath::StringType data,
@@ skipping 57 matching lines @@
       video_file->min_fps_render /= num_concurrent_decoders;
     if (video_file->min_fps_no_render != -1)
       video_file->min_fps_no_render /= num_concurrent_decoders;
   }
 }
 
 void VideoDecodeAcceleratorTest::InitializeRenderingHelper(
     const RenderingHelperParams& helper_params) {
   rendering_helper_.Setup();
 
-  base::WaitableEvent done(false, false);
+  base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                           base::WaitableEvent::InitialState::NOT_SIGNALED);
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&RenderingHelper::Initialize,
                  base::Unretained(&rendering_helper_), helper_params, &done));
   done.Wait();
 }
 
 void VideoDecodeAcceleratorTest::CreateAndStartDecoder(
     GLRenderingVDAClient* client,
     ClientStateNotification<ClientState>* note) {
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&GLRenderingVDAClient::CreateAndStartDecoder,
                             base::Unretained(client)));
   ASSERT_EQ(note->Wait(), CS_DECODER_SET);
 }
 
 void VideoDecodeAcceleratorTest::WaitUntilDecodeFinish(
     ClientStateNotification<ClientState>* note) {
   for (int i = 0; i < CS_MAX; i++) {
     if (note->Wait() == CS_DESTROYED)
       break;
   }
 }
 
 void VideoDecodeAcceleratorTest::WaitUntilIdle() {
-  base::WaitableEvent done(false, false);
+  base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                           base::WaitableEvent::InitialState::NOT_SIGNALED);
   g_env->GetRenderingTaskRunner()->PostTask(
       FROM_HERE,
       base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
   done.Wait();
 }
 
 void VideoDecodeAcceleratorTest::OutputLogFile(
     const base::FilePath::CharType* log_path,
     const std::string& content) {
   base::File file(base::FilePath(log_path),
@@ skipping 186 matching lines @@
       int min_fps = suppress_rendering ? video_file->min_fps_no_render
                                        : video_file->min_fps_render;
       if (min_fps > 0 && !test_reuse_delay)
         EXPECT_GT(client->frames_per_second(), min_fps);
     }
   }
 
   if (render_as_thumbnails) {
     std::vector<unsigned char> rgb;
     bool alpha_solid;
-    base::WaitableEvent done(false, false);
+    base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED);
     g_env->GetRenderingTaskRunner()->PostTask(
         FROM_HERE, base::Bind(&RenderingHelper::GetThumbnailsAsRGB,
                               base::Unretained(&rendering_helper_), &rgb,
                               &alpha_solid, &done));
     done.Wait();
 
     std::vector<std::string> golden_md5s;
     std::string md5_string = base::MD5String(
         base::StringPiece(reinterpret_cast<char*>(&rgb[0]), rgb.size()));
     ReadGoldenThumbnailMD5s(test_video_files_[0], &golden_md5s);
@@ skipping 333 matching lines @@
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env =
       reinterpret_cast<media::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }