Change class VideoCaptureDevice::Name to struct VideoCaptureDeviceDescriptor

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 <queue>
 #include <string>
 #include <utility>
@@ skipping 277 matching lines @@
 #endif
   }
 
   ~MediaStreamDispatcherHostTest() override {
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::Shutdown();
 #endif
   }
 
   void SetUp() override {
-    video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
+    video_capture_device_factory_->GetDeviceDescriptors(
+        &physical_video_devices_);
     ASSERT_GT(physical_video_devices_.size(), 0u);
 
     media_stream_manager_->audio_input_device_manager()->GetFakeDeviceNames(
         &physical_audio_devices_);
     ASSERT_GT(physical_audio_devices_.size(), 0u);
   }
 
   void TearDown() override { host_->OnChannelClosing(); }
 
  protected:
@@ skipping 81 matching lines @@
   }
 
   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) {
         if (audio_it->unique_id == devices[i].device.id)
           return true;
       }
-      media::VideoCaptureDevice::Names::const_iterator video_it =
+      media::VideoCaptureDeviceDescriptors::const_iterator video_it =
           physical_video_devices_.begin();
       for (; video_it != physical_video_devices_.end(); ++video_it) {
-        if (video_it->id() == devices[i].device.id)
+        if (video_it->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 =
           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;
         }
       }
-      media::VideoCaptureDevice::Names::const_iterator video_it =
+      media::VideoCaptureDeviceDescriptors::const_iterator video_it =
           physical_video_devices_.begin();
       for (; video_it != physical_video_devices_.end(); ++video_it) {
         if (content::DoesMediaDeviceIDMatchHMAC(
                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
-                origin,
-                devices[i].device.id,
-                video_it->id())) {
+                origin, devices[i].device.id, video_it->device_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
       if (!found_match)
         return false;
     }
     return true;
   }
 
@@ skipping 18 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::VideoCaptureDevice::Names physical_video_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 164 matching lines @@
         audio_it->unique_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.audio.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
   }
 
-  media::VideoCaptureDevice::Names::const_iterator video_it =
+  media::VideoCaptureDeviceDescriptors::const_iterator video_it =
       physical_video_devices_.begin();
   for (; video_it != physical_video_devices_.end(); ++video_it) {
     std::string source_id = content::GetHMACForMediaDeviceID(
-        browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
-        origin_,
-        video_it->id());
+        browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(), origin_,
+        video_it->device_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.video.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->video_devices_[0].device.id, source_id);
   }
 }
 
@@ skipping 12 matching lines @@
         audio_it->unique_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.audio.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
   }
 
-  media::VideoCaptureDevice::Names::const_iterator video_it =
+  media::VideoCaptureDeviceDescriptors::const_iterator video_it =
       physical_video_devices_.begin();
   for (; video_it != physical_video_devices_.end(); ++video_it) {
     std::string source_id = content::GetHMACForMediaDeviceID(
-        browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
-        origin_,
-        video_it->id());
+        browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(), origin_,
+        video_it->device_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.video.device_ids.push_back(source_id);
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->video_devices_[0].device.id, source_id);
   }
 }
 
@@ skipping 35 matching lines @@
   StreamControls controls(true, true);
   controls.video.alternate_device_ids.push_back("invalid source id");
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsNoAvailableVideoDevice) {
   physical_video_devices_.clear();
   video_capture_device_factory_->set_number_of_devices(0);
-  video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
+  video_capture_device_factory_->GetDeviceDescriptors(&physical_video_devices_);
   StreamControls controls(true, true);
 
   SetupFakeUI(false);
   GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
 // Test that if a OnStopStreamDevice message is received for a device that has
 // been opened in a MediaStream and by pepper, the device is only stopped for
 // the MediaStream.
@@ skipping 185 matching lines @@
 
 TEST_F(MediaStreamDispatcherHostTest, DeviceChangeNotification) {
   SetupFakeUI(false);
   // warm up the cache
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
   SubscribeToDeviceChangeNotificationsAndWaitForNotification(kRenderId);
 }
 
 };  // namespace content