Merge AssociateStreamWithProducer message into CreateStream message for both audio output and input.

media/audio/audio_output_device_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/at_exit.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
@@ skipping 31 matching lines @@
                               AudioBus* dest,
                               int audio_delay_milliseconds));
   MOCK_METHOD0(OnRenderError, void());
 };
 
 class MockAudioOutputIPC : public AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
-  MOCK_METHOD1(AddDelegate, int(AudioOutputIPCDelegate* delegate));
-  MOCK_METHOD1(RemoveDelegate, void(int stream_id));
-
-  MOCK_METHOD2(CreateStream,
-      void(int stream_id, const AudioParameters& params));
-  MOCK_METHOD1(PlayStream, void(int stream_id));
-  MOCK_METHOD1(CloseStream, void(int stream_id));
-  MOCK_METHOD2(SetVolume, void(int stream_id, double volume));
-  MOCK_METHOD1(PauseStream, void(int stream_id));
+  MOCK_METHOD2(CreateStream, void(AudioOutputIPCDelegate* delegate,
+                                  const AudioParameters& params));
+  MOCK_METHOD0(PlayStream, void());
+  MOCK_METHOD0(PauseStream, void());
+  MOCK_METHOD0(CloseStream, void());
+  MOCK_METHOD1(SetVolume, void(double volume));
 };
 
 // Creates a copy of a SyncSocket handle that we can give to AudioOutputDevice.
 // On Windows this means duplicating the pipe handle so that AudioOutputDevice
 // can call CloseHandle() (since ownership has been transferred), but on other
 // platforms, we just copy the same socket handle since AudioOutputDevice on
 // those platforms won't actually own the socket (FileDescriptor.auto_close is
 // false).
 bool DuplicateSocketHandle(SyncSocket::Handle socket_handle,
                            SyncSocket::Handle* copy) {
@@ skipping 33 matching lines @@
   void WaitUntilRenderCallback();
   void StopAudioDevice();
 
  protected:
   // Used to clean up TLS pointers that the test(s) will initialize.
   // Must remain the first member of this class.
   base::ShadowingAtExitManager at_exit_manager_;
   MessageLoopForIO io_loop_;
   AudioParameters default_audio_parameters_;
   StrictMock<MockRenderCallback> callback_;
-  StrictMock<MockAudioOutputIPC> audio_output_ipc_;
+  MockAudioOutputIPC* audio_output_ipc_;  // owned by audio_device_
   scoped_refptr<AudioOutputDevice> audio_device_;
 
  private:
   int CalculateMemorySize();
 
   const bool synchronized_io_;
   const int input_channels_;
   SharedMemory shared_memory_;
   CancelableSyncSocket browser_socket_;
   CancelableSyncSocket renderer_socket_;
@@ skipping 22 matching lines @@
 }
 
 AudioOutputDeviceTest::AudioOutputDeviceTest()
     : synchronized_io_(GetParam()),
       input_channels_(synchronized_io_ ? 2 : 0) {
   default_audio_parameters_.Reset(
       AudioParameters::AUDIO_PCM_LINEAR,
       CHANNEL_LAYOUT_STEREO, 2, input_channels_,
       48000, 16, 1024);
 
+  audio_output_ipc_ = new MockAudioOutputIPC();
   audio_device_ = new AudioOutputDevice(
-      &audio_output_ipc_, io_loop_.message_loop_proxy());
+      scoped_ptr<AudioOutputIPC>(audio_output_ipc_),
+      io_loop_.message_loop_proxy());
 
   audio_device_->Initialize(default_audio_parameters_,
                             &callback_);
 
   io_loop_.RunUntilIdle();
 }
 
 AudioOutputDeviceTest::~AudioOutputDeviceTest() {
   audio_device_ = NULL;
 }
 
 void AudioOutputDeviceTest::StartAudioDevice() {
   audio_device_->Start();
 
-  EXPECT_CALL(audio_output_ipc_, AddDelegate(_)).WillOnce(Return(kStreamId));
-  EXPECT_CALL(audio_output_ipc_, CreateStream(kStreamId, _));
+  EXPECT_CALL(*audio_output_ipc_, CreateStream(audio_device_.get(), _));
 
   io_loop_.RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::CreateStream() {
   const int kMemorySize = CalculateMemorySize();
 
   ASSERT_TRUE(shared_memory_.CreateAndMapAnonymous(kMemorySize));
   memset(shared_memory_.memory(), 0xff, kMemorySize);
 
@@ skipping 15 matching lines @@
   io_loop_.RunUntilIdle();
 }
 
 void AudioOutputDeviceTest::ExpectRenderCallback() {
   // We should get a 'play' notification when we call OnStreamCreated().
   // Respond by asking for some audio data.  This should ask our callback
   // to provide some audio data that AudioOutputDevice then writes into the
   // shared memory section.
   const int kMemorySize = CalculateMemorySize();
 
-  EXPECT_CALL(audio_output_ipc_, PlayStream(kStreamId))
+  EXPECT_CALL(*audio_output_ipc_, PlayStream())
       .WillOnce(SendPendingBytes(&browser_socket_, kMemorySize));
 
   // We expect calls to our audio renderer callback, which returns the number
   // of frames written to the memory section.
   // Here's the second place where it gets hacky:  There's no way for us to
   // know (without using a sleep loop!) when the AudioOutputDevice has finished
   // writing the interleaved audio data into the shared memory section.
   // So, for the sake of this test, we consider the call to Render a sign
   // of success and quit the loop.
   if (synchronized_io_) {
@@ skipping 13 matching lines @@
 void AudioOutputDeviceTest::WaitUntilRenderCallback() {
   // Don't hang the test if we never get the Render() callback.
   io_loop_.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                            TestTimeouts::action_timeout());
   io_loop_.Run();
 }
 
 void AudioOutputDeviceTest::StopAudioDevice() {
   audio_device_->Stop();
 
-  EXPECT_CALL(audio_output_ipc_, CloseStream(kStreamId));
-  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(kStreamId));
+  EXPECT_CALL(*audio_output_ipc_, CloseStream());
 
   io_loop_.RunUntilIdle();
 }
 
 TEST_P(AudioOutputDeviceTest, Initialize) {
   // Tests that the object can be constructed, initialized and destructed
   // without having ever been started/stopped.
 }
 
 // Calls Start() followed by an immediate Stop() and check for the basic message
@@ skipping 14 matching lines @@
 // Simulate receiving OnStreamCreated() prior to processing ShutDownOnIOThread()
 // on the IO loop.
 TEST_P(AudioOutputDeviceTest, StopBeforeRender) {
   StartAudioDevice();
 
   // Call Stop() but don't run the IO loop yet.
   audio_device_->Stop();
 
   // Expect us to shutdown IPC but not to render anything despite the stream
   // getting created.
-  EXPECT_CALL(audio_output_ipc_, CloseStream(kStreamId));
-  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(kStreamId));
+  EXPECT_CALL(*audio_output_ipc_, CloseStream());
   CreateStream();
 }
 
 // Full test with output only.
 TEST_P(AudioOutputDeviceTest, CreateStream) {
   StartAudioDevice();
   ExpectRenderCallback();
   CreateStream();
   WaitUntilRenderCallback();
   StopAudioDevice();
 }
 
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 INSTANTIATE_TEST_CASE_P(RenderIO, AudioOutputDeviceTest, Values(true));
 
 }  // namespace media.