Rejigger audio capture pipeline to work with separate main+worker threads (Mac).

media/audio/virtual_audio_input_stream_unittest.cc

 // Copyright (c) 2012 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 <list>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
@@ skipping 79 matching lines @@
   }
 
  private:
   base::WaitableEvent data_pulled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestAudioSource);
 };
 
 }  // namespace
 
-class VirtualAudioInputStreamTest : public testing::Test {
+class VirtualAudioInputStreamTest : public testing::TestWithParam<bool> {
  public:
   VirtualAudioInputStreamTest()
       : audio_thread_(new base::Thread("AudioThread")),
+        worker_thread_(new base::Thread("AudioWorkerThread")),
         stream_(NULL),
         closed_stream_(false, false) {
     audio_thread_->Start();
     audio_message_loop_ = audio_thread_->message_loop_proxy();
   }
 
   virtual ~VirtualAudioInputStreamTest() {
     SyncWithAudioThread();
 
     DCHECK(output_streams_.empty());
     DCHECK(stopped_output_streams_.empty());
   }
 
   void Create() {
+    const bool worker_is_separate_thread = GetParam();
     stream_ = new VirtualAudioInputStream(
-        kParams, audio_message_loop_,
+        kParams, GetWorkerLoop(worker_is_separate_thread),
         base::Bind(&base::DeletePointer<VirtualAudioInputStream>));
     stream_->Open();
   }
 
   void Start() {
     EXPECT_CALL(input_callback_, OnClose(_));
     EXPECT_CALL(input_callback_, OnData(_, NotNull(), _, _, _))
         .Times(AtLeast(1));
 
     ASSERT_TRUE(!!stream_);
     stream_->Start(&input_callback_);
   }
 
   void CreateAndStartOneOutputStream() {
     ASSERT_TRUE(!!stream_);
     AudioOutputStream* const output_stream = new VirtualAudioOutputStream(
         kParams,
-        audio_message_loop_.get(),
         stream_,
         base::Bind(&base::DeletePointer<VirtualAudioOutputStream>));
     output_streams_.push_back(output_stream);
 
     output_stream->Open();
     output_stream->Start(&source_);
   }
 
   void Stop() {
     ASSERT_TRUE(!!stream_);
@@ skipping 57 matching lines @@
       (*it)->Start(&source_);
       output_streams_.push_back(*it);
     }
     stopped_output_streams_.clear();
   }
 
   const scoped_refptr<base::MessageLoopProxy>& audio_message_loop() const {
     return audio_message_loop_;
   }
 
+  const scoped_refptr<base::MessageLoopProxy>& GetWorkerLoop(
+      bool worker_is_separate_thread) {
+    if (worker_is_separate_thread) {
+      if (!worker_thread_->IsRunning()) {
+        worker_thread_->Start();
+        worker_message_loop_ = worker_thread_->message_loop_proxy();
+      }
+      return worker_message_loop_;
+    } else {
+      return audio_message_loop_;
+    }
+  }
+
  private:
   void SyncWithAudioThread() {
     base::WaitableEvent done(false, false);
     audio_message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&done)));
     done.Wait();
   }
 
   scoped_ptr<base::Thread> audio_thread_;
   scoped_refptr<base::MessageLoopProxy> audio_message_loop_;
+  scoped_ptr<base::Thread> worker_thread_;
+  scoped_refptr<base::MessageLoopProxy> worker_message_loop_;
 
   VirtualAudioInputStream* stream_;
   MockInputCallback input_callback_;
   base::WaitableEvent closed_stream_;
 
   std::list<AudioOutputStream*> output_streams_;
   std::list<AudioOutputStream*> stopped_output_streams_;
   TestAudioSource source_;
 
   DISALLOW_COPY_AND_ASSIGN(VirtualAudioInputStreamTest);
 };
 
 #define RUN_ON_AUDIO_THREAD(method)  \
   audio_message_loop()->PostTask(  \
       FROM_HERE, base::Bind(&VirtualAudioInputStreamTest::method,  \
                             base::Unretained(this)))
 
-TEST_F(VirtualAudioInputStreamTest, CreateAndClose) {
+TEST_P(VirtualAudioInputStreamTest, CreateAndClose) {
   RUN_ON_AUDIO_THREAD(Create);
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
-TEST_F(VirtualAudioInputStreamTest, NoOutputs) {
+TEST_P(VirtualAudioInputStreamTest, NoOutputs) {
   RUN_ON_AUDIO_THREAD(Create);
   RUN_ON_AUDIO_THREAD(Start);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
-TEST_F(VirtualAudioInputStreamTest, SingleOutput) {
+TEST_P(VirtualAudioInputStreamTest, SingleOutput) {
   RUN_ON_AUDIO_THREAD(Create);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
-TEST_F(VirtualAudioInputStreamTest, SingleOutputPausedAndRestarted) {
+TEST_P(VirtualAudioInputStreamTest, SingleOutputPausedAndRestarted) {
   RUN_ON_AUDIO_THREAD(Create);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
   RUN_ON_AUDIO_THREAD(RestartAllStoppedOutputStreams);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
-TEST_F(VirtualAudioInputStreamTest, MultipleOutputs) {
+TEST_P(VirtualAudioInputStreamTest, MultipleOutputs) {
   RUN_ON_AUDIO_THREAD(Create);
   RUN_ON_AUDIO_THREAD(Start);
   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
   RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(StopFirstOutputStream);
   RUN_ON_AUDIO_THREAD(RestartAllStoppedOutputStreams);
   WaitForDataToFlow();
   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   RUN_ON_AUDIO_THREAD(Stop);
   RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
 // A combination of all of the above tests with many output streams.
-TEST_F(VirtualAudioInputStreamTest, ComprehensiveTest) {
+TEST_P(VirtualAudioInputStreamTest, ComprehensiveTest) {
   static const int kNumOutputs = 8;
   static const int kHalfNumOutputs = kNumOutputs / 2;
   static const int kPauseIterations = 5;
 
   RUN_ON_AUDIO_THREAD(Create);
   for (int i = 0; i < kHalfNumOutputs; ++i) {
     RUN_ON_AUDIO_THREAD(CreateAndStartOneOutputStream);
   }
   RUN_ON_AUDIO_THREAD(Start);
   WaitForDataToFlow();
@@ skipping 11 matching lines @@
     RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   }
   RUN_ON_AUDIO_THREAD(Stop);
   for (int i = 0; i < kHalfNumOutputs; ++i) {
     RUN_ON_AUDIO_THREAD(StopAndCloseOneOutputStream);
   }
   RUN_ON_AUDIO_THREAD(Close);
   WaitUntilClosed();
 }
 
+INSTANTIATE_TEST_CASE_P(SingleVersusMultithreaded,
+                        VirtualAudioInputStreamTest,
+                        ::testing::Values(false, true));
+
 }  // namespace media