Add support for the audio-output-device switching IPC mechanism to the renderer lower layers (media…

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/bind_helpers.h"
+#include "base/callback.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_handle.h"
 #include "base/sync_socket.h"
+#include "base/task_runner.h"
 #include "base/test/test_timeouts.h"
+#include "base/thread_task_runner_handle.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/sample_rates.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gmock_mutant.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::CancelableSyncSocket;
 using base::SharedMemory;
 using base::SyncSocket;
 using testing::_;
@@ skipping 22 matching lines @@
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
   MOCK_METHOD3(CreateStream, void(AudioOutputIPCDelegate* delegate,
                                   const AudioParameters& params,
                                   int session_id));
   MOCK_METHOD0(PlayStream, void());
   MOCK_METHOD0(PauseStream, void());
   MOCK_METHOD0(CloseStream, void());
   MOCK_METHOD1(SetVolume, void(double volume));
+  MOCK_METHOD3(SwitchOutputDevice, void(const std::string& device_id,
+                                        const GURL& security_origin,
+                                        int request_id));
+};
+
+class MockSwitchOutputDeviceCallback {
+ public:
+  MOCK_METHOD1(Callback, void(media::SwitchOutputDeviceResult result));
 };
 
 ACTION_P2(SendPendingBytes, socket, pending_bytes) {
   socket->Send(&pending_bytes, sizeof(pending_bytes));
 }
 
 // Used to terminate a loop from a different thread than the loop belongs to.
 // |loop| should be a MessageLoopProxy.
 ACTION_P(QuitLoop, loop) {
   loop->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
 }
 
 }  // namespace.
 
 class AudioOutputDeviceTest
     : public testing::Test,
       public testing::WithParamInterface<bool> {
  public:
   AudioOutputDeviceTest();
   ~AudioOutputDeviceTest();
 
   void StartAudioDevice();
   void CreateStream();
   void ExpectRenderCallback();
   void WaitUntilRenderCallback();
   void StopAudioDevice();
+  void SwitchOutputDevice();
 
  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_;
   base::MessageLoopForIO io_loop_;
   AudioParameters default_audio_parameters_;
   StrictMock<MockRenderCallback> callback_;
   MockAudioOutputIPC* audio_output_ipc_;  // owned by audio_device_
   scoped_refptr<AudioOutputDevice> audio_device_;
+  MockSwitchOutputDeviceCallback switch_output_device_callback_;
 
  private:
   int CalculateMemorySize();
+  void SwitchOutputDeviceCallback(SwitchOutputDeviceResult result);
 
   SharedMemory shared_memory_;
   CancelableSyncSocket browser_socket_;
   CancelableSyncSocket renderer_socket_;
 
   DISALLOW_COPY_AND_ASSIGN(AudioOutputDeviceTest);
 };
 
 int AudioOutputDeviceTest::CalculateMemorySize() {
   // Calculate output memory size.
@@ skipping 85 matching lines @@
 }
 
 void AudioOutputDeviceTest::StopAudioDevice() {
   audio_device_->Stop();
 
   EXPECT_CALL(*audio_output_ipc_, CloseStream());
 
   io_loop_.RunUntilIdle();
 }
 
+void AudioOutputDeviceTest::SwitchOutputDevice() {
+  GURL security_origin("http://localhost");
+  std::string device_id = "";
+  scoped_ptr<media::SwitchOutputDeviceCallback> callback_ptr(
+      new media::SwitchOutputDeviceCallback(
+          base::Bind(&MockSwitchOutputDeviceCallback::Callback,
+                     base::Unretained(&switch_output_device_callback_))));
+
+  scoped_ptr<SwitchOutputDeviceCallbackRunner> callback_runner(
+      new SwitchOutputDeviceCallbackRunner(
+          callback_ptr.Pass(), base::ThreadTaskRunnerHandle::Get()));
+  int request_id = 1;
+
+  // Switch the output device and check that the IPC message is sent
+  audio_device_->SwitchOutputDevice(device_id, security_origin,
+                                    callback_runner.Pass());
+  EXPECT_CALL(*audio_output_ipc_,
+              SwitchOutputDevice(device_id, security_origin, request_id));
+  io_loop_.RunUntilIdle();
+
+  // Simulate the reception of a successful response from the browser
+  audio_device_->OnOutputDeviceSwitched(request_id,
+                                        SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS);
+  EXPECT_CALL(switch_output_device_callback_,
+              Callback(SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS));
+  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
 // filter messages being sent in that case.
 TEST_P(AudioOutputDeviceTest, StartStop) {
   StartAudioDevice();
   StopAudioDevice();
@@ skipping 23 matching lines @@
 
 // Full test with output only.
 TEST_P(AudioOutputDeviceTest, CreateStream) {
   StartAudioDevice();
   ExpectRenderCallback();
   CreateStream();
   WaitUntilRenderCallback();
   StopAudioDevice();
 }
 
+// Switch the output device
+TEST_P(AudioOutputDeviceTest, SwitchOutputDevice) {
+  StartAudioDevice();
+  SwitchOutputDevice();
+  StopAudioDevice();
+}
+
 INSTANTIATE_TEST_CASE_P(Render, AudioOutputDeviceTest, Values(false));
 
 }  // namespace media.