Pass task runners to AudioManager constructor.

components/audio_modem/audio_recorder_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_recorder.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
 #include "base/run_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/audio_modem/audio_recorder_impl.h"
 #include "components/audio_modem/public/audio_modem_types.h"
 #include "components/audio_modem/test/random_samples.h"
 #include "content/public/test/test_browser_thread_bundle.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"
 
@@ skipping 50 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestAudioInputStream);
 };
 
 }  // namespace
 
 namespace audio_modem {
 
 class AudioRecorderTest : public testing::Test {
  public:
   AudioRecorderTest() : total_samples_(0), recorder_(nullptr) {
-    if (!media::AudioManager::Get())
-      media::AudioManager::CreateForTesting();
+    audio_manager_ = media::AudioManager::CreateForTesting(
+        base::ThreadTaskRunnerHandle::Get());
+    base::RunLoop().RunUntilIdle();
   }
 
   ~AudioRecorderTest() override {
     DeleteRecorder();
     for (size_t i = 0; i < channel_data_.size(); ++i)
       base::AlignedFree(channel_data_[i]);
   }
 
   void CreateSimpleRecorder() {
     // If we have input devices, we'll create a recorder which uses a real
     // input stream, if not, we'll create a recorder which uses our mock input
     // stream.
     if (media::AudioManager::Get()->HasAudioInputDevices()) {
       DeleteRecorder();
       recorder_ = new AudioRecorderImpl();
       recorder_->Initialize(base::Bind(&AudioRecorderTest::DecodeSamples,
                                        base::Unretained(this)));
+      base::RunLoop().RunUntilIdle();
     } else {
       CreateRecorder(kSomeNumber);
     }
   }
 
   void CreateRecorder(size_t samples) {
     DeleteRecorder();
 
     params_ = media::AudioManager::Get()->GetInputStreamParameters(
         media::AudioManagerBase::kDefaultDeviceId);
 
     channel_data_.clear();
     channel_data_.push_back(GenerateSamples(0x1337, samples));
     channel_data_.push_back(GenerateSamples(0x7331, samples));
 
     total_samples_ = samples;
 
     recorder_ = new AudioRecorderImpl();
     recorder_->set_input_stream_for_testing(
         new TestAudioInputStream(params_, channel_data_, samples));
     recorder_->set_params_for_testing(new media::AudioParameters(params_));
     recorder_->Initialize(
         base::Bind(&AudioRecorderTest::DecodeSamples, base::Unretained(this)));
+    base::RunLoop().RunUntilIdle();
   }
 
   void DeleteRecorder() {
     if (!recorder_)
       return;
     recorder_->Finalize();
     recorder_ = nullptr;
+    base::RunLoop().RunUntilIdle();
   }
 
   void RecordAndVerifySamples() {
     received_samples_.clear();
     run_loop_.reset(new base::RunLoop());
     recorder_->Record();
     run_loop_->Run();
   }
 
   void DecodeSamples(const std::string& samples) {
@@ skipping 32 matching lines @@
   }
 
  protected:
   float* GenerateSamples(int random_seed, size_t size) {
     float* samples = static_cast<float*>(base::AlignedAlloc(
         size * sizeof(float), media::AudioBus::kChannelAlignment));
     PopulateSamples(0x1337, size, samples);
     return samples;
   }
   bool IsRecording() {
-    recorder_->FlushAudioLoopForTesting();
+    base::RunLoop().RunUntilIdle();
     return recorder_->is_recording_;
   }
 
+  content::TestBrowserThreadBundle thread_bundle_;
+  media::ScopedAudioManagerPtr audio_manager_;
+
   std::vector<float*> channel_data_;
   media::AudioParameters params_;
   size_t total_samples_;
 
   // Deleted by calling Finalize() on the object.
   AudioRecorderImpl* recorder_;
 
   std::string received_samples_;
 
   scoped_ptr<base::RunLoop> run_loop_;
-  content::TestBrowserThreadBundle thread_bundle_;
 };
 
 
 // http://crbug.com/463854
 #if defined(OS_MACOSX)
 #define MAYBE_BasicRecordAndStop DISABLED_BasicRecordAndStop
 #else
 #define MAYBE_BasicRecordAndStop BasicRecordAndStop
 #endif
 
 TEST_F(AudioRecorderTest, MAYBE_BasicRecordAndStop) {
   CreateSimpleRecorder();
 
   recorder_->Record();
   EXPECT_TRUE(IsRecording());
-  recorder_->Stop();
-  EXPECT_FALSE(IsRecording());
-  recorder_->Record();
 
-  EXPECT_TRUE(IsRecording());
-  recorder_->Stop();
-  EXPECT_FALSE(IsRecording());
-  recorder_->Record();
-
-  EXPECT_TRUE(IsRecording());
   recorder_->Stop();
   EXPECT_FALSE(IsRecording());
 
+  recorder_->Record();
+  EXPECT_TRUE(IsRecording());
+
+  recorder_->Stop();
+  EXPECT_FALSE(IsRecording());
+
+  recorder_->Record();
+  EXPECT_TRUE(IsRecording());
+
+  recorder_->Stop();
+  EXPECT_FALSE(IsRecording());
+
   DeleteRecorder();
 }
 
 // http://crbug.com/460685
 #if defined(OS_MACOSX)
 #define MAYBE_OutOfOrderRecordAndStopMultiple \
   DISABLED_OutOfOrderRecordAndStopMultiple
 #else
 #define MAYBE_OutOfOrderRecordAndStopMultiple \
   OutOfOrderRecordAndStopMultiple
@@ skipping 23 matching lines @@
   CreateRecorder(kNumSamples);
 
   RecordAndVerifySamples();
 
   DeleteRecorder();
 }
 
 // TODO(rkc): Add tests with recording different sample rates.
 
 }  // namespace audio_modem