[chromecast] Simplify CastAudioOutputStream.

chromecast/media/audio/cast_audio_output_stream_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 "chromecast/media/audio/cast_audio_output_stream.h"
 
-#include <stddef.h>
-#include <stdint.h>
-#include <utility>
-
-#include "base/bind.h"
-#include "base/macros.h"
 #include "base/run_loop.h"
-#include "base/synchronization/waitable_event.h"
-#include "base/thread_task_runner_handle.h"
 #include "chromecast/base/metrics/cast_metrics_test_helper.h"
 #include "chromecast/media/audio/cast_audio_manager.h"
-#include "chromecast/media/base/media_message_loop.h"
-#include "chromecast/media/cma/backend/media_pipeline_backend_default.h"
 #include "chromecast/public/media/cast_decoder_buffer.h"
-#include "chromecast/public/media/decoder_config.h"
-#include "chromecast/public/media/decrypt_context.h"
 #include "chromecast/public/media/media_pipeline_backend.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromecast {
 namespace media {
 namespace {
 const char kDefaultDeviceId[] = "";
 
-void RunUntilIdle(base::TaskRunner* task_runner) {
-  base::WaitableEvent completion_event(false, false);
-  task_runner->PostTask(FROM_HERE,
-                        base::Bind(&base::WaitableEvent::Signal,
-                                   base::Unretained(&completion_event)));
-  completion_event.Wait();
-}
-
 class FakeAudioDecoder : public MediaPipelineBackend::AudioDecoder {
  public:
   enum PipelineStatus {
     PIPELINE_STATUS_OK,
     PIPELINE_STATUS_BUSY,
     PIPELINE_STATUS_ERROR,
     PIPELINE_STATUS_ASYNC_ERROR,
   };
 
   FakeAudioDecoder()
@@ skipping 138 matching lines @@
 class FakeAudioManager : public CastAudioManager {
  public:
   FakeAudioManager(scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : CastAudioManager(task_runner, task_runner, nullptr, nullptr),
         media_pipeline_backend_(nullptr) {}
   ~FakeAudioManager() override {}
 
   // CastAudioManager overrides.
   std::unique_ptr<MediaPipelineBackend> CreateMediaPipelineBackend(
       const MediaPipelineDeviceParams& params) override {
-    DCHECK(media::MediaMessageLoop::GetTaskRunner()->BelongsToCurrentThread());
+    DCHECK(GetTaskRunner()->BelongsToCurrentThread());
     DCHECK(!media_pipeline_backend_);
 
     std::unique_ptr<FakeMediaPipelineBackend> backend(
         new FakeMediaPipelineBackend());
     // Cache the backend locally to be used by tests.
     media_pipeline_backend_ = backend.get();
     return std::move(backend);
   }
   void ReleaseOutputStream(::media::AudioOutputStream* stream) override {
     DCHECK(media_pipeline_backend_);
@@ skipping 18 matching lines @@
       : format_(::media::AudioParameters::AUDIO_PCM_LINEAR),
         channel_layout_(::media::CHANNEL_LAYOUT_MONO),
         sample_rate_(::media::AudioParameters::kAudioCDSampleRate),
         bits_per_sample_(16),
         frames_per_buffer_(256) {}
   ~CastAudioOutputStreamTest() override {}
 
  protected:
   void SetUp() override {
     metrics::InitializeMetricsHelperForTesting();
-
-    audio_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    backend_task_runner_ = media::MediaMessageLoop::GetTaskRunner();
-    audio_manager_.reset(new FakeAudioManager(audio_task_runner_));
+    audio_manager_.reset(new FakeAudioManager(message_loop_.task_runner()));
   }
 
   void TearDown() override {
     audio_manager_.reset();
   }
 
   ::media::AudioParameters GetAudioParams() {
     return ::media::AudioParameters(format_, channel_layout_, sample_rate_,
                                     bits_per_sample_, frames_per_buffer_);
   }
 
   FakeMediaPipelineBackend* GetBackend() {
     return audio_manager_->media_pipeline_backend();
   }
 
   FakeAudioDecoder* GetAudio() {
     FakeMediaPipelineBackend* backend = GetBackend();
     return (backend ? backend->decoder() : nullptr);
   }
 
-  // Synchronous utility functions.
   ::media::AudioOutputStream* CreateStream() {
     return audio_manager_->MakeAudioOutputStream(GetAudioParams(),
                                                  kDefaultDeviceId);
   }
-  bool OpenStream(::media::AudioOutputStream* stream) {
-    bool success = stream->Open();
-    // Drain the backend task runner so that appropriate states are set on
-    // the backend pipeline devices.
-    RunUntilIdle(backend_task_runner_.get());
-    return success;
-  }
-  void CloseStream(::media::AudioOutputStream* stream) {
-    stream->Close();
-    RunUntilIdle(backend_task_runner_.get());
-    // Backend task runner may have posted more tasks to the audio task runner.
-    // So we need to drain it once more.
-    message_loop_.RunUntilIdle();
-  }
-  void StartStream(
-      ::media::AudioOutputStream* stream,
-      ::media::AudioOutputStream::AudioSourceCallback* source_callback) {
-    stream->Start(source_callback);
-    // Drain the audio task runner so that tasks posted by
-    // media::AudioOutputStream::Start are run as well.
-    message_loop_.RunUntilIdle();
-    // Drain the backend task runner so that appropriate states are set on
-    // the backend pipeline devices.
-    RunUntilIdle(backend_task_runner_.get());
-    // Drain the audio task runner again to run the tasks posted by the
-    // backend on audio task runner.
-    message_loop_.RunUntilIdle();
-  }
-  void StopStream(::media::AudioOutputStream* stream) {
-    stream->Stop();
-    // Drain the backend task runner so that appropriate states are set on
-    // the backend pipeline devices.
-    RunUntilIdle(backend_task_runner_.get());
-  }
-  void SetStreamVolume(::media::AudioOutputStream* stream, double volume) {
-    stream->SetVolume(volume);
-    // Drain the backend task runner so that appropriate states are set on
-    // the backend pipeline devices.
-    RunUntilIdle(backend_task_runner_.get());
-  }
-  double GetStreamVolume(::media::AudioOutputStream* stream) {
-    double volume = 0.0;
-    stream->GetVolume(&volume);
-    // No need to drain the backend task runner because getting the volume
-    // does not involve posting any task to the backend.
-    return volume;
-  }
 
-  void RunAudioLoopFor(int frames) {
+  // Runs the messsage loop for duration equivalent to the given number of
+  // audio |frames|.
+  void RunMessageLoopFor(int frames) {
     ::media::AudioParameters audio_params = GetAudioParams();
     base::TimeDelta duration = audio_params.GetBufferDuration() * frames;
 
     base::RunLoop run_loop;
     message_loop_.task_runner()->PostDelayedTask(
         FROM_HERE, run_loop.QuitClosure(), duration);
     run_loop.Run();
   }
 
   base::MessageLoop message_loop_;
   std::unique_ptr<FakeAudioManager> audio_manager_;
-  scoped_refptr<base::SingleThreadTaskRunner> audio_task_runner_;
-  scoped_refptr<base::SingleThreadTaskRunner> backend_task_runner_;
-
   // AudioParameters used to create AudioOutputStream.
   // Tests can modify these parameters before calling CreateStream.
   ::media::AudioParameters::Format format_;
   ::media::ChannelLayout channel_layout_;
   int sample_rate_;
   int bits_per_sample_;
   int frames_per_buffer_;
 };
 
 TEST_F(CastAudioOutputStreamTest, Format) {
   ::media::AudioParameters::Format format[] = {
       //::media::AudioParameters::AUDIO_PCM_LINEAR,
       ::media::AudioParameters::AUDIO_PCM_LOW_LATENCY};
   for (size_t i = 0; i < arraysize(format); ++i) {
     format_ = format[i];
     ::media::AudioOutputStream* stream = CreateStream();
     ASSERT_TRUE(stream);
-    EXPECT_TRUE(OpenStream(stream));
+    EXPECT_TRUE(stream->Open());
 
     FakeAudioDecoder* audio_decoder = GetAudio();
     ASSERT_TRUE(audio_decoder);
     const AudioConfig& audio_config = audio_decoder->config();
     EXPECT_EQ(kCodecPCM, audio_config.codec);
     EXPECT_EQ(kSampleFormatS16, audio_config.sample_format);
     EXPECT_FALSE(audio_config.encryption_scheme.is_encrypted());
 
-    CloseStream(stream);
+    stream->Close();
   }
 }
 
 TEST_F(CastAudioOutputStreamTest, ChannelLayout) {
   ::media::ChannelLayout layout[] = {::media::CHANNEL_LAYOUT_MONO,
                                      ::media::CHANNEL_LAYOUT_STEREO};
   for (size_t i = 0; i < arraysize(layout); ++i) {
     channel_layout_ = layout[i];
     ::media::AudioOutputStream* stream = CreateStream();
     ASSERT_TRUE(stream);
-    EXPECT_TRUE(OpenStream(stream));
+    EXPECT_TRUE(stream->Open());
 
     FakeAudioDecoder* audio_decoder = GetAudio();
     ASSERT_TRUE(audio_decoder);
     const AudioConfig& audio_config = audio_decoder->config();
     EXPECT_EQ(::media::ChannelLayoutToChannelCount(channel_layout_),
               audio_config.channel_number);
 
-    CloseStream(stream);
+    stream->Close();
   }
 }
 
 TEST_F(CastAudioOutputStreamTest, SampleRate) {
   sample_rate_ = ::media::AudioParameters::kAudioCDSampleRate;
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   const AudioConfig& audio_config = audio_decoder->config();
   EXPECT_EQ(sample_rate_, audio_config.samples_per_second);
 
-  CloseStream(stream);
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, BitsPerSample) {
   bits_per_sample_ = 16;
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   const AudioConfig& audio_config = audio_decoder->config();
   EXPECT_EQ(bits_per_sample_ / 8, audio_config.bytes_per_channel);
 
-  CloseStream(stream);
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceState) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_FALSE(GetAudio());
 
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   FakeMediaPipelineBackend* backend = GetBackend();
   ASSERT_TRUE(backend);
   EXPECT_EQ(FakeMediaPipelineBackend::kStateStopped, backend->state());
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
-  StartStream(stream, source_callback.get());
+  stream->Start(source_callback.get());
   EXPECT_EQ(FakeMediaPipelineBackend::kStateRunning, backend->state());
 
-  StopStream(stream);
+  stream->Stop();
   EXPECT_EQ(FakeMediaPipelineBackend::kStatePaused, backend->state());
 
-  CloseStream(stream);
+  stream->Close();
   EXPECT_FALSE(GetAudio());
 }
 
 TEST_F(CastAudioOutputStreamTest, PushFrame) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   // Verify initial state.
   EXPECT_EQ(0u, audio_decoder->pushed_buffer_count());
   EXPECT_FALSE(audio_decoder->last_buffer());
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
-  StartStream(stream, source_callback.get());
-  RunAudioLoopFor(2);
-  StopStream(stream);
+  stream->Start(source_callback.get());
+  RunMessageLoopFor(2);
+  stream->Stop();
 
   // Verify that the stream pushed frames to the backend.
   EXPECT_LT(0u, audio_decoder->pushed_buffer_count());
   EXPECT_TRUE(audio_decoder->last_buffer());
 
   // Verify decoder buffer.
   ::media::AudioParameters audio_params = GetAudioParams();
   const size_t expected_frame_size =
       static_cast<size_t>(audio_params.GetBytesPerBuffer());
   const CastDecoderBuffer* buffer = audio_decoder->last_buffer();
   EXPECT_TRUE(buffer->data());
   EXPECT_EQ(expected_frame_size, buffer->data_size());
   EXPECT_FALSE(buffer->decrypt_config());  // Null because of raw audio.
   EXPECT_FALSE(buffer->end_of_stream());
 
   // No error must be reported to source callback.
   EXPECT_FALSE(source_callback->error());
 
-  CloseStream(stream);
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceBusy) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   audio_decoder->set_pipeline_status(FakeAudioDecoder::PIPELINE_STATUS_BUSY);
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
-  StartStream(stream, source_callback.get());
-
+  stream->Start(source_callback.get());
+  RunMessageLoopFor(5);
   // Make sure that one frame was pushed.
   EXPECT_EQ(1u, audio_decoder->pushed_buffer_count());
   // No error must be reported to source callback.
   EXPECT_FALSE(source_callback->error());
 
   // Sleep for a few frames and verify that more frames were not pushed
   // because the backend device was busy.
-  RunAudioLoopFor(5);
-  RunUntilIdle(backend_task_runner_.get());
+  RunMessageLoopFor(5);
   EXPECT_EQ(1u, audio_decoder->pushed_buffer_count());
 
   // Unblock the pipeline and verify that PushFrame resumes.
-  // (have to post because this directly calls buffer complete)
-  backend_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&FakeAudioDecoder::set_pipeline_status,
-                 base::Unretained(audio_decoder),
-                 FakeAudioDecoder::PIPELINE_STATUS_OK));
-  RunAudioLoopFor(5);
-  RunUntilIdle(backend_task_runner_.get());
+  audio_decoder->set_pipeline_status(FakeAudioDecoder::PIPELINE_STATUS_OK);
+  RunMessageLoopFor(5);
   EXPECT_LT(1u, audio_decoder->pushed_buffer_count());
   EXPECT_FALSE(source_callback->error());
 
-  StopStream(stream);
-  CloseStream(stream);
+  stream->Stop();
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   audio_decoder->set_pipeline_status(FakeAudioDecoder::PIPELINE_STATUS_ERROR);
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
-  StartStream(stream, source_callback.get());
-  RunAudioLoopFor(2);
-
+  stream->Start(source_callback.get());
+  RunMessageLoopFor(2);
   // Make sure that AudioOutputStream attempted to push the initial frame.
   EXPECT_LT(0u, audio_decoder->pushed_buffer_count());
   // AudioOutputStream must report error to source callback.
   EXPECT_TRUE(source_callback->error());
 
-  StopStream(stream);
-  CloseStream(stream);
+  stream->Stop();
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceAsyncError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  EXPECT_TRUE(OpenStream(stream));
+  EXPECT_TRUE(stream->Open());
 
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
   audio_decoder->set_pipeline_status(
       FakeAudioDecoder::PIPELINE_STATUS_ASYNC_ERROR);
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
-  StartStream(stream, source_callback.get());
-  RunAudioLoopFor(5);
+  stream->Start(source_callback.get());
+  RunMessageLoopFor(5);
 
   // Make sure that one frame was pushed.
   EXPECT_EQ(1u, audio_decoder->pushed_buffer_count());
-
-  // Unblock the pipeline and verify that PushFrame resumes.
-  // (have to post because this directly calls buffer complete)
-  backend_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&FakeAudioDecoder::set_pipeline_status,
-                 base::Unretained(audio_decoder),
-                 FakeAudioDecoder::PIPELINE_STATUS_OK));
-
-  RunAudioLoopFor(5);
-  RunUntilIdle(backend_task_runner_.get());
   // AudioOutputStream must report error to source callback.
   EXPECT_TRUE(source_callback->error());
 
-  StopStream(stream);
-  CloseStream(stream);
+  stream->Stop();
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, Volume) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(OpenStream(stream));
+  ASSERT_TRUE(stream->Open());
   FakeAudioDecoder* audio_decoder = GetAudio();
   ASSERT_TRUE(audio_decoder);
 
-  double volume = GetStreamVolume(stream);
+  double volume = 0.0;
+  stream->GetVolume(&volume);
   EXPECT_EQ(1.0, volume);
   EXPECT_EQ(1.0f, audio_decoder->volume());
 
-  SetStreamVolume(stream, 0.5);
-  volume = GetStreamVolume(stream);
+  stream->SetVolume(0.5);
+  stream->GetVolume(&volume);
   EXPECT_EQ(0.5, volume);
   EXPECT_EQ(0.5f, audio_decoder->volume());
 
-  CloseStream(stream);
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, StartStopStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(OpenStream(stream));
+  ASSERT_TRUE(stream->Open());
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
   stream->Start(source_callback.get());
-  RunAudioLoopFor(2);
+  RunMessageLoopFor(2);
   stream->Stop();
   stream->Start(source_callback.get());
-  RunAudioLoopFor(2);
-  RunUntilIdle(backend_task_runner_.get());
+  RunMessageLoopFor(2);
 
   FakeAudioDecoder* audio_device = GetAudio();
   EXPECT_TRUE(audio_device);
   EXPECT_EQ(FakeMediaPipelineBackend::kStateRunning, GetBackend()->state());
 
-  CloseStream(stream);
+  stream->Close();
 }
 
 TEST_F(CastAudioOutputStreamTest, CloseWithoutStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
-  ASSERT_TRUE(OpenStream(stream));
-  CloseStream(stream);
+  ASSERT_TRUE(stream->Open());
+  stream->Close();
 }
 
 }  // namespace
 }  // namespace media
 }  // namespace chromecast