Reland: Pass task runners to AudioManager constructor.

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"
 
@@ skipping 153 matching lines @@
     return audio_bus->frames();
   }
   void OnError(::media::AudioOutputStream* stream) override { error_ = true; }
 
  private:
   bool error_;
 };
 
 class FakeAudioManager : public CastAudioManager {
  public:
-  FakeAudioManager()
-      : CastAudioManager(nullptr, nullptr), media_pipeline_backend_(nullptr) {}
+  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(!media_pipeline_backend_);
 
     std::unique_ptr<FakeMediaPipelineBackend> backend(
         new FakeMediaPipelineBackend());
@@ skipping 25 matching lines @@
         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_manager_.reset(new FakeAudioManager);
-    audio_task_runner_ = audio_manager_->GetTaskRunner();
+    audio_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     backend_task_runner_ = media::MediaMessageLoop::GetTaskRunner();
+    audio_manager_.reset(new FakeAudioManager(audio_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() {
-    ::media::AudioOutputStream* stream = nullptr;
-
-    base::WaitableEvent completion_event(false, false);
-    audio_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&CastAudioOutputStreamTest::CreateStreamOnAudioThread,
-                   base::Unretained(this), GetAudioParams(), &stream,
-                   &completion_event));
-    completion_event.Wait();
-
-    return stream;
+    return audio_manager_->MakeAudioOutputStream(GetAudioParams(),
+                                                 kDefaultDeviceId);
   }
   bool OpenStream(::media::AudioOutputStream* stream) {
-    DCHECK(stream);
-
-    bool success = false;
-    base::WaitableEvent completion_event(false, false);
-    audio_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&CastAudioOutputStreamTest::OpenStreamOnAudioThread,
-                   base::Unretained(this), stream, &success,
-                   &completion_event));
-    completion_event.Wait();
-
+    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) {
-    audio_task_runner_->PostTask(FROM_HERE,
-                                 base::Bind(&::media::AudioOutputStream::Close,
-                                            base::Unretained(stream)));
-    RunUntilIdle(audio_task_runner_.get());
+    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.
-    RunUntilIdle(audio_task_runner_.get());
+    message_loop_.RunUntilIdle();
   }
   void StartStream(
       ::media::AudioOutputStream* stream,
       ::media::AudioOutputStream::AudioSourceCallback* source_callback) {
-    audio_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&::media::AudioOutputStream::Start,
-                              base::Unretained(stream), source_callback));
-    // Drain the audio task runner twice so that tasks posted by
+    stream->Start(source_callback);
+    // Drain the audio task runner so that tasks posted by
     // media::AudioOutputStream::Start are run as well.
-    RunUntilIdle(audio_task_runner_.get());
-    RunUntilIdle(audio_task_runner_.get());
+    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.
-    RunUntilIdle(audio_task_runner_.get());
+    message_loop_.RunUntilIdle();
   }
   void StopStream(::media::AudioOutputStream* stream) {
-    audio_task_runner_->PostTask(FROM_HERE,
-                                 base::Bind(&::media::AudioOutputStream::Stop,
-                                            base::Unretained(stream)));
-    RunUntilIdle(audio_task_runner_.get());
+    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) {
-    audio_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&::media::AudioOutputStream::SetVolume,
-                              base::Unretained(stream), volume));
-    RunUntilIdle(audio_task_runner_.get());
+    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;
-    audio_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&::media::AudioOutputStream::GetVolume,
-                              base::Unretained(stream), &volume));
-    RunUntilIdle(audio_task_runner_.get());
+    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 CreateStreamOnAudioThread(const ::media::AudioParameters& audio_params,
-                                 ::media::AudioOutputStream** stream,
-                                 base::WaitableEvent* completion_event) {
-    DCHECK(audio_task_runner_->BelongsToCurrentThread());
-    *stream = audio_manager_->MakeAudioOutputStream(GetAudioParams(),
-                                                    kDefaultDeviceId);
-    completion_event->Signal();
-  }
-  void OpenStreamOnAudioThread(::media::AudioOutputStream* stream,
-                               bool* success,
-                               base::WaitableEvent* completion_event) {
-    DCHECK(audio_task_runner_->BelongsToCurrentThread());
-    *success = stream->Open();
-    completion_event->Signal();
+  void RunAudioLoopFor(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_;
@@ skipping 99 matching lines @@
 
   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);
 
   // 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());
@@ skipping 22 matching lines @@
       new FakeAudioSourceCallback);
   StartStream(stream, source_callback.get());
 
   // 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.
-  ::media::AudioParameters audio_params = GetAudioParams();
-  base::TimeDelta pause = audio_params.GetBufferDuration() * 5;
-  base::PlatformThread::Sleep(pause);
-  RunUntilIdle(audio_task_runner_.get());
+  RunAudioLoopFor(5);
   RunUntilIdle(backend_task_runner_.get());
   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));
-
-  base::PlatformThread::Sleep(pause);
-  RunUntilIdle(audio_task_runner_.get());
+  RunAudioLoopFor(5);
   RunUntilIdle(backend_task_runner_.get());
   EXPECT_LT(1u, audio_decoder->pushed_buffer_count());
   EXPECT_FALSE(source_callback->error());
 
   StopStream(stream);
   CloseStream(stream);
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_TRUE(OpenStream(stream));
 
   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);
 
   // 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);
 }
 
 TEST_F(CastAudioOutputStreamTest, DeviceAsyncError) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   EXPECT_TRUE(OpenStream(stream));
 
   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);
 
   // 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));
 
-  RunUntilIdle(audio_task_runner_.get());
+  RunAudioLoopFor(5);
   RunUntilIdle(backend_task_runner_.get());
   // AudioOutputStream must report error to source callback.
   EXPECT_TRUE(source_callback->error());
 
   StopStream(stream);
   CloseStream(stream);
 }
 
 TEST_F(CastAudioOutputStreamTest, Volume) {
   ::media::AudioOutputStream* stream = CreateStream();
@@ skipping 14 matching lines @@
   CloseStream(stream);
 }
 
 TEST_F(CastAudioOutputStreamTest, StartStopStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   ASSERT_TRUE(OpenStream(stream));
 
   std::unique_ptr<FakeAudioSourceCallback> source_callback(
       new FakeAudioSourceCallback);
-  audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&::media::AudioOutputStream::Start,
-                            base::Unretained(stream), source_callback.get()));
-  audio_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&::media::AudioOutputStream::Stop, base::Unretained(stream)));
-  audio_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&::media::AudioOutputStream::Start,
-                            base::Unretained(stream), source_callback.get()));
-  RunUntilIdle(audio_task_runner_.get());
+  stream->Start(source_callback.get());
+  RunAudioLoopFor(2);
+  stream->Stop();
+  stream->Start(source_callback.get());
+  RunAudioLoopFor(2);
   RunUntilIdle(backend_task_runner_.get());
 
   FakeAudioDecoder* audio_device = GetAudio();
   EXPECT_TRUE(audio_device);
   EXPECT_EQ(FakeMediaPipelineBackend::kStateRunning, GetBackend()->state());
 
   CloseStream(stream);
 }
 
 TEST_F(CastAudioOutputStreamTest, CloseWithoutStart) {
   ::media::AudioOutputStream* stream = CreateStream();
   ASSERT_TRUE(stream);
   ASSERT_TRUE(OpenStream(stream));
   CloseStream(stream);
 }
 
 }  // namespace
 }  // namespace media
 }  // namespace chromecast