Initialization of audio manager for Android is now done on the audio thread

media/audio/android/audio_android_unittest.cc

 // Copyright 2013 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 "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
+#include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "media/audio/android/audio_manager_android.h"
 #include "media/audio/audio_io.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/audio/mock_audio_source_callback.h"
@@ skipping 382 matching lines @@
   scoped_ptr<media::SeekableBuffer> fifo_;
   scoped_ptr<uint8[]> buffer_;
   bool started_;
 
   DISALLOW_COPY_AND_ASSIGN(FullDuplexAudioSinkSource);
 };
 
 // Test fixture class for tests which only exercise the output path.
 class AudioAndroidOutputTest : public testing::Test {
  public:
-  AudioAndroidOutputTest() {}
+  AudioAndroidOutputTest()
+      : loop_(new base::MessageLoopForUI()),
+        audio_manager_(AudioManager::CreateForTesting()),
+        audio_output_stream_(NULL) {
+  }
+
+  virtual ~AudioAndroidOutputTest() {
+  }
 
  protected:
-  virtual void SetUp() {
-    audio_manager_.reset(AudioManager::CreateForTesting());
-    loop_.reset(new base::MessageLoopForUI());
+  AudioManager* audio_manager() { return audio_manager_.get(); }
+  base::MessageLoopForUI* loop() { return loop_.get(); }
+  const AudioParameters& audio_output_parameters() {
+    return audio_output_parameters_;
   }
 
-  virtual void TearDown() {}
+  // Synchronously runs the provided callback/closure on the audio thread.
+  void RunOnAudioThread(const base::Closure& closure) {
+    if (!audio_manager()->GetTaskRunner()->BelongsToCurrentThread()) {
+      base::WaitableEvent event(false, false);
+      audio_manager()->GetTaskRunner()->PostTask(
+          FROM_HERE,
+          base::Bind(&AudioAndroidOutputTest::RunOnAudioThreadImpl,
+                     base::Unretained(this),
+                     closure,
+                     &event));
+      event.Wait();
+    } else {
+      closure.Run();
+    }
+  }
 
-  AudioManager* audio_manager() { return audio_manager_.get(); }
-  base::MessageLoopForUI* loop() { return loop_.get(); }
+  void RunOnAudioThreadImpl(const base::Closure& closure,
+                            base::WaitableEvent* event) {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    closure.Run();
+    event->Signal();
+  }
 
-  AudioParameters GetDefaultOutputStreamParameters() {
-    return audio_manager()->GetDefaultOutputStreamParameters();
+  void GetDefaultOutputStreamParametersOnAudioThread() {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidOutputTest::GetDefaultOutputStreamParameters,
+                   base::Unretained(this)));
+  }
+
+  void MakeAudioOutputStreamOnAudioThread(const AudioParameters& params) {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidOutputTest::MakeOutputStream,
+                   base::Unretained(this),
+                   params));
+  }
+
+  void OpenAndCloseAudioOutputStreamOnAudioThread() {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidOutputTest::OpenAndClose,
+                   base::Unretained(this)));
+  }
+
+  void OpenAndStartAudioOutputStreamOnAudioThread(
+      AudioOutputStream::AudioSourceCallback* source) {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidOutputTest::OpenAndStart,
+                   base::Unretained(this),
+                   source));
+  }
+
+  void StopAndCloseAudioOutputStreamOnAudioThread() {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidOutputTest::StopAndClose,
+                   base::Unretained(this)));
   }
 
   double AverageTimeBetweenCallbacks(int num_callbacks) const {
     return ((end_time_ - start_time_) / static_cast<double>(num_callbacks - 1))
         .InMillisecondsF();
   }
 
   void StartOutputStreamCallbacks(const AudioParameters& params) {
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
-    AudioOutputStream* stream = audio_manager()->MakeAudioOutputStream(
-        params, std::string());
-    EXPECT_TRUE(stream);
+    MakeAudioOutputStreamOnAudioThread(params);
 
     int count = 0;
     MockAudioSourceCallback source;
 
     EXPECT_CALL(source, OnMoreData(NotNull(), _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
              DoAll(CheckCountAndPostQuitTask(&count, num_callbacks, loop()),
                    Invoke(RealOnMoreData)));
-    EXPECT_CALL(source, OnError(stream)).Times(0);
+    EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
     EXPECT_CALL(source, OnMoreIOData(_, _, _)).Times(0);
 
-    EXPECT_TRUE(stream->Open());
-    stream->Start(&source);
+    OpenAndStartAudioOutputStreamOnAudioThread(&source);
+
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
-    stream->Stop();
-    stream->Close();
+
+    StopAndCloseAudioOutputStreamOnAudioThread();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
     VLOG(0) << "expected time between callbacks: "
             << expected_time_between_callbacks_ms << " ms";
     VLOG(0) << "average time between callbacks: "
             << average_time_between_callbacks_ms << " ms";
     EXPECT_GE(average_time_between_callbacks_ms,
               0.70 * expected_time_between_callbacks_ms);
     EXPECT_LE(average_time_between_callbacks_ms,
               1.30 * expected_time_between_callbacks_ms);
   }
 
+  void GetDefaultOutputStreamParameters() {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    audio_output_parameters_ =
+        audio_manager()->GetDefaultOutputStreamParameters();
+    EXPECT_TRUE(audio_output_parameters_.IsValid());
+  }
+
+  void MakeOutputStream(const AudioParameters& params) {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    audio_output_stream_ = audio_manager()->MakeAudioOutputStream(
+        params, std::string());
+    EXPECT_TRUE(audio_output_stream_);
+  }
+
+  void OpenAndClose() {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    EXPECT_TRUE(audio_output_stream_->Open());
+    audio_output_stream_->Close();
+    audio_output_stream_ = NULL;
+  }
+
+  void OpenAndStart(AudioOutputStream::AudioSourceCallback* source) {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    EXPECT_TRUE(audio_output_stream_->Open());
+    audio_output_stream_->Start(source);
+  }
+
+  void StopAndClose() {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    audio_output_stream_->Stop();
+    audio_output_stream_->Close();
+    audio_output_stream_ = NULL;
+  }
+
   scoped_ptr<base::MessageLoopForUI> loop_;
   scoped_ptr<AudioManager> audio_manager_;
+  AudioParameters audio_output_parameters_;
+  AudioOutputStream* audio_output_stream_;
   base::TimeTicks start_time_;
   base::TimeTicks end_time_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioAndroidOutputTest);
 };
 
 // AudioRecordInputStream should only be created on Jelly Bean and higher. This
 // ensures we only test against the AudioRecord path when that is satisfied.
 std::vector<bool> RunAudioRecordInputPathTests() {
   std::vector<bool> tests;
   tests.push_back(false);
   if (base::android::BuildInfo::GetInstance()->sdk_int() >= 16)
     tests.push_back(true);
   return tests;
 }
 
 // Test fixture class for tests which exercise the input path, or both input and
 // output paths. It is value-parameterized to test against both the Java
 // AudioRecord (when true) and native OpenSLES (when false) input paths.
 class AudioAndroidInputTest : public AudioAndroidOutputTest,
                               public testing::WithParamInterface<bool> {
  public:
-  AudioAndroidInputTest() {}
+  AudioAndroidInputTest() : audio_input_stream_(NULL) {}
 
  protected:
+  const AudioParameters& audio_input_parameters() {
+    return audio_input_parameters_;
+  }
+
   AudioParameters GetInputStreamParameters() {
-    AudioParameters input_params = audio_manager()->GetInputStreamParameters(
-        AudioManagerBase::kDefaultDeviceId);
+    GetDefaultInputStreamParametersOnAudioThread();
+
     // Override the platform effects setting to use the AudioRecord or OpenSLES
     // path as requested.
     int effects = GetParam() ? AudioParameters::ECHO_CANCELLER :
                                AudioParameters::NO_EFFECTS;
-    AudioParameters params(input_params.format(),
-                           input_params.channel_layout(),
-                           input_params.input_channels(),
-                           input_params.sample_rate(),
-                           input_params.bits_per_sample(),
-                           input_params.frames_per_buffer(),
+    AudioParameters params(audio_input_parameters().format(),
+                           audio_input_parameters().channel_layout(),
+                           audio_input_parameters().input_channels(),
+                           audio_input_parameters().sample_rate(),
+                           audio_input_parameters().bits_per_sample(),
+                           audio_input_parameters().frames_per_buffer(),
                            effects);
     return params;
   }
 
+  void GetDefaultInputStreamParametersOnAudioThread() {
+     RunOnAudioThread(
+        base::Bind(&AudioAndroidInputTest::GetDefaultInputStreamParameters,
+                   base::Unretained(this)));
+  }
+
+  void MakeAudioInputStreamOnAudioThread(const AudioParameters& params) {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidInputTest::MakeInputStream,
+                   base::Unretained(this),
+                   params));
+  }
+
+  void OpenAndCloseAudioInputStreamOnAudioThread() {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidInputTest::OpenAndClose,
+                   base::Unretained(this)));
+  }
+
+  void OpenAndStartAudioInputStreamOnAudioThread(
+      AudioInputStream::AudioInputCallback* sink) {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidInputTest::OpenAndStart,
+                   base::Unretained(this),
+                   sink));
+  }
+
+  void StopAndCloseAudioInputStreamOnAudioThread() {
+    RunOnAudioThread(
+        base::Bind(&AudioAndroidInputTest::StopAndClose,
+                   base::Unretained(this)));
+  }
+
   void StartInputStreamCallbacks(const AudioParameters& params) {
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
-    AudioInputStream* stream = audio_manager()->MakeAudioInputStream(
-        params, AudioManagerBase::kDefaultDeviceId);
-    EXPECT_TRUE(stream);
+
+    MakeAudioInputStreamOnAudioThread(params);
 
     int count = 0;
     MockAudioInputCallback sink;
 
     EXPECT_CALL(sink,
-                OnData(stream, NotNull(), params.GetBytesPerBuffer(), _, _))
+                OnData(audio_input_stream_,
+                       NotNull(),
+                       params.
+                       GetBytesPerBuffer(), _, _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
              CheckCountAndPostQuitTask(&count, num_callbacks, loop()));
-    EXPECT_CALL(sink, OnError(stream)).Times(0);
+    EXPECT_CALL(sink, OnError(audio_input_stream_)).Times(0);
 
-    EXPECT_TRUE(stream->Open());
-    stream->Start(&sink);
+    OpenAndStartAudioInputStreamOnAudioThread(&sink);
+
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
-    stream->Stop();
-    stream->Close();
+
+    StopAndCloseAudioInputStreamOnAudioThread();
 
     double average_time_between_callbacks_ms =
         AverageTimeBetweenCallbacks(num_callbacks);
     VLOG(0) << "expected time between callbacks: "
             << expected_time_between_callbacks_ms << " ms";
     VLOG(0) << "average time between callbacks: "
             << average_time_between_callbacks_ms << " ms";
     EXPECT_GE(average_time_between_callbacks_ms,
               0.70 * expected_time_between_callbacks_ms);
     EXPECT_LE(average_time_between_callbacks_ms,
               1.30 * expected_time_between_callbacks_ms);
   }
 
+  void GetDefaultInputStreamParameters() {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    audio_input_parameters_ = audio_manager()->GetInputStreamParameters(
+        AudioManagerBase::kDefaultDeviceId);
+  }
+
+  void MakeInputStream(const AudioParameters& params) {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    audio_input_stream_ = audio_manager()->MakeAudioInputStream(
+        params, AudioManagerBase::kDefaultDeviceId);
+    EXPECT_TRUE(audio_input_stream_);
+  }
+
+  void OpenAndClose() {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    EXPECT_TRUE(audio_input_stream_->Open());
+    audio_input_stream_->Close();
+    audio_input_stream_ = NULL;
+  }
+
+  void OpenAndStart(AudioInputStream::AudioInputCallback* sink) {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    EXPECT_TRUE(audio_input_stream_->Open());
+    audio_input_stream_->Start(sink);
+  }
+
+  void StopAndClose() {
+    DCHECK(audio_manager()->GetTaskRunner()->BelongsToCurrentThread());
+    audio_input_stream_->Stop();
+    audio_input_stream_->Close();
+    audio_input_stream_ = NULL;
+  }
+
+  AudioInputStream* audio_input_stream_;
+  AudioParameters audio_input_parameters_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioAndroidInputTest);
 };
 
 // Get the default audio input parameters and log the result.
 TEST_P(AudioAndroidInputTest, GetDefaultInputStreamParameters) {
   // We don't go through AudioAndroidInputTest::GetInputStreamParameters() here
   // so that we can log the real (non-overridden) values of the effects.
-  AudioParameters params = audio_manager()->GetInputStreamParameters(
-      AudioManagerBase::kDefaultDeviceId);
-  EXPECT_TRUE(params.IsValid());
-  VLOG(1) << params;
+  GetDefaultInputStreamParametersOnAudioThread();
+  EXPECT_TRUE(audio_input_parameters().IsValid());
+  VLOG(1) << audio_input_parameters();
 }
 
 // Get the default audio output parameters and log the result.
 TEST_F(AudioAndroidOutputTest, GetDefaultOutputStreamParameters) {
-  AudioParameters params = GetDefaultOutputStreamParameters();
-  EXPECT_TRUE(params.IsValid());
-  VLOG(1) << params;
-}
-
-// Check if low-latency output is supported and log the result as output.
-TEST_F(AudioAndroidOutputTest, IsAudioLowLatencySupported) {
-  AudioManagerAndroid* manager =
-      static_cast<AudioManagerAndroid*>(audio_manager());
-  bool low_latency = manager->IsAudioLowLatencySupported();
-  low_latency ? VLOG(0) << "Low latency output is supported"
-              : VLOG(0) << "Low latency output is *not* supported";
+  GetDefaultOutputStreamParametersOnAudioThread();
+  VLOG(1) << audio_output_parameters();
 }
 
 // Verify input device enumeration.
 TEST_F(AudioAndroidInputTest, GetAudioInputDeviceNames) {
   if (!audio_manager()->HasAudioInputDevices())
     return;
   AudioDeviceNames devices;
-  audio_manager()->GetAudioInputDeviceNames(&devices);
+  RunOnAudioThread(
+      base::Bind(&AudioManager::GetAudioInputDeviceNames,
+                 base::Unretained(audio_manager()),
+                 &devices));
   CheckDeviceNames(devices);
 }
 
 // Verify output device enumeration.
 TEST_F(AudioAndroidOutputTest, GetAudioOutputDeviceNames) {
   if (!audio_manager()->HasAudioOutputDevices())
     return;
   AudioDeviceNames devices;
-  audio_manager()->GetAudioOutputDeviceNames(&devices);
+  RunOnAudioThread(
+      base::Bind(&AudioManager::GetAudioOutputDeviceNames,
+                 base::Unretained(audio_manager()),
+                 &devices));
   CheckDeviceNames(devices);
 }
 
 // Ensure that a default input stream can be created and closed.
 TEST_P(AudioAndroidInputTest, CreateAndCloseInputStream) {
   AudioParameters params = GetInputStreamParameters();
-  AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
-      params, AudioManagerBase::kDefaultDeviceId);
-  EXPECT_TRUE(ais);
-  ais->Close();
+  MakeAudioInputStreamOnAudioThread(params);
+  RunOnAudioThread(
+      base::Bind(&AudioInputStream::Close,
+                 base::Unretained(audio_input_stream_)));
 }
 
 // Ensure that a default output stream can be created and closed.
 // TODO(henrika): should we also verify that this API changes the audio mode
 // to communication mode, and calls RegisterHeadsetReceiver, the first time
 // it is called?
 TEST_F(AudioAndroidOutputTest, CreateAndCloseOutputStream) {
-  AudioParameters params = GetDefaultOutputStreamParameters();
-  AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string());
-  EXPECT_TRUE(aos);
-  aos->Close();
+  GetDefaultOutputStreamParametersOnAudioThread();
+  MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
+  RunOnAudioThread(
+      base::Bind(&AudioOutputStream::Close,
+                 base::Unretained(audio_output_stream_)));
 }
 
 // Ensure that a default input stream can be opened and closed.
 TEST_P(AudioAndroidInputTest, OpenAndCloseInputStream) {
   AudioParameters params = GetInputStreamParameters();
-  AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
-      params, AudioManagerBase::kDefaultDeviceId);
-  EXPECT_TRUE(ais);
-  EXPECT_TRUE(ais->Open());
-  ais->Close();
+  MakeAudioInputStreamOnAudioThread(params);
+  OpenAndCloseAudioInputStreamOnAudioThread();
 }
 
 // Ensure that a default output stream can be opened and closed.
 TEST_F(AudioAndroidOutputTest, OpenAndCloseOutputStream) {
-  AudioParameters params = GetDefaultOutputStreamParameters();
-  AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string());
-  EXPECT_TRUE(aos);
-  EXPECT_TRUE(aos->Open());
-  aos->Close();
+  GetDefaultOutputStreamParametersOnAudioThread();
+  MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
+  OpenAndCloseAudioOutputStreamOnAudioThread();
 }
 
 // Start input streaming using default input parameters and ensure that the
 // callback sequence is sane.
-// Disabled per crbug/337867
 TEST_P(AudioAndroidInputTest, DISABLED_StartInputStreamCallbacks) {
-  AudioParameters params = GetInputStreamParameters();
-  StartInputStreamCallbacks(params);
+  AudioParameters native_params = GetInputStreamParameters();
+  StartInputStreamCallbacks(native_params);
 }
 
 // Start input streaming using non default input parameters and ensure that the
 // callback sequence is sane. The only change we make in this test is to select
 // a 10ms buffer size instead of the default size.
-// TODO(henrika): possibly add support for more variations.
-// Disabled per crbug/337867
-TEST_P(AudioAndroidInputTest, DISABLED_StartInputStreamCallbacksNonDefaultParameters) {
+TEST_P(AudioAndroidInputTest,
+       DISABLED_StartInputStreamCallbacksNonDefaultParameters) {
   AudioParameters native_params = GetInputStreamParameters();
   AudioParameters params(native_params.format(),
                          native_params.channel_layout(),
                          native_params.input_channels(),
                          native_params.sample_rate(),
                          native_params.bits_per_sample(),
                          native_params.sample_rate() / 100,
                          native_params.effects());
   StartInputStreamCallbacks(params);
 }
 
 // Start output streaming using default output parameters and ensure that the
 // callback sequence is sane.
 TEST_F(AudioAndroidOutputTest, StartOutputStreamCallbacks) {
-  AudioParameters params = GetDefaultOutputStreamParameters();
-  StartOutputStreamCallbacks(params);
+  GetDefaultOutputStreamParametersOnAudioThread();
+  StartOutputStreamCallbacks(audio_output_parameters());
 }
 
 // Start output streaming using non default output parameters and ensure that
 // the callback sequence is sane. The only change we make in this test is to
 // select a 10ms buffer size instead of the default size and to open up the
 // device in mono.
 // TODO(henrika): possibly add support for more variations.
 TEST_F(AudioAndroidOutputTest, StartOutputStreamCallbacksNonDefaultParameters) {
-  AudioParameters native_params = GetDefaultOutputStreamParameters();
-  AudioParameters params(native_params.format(),
+  GetDefaultOutputStreamParametersOnAudioThread();
+  AudioParameters params(audio_output_parameters().format(),
                          CHANNEL_LAYOUT_MONO,
-                         native_params.sample_rate(),
-                         native_params.bits_per_sample(),
-                         native_params.sample_rate() / 100);
+                         audio_output_parameters().sample_rate(),
+                         audio_output_parameters().bits_per_sample(),
+                         audio_output_parameters().sample_rate() / 100);
   StartOutputStreamCallbacks(params);
 }
 
 // Play out a PCM file segment in real time and allow the user to verify that
 // the rendered audio sounds OK.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_F(AudioAndroidOutputTest, DISABLED_RunOutputStreamWithFileAsSource) {
-  AudioParameters params = GetDefaultOutputStreamParameters();
-  VLOG(1) << params;
-  AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string());
-  EXPECT_TRUE(aos);
+  GetDefaultOutputStreamParametersOnAudioThread();
+  VLOG(1) << audio_output_parameters();
+  MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
 
   std::string file_name;
+  const AudioParameters params = audio_output_parameters();
   if (params.sample_rate() == 48000 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_48k;
   } else if (params.sample_rate() == 48000 && params.channels() == 1) {
     file_name = kSpeechFile_16b_m_48k;
   } else if (params.sample_rate() == 44100 && params.channels() == 2) {
     file_name = kSpeechFile_16b_s_44k;
   } else if (params.sample_rate() == 44100 && params.channels() == 1) {
     file_name = kSpeechFile_16b_m_44k;
   } else {
     FAIL() << "This test supports 44.1kHz and 48kHz mono/stereo only.";
     return;
   }
 
   base::WaitableEvent event(false, false);
   FileAudioSource source(&event, file_name);
 
-  EXPECT_TRUE(aos->Open());
-  aos->SetVolume(1.0);
-  aos->Start(&source);
+  OpenAndStartAudioOutputStreamOnAudioThread(&source);
   VLOG(0) << ">> Verify that the file is played out correctly...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
-  aos->Stop();
-  aos->Close();
+  StopAndCloseAudioOutputStreamOnAudioThread();
 }
 
 // Start input streaming and run it for ten seconds while recording to a
 // local audio file.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest, DISABLED_RunSimplexInputStreamWithFileAsSink) {
   AudioParameters params = GetInputStreamParameters();
   VLOG(1) << params;
-  AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
-      params, AudioManagerBase::kDefaultDeviceId);
-  EXPECT_TRUE(ais);
+  MakeAudioInputStreamOnAudioThread(params);
 
   std::string file_name = base::StringPrintf("out_simplex_%d_%d_%d.pcm",
                                              params.sample_rate(),
                                              params.frames_per_buffer(),
                                              params.channels());
 
   base::WaitableEvent event(false, false);
   FileAudioSink sink(&event, params, file_name);
 
-  EXPECT_TRUE(ais->Open());
-  ais->Start(&sink);
+  OpenAndStartAudioInputStreamOnAudioThread(&sink);
   VLOG(0) << ">> Speak into the microphone to record audio...";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
-  ais->Stop();
-  ais->Close();
+  StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 // Same test as RunSimplexInputStreamWithFileAsSink but this time output
 // streaming is active as well (reads zeros only).
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
   AudioParameters in_params = GetInputStreamParameters();
-  AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
-      in_params, AudioManagerBase::kDefaultDeviceId);
-  EXPECT_TRUE(ais);
+  VLOG(1) << in_params;
+  MakeAudioInputStreamOnAudioThread(in_params);
 
-  AudioParameters out_params =
-      audio_manager()->GetDefaultOutputStreamParameters();
-  AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      out_params, std::string());
-  EXPECT_TRUE(aos);
+  GetDefaultOutputStreamParametersOnAudioThread();
+  VLOG(1) << audio_output_parameters();
+  MakeAudioOutputStreamOnAudioThread(audio_output_parameters());
 
   std::string file_name = base::StringPrintf("out_duplex_%d_%d_%d.pcm",
                                              in_params.sample_rate(),
                                              in_params.frames_per_buffer(),
                                              in_params.channels());
 
   base::WaitableEvent event(false, false);
   FileAudioSink sink(&event, in_params, file_name);
   MockAudioSourceCallback source;
 
   EXPECT_CALL(source, OnMoreData(NotNull(), _))
       .WillRepeatedly(Invoke(RealOnMoreData));
-  EXPECT_CALL(source, OnError(aos)).Times(0);
+  EXPECT_CALL(source, OnError(audio_output_stream_)).Times(0);
   EXPECT_CALL(source, OnMoreIOData(_, _, _)).Times(0);
 
-  EXPECT_TRUE(ais->Open());
-  EXPECT_TRUE(aos->Open());
-  ais->Start(&sink);
-  aos->Start(&source);
+  OpenAndStartAudioInputStreamOnAudioThread(&sink);
+  OpenAndStartAudioOutputStreamOnAudioThread(&source);
   VLOG(0) << ">> Speak into the microphone to record audio";
   EXPECT_TRUE(event.TimedWait(TestTimeouts::action_max_timeout()));
-  aos->Stop();
-  ais->Stop();
-  aos->Close();
-  ais->Close();
+  StopAndCloseAudioOutputStreamOnAudioThread();
+  StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 // Start audio in both directions while feeding captured data into a FIFO so
 // it can be read directly (in loopback) by the render side. A small extra
 // delay will be added by the FIFO and an estimate of this delay will be
 // printed out during the test.
 // NOTE: this test requires user interaction and is not designed to run as an
 // automatized test on bots.
 TEST_P(AudioAndroidInputTest,
        DISABLED_RunSymmetricInputAndOutputStreamsInFullDuplex) {
   // Get native audio parameters for the input side.
   AudioParameters default_input_params = GetInputStreamParameters();
 
   // Modify the parameters so that both input and output can use the same
   // parameters by selecting 10ms as buffer size. This will also ensure that
   // the output stream will be a mono stream since mono is default for input
   // audio on Android.
   AudioParameters io_params(default_input_params.format(),
                             default_input_params.channel_layout(),
                             ChannelLayoutToChannelCount(
                                 default_input_params.channel_layout()),
                             default_input_params.sample_rate(),
                             default_input_params.bits_per_sample(),
                             default_input_params.sample_rate() / 100,
                             default_input_params.effects());
   VLOG(1) << io_params;
 
   // Create input and output streams using the common audio parameters.
-  AudioInputStream* ais = audio_manager()->MakeAudioInputStream(
-      io_params, AudioManagerBase::kDefaultDeviceId);
-  EXPECT_TRUE(ais);
-  AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      io_params, std::string());
-  EXPECT_TRUE(aos);
+  MakeAudioInputStreamOnAudioThread(io_params);
+  MakeAudioOutputStreamOnAudioThread(io_params);
 
   FullDuplexAudioSinkSource full_duplex(io_params);
 
   // Start a full duplex audio session and print out estimates of the extra
   // delay we should expect from the FIFO. If real-time delay measurements are
   // performed, the result should be reduced by this extra delay since it is
   // something that has been added by the test.
-  EXPECT_TRUE(ais->Open());
-  EXPECT_TRUE(aos->Open());
-  ais->Start(&full_duplex);
-  aos->Start(&full_duplex);
+  OpenAndStartAudioInputStreamOnAudioThread(&full_duplex);
+  OpenAndStartAudioOutputStreamOnAudioThread(&full_duplex);
   VLOG(1) << "HINT: an estimate of the extra FIFO delay will be updated "
           << "once per second during this test.";
   VLOG(0) << ">> Speak into the mic and listen to the audio in loopback...";
   fflush(stdout);
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
-  aos->Stop();
-  ais->Stop();
-  aos->Close();
-  ais->Close();
+  StopAndCloseAudioOutputStreamOnAudioThread();
+  StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media