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

content/browser/renderer_host/media/audio_renderer_host_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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/sync_socket.h"
 #include "content/browser/media/capture/audio_mirroring_manager.h"
@@ skipping 14 matching lines @@
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::DoAll;
 using ::testing::NotNull;
 
 namespace {
 const int kRenderProcessId = 1;
 const int kRenderFrameId = 5;
 const int kStreamId = 50;
 const int kBadStreamId = 99;
-const int kSwitchOutputDeviceRequestId = 1;
 const GURL kSecurityOrigin("http://localhost");
-const std::string kDefaultDeviceID = "";
+const GURL kDefaultSecurityOrigin;
+const std::string kDefaultDeviceID;
 const std::string kBadDeviceID = "bad-device-id";
 }  // namespace
 
 namespace content {
 
 class MockAudioMirroringManager : public AudioMirroringManager {
  public:
   MockAudioMirroringManager() {}
   virtual ~MockAudioMirroringManager() {}
 
@@ skipping 16 matching lines @@
                         const ResourceContext::SaltCallback& salt_callback)
       : AudioRendererHost(kRenderProcessId,
                           audio_manager,
                           mirroring_manager,
                           media_internals,
                           media_stream_manager,
                           salt_callback),
         shared_memory_length_(0) {}
 
   // A list of mock methods.
+  MOCK_METHOD3(OnDeviceAuthorized,
+               void(int stream_id,
+                    bool success,
+                    const media::AudioParameters& output_params));
   MOCK_METHOD2(OnStreamCreated, void(int stream_id, int length));
   MOCK_METHOD1(OnStreamPlaying, void(int stream_id));
   MOCK_METHOD1(OnStreamPaused, void(int stream_id));
   MOCK_METHOD1(OnStreamError, void(int stream_id));
   MOCK_METHOD3(OnOutputDeviceSwitched,
                void(int stream_id,
-                    int request_id,
-                    media::SwitchOutputDeviceResult result));
+                    media::SwitchOutputDeviceResult result,
+                    const media::AudioParameters& output_params));
 
  private:
   virtual ~MockAudioRendererHost() {
     // Make sure all audio streams have been deleted.
     EXPECT_TRUE(audio_entries_.empty());
   }
 
   // This method is used to dispatch IPC messages to the renderer. We intercept
   // these messages here and dispatch to our mock methods to verify the
   // conversation between this object and the renderer.
   virtual bool Send(IPC::Message* message) {
     CHECK(message);
 
     // In this method we dispatch the messages to the according handlers as if
     // we are the renderer.
     bool handled = true;
     IPC_BEGIN_MESSAGE_MAP(MockAudioRendererHost, *message)
+      IPC_MESSAGE_HANDLER(AudioMsg_NotifyDeviceAuthorized,
+                          OnNotifyDeviceAuthorized)
       IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamCreated,
                           OnNotifyStreamCreated)
       IPC_MESSAGE_HANDLER(AudioMsg_NotifyStreamStateChanged,
                           OnNotifyStreamStateChanged)
       IPC_MESSAGE_HANDLER(AudioMsg_NotifyOutputDeviceSwitched,
                           OnNotifyOutputDeviceSwitched)
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
+  void OnNotifyDeviceAuthorized(int stream_id,
+                                bool success,
+                                const media::AudioParameters& output_params) {
+    OnDeviceAuthorized(stream_id, success, output_params);
+  }
+
   void OnNotifyStreamCreated(
       int stream_id, base::SharedMemoryHandle handle,
       base::SyncSocket::TransitDescriptor socket_descriptor, uint32 length) {
     // Maps the shared memory.
     shared_memory_.reset(new base::SharedMemory(handle, false));
     CHECK(shared_memory_->Map(length));
     CHECK(shared_memory_->memory());
     shared_memory_length_ = length;
 
     // Create the SyncSocket using the handle.
@@ skipping 17 matching lines @@
       case media::AUDIO_OUTPUT_IPC_DELEGATE_STATE_ERROR:
         OnStreamError(stream_id);
         break;
       default:
         FAIL() << "Unknown stream state";
         break;
     }
   }
 
   void OnNotifyOutputDeviceSwitched(int stream_id,
-                                    int request_id,
-                                    media::SwitchOutputDeviceResult result) {
+                                    media::SwitchOutputDeviceResult result,
+                                    const media::AudioParameters& params) {
     switch (result) {
       case media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS:
       case media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_FOUND:
       case media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_AUTHORIZED:
-      case media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_OBSOLETE:
-      case media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_SUPPORTED:
-        OnOutputDeviceSwitched(stream_id, request_id, result);
+      case media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_INTERNAL:
+        OnOutputDeviceSwitched(stream_id, result, params);
         break;
       default:
         FAIL() << "Unknown SwitchOutputDevice result";
         break;
     }
   }
 
   scoped_ptr<base::SharedMemory> shared_memory_;
   scoped_ptr<base::SyncSocket> sync_socket_;
   uint32 shared_memory_length_;
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioRendererHost);
 };
 
 namespace {
 std::string ReturnMockSalt() {
   return std::string();
 }
 
 ResourceContext::SaltCallback GetMockSaltCallback() {
   return base::Bind(&ReturnMockSalt);
 }
+
+void WaitForEnumeration(base::RunLoop* loop,
+                        const AudioOutputDeviceEnumeration& e) {
+  loop->Quit();
 }
+}  // namespace
 
 class AudioRendererHostTest : public testing::Test {
  public:
   AudioRendererHostTest() {
     audio_manager_.reset(media::AudioManager::CreateForTesting());
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeDeviceForMediaStream);
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
+
+    // Enable caching to make enumerations run in a single thread
+    media_stream_manager_->audio_output_device_enumerator()->SetCachePolicy(
+        AudioOutputDeviceEnumerator::CACHE_POLICY_MANUAL_INVALIDATION);
+    base::RunLoop().RunUntilIdle();
+    base::RunLoop run_loop;
+    media_stream_manager_->audio_output_device_enumerator()->Enumerate(
+        base::Bind(&WaitForEnumeration, &run_loop));
+    run_loop.Run();
+
     host_ = new MockAudioRendererHost(audio_manager_.get(), &mirroring_manager_,
                                       MediaInternals::GetInstance(),
                                       media_stream_manager_.get(),
                                       GetMockSaltCallback());
 
     // Simulate IPC channel connected.
     host_->set_peer_process_for_testing(base::Process::Current());
   }
 
   ~AudioRendererHostTest() override {
     // Simulate closing the IPC channel and give the audio thread time to close
     // the underlying streams.
     host_->OnChannelClosing();
     SyncWithAudioThread();
 
     // Release the reference to the mock object.  The object will be destructed
     // on message_loop_.
     host_ = NULL;
   }
 
  protected:
   void Create(bool unified_stream) {
+    EXPECT_CALL(*host_.get(), OnDeviceAuthorized(kStreamId, true, _));
     EXPECT_CALL(*host_.get(), OnStreamCreated(kStreamId, _));
 
     EXPECT_CALL(mirroring_manager_,
                 AddDiverter(kRenderProcessId, kRenderFrameId, NotNull()))
         .RetiresOnSaturation();
 
     // Send a create stream message to the audio output stream and wait until
     // we receive the created message.
     int session_id;
     media::AudioParameters params;
     if (unified_stream) {
       // Use AudioInputDeviceManager::kFakeOpenSessionId as the session id to
       // pass the permission check.
       session_id = AudioInputDeviceManager::kFakeOpenSessionId;
       params = media::AudioParameters(
           media::AudioParameters::AUDIO_FAKE,
           media::CHANNEL_LAYOUT_STEREO,
           media::AudioParameters::kAudioCDSampleRate, 16,
           media::AudioParameters::kAudioCDSampleRate / 10,
           media::AudioParameters::NO_EFFECTS);
     } else {
       session_id = 0;
       params = media::AudioParameters(
           media::AudioParameters::AUDIO_FAKE,
           media::CHANNEL_LAYOUT_STEREO,
           media::AudioParameters::kAudioCDSampleRate, 16,
           media::AudioParameters::kAudioCDSampleRate / 10);
     }
-    host_->OnCreateStream(kStreamId, kRenderFrameId, session_id, params);
+    host_->OnRequestDeviceAuthorization(kStreamId, kRenderFrameId, session_id,
+                                        kDefaultDeviceID,
+                                        kDefaultSecurityOrigin);
+    host_->OnCreateStream(kStreamId, kRenderFrameId, params);
 
     // At some point in the future, a corresponding RemoveDiverter() call must
     // be made.
     EXPECT_CALL(mirroring_manager_, RemoveDiverter(NotNull()))
         .RetiresOnSaturation();
     SyncWithAudioThread();
   }
 
   void Close() {
     // Send a message to AudioRendererHost to tell it we want to close the
@@ skipping 13 matching lines @@
     host_->OnPauseStream(kStreamId);
     SyncWithAudioThread();
   }
 
   void SetVolume(double volume) {
     host_->OnSetVolume(kStreamId, volume);
     SyncWithAudioThread();
   }
 
   void SwitchOutputDevice(int stream_id,
-                          std::string device_id,
+                          const std::string& device_id,
+                          const GURL& security_origin,
                           media::SwitchOutputDeviceResult expected_result) {
     EXPECT_CALL(*host_.get(),
-                OnOutputDeviceSwitched(stream_id, kSwitchOutputDeviceRequestId,
-                                       expected_result));
+                OnOutputDeviceSwitched(stream_id, expected_result, _));
     host_->OnSwitchOutputDevice(stream_id, kRenderFrameId, device_id,
-                                kSecurityOrigin, kSwitchOutputDeviceRequestId);
+                                security_origin);
     SyncWithAudioThread();
   }
 
   void SimulateError() {
     EXPECT_EQ(1u, host_->audio_entries_.size())
         << "Calls Create() before calling this method";
 
     // Expect an error signal sent through IPC.
     EXPECT_CALL(*host_.get(), OnStreamError(kStreamId));
 
@@ skipping 56 matching lines @@
 TEST_F(AudioRendererHostTest, SetVolume) {
   Create(false);
   SetVolume(0.5);
   Play();
   Pause();
   Close();
 }
 
 TEST_F(AudioRendererHostTest, SwitchOutputDevice) {
   Create(false);
-  SwitchOutputDevice(kStreamId, kDefaultDeviceID,
+  SwitchOutputDevice(kStreamId, kDefaultDeviceID, kDefaultSecurityOrigin,
                      media::SWITCH_OUTPUT_DEVICE_RESULT_SUCCESS);
   Close();
 }
 
 TEST_F(AudioRendererHostTest, SwitchOutputDeviceNotAuthorized) {
   Create(false);
-  SwitchOutputDevice(kStreamId, kBadDeviceID,
+  SwitchOutputDevice(kStreamId, kBadDeviceID, kSecurityOrigin,
                      media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_NOT_AUTHORIZED);
   Close();
 }
 
 TEST_F(AudioRendererHostTest, SwitchOutputDeviceNoStream) {
   Create(false);
-  SwitchOutputDevice(kBadStreamId, kDefaultDeviceID,
-                     media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_OBSOLETE);
+  SwitchOutputDevice(kBadStreamId, kDefaultDeviceID, kDefaultSecurityOrigin,
+                     media::SWITCH_OUTPUT_DEVICE_RESULT_ERROR_INTERNAL);
   Close();
 }
 
 // Simulate the case where a stream is not properly closed.
 TEST_F(AudioRendererHostTest, CreatePlayAndShutdown) {
   Create(false);
   Play();
 }
 
 // Simulate the case where a stream is not properly closed.
@@ skipping 20 matching lines @@
 }
 
 TEST_F(AudioRendererHostTest, CreateUnifiedStreamAndClose) {
   Create(true);
   Close();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.
 
 }  // namespace content