Share one thread between all AudioOutputControllers instead of creating one per stream.

media/audio/audio_output_controller_unittest.cc

 // Copyright (c) 2010 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/environment.h"
 #include "base/basictypes.h"
 #include "base/waitable_event.h"
 #include "media/audio/audio_output_controller.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AtLeast;
 using ::testing::Exactly;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;
+using ::testing::Return;
 
 static const int kSampleRate = AudioManager::kAudioCDSampleRate;
 static const int kBitsPerSample = 16;
 static const int kChannels = 2;
 static const int kHardwareBufferSize = kSampleRate * kBitsPerSample *
                                        kChannels / 8;
 static const int kBufferCapacity = 3 * kHardwareBufferSize;
 
 namespace media {
 
@@ skipping 34 matching lines @@
   return audio_man->HasAudioOutputDevices();
 }
 
 static bool IsRunningHeadless() {
   scoped_ptr<base::Environment> env(base::Environment::Create());
   if (env->HasVar("CHROME_HEADLESS"))
     return true;
   return false;
 }
 
+ACTION_P(SignalEvent, event) {
+  event->Signal();
+}
+
 ACTION_P3(SignalEvent, event, count, limit) {
   if (++*count >= limit) {
     event->Signal();
   }
 }
 
 TEST(AudioOutputControllerTest, CreateAndClose) {
   if (!HasAudioOutputDevices() || IsRunningHeadless())
     return;
 
   MockAudioOutputControllerEventHandler event_handler;
   scoped_refptr<AudioOutputController> controller =
       AudioOutputController::Create(&event_handler,
                                     AudioManager::AUDIO_PCM_LINEAR, kChannels,
                                     kSampleRate, kBitsPerSample,
                                     kHardwareBufferSize, kBufferCapacity);
   ASSERT_TRUE(controller.get());
 
-  // Close the controller immediately.
+  // Close the controller immediately. At this point, chances are that
+  // DoCreate() hasn't been called yet. In any case, it should be safe to call
+  // Close() and it should not try to call |event_handler| later (the test
+  // would crash otherwise).
   controller->Close();
 }
 
 TEST(AudioOutputControllerTest, PlayAndClose) {
   if (!HasAudioOutputDevices() || IsRunningHeadless())
     return;
 
   MockAudioOutputControllerEventHandler event_handler;
   base::WaitableEvent event(false, false);
   int count = 0;
 
   // If OnCreated is called then signal the event.
   EXPECT_CALL(event_handler, OnCreated(NotNull()))
-      .WillOnce(InvokeWithoutArgs(&event, &base::WaitableEvent::Signal));
+      .WillOnce(SignalEvent(&event));
 
   // OnPlaying() will be called only once.
   EXPECT_CALL(event_handler, OnPlaying(NotNull()))
       .Times(Exactly(1));
 
   // If OnMoreData is called enough then signal the event.
   EXPECT_CALL(event_handler, OnMoreData(NotNull(), _, 0))
       .Times(AtLeast(10))
       .WillRepeatedly(SignalEvent(&event, &count, 10));
 
   scoped_refptr<AudioOutputController> controller =
       AudioOutputController::Create(&event_handler,
                                     AudioManager::AUDIO_PCM_LINEAR, kChannels,
                                     kSampleRate, kBitsPerSample,
                                     kHardwareBufferSize, kBufferCapacity);
   ASSERT_TRUE(controller.get());
 
   // Wait for OnCreated() to be called.
   event.Wait();
-  event.Reset();
 
   // Play and then wait for the event to be signaled.
   controller->Play();
   event.Wait();
 
-  // Now stop the controller. This should shutdown the internal
-  // thread and we hold the only reference to it.
+  // Now stop the controller. The object is freed later after DoClose() is
+  // executed.
   controller->Close();
 }
 
 TEST(AudioOutputControllerTest, PlayPauseClose) {
   if (!HasAudioOutputDevices() || IsRunningHeadless())
     return;
 
   MockAudioOutputControllerEventHandler event_handler;
   base::WaitableEvent event(false, false);
   int count = 0;
@@ skipping 30 matching lines @@
 
   // Play and then wait for the event to be signaled.
   controller->Play();
   event.Wait();
   event.Reset();
 
   // And then wait for pause to complete.
   controller->Pause();
   event.Wait();
 
-  // Now stop the controller. This should shutdown the internal
-  // thread and we hold the only reference to it.
+  // Now stop the controller. The object is freed later after DoClose() is
+  // executed.
   controller->Close();
 }
 
 TEST(AudioOutputControllerTest, PlayPausePlay) {
   if (!HasAudioOutputDevices() || IsRunningHeadless())
     return;
 
   MockAudioOutputControllerEventHandler event_handler;
   base::WaitableEvent event(false, false);
   int count = 0;
@@ skipping 42 matching lines @@
   // And then wait for pause to complete.
   controller->Pause();
   event.Wait();
   event.Reset();
 
   // Then we play again.
   // Play and then wait for the event to be signaled.
   controller->Play();
   event.Wait();
 
-  // Now stop the controller. This should shutdown the internal
-  // thread and we hold the only reference to it.
+  // Now stop the controller. The object is freed later after DoClose() is
+  // executed.
   controller->Close();
 }
 
 TEST(AudioOutputControllerTest, HardwareBufferTooLarge) {
   if (!HasAudioOutputDevices() || IsRunningHeadless())
     return;
 
   // Create an audio device with a very large hardware buffer size.
   MockAudioOutputControllerEventHandler event_handler;
   scoped_refptr<AudioOutputController> controller =
       AudioOutputController::Create(&event_handler,
                                     AudioManager::AUDIO_PCM_LINEAR, kChannels,
                                     kSampleRate, kBitsPerSample,
                                     kHardwareBufferSize * 1000,
                                     kBufferCapacity);
 
   // Use assert because we don't stop the device and assume we can't
   // create one.
   ASSERT_FALSE(controller);
 }
 
 TEST(AudioOutputControllerTest, CloseTwice) {
   if (!HasAudioOutputDevices() || IsRunningHeadless())
     return;
 
   MockAudioOutputControllerEventHandler event_handler;
+  base::WaitableEvent event(false, false);
+
+  // If OnCreated is called then signal the event.
+  EXPECT_CALL(event_handler, OnCreated(NotNull()))
+      .WillOnce(SignalEvent(&event));
+
+  // One OnMoreData() is expected.
+  EXPECT_CALL(event_handler, OnMoreData(NotNull(), _, 0))
+      .Times(AtLeast(1))
+      .WillRepeatedly(SignalEvent(&event));
+
   scoped_refptr<AudioOutputController> controller =
       AudioOutputController::Create(&event_handler,
                                     AudioManager::AUDIO_PCM_LINEAR, kChannels,
                                     kSampleRate, kBitsPerSample,
                                     kHardwareBufferSize, kBufferCapacity);
   ASSERT_TRUE(controller.get());
 
-  // Close the controller immediately.
+  // Wait for OnCreated() to be called.
+  event.Wait();
+
+  // Wait for OnMoreData() to be called.
+  event.Wait();
+
   controller->Close();
   controller->Close();
 }
 
 }  // namespace media