Browser-wide audio mirroring for TabCapture API

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 <vector>
+
+#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_VIRTUAL,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_output_streams == 0 && 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_->buffer_duration_ms_ = base::TimeDelta();
+      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.
+      EXPECT_EQ(num_expected_source_callbacks, source_.callbacks());
+      EXPECT_EQ(0, source_.errors());
+
+      for (std::vector<AudioOutputStream*>::iterator it =
+           output_streams_.begin(); it != output_streams_.end(); ++it)
+        (*it)->Stop();
+
+      stream_->Stop();
+
+      audio_manager_->GetMessageLoop()->PostTask(
+          FROM_HERE, base::Bind(&VirtualAudioInputStreamTest::EndTest,
+                                base::Unretained(this)));
+    }
+  }
+
+  void OpenAndCloseOnAudioThread() {
+    ASSERT_TRUE(audio_manager_->GetMessageLoop()->BelongsToCurrentThread());
+    stream_->Open();
+
+    // Create 2 output streams, which we just open and close without starting.
+    const int num_output_stream = 2;
+
+    for (int i = 0; i < num_output_stream; ++i) {
+      AudioOutputStream* output_stream =
+          audio_manager_->MakeAudioOutputStream(output_params_);
+      DCHECK(output_stream);
+      output_streams_.push_back(output_stream);
+
+      output_stream->Open();
+    }
+
+    audio_manager_->GetMessageLoop()->PostTask(
+        FROM_HERE, base::Bind(&VirtualAudioInputStreamTest::EndTest,
+                              base::Unretained(this)));
+  }
+
+  void StartStopOnAudioThread(int num_output_streams,
+                              int num_callback_iterations,
+                              int num_expected_source_callbacks) {
+    ASSERT_TRUE(audio_manager_->GetMessageLoop()->BelongsToCurrentThread());
+    stream_->Open();
+    stream_->Start(&input_callback_);
+    StartStopCallback(true, num_output_streams, num_callback_iterations,
+                      num_expected_source_callbacks);
+  }
+
+  void StartStopCallback(bool init,
+                         int num_output_streams,
+                         int num_callback_iterations,
+                         int num_expected_source_callbacks) {
+    ASSERT_TRUE(audio_manager_->GetMessageLoop()->BelongsToCurrentThread());
+
+    if (init) {
+      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_);
+      }
+
+      // Start with an odd iteration number so we call Stop() first below.
+      DCHECK_NE(0, num_callback_iterations % 2);
+    }
+
+    // Start or stop half the streams.
+    for (int i = 0; i < num_output_streams / 2; ++i) {
+      if (num_callback_iterations % 2 != 0)
+        output_streams_[i]->Stop();
+      else
+        output_streams_[i]->Start(&source_);
+    }
+
+    if (num_callback_iterations > 0) {
+      // Force the next callback to be immediate.
+      stream_->buffer_duration_ms_ = base::TimeDelta::FromMilliseconds(0);
+      audio_manager_->GetMessageLoop()->PostTask(
+          FROM_HERE, base::Bind(
+              &VirtualAudioInputStreamTest::StartStopCallback,
+              base::Unretained(this),
+              false,
+              num_output_streams,
+              --num_callback_iterations,
+              num_expected_source_callbacks));
+    } else {
+      // Finish the test.
+      EXPECT_EQ(num_expected_source_callbacks, source_.callbacks());
+      EXPECT_EQ(0, source_.errors());
+
+      for (std::vector<AudioOutputStream*>::iterator it =
+           output_streams_.begin(); it != output_streams_.end(); ++it)
+        (*it)->Stop();
+
+      stream_->Stop();
+
+      audio_manager_->GetMessageLoop()->PostTask(FROM_HERE,
+          base::Bind(&VirtualAudioInputStreamTest::EndTest,
+                 base::Unretained(this)));
+    }
+  }
+
+  void EndTest() {
+    for (std::vector<AudioOutputStream*>::iterator it =
+         output_streams_.begin(); it != output_streams_.end(); ++it)
+      (*it)->Close();
+
+    stream_->Close();
+
+    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_);
+
+  const int num_output_streams = 1;
+  const int num_callback_iterations = 1;
+  const int num_streams_removed_per_round = 0;
+  const 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_);
+
+  const int num_output_streams = 5;
+  const int num_callback_iterations = 5;
+  const int num_streams_removed_per_round = 0;
+  const 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, AttachAndRemoveStreams) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  const int num_output_streams = 8;
+  const int num_callback_iterations = 5;
+  const int num_streams_removed_per_round = 1;
+  const int num_expected_source_callbacks = 8 + 7 + 6 + 5 + 4;
+
+  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();
+}
+
+// Opens/closes a VirtualAudioInputStream and a number of attached
+// VirtualAudioOutputStreams without calling Start()/Stop().
+TEST_F(VirtualAudioInputStreamTest, OpenAndClose) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  audio_manager_->GetMessageLoop()->PostTask(
+      FROM_HERE, base::Bind(
+          &VirtualAudioInputStreamTest::OpenAndCloseOnAudioThread,
+          base::Unretained(this)));
+
+  done_.Wait();
+}
+
+// Creates and closes and VirtualAudioInputStream.
+TEST_F(VirtualAudioInputStreamTest, CreateAndClose) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  audio_manager_->GetMessageLoop()->PostTask(
+      FROM_HERE, base::Bind(&VirtualAudioInputStreamTest::EndTest,
+                            base::Unretained(this)));
+
+  done_.Wait();
+}
+
+// Starts and stops VirtualAudioOutputStreams while attached to a
+// VirtualAudioInputStream.
+TEST_F(VirtualAudioInputStreamTest, AttachAndStartStopStreams) {
+  stream_ = static_cast<VirtualAudioInputStream*>(
+      audio_manager_->MakeAudioInputStream(params_, "1"));
+  DCHECK(stream_);
+
+  const int num_output_streams = 4;
+  const int num_callback_iterations = 5;
+  const int num_expected_source_callbacks = 2 + 4 + 2 + 4 + 2;
+
+  audio_manager_->GetMessageLoop()->PostTask(
+      FROM_HERE, base::Bind(
+          &VirtualAudioInputStreamTest::StartStopOnAudioThread,
+          base::Unretained(this),
+          num_output_streams,
+          num_callback_iterations,
+          num_expected_source_callbacks));
+
+  done_.Wait();
+}
+
+}  // namespace media