Looking up device id by session id for AudioRendererMixerInput

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 "content/browser/renderer_host/media/audio_renderer_host.h"
 
 #include <stdint.h>
 
 #include <memory>
 
@@ skipping 58 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,
+  MOCK_METHOD4(OnDeviceAuthorized,
                void(int stream_id,
                     media::OutputDeviceStatus device_status,
-                    const media::AudioParameters& output_params));
+                    const media::AudioParameters& output_params,
+                    const std::string& matched_device_id));
   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));
 
  private:
   virtual ~MockAudioRendererHost() {
     // Make sure all audio streams have been deleted.
     EXPECT_TRUE(audio_entries_.empty());
   }
@@ skipping 17 matching lines @@
       IPC_MESSAGE_UNHANDLED(handled = false)
     IPC_END_MESSAGE_MAP()
     EXPECT_TRUE(handled);
 
     delete message;
     return true;
   }
 
   void OnNotifyDeviceAuthorized(int stream_id,
                                 media::OutputDeviceStatus device_status,
-                                const media::AudioParameters& output_params) {
-    OnDeviceAuthorized(stream_id, device_status, output_params);
+                                const media::AudioParameters& output_params,
+                                const std::string& matched_device_id) {
+    OnDeviceAuthorized(stream_id, device_status, output_params,
+                       matched_device_id);
   }
 
   void OnNotifyStreamCreated(
       int stream_id,
       base::SharedMemoryHandle handle,
       base::SyncSocket::TransitDescriptor socket_descriptor,
       uint32_t length) {
     // Maps the shared memory.
     shared_memory_.reset(new base::SharedMemory(handle, false));
     CHECK(shared_memory_->Map(length));
@@ skipping 95 matching lines @@
               const std::string& device_id,
               const url::Origin& security_origin) {
     media::OutputDeviceStatus expected_device_status =
         device_id == kDefaultDeviceId
             ? media::OUTPUT_DEVICE_STATUS_OK
             : device_id == kBadDeviceId
                   ? media::OUTPUT_DEVICE_STATUS_ERROR_NOT_AUTHORIZED
                   : media::OUTPUT_DEVICE_STATUS_ERROR_NOT_FOUND;
 
     EXPECT_CALL(*host_.get(),
-                OnDeviceAuthorized(kStreamId, expected_device_status, _));
+                OnDeviceAuthorized(kStreamId, expected_device_status, _, _));
 
     if (expected_device_status == media::OUTPUT_DEVICE_STATUS_OK) {
       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.
@@ skipping 155 matching lines @@
 }
 
 TEST_F(AudioRendererHostTest, CreateInvalidDevice) {
   Create(false, kInvalidDeviceId, url::Origin(GURL(kSecurityOrigin)));
   Close();
 }
 
 // TODO(hclam): Add tests for data conversation in low latency mode.
 
 }  // namespace content