Migrate WaitableEvent to enum-based constructor in media/

media/audio/virtual_audio_input_stream_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.
 
 #include <stdint.h>
 
 #include <list>
 #include <memory>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 namespace media {
 
 namespace {
 
 const AudioParameters kParams(
     AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO, 8000, 8, 10);
 
 class MockInputCallback : public AudioInputStream::AudioInputCallback {
  public:
   MockInputCallback()
-      : data_pushed_(false, false) {
+      : data_pushed_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                     base::WaitableEvent::InitialState::NOT_SIGNALED) {
     ON_CALL(*this, OnData(_, _, _, _)).WillByDefault(
         InvokeWithoutArgs(&data_pushed_, &base::WaitableEvent::Signal));
   }
 
   virtual ~MockInputCallback() {}
 
   MOCK_METHOD4(OnData,
                void(AudioInputStream* stream,
                     const AudioBus* source,
                     uint32_t hardware_delay_bytes,
                     double volume));
   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
 
   void WaitForDataPushes() {
     for (int i = 0; i < 3; ++i) {
       data_pushed_.Wait();
     }
   }
 
  private:
   base::WaitableEvent data_pushed_;
 
   DISALLOW_COPY_AND_ASSIGN(MockInputCallback);
 };
 
 class TestAudioSource : public SineWaveAudioSource {
  public:
   TestAudioSource()
-      : SineWaveAudioSource(
-            kParams.channel_layout(), 200.0, kParams.sample_rate()),
-        data_pulled_(false, false) {}
+      : SineWaveAudioSource(kParams.channel_layout(),
+                            200.0,
+                            kParams.sample_rate()),
+        data_pulled_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                     base::WaitableEvent::InitialState::NOT_SIGNALED) {}
 
   ~TestAudioSource() override {}
 
   int OnMoreData(AudioBus* audio_bus,
                  uint32_t total_bytes_delay,
                  uint32_t frames_skipped) override {
     const int ret = SineWaveAudioSource::OnMoreData(
         audio_bus, total_bytes_delay, frames_skipped);
     data_pulled_.Signal();
     return ret;
@@ skipping 12 matching lines @@
 };
 
 }  // namespace
 
 class VirtualAudioInputStreamTest : public testing::TestWithParam<bool> {
  public:
   VirtualAudioInputStreamTest()
       : audio_thread_(new base::Thread("AudioThread")),
         worker_thread_(new base::Thread("AudioWorkerThread")),
         stream_(NULL),
-        closed_stream_(false, false) {
+        closed_stream_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                       base::WaitableEvent::InitialState::NOT_SIGNALED) {
     audio_thread_->Start();
     audio_task_runner_ = audio_thread_->task_runner();
   }
 
   virtual ~VirtualAudioInputStreamTest() {
     SyncWithAudioThread();
 
     DCHECK(output_streams_.empty());
     DCHECK(stopped_output_streams_.empty());
   }
@@ skipping 102 matching lines @@
         worker_task_runner_ = worker_thread_->task_runner();
       }
       return worker_task_runner_;
     } else {
       return audio_task_runner_;
     }
   }
 
  private:
   void SyncWithAudioThread() {
-    base::WaitableEvent done(false, false);
+    base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
+                             base::WaitableEvent::InitialState::NOT_SIGNALED);
     audio_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
     done.Wait();
   }
 
   std::unique_ptr<base::Thread> audio_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
   std::unique_ptr<base::Thread> worker_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> worker_task_runner_;
@@ skipping 107 matching lines @@
   }
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
 INSTANTIATE_TEST_CASE_P(SingleVersusMultithreaded,
                         VirtualAudioInputStreamTest,
                         ::testing::Values(false, true));
 
 }  // namespace media