Allow audio system to handle synchronized low-latency audio I/O

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"
@@ skipping 34 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioOutputControllerEventHandler);
 };
 
 class MockAudioOutputControllerSyncReader
     : public AudioOutputController::SyncReader {
  public:
   MockAudioOutputControllerSyncReader() {}
 
   MOCK_METHOD1(UpdatePendingBytes, void(uint32 bytes));
-  MOCK_METHOD1(Read, int(AudioBus* audio_bus));
+  MOCK_METHOD2(Read, int(AudioBus* source, AudioBus* dest));
   MOCK_METHOD0(Close, void());
   MOCK_METHOD0(DataReady, bool());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockAudioOutputControllerSyncReader);
 };
 
 ACTION_P(SignalEvent, event) {
   event->Signal();
 }
 
 // Custom action to clear a memory buffer.
 ACTION(ClearBuffer) {
-  arg0->Zero();
+  arg1->Zero();
 }
 
 // Closes AudioOutputController synchronously.
 static void CloseAudioController(AudioOutputController* controller) {
   controller->Close(MessageLoop::QuitClosure());
   MessageLoop::current()->Run();
 }
 
 class AudioOutputControllerTest : public testing::Test {
  public:
@@ skipping 43 matching lines @@
   // If OnCreated is called then signal the event.
   EXPECT_CALL(event_handler, OnCreated(NotNull()))
       .WillOnce(InvokeWithoutArgs(&event, &base::WaitableEvent::Signal));
 
   // OnPlaying() will be called only once.
   EXPECT_CALL(event_handler, OnPlaying(NotNull()));
 
   MockAudioOutputControllerSyncReader sync_reader;
   EXPECT_CALL(sync_reader, UpdatePendingBytes(_))
       .Times(AtLeast(2));
-  EXPECT_CALL(sync_reader, Read(_))
+  EXPECT_CALL(sync_reader, Read(_, _))
       .WillRepeatedly(DoAll(ClearBuffer(), SignalEvent(&event),
                             Return(4)));
   EXPECT_CALL(sync_reader, DataReady())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(event_handler, OnPaused(NotNull()))
       .WillOnce(InvokeWithoutArgs(&pause_event, &base::WaitableEvent::Signal));
   EXPECT_CALL(sync_reader, Close());
 
   AudioParameters params(AudioParameters::AUDIO_PCM_LINEAR, kChannelLayout,
                          kSampleRate, kBitsPerSample, kSamplesPerPacket);
@@ skipping 51 matching lines @@
       .WillOnce(InvokeWithoutArgs(&play_event, &base::WaitableEvent::Signal));
 
   // OnPaused() should never be called since the pause during kStarting is
   // dropped when the second play comes in.
   EXPECT_CALL(event_handler, OnPaused(NotNull()))
       .Times(0);
 
   MockAudioOutputControllerSyncReader sync_reader;
   EXPECT_CALL(sync_reader, UpdatePendingBytes(_))
       .Times(AtLeast(1));
-  EXPECT_CALL(sync_reader, Read(_))
+  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();
   controller->Pause();
   controller->Play();
   play_event.Wait();
 
   // Now stop the controller.
   CloseAudioController(controller);
 }
 
 }  // namespace media