Browser-wide audio mirroring for TabCapture API

media/audio/audio_output_controller_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 "base/bind.h"
 #include "base/environment.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "media/audio/audio_output_controller.h"
+#include "media/audio/virtual_audio_input_stream.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 // TODO(vrk): These tests need to be rewritten! (crbug.com/112500)
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::DoAll;
 using ::testing::Exactly;
 using ::testing::InvokeWithoutArgs;
@@ skipping 48 matching lines @@
 }
 
 // Closes AudioOutputController synchronously.
 static void CloseAudioController(AudioOutputController* controller) {
   controller->Close(MessageLoop::QuitClosure());
   MessageLoop::current()->Run();
 }
 
 class AudioOutputControllerTest : public testing::Test {
  public:
-  AudioOutputControllerTest() {}
+  AudioOutputControllerTest() : done_(false, false) {}
   virtual ~AudioOutputControllerTest() {}
 
+  void EndTestVirtualAudioTest(int callbacks) {
+    stream_->Stop();
+    stream_->Close();
+
+    done_.Signal();
+  }
+
  protected:
+  AudioInputStream* stream_;
   MessageLoopForIO message_loop_;
+  base::WaitableEvent done_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioOutputControllerTest);
 };
 
 TEST_F(AudioOutputControllerTest, CreateAndClose) {
   scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
   if (!audio_manager->HasAudioOutputDevices())
     return;
 
@@ skipping 181 matching lines @@
   // Force a state change and wait for the stream to come back to playing state.
   play_event.Reset();
   audio_manager->GetMessageLoop()->PostTask(FROM_HERE,
       base::Bind(&AudioOutputController::OnDeviceChange, controller));
   play_event.Wait();
 
   // Now stop the controller.
   CloseAudioController(controller);
 }
 
+// Tests that we detach an existing audio stream and re-attach them as virtual
+// output streams when a VirtualAudioInputStream is created.
+TEST_F(AudioOutputControllerTest, VirtualStreamsTriggerDeviceChange) {
+  scoped_ptr<AudioManager> audio_manager(AudioManager::Create());
+  if (!audio_manager->HasAudioOutputDevices())
+    return;
+
+  MockAudioOutputControllerEventHandler event_handler;
+  base::WaitableEvent event(false, false);
+  EXPECT_CALL(event_handler, OnCreated(NotNull()))
+      .WillOnce(InvokeWithoutArgs(&event, &base::WaitableEvent::Signal));
+
+  // OnPlaying() will be called once normally and once after being recreated.
+  base::WaitableEvent play_event(false, false);
+  EXPECT_CALL(event_handler, OnPlaying(NotNull()))
+      .Times(2)
+      .WillRepeatedly(InvokeWithoutArgs(
+          &play_event, &base::WaitableEvent::Signal));
+
+  // OnPaused() should not be called during the state change event.
+  EXPECT_CALL(event_handler, OnPaused(NotNull()))
+      .Times(0);
+
+  MockAudioOutputControllerSyncReader sync_reader;
+  EXPECT_CALL(sync_reader, UpdatePendingBytes(_))
+      .Times(AtLeast(1));
+  EXPECT_CALL(sync_reader, Read(_, _))
+      .WillRepeatedly(DoAll(ClearBuffer(), SignalEvent(&event), Return(4)));
+  EXPECT_CALL(sync_reader, DataReady())
+      .WillRepeatedly(Return(true));
+  EXPECT_CALL(sync_reader, Close());
+
+  AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
+                         kSampleRate, kBitsPerSample, kSamplesPerPacket);
+  scoped_refptr<AudioOutputController> controller =
+      AudioOutputController::Create(
+          audio_manager.get(), &event_handler, params, &sync_reader);
+  ASSERT_TRUE(controller.get());
+
+  // Wait for OnCreated() to be called.
+  event.Wait();
+
+  ASSERT_FALSE(play_event.IsSignaled());
+  controller->Play();
+  play_event.Wait();
+
+  play_event.Reset();
+
+  // Create a new VirtualAudioInputStream and expect another play event and
+  // the existing output stream to be recreated as a VirtualAudiOutputStream and
+  // attached.
+  stream_ = audio_manager->MakeAudioInputStream(
+                AudioParameters(AudioParameters::AUDIO_MIRROR_BROWSER,
+                CHANNEL_LAYOUT_MONO, 8000, 8, 128), "1");
+
+  play_event.Wait();
+  EXPECT_EQ(1u,
+            static_cast<VirtualAudioInputStream*>(stream_)->converters_.size());
+
+  int callbacks = 0;
+  audio_manager->GetMessageLoop()->PostTask(FROM_HERE, base::Bind(
+      &AudioOutputControllerTest::EndTestVirtualAudioTest,
+      base::Unretained(this),
+      callbacks));
+  done_.Wait();
+
+  // Now stop the controller.
+  CloseAudioController(controller);
+}
+
 }  // namespace media