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

content/renderer/media/audio_message_filter_unittest.cc

Index: content/renderer/media/audio_message_filter_unittest.cc
diff --git a/content/renderer/media/audio_message_filter_unittest.cc b/content/renderer/media/audio_message_filter_unittest.cc
index 65b3baa6a78b07f68d45eaf45309835bd27451ad..f85ef0ea13472d3dbfdf51fdbda9545cf9d98f86 100644
--- a/content/renderer/media/audio_message_filter_unittest.cc
+++ b/content/renderer/media/audio_message_filter_unittest.cc
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <string>
+
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/media/audio_message_filter.h"
 #include "media/audio/audio_output_ipc.h"
@@ -23,6 +25,13 @@ class MockAudioDelegate : public media::AudioOutputIPCDelegate {
     state_ = state;
   }
 
+  void OnDeviceAuthorized(
+      bool success,
+      const media::AudioParameters& output_params) override {
+    device_authorized_received_ = true;
+    output_params_ = output_params;
+  }
+
   void OnStreamCreated(base::SharedMemoryHandle handle,
                        base::SyncSocket::Handle,
                        int length) override {
@@ -31,10 +40,12 @@ class MockAudioDelegate : public media::AudioOutputIPCDelegate {
     length_ = length;
   }
 
-  void OnOutputDeviceSwitched(int request_id,
-                              media::SwitchOutputDeviceResult result) override {
+  void OnOutputDeviceSwitched(
+      media::SwitchOutputDeviceResult result,
+      const media::AudioParameters& output_params) override {
     output_device_switched_received_ = true;
     switch_output_device_result_ = result;
+    output_params_ = output_params;
   }
 
   void OnIPCClosed() override {}
@@ -43,6 +54,9 @@ class MockAudioDelegate : public media::AudioOutputIPCDelegate {
     state_changed_received_ = false;
     state_ = media::AUDIO_OUTPUT_IPC_DELEGATE_STATE_ERROR;
 
+    device_authorized_received_ = false;
+    output_params_ = media::AudioParameters();
+
     created_received_ = false;
     handle_ = base::SharedMemory::NULLHandle();
     length_ = 0;
@@ -52,12 +66,15 @@ class MockAudioDelegate : public media::AudioOutputIPCDelegate {
 
     output_device_switched_received_ = false;
     switch_output_device_result_ =
-        media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_SUPPORTED;
+        media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_INTERNAL;
   }
 
   bool state_changed_received() { return state_changed_received_; }
   media::AudioOutputIPCDelegateState state() { return state_; }
 
+  bool device_authorized_received() { return device_authorized_received_; }
+  media::AudioParameters output_params() { return output_params_; }
+
   bool created_received() { return created_received_; }
   base::SharedMemoryHandle handle() { return handle_; }
   uint32 length() { return length_; }
@@ -73,6 +90,9 @@ class MockAudioDelegate : public media::AudioOutputIPCDelegate {
   bool state_changed_received_;
   media::AudioOutputIPCDelegateState state_;
 
+  bool device_authorized_received_;
+  media::AudioParameters output_params_;
+
   bool created_received_;
   base::SharedMemoryHandle handle_;
   int length_;
@@ -86,6 +106,19 @@ class MockAudioDelegate : public media::AudioOutputIPCDelegate {
   DISALLOW_COPY_AND_ASSIGN(MockAudioDelegate);
 };
 
+media::AudioParameters MockOutputParams() {
+  return media::AudioParameters(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
+                                media::CHANNEL_LAYOUT_STEREO,
+                                media::AudioParameters::kAudioCDSampleRate, 16,
+                                100);
+}
+
+media::AudioParameters MockOutputParamsSwitch() {
+  return media::AudioParameters(
+      media::AudioParameters::AUDIO_PCM_LOW_LATENCY, media::CHANNEL_LAYOUT_MONO,
+      media::AudioParameters::kTelephoneSampleRate, 16, 10);
+}
+
 }  // namespace
 
 TEST(AudioMessageFilterTest, Basic) {
@@ -98,10 +131,22 @@ TEST(AudioMessageFilterTest, Basic) {
   const scoped_ptr<media::AudioOutputIPC> ipc =
       filter->CreateAudioOutputIPC(kRenderFrameId);
   static const int kSessionId = 0;
-  ipc->CreateStream(&delegate, media::AudioParameters(), kSessionId);
+  static const std::string kDeviceId;
+  static const GURL kSecurityOrigin;
+  ipc->RequestDeviceAuthorization(&delegate, kSessionId, kDeviceId,
+                                  kSecurityOrigin);
+  ipc->CreateStream(&delegate, media::AudioParameters());
   static const int kStreamId = 1;
   EXPECT_EQ(&delegate, filter->delegates_.Lookup(kStreamId));
 
+  // AudioMsg_NotifyDeviceAuthorized
+  EXPECT_FALSE(delegate.device_authorized_received());
+  filter->OnMessageReceived(
+      AudioMsg_NotifyDeviceAuthorized(kStreamId, true, MockOutputParams()));
+  EXPECT_TRUE(delegate.device_authorized_received());
+  EXPECT_TRUE(delegate.output_params().Equals(MockOutputParams()));
+  delegate.Reset();
+
   // AudioMsg_NotifyStreamCreated
   base::SyncSocket::TransitDescriptor socket_descriptor;
   const uint32 kLength = 1024;
@@ -123,13 +168,14 @@ TEST(AudioMessageFilterTest, Basic) {
   delegate.Reset();
 
   // AudioMsg_NotifyOutputDeviceSwitched
-  static const int kSwitchOutputRequestId = 1;
   EXPECT_FALSE(delegate.output_device_switched_received());
-  filter->OnOutputDeviceSwitched(kStreamId, kSwitchOutputRequestId,
-                                 media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS);
+  filter->OnOutputDeviceSwitched(kStreamId,
+                                 media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS,
+                                 MockOutputParamsSwitch());
   EXPECT_TRUE(delegate.output_device_switched_received());
   EXPECT_EQ(media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS,
             delegate.switch_output_device_result());
+  EXPECT_TRUE(delegate.output_params().Equals(MockOutputParamsSwitch()));
   message_loop.RunUntilIdle();
 
   ipc->CloseStream();
@@ -149,9 +195,8 @@ TEST(AudioMessageFilterTest, Delegates) {
       filter->CreateAudioOutputIPC(kRenderFrameId);
   const scoped_ptr<media::AudioOutputIPC> ipc2 =
       filter->CreateAudioOutputIPC(kRenderFrameId);
-  static const int kSessionId = 0;
-  ipc1->CreateStream(&delegate1, media::AudioParameters(), kSessionId);
-  ipc2->CreateStream(&delegate2, media::AudioParameters(), kSessionId);
+  ipc1->CreateStream(&delegate1, media::AudioParameters());
+  ipc2->CreateStream(&delegate2, media::AudioParameters());
   static const int kStreamId1 = 1;
   static const int kStreamId2 = 2;
   EXPECT_EQ(&delegate1, filter->delegates_.Lookup(kStreamId1));