Allow AudioOutputDevice objects to be initialized with a specific hardware output device and store …

content/renderer/media/webrtc_audio_renderer_unittest.cc

 // Copyright 2014 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 <string>
 #include <vector>
 
 #include "base/single_thread_task_runner.h"
 #include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_audio_renderer.h"
 #include "media/audio/audio_output_device.h"
 #include "media/audio/audio_output_ipc.h"
 #include "media/base/audio_bus.h"
 #include "media/base/mock_audio_renderer_sink.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
 using testing::Return;
+using testing::_;
 
 namespace content {
 
 namespace {
 
 const int kHardwareSampleRate = 44100;
 const int kHardwareBufferSize = 512;
 
 class MockAudioOutputIPC : public media::AudioOutputIPC {
  public:
   MockAudioOutputIPC() {}
   virtual ~MockAudioOutputIPC() {}
 
-  MOCK_METHOD3(CreateStream, void(media::AudioOutputIPCDelegate* delegate,
-                                  const media::AudioParameters& params,
-                                  int session_id));
+  MOCK_METHOD4(RequestDeviceAuthorization,
+               void(media::AudioOutputIPCDelegate* delegate,
+                    int session_id,
+                    const std::string& device_id,
+                    const url::Origin& security_origin));
+  MOCK_METHOD2(CreateStream,
+               void(media::AudioOutputIPCDelegate* delegate,
+                    const media::AudioParameters& params));
   MOCK_METHOD0(PlayStream, void());
   MOCK_METHOD0(PauseStream, void());
   MOCK_METHOD0(CloseStream, void());
   MOCK_METHOD1(SetVolume, void(double volume));
-  MOCK_METHOD3(SwitchOutputDevice,
+  MOCK_METHOD2(SwitchOutputDevice,
                void(const std::string& device_id,
-                    const GURL& security_origin,
-                    int request_id));
+                    const url::Origin& security_origin));
 };
 
 class FakeAudioOutputDevice
     : NON_EXPORTED_BASE(public media::AudioOutputDevice) {
  public:
   FakeAudioOutputDevice(
       scoped_ptr<media::AudioOutputIPC> ipc,
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
       : AudioOutputDevice(ipc.Pass(),
-                          io_task_runner) {}
+                          io_task_runner,
+                          0,
+                          std::string(),
+                          url::Origin()) {}
   MOCK_METHOD0(Start, void());
   MOCK_METHOD0(Stop, void());
   MOCK_METHOD0(Pause, void());
   MOCK_METHOD0(Play, void());
   MOCK_METHOD1(SetVolume, bool(double volume));
   MOCK_METHOD0(GetOutputDevice, media::OutputDevice*());
 
  protected:
   virtual ~FakeAudioOutputDevice() {}
 };
 
 class MockAudioDeviceFactory : public AudioDeviceFactory {
  public:
   MockAudioDeviceFactory() {}
   virtual ~MockAudioDeviceFactory() {}
-  MOCK_METHOD1(CreateOutputDevice, media::AudioOutputDevice*(int));
+  MOCK_METHOD4(CreateOutputDevice,
+               media::AudioOutputDevice*(int,
+                                         int,
+                                         const std::string&,
+                                         const url::Origin&));
   MOCK_METHOD1(CreateInputDevice, media::AudioInputDevice*(int));
 };
 
 class MockAudioRendererSource : public WebRtcAudioRendererSource {
  public:
   MockAudioRendererSource() {}
   virtual ~MockAudioRendererSource() {}
   MOCK_METHOD4(RenderData, void(media::AudioBus* audio_bus,
                                 int sample_rate,
                                 int audio_delay_milliseconds,
@@ skipping 13 matching lines @@
             message_loop_->task_runner())),
         factory_(new MockAudioDeviceFactory()),
         source_(new MockAudioRendererSource()),
         stream_(new rtc::RefCountedObject<MockMediaStream>("label")),
         renderer_(new WebRtcAudioRenderer(message_loop_->task_runner(),
                                           stream_,
                                           1,
                                           1,
                                           44100,
                                           kHardwareBufferSize)) {
-    EXPECT_CALL(*factory_.get(), CreateOutputDevice(1))
+    EXPECT_CALL(*factory_.get(), CreateOutputDevice(1, _, _, _))
         .WillOnce(Return(mock_output_device_.get()));
     EXPECT_CALL(*mock_output_device_.get(), Start());
     EXPECT_TRUE(renderer_->Initialize(source_.get()));
     renderer_proxy_ = renderer_->CreateSharedAudioRendererProxy(stream_);
   }
 
   // Used to construct |mock_output_device_|.
   scoped_ptr<base::MessageLoopForIO> message_loop_;
   MockAudioOutputIPC* mock_ipc_;  // Owned by AudioOuputDevice.
 
@@ skipping 63 matching lines @@
   EXPECT_EQ(kExpectedBufferSize, renderer_->frames_per_buffer());
   EXPECT_EQ(kHardwareSampleRate, renderer_->sample_rate());
   EXPECT_EQ(2, renderer_->channels());
 
   EXPECT_CALL(*mock_output_device_.get(), Stop());
   EXPECT_CALL(*source_.get(), RemoveAudioRenderer(renderer_.get()));
   renderer_proxy_->Stop();
 }
 
 }  // namespace content