Reland: Pass task runners to AudioManager constructor.

components/audio_modem/audio_player_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 "components/audio_modem/audio_player.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
-#include "base/single_thread_task_runner.h"
+#include "base/run_loop.h"
+#include "base/test/test_message_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "components/audio_modem/audio_player_impl.h"
 #include "components/audio_modem/public/audio_modem_types.h"
 #include "components/audio_modem/test/random_samples.h"
-#include "media/audio/audio_manager.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_bus.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 class TestAudioOutputStream : public media::AudioOutputStream {
  public:
   using GatherSamplesCallback =
       base::Callback<void(scoped_ptr<media::AudioBus>, int frames)>;
@@ skipping 44 matching lines @@
 };
 
 }  // namespace
 
 namespace audio_modem {
 
 class AudioPlayerTest : public testing::Test,
                         public base::SupportsWeakPtr<AudioPlayerTest> {
  public:
   AudioPlayerTest() : buffer_index_(0), player_(nullptr) {
-    if (!media::AudioManager::Get())
-      media::AudioManager::CreateForTesting();
+    audio_manager_ = media::AudioManager::CreateForTesting(
+        base::ThreadTaskRunnerHandle::Get());
+    base::RunLoop().RunUntilIdle();
   }
 
   ~AudioPlayerTest() override { DeletePlayer(); }
 
   void CreatePlayer() {
     DeletePlayer();
     player_ = new AudioPlayerImpl();
     player_->set_output_stream_for_testing(new TestAudioOutputStream(
         kDefaultFrameCount,
         kMaxFrameCount,
         base::Bind(&AudioPlayerTest::GatherSamples, AsWeakPtr())));
     player_->Initialize();
+    base::RunLoop().RunUntilIdle();
   }
 
   void DeletePlayer() {
     if (!player_)
       return;
     player_->Finalize();
     player_ = nullptr;
+    base::RunLoop().RunUntilIdle();
   }
 
   void PlayAndVerifySamples(
       const scoped_refptr<media::AudioBusRefCounted>& samples) {
     DCHECK_LT(samples->frames(), kMaxFrameCount);
 
     buffer_ = media::AudioBus::Create(1, kMaxFrameCount);
     buffer_index_ = 0;
     player_->Play(samples);
-    player_->FlushAudioLoopForTesting();
     player_->Stop();
+    base::RunLoop().RunUntilIdle();
 
     int differences = 0;
     for (int i = 0; i < kMaxFrameCount; ++i) {
       differences += (buffer_->channel(0)[i] !=
                       samples->channel(0)[i % samples->frames()]);
     }
     ASSERT_EQ(0, differences);
 
     buffer_.reset();
   }
 
   void GatherSamples(scoped_ptr<media::AudioBus> bus, int frames) {
     if (!buffer_.get())
       return;
     bus->CopyPartialFramesTo(0, frames, buffer_index_, buffer_.get());
     buffer_index_ += frames;
   }
 
  protected:
   bool IsPlaying() {
-    player_->FlushAudioLoopForTesting();
+    base::RunLoop().RunUntilIdle();
     return player_->is_playing_;
   }
 
   static const int kDefaultFrameCount = 1024;
   static const int kMaxFrameCount = 1024 * 100;
 
+  base::TestMessageLoop message_loop_;
+  media::ScopedAudioManagerPtr audio_manager_;
   scoped_ptr<media::AudioBus> buffer_;
   int buffer_index_;
 
   // Deleted by calling Finalize() on the object.
   AudioPlayerImpl* player_;
-  base::MessageLoop message_loop_;
 };
 
 TEST_F(AudioPlayerTest, BasicPlayAndStop) {
   CreatePlayer();
   scoped_refptr<media::AudioBusRefCounted> samples =
       media::AudioBusRefCounted::Create(1, 7331);
 
   player_->Play(samples);
   EXPECT_TRUE(IsPlaying());
-  player_->Stop();
-  EXPECT_FALSE(IsPlaying());
-  player_->Play(samples);
 
-  EXPECT_TRUE(IsPlaying());
-  player_->Stop();
-  EXPECT_FALSE(IsPlaying());
-  player_->Play(samples);
-
-  EXPECT_TRUE(IsPlaying());
   player_->Stop();
   EXPECT_FALSE(IsPlaying());
 
+  player_->Play(samples);
+  EXPECT_TRUE(IsPlaying());
+
+  player_->Stop();
+  EXPECT_FALSE(IsPlaying());
+
+  player_->Play(samples);
+  EXPECT_TRUE(IsPlaying());
+
+  player_->Stop();
+  EXPECT_FALSE(IsPlaying());
+
   DeletePlayer();
 }
 
 TEST_F(AudioPlayerTest, OutOfOrderPlayAndStopMultiple) {
   CreatePlayer();
   scoped_refptr<media::AudioBusRefCounted> samples =
       media::AudioBusRefCounted::Create(1, 1337);
 
   player_->Stop();
   player_->Stop();
@@ skipping 28 matching lines @@
 
   PlayAndVerifySamples(
       CreateRandomAudioRefCounted(0x7331, 1, kNumSamples - 3123));
 
   PlayAndVerifySamples(CreateRandomAudioRefCounted(0xf00d, 1, kNumSamples * 2));
 
   DeletePlayer();
 }
 
 }  // namespace audio_modem