Browser-wide audio mirroring for TabCapture API

media/audio/virtual_audio_input_stream_unittest.cc

Index: media/audio/virtual_audio_input_stream_unittest.cc
diff --git a/media/audio/virtual_audio_input_stream_unittest.cc b/media/audio/virtual_audio_input_stream_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..dfcbc1b83a9129a6b95410b9c737ee26608d2166
--- /dev/null
+++ b/media/audio/virtual_audio_input_stream_unittest.cc
@@ -0,0 +1,178 @@
+// 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 "base/message_loop.h"
+#include "base/synchronization/waitable_event.h"
+#include "media/audio/audio_manager.h"
+#include "media/audio/simple_sources.h"
+#include "media/audio/virtual_audio_input_stream.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media {
+
+class MockInputCallback : public AudioInputStream::AudioInputCallback {
+ public:
+  MockInputCallback() {}
+  virtual void OnData(AudioInputStream* stream, const uint8* data,
+                      uint32 size, uint32 hardware_delay_bytes,
+                      double volume) {}
+  virtual void OnClose(AudioInputStream* stream) {}
+  virtual void OnError(AudioInputStream* stream, int code) {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockInputCallback);
+};
+
+class VirtualAudioInputStreamTest : public testing::Test {
+ public:
+  VirtualAudioInputStreamTest()
+      : audio_manager_(AudioManager::Create()),
+        params_(AudioParameters::AUDIO_MIRROR_BROWSER,
+            CHANNEL_LAYOUT_MONO, 8000, 8, 128),
+        output_params_(AudioParameters::AUDIO_PCM_LINEAR,
+            CHANNEL_LAYOUT_MONO, 8000, 8, 128),
+        stream_(NULL),
+        source_(CHANNEL_LAYOUT_STEREO, 200.0, 128),
+        done_(false, false) {
+  }
+
+  void StartStreamAndRunTestsOnAudioThread(int num_output_streams,
+                                           int num_callback_iterations,
+                                           int num_streams_removed_per_round,
+                                           int num_expected_source_callbacks) {
+    ASSERT_TRUE(audio_manager_->GetMessageLoop()->BelongsToCurrentThread());
+    stream_->Open();
+    stream_->Start(&input_callback_);
+    AddStreamsAndDoCallbacks(num_output_streams,
+                             num_callback_iterations,
+                             num_streams_removed_per_round,
+                             num_expected_source_callbacks);
+  }
+
+  void AddStreamsAndDoCallbacks(int num_output_streams,
+                                int num_callback_iterations,
+                                int num_streams_removed_per_round,
+                                int num_expected_source_callbacks) {
+    ASSERT_TRUE(audio_manager_->GetMessageLoop()->BelongsToCurrentThread());
+
+    for (int i = 0; i < num_output_streams; ++i) {
+      AudioOutputStream* output_stream =
+          audio_manager_->MakeAudioOutputStream(output_params_);
+      DCHECK(output_stream);
+      output_streams_.push_back(output_stream);
+
+      output_stream->Open();
+      output_stream->Start(&source_);
+    }
+
+    if (num_streams_removed_per_round > 0) {
+      AudioOutputStream* output_stream = output_streams_.back();
+      output_streams_.pop_back();
+      output_stream->Stop();
+      output_stream->Close();
+    }
+
+    if (num_callback_iterations > 0) {
+      // Force the next callback to be immediate.
+      stream_->next_read_time_ -= base::TimeDelta::FromMilliseconds(10000);
+      audio_manager_->GetMessageLoop()->PostTask(FROM_HERE,
+          base::Bind(&VirtualAudioInputStreamTest::AddStreamsAndDoCallbacks,
+                     base::Unretained(this),
+                     0,
+                     --num_callback_iterations,
+                     num_streams_removed_per_round,
+                     num_expected_source_callbacks));
+    } else {
+      // Finish the test.
+      for (std::vector<AudioOutputStream*>::iterator it =
+           output_streams_.begin(); it != output_streams_.end(); ++it) {
+        (*it)->Stop();
+        (*it)->Close();
+      }
+
+      stream_->Stop();
+      stream_->Close();
+
+      EXPECT_EQ(num_expected_source_callbacks, source_.callbacks());
+      EXPECT_EQ(0, source_.errors());
+
+      done_.Signal();
+    }
+  }
+
+ protected:
+  scoped_ptr<AudioManager> audio_manager_;
+  AudioParameters params_;
+  AudioParameters output_params_;
+  VirtualAudioInputStream* stream_;
+  MockInputCallback input_callback_;
+  std::vector<AudioOutputStream*> output_streams_;
+  SineWaveAudioSource source_;
+  base::WaitableEvent done_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(VirtualAudioInputStreamTest);
+};
+
+TEST_F(VirtualAudioInputStreamTest, AttachAndDriveSingleStream) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  int num_output_streams = 1;
+  int num_callback_iterations = 1;
+  int num_streams_removed_per_round = 0;
+  int num_expected_source_callbacks = 1;
+
+  audio_manager_->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
+      &VirtualAudioInputStreamTest::StartStreamAndRunTestsOnAudioThread,
+      base::Unretained(this),
+      num_output_streams, num_callback_iterations,
+      num_streams_removed_per_round,
+      num_expected_source_callbacks));
+
+  done_.Wait();
+}
+
+TEST_F(VirtualAudioInputStreamTest, AttachAndDriveMultipleStreams) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  int num_output_streams = 5;
+  int num_callback_iterations = 5;
+  int num_streams_removed_per_round = 0;
+  int num_expected_source_callbacks = 25;
+
+  audio_manager_->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
+      &VirtualAudioInputStreamTest::StartStreamAndRunTestsOnAudioThread,
+      base::Unretained(this),
+      num_output_streams, num_callback_iterations,
+      num_streams_removed_per_round,
+      num_expected_source_callbacks));
+
+  done_.Wait();
+}
+
+TEST_F(VirtualAudioInputStreamTest, RemoveStreams) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  int num_output_streams = 8;
+  int num_callback_iterations = 5;
+  int num_streams_removed_per_round = 1;
+  int num_expected_source_callbacks = 7 + 6 + 5 + 4 + 3;
+
+  audio_manager_->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
+      &VirtualAudioInputStreamTest::StartStreamAndRunTestsOnAudioThread,
+      base::Unretained(this),
+      num_output_streams, num_callback_iterations,
+      num_streams_removed_per_round,
+      num_expected_source_callbacks));
+
+  done_.Wait();
+}
+
+}  // namespace media