Replace AudioManager::GetAudio*DeviceNames with AudioManager::GetAudio*DeviceDescriptions

content/browser/renderer_host/media/media_stream_dispatcher_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/media_stream_dispatcher_host.h"
 
 #include <stddef.h>
 #include <memory>
 #include <queue>
 #include <string>
@@ skipping 46 matching lines @@
 
 const int kProcessId = 5;
 const int kRenderId = 6;
 const int kPageRequestId = 7;
 
 namespace content {
 
 namespace {
 
 void AudioInputDevicesEnumerated(base::Closure quit_closure,
-                                 media::AudioDeviceNames* out,
+                                 media::AudioDeviceDescriptions* out,
                                  const MediaDeviceEnumeration& enumeration) {
   for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
-    out->emplace_back(info.label, info.device_id);
+    out->emplace_back(info.label, info.device_id, info.group_id);
   }
   quit_closure.Run();
 }
 
 }  // namespace
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(
@@ skipping 259 matching lines @@
     host_->OnOpenDevice(render_frame_id, page_request_id, device_id,
                         MEDIA_DEVICE_VIDEO_CAPTURE, origin_,
                         run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->video_devices_, origin_));
   }
 
   bool DoesContainRawIds(const StreamDeviceInfoArray& devices) {
     for (size_t i = 0; i < devices.size(); ++i) {
-      media::AudioDeviceNames::const_iterator audio_it =
-          physical_audio_devices_.begin();
-      for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
-        // Skip default and communications audio devices, whose IDs are not
-        // translated.
-        if (devices[i].device.id ==
-                media::AudioDeviceDescription::kDefaultDeviceId ||
-            devices[i].device.id ==
-                media::AudioDeviceDescription::kCommunicationsDeviceId) {
-          continue;
+      if (devices[i].device.id !=
+              media::AudioDeviceDescription::kDefaultDeviceId &&
+          devices[i].device.id !=
+              media::AudioDeviceDescription::kCommunicationsDeviceId) {
+        for (const auto& audio_device : physical_audio_devices_) {
+          if (audio_device.unique_id == devices[i].device.id)
+            return true;
         }
-        if (audio_it->unique_id == devices[i].device.id)
-          return true;
       }
-      media::VideoCaptureDeviceDescriptors::const_iterator video_it =
-          physical_video_devices_.begin();
-      for (; video_it != physical_video_devices_.end(); ++video_it) {
-        if (video_it->device_id == devices[i].device.id)
+      for (const auto& video_device : physical_video_devices_) {
+        if (video_device.device_id == devices[i].device.id)
           return true;
       }
     }
     return false;
   }
 
   bool DoesEveryDeviceMapToRawId(const StreamDeviceInfoArray& devices,
                                  const url::Origin& origin) {
     for (size_t i = 0; i < devices.size(); ++i) {
       bool found_match = false;
-      media::AudioDeviceNames::const_iterator audio_it =
+      media::AudioDeviceDescriptions::const_iterator audio_it =
           physical_audio_devices_.begin();
       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
         if (content::DoesMediaDeviceIDMatchHMAC(
                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
                 origin,
                 devices[i].device.id,
                 audio_it->unique_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
@@ skipping 34 matching lines @@
 
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<media::AudioManager, media::AudioManagerDeleter>
       audio_manager_;
   MockMediaStreamUIProxy* stream_ui_;
   ContentBrowserClient* old_browser_client_;
   std::unique_ptr<ContentClient> content_client_;
   content::TestBrowserContext browser_context_;
-  media::AudioDeviceNames physical_audio_devices_;
+  media::AudioDeviceDescriptions physical_audio_devices_;
   media::VideoCaptureDeviceDescriptors physical_video_devices_;
   url::Origin origin_;
   media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
   StreamControls controls(false, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
@@ skipping 149 matching lines @@
   run_loop1.Run();
   run_loop2.Run();
 }
 
 // Test that we can generate streams where a sourceId is specified in
 // the request.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithSourceId) {
   ASSERT_GE(physical_audio_devices_.size(), 1u);
   ASSERT_GE(physical_video_devices_.size(), 1u);
 
-  media::AudioDeviceNames::const_iterator audio_it =
+  media::AudioDeviceDescriptions::const_iterator audio_it =
       physical_audio_devices_.begin();
   for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
     std::string source_id = content::GetHMACForMediaDeviceID(
         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
         origin_,
         audio_it->unique_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.audio.device_id = source_id;
 
@@ skipping 200 matching lines @@
   base::RunLoop run_loop;
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   media_stream_manager_->media_devices_manager()->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   run_loop.Run();
 }
 
 };  // namespace content