Part 1: Plumb render view ID to render host

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 95 matching lines @@
  public:
   AudioOutputDeviceTest()
       : default_audio_parameters_(AudioParameters::AUDIO_PCM_LINEAR,
                                   CHANNEL_LAYOUT_STEREO,
                                   48000, 16, 1024),
         stream_id_(-1) {
   }
 
   ~AudioOutputDeviceTest() {}
 
-  AudioOutputDevice* CreateAudioDevice() {
-    return new AudioOutputDevice(
-        &audio_output_ipc_, io_loop_.message_loop_proxy());
-  }
-
   void set_stream_id(int stream_id) { stream_id_ = stream_id; }
 
  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_;
   const AudioParameters default_audio_parameters_;
   MockRenderCallback callback_;
-  MockAudioOutputIPC audio_output_ipc_;
   int stream_id_;
 };
 
 // The simplest test for AudioOutputDevice.  Used to test construction of
 // AudioOutputDevice and that the runtime environment is set up correctly.
 TEST_F(AudioOutputDeviceTest, Initialize) {
-  scoped_refptr<AudioOutputDevice> audio_device(CreateAudioDevice());
+  MockAudioOutputIPC* audio_output_ipc = new MockAudioOutputIPC;

[tommi (sloooow) - chröme, 2012/07/31 10:52:41]

new MockAudioOutputIPC();
(same throughout)

[sail, 2012/07/31 22:02:08]

Done.

+  scoped_refptr<AudioOutputDevice> audio_device(
+      new AudioOutputDevice(audio_output_ipc, io_loop_.message_loop_proxy()));
   audio_device->Initialize(default_audio_parameters_, &callback_);
   io_loop_.RunAllPending();
 }
 
 // Calls Start() followed by an immediate Stop() and check for the basic message
 // filter messages being sent in that case.
 TEST_F(AudioOutputDeviceTest, StartStop) {
-  scoped_refptr<AudioOutputDevice> audio_device(CreateAudioDevice());
+  MockAudioOutputIPC* audio_output_ipc = new MockAudioOutputIPC;
+  scoped_refptr<AudioOutputDevice> audio_device(
+      new AudioOutputDevice(audio_output_ipc, io_loop_.message_loop_proxy()));
   audio_device->Initialize(default_audio_parameters_, &callback_);
 
-  EXPECT_CALL(audio_output_ipc_, AddDelegate(audio_device.get()))
+  EXPECT_CALL(*audio_output_ipc, AddDelegate(audio_device.get()))
       .WillOnce(Return(1));
-  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(1)).WillOnce(Return());
+  EXPECT_CALL(*audio_output_ipc, RemoveDelegate(1)).WillOnce(Return());
 
   audio_device->Start();
   audio_device->Stop();
 
-  EXPECT_CALL(audio_output_ipc_, CreateStream(_, _));
-  EXPECT_CALL(audio_output_ipc_, CloseStream(_));
+  EXPECT_CALL(*audio_output_ipc, CreateStream(_, _));
+  EXPECT_CALL(*audio_output_ipc, CloseStream(_));
 
   io_loop_.RunAllPending();
 }
 
 // Starts an audio stream, creates a shared memory section + SyncSocket pair
 // that AudioOutputDevice must use for audio data.  It then sends a request for
 // a single audio packet and quits when the packet has been sent.
 TEST_F(AudioOutputDeviceTest, CreateStream) {
-  scoped_refptr<AudioOutputDevice> audio_device(CreateAudioDevice());
+  MockAudioOutputIPC* audio_output_ipc = new MockAudioOutputIPC;
+  scoped_refptr<AudioOutputDevice> audio_device(
+      new AudioOutputDevice(audio_output_ipc, io_loop_.message_loop_proxy()));
   audio_device->Initialize(default_audio_parameters_, &callback_);
 
-  EXPECT_CALL(audio_output_ipc_, AddDelegate(audio_device.get()))
+  EXPECT_CALL(*audio_output_ipc, AddDelegate(audio_device.get()))
       .WillOnce(Return(1));
-  EXPECT_CALL(audio_output_ipc_, RemoveDelegate(1)).WillOnce(Return());
+  EXPECT_CALL(*audio_output_ipc, RemoveDelegate(1)).WillOnce(Return());
 
   audio_device->Start();
 
-  EXPECT_CALL(audio_output_ipc_, CreateStream(_, _))
+  EXPECT_CALL(*audio_output_ipc, CreateStream(_, _))
       .WillOnce(WithArgs<0>(
           Invoke(this, &AudioOutputDeviceTest::set_stream_id)));
 
 
   EXPECT_EQ(stream_id_, -1);
   io_loop_.RunAllPending();
 
   // OnCreateStream() must have been called and we should have a valid
   // stream id.
   ASSERT_NE(stream_id_, -1);
@@ skipping 19 matching lines @@
   ASSERT_TRUE(DuplicateSocketHandle(renderer_socket.handle(),
                                     &audio_device_socket));
   base::SharedMemoryHandle duplicated_memory_handle;
   ASSERT_TRUE(shared_memory.ShareToProcess(base::GetCurrentProcessHandle(),
                                            &duplicated_memory_handle));
 
   // 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.
-  EXPECT_CALL(audio_output_ipc_, PlayStream(stream_id_))
+  EXPECT_CALL(*audio_output_ipc, PlayStream(stream_id_))
       .WillOnce(SendPendingBytes(&browser_socket, memory_size));
 
   // 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.
 
@@ skipping 16 matching lines @@
           Return(kNumberOfFramesToProcess)));
 
   audio_device->OnStreamCreated(duplicated_memory_handle, audio_device_socket,
                                 memory_size);
 
   io_loop_.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                            TestTimeouts::action_timeout());
   io_loop_.Run();
 
   // Close the stream sequence.
-  EXPECT_CALL(audio_output_ipc_, CloseStream(stream_id_));
+  EXPECT_CALL(*audio_output_ipc, CloseStream(stream_id_));
 
   audio_device->Stop();
   io_loop_.RunAllPending();
 }
 
 }  // namespace media.