Change class VideoCaptureDevice::Name to struct VideoCaptureDeviceDescriptor

media/capture/video/mac/video_capture_device_decklink_mac.mm

 // Copyright 2014 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 "media/capture/video/mac/video_capture_device_decklink_mac.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 29 matching lines @@
 };
 
 // This class is used to interact directly with DeckLink SDK for video capture.
 // Implements the reference counted interface IUnknown. Has a weak reference to
 // VideoCaptureDeviceDeckLinkMac for sending captured frames, error messages and
 // logs.
 class DeckLinkCaptureDelegate
     : public IDeckLinkInputCallback,
       public base::RefCountedThreadSafe<DeckLinkCaptureDelegate> {
  public:
-  DeckLinkCaptureDelegate(const media::VideoCaptureDevice::Name& device_name,
-                          media::VideoCaptureDeviceDeckLinkMac* frame_receiver);
+  DeckLinkCaptureDelegate(
+      const media::VideoCaptureDeviceDescriptor& device_descriptor,
+      media::VideoCaptureDeviceDeckLinkMac* frame_receiver);
 
   void AllocateAndStart(const media::VideoCaptureParams& params);
   void StopAndDeAllocate();
 
   // Remove the VideoCaptureDeviceDeckLinkMac's weak reference.
   void ResetVideoCaptureDeviceReference();
 
  private:
   // IDeckLinkInputCallback interface implementation.
   HRESULT VideoInputFormatChanged(
       BMDVideoInputFormatChangedEvents notification_events,
       IDeckLinkDisplayMode* new_display_mode,
       BMDDetectedVideoInputFormatFlags detected_signal_flags) override;
   HRESULT VideoInputFrameArrived(
       IDeckLinkVideoInputFrame* video_frame,
       IDeckLinkAudioInputPacket* audio_packet) override;
 
   // IUnknown interface implementation.
   HRESULT QueryInterface(REFIID iid, void** ppv) override;
   ULONG AddRef() override;
   ULONG Release() override;
 
   // Forwarder to VideoCaptureDeviceDeckLinkMac::SendErrorString().
   void SendErrorString(const tracked_objects::Location& from_here,
                        const std::string& reason);
 
   // Forwarder to VideoCaptureDeviceDeckLinkMac::SendLogString().
   void SendLogString(const std::string& message);
 
-  const media::VideoCaptureDevice::Name device_name_;
+  const media::VideoCaptureDeviceDescriptor device_descriptor_;
 
   // Protects concurrent setting and using of |frame_receiver_|.
   base::Lock lock_;
   // Weak reference to the captured frames client, used also for error messages
   // and logging. Initialized on construction and used until cleared by calling
   // ResetVideoCaptureDeviceReference().
   media::VideoCaptureDeviceDeckLinkMac* frame_receiver_;
 
   // This is used to control the video capturing device input interface.
   ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_;
@@ skipping 24 matching lines @@
   // Interlaced formats are going to be marked as double the frame rate,
   // which follows the general naming convention.
   if (display_mode->GetFieldDominance() == bmdLowerFieldFirst ||
       display_mode->GetFieldDominance() == bmdUpperFieldFirst) {
     display_mode_frame_rate *= 2.0f;
   }
   return display_mode_frame_rate;
 }
 
 DeckLinkCaptureDelegate::DeckLinkCaptureDelegate(
-    const media::VideoCaptureDevice::Name& device_name,
+    const media::VideoCaptureDeviceDescriptor& device_descriptor,
     media::VideoCaptureDeviceDeckLinkMac* frame_receiver)
-    : device_name_(device_name), frame_receiver_(frame_receiver) {
-}
+    : device_descriptor_(device_descriptor), frame_receiver_(frame_receiver) {}
 
 DeckLinkCaptureDelegate::~DeckLinkCaptureDelegate() {
 }
 
 void DeckLinkCaptureDelegate::AllocateAndStart(
     const media::VideoCaptureParams& params) {
   DCHECK(thread_checker_.CalledOnValidThread());
   scoped_refptr<IDeckLinkIterator> decklink_iter(
       CreateDeckLinkIteratorInstance());
   DLOG_IF(ERROR, !decklink_iter.get()) << "Error creating DeckLink iterator";
   if (!decklink_iter.get())
     return;
 
   ScopedDeckLinkPtr<IDeckLink> decklink_local;
   while (decklink_iter->Next(decklink_local.Receive()) == S_OK) {
     CFStringRef device_model_name = NULL;
     if ((decklink_local->GetModelName(&device_model_name) == S_OK) ||
-        (device_name_.id() == base::SysCFStringRefToUTF8(device_model_name))) {
+        (device_descriptor_.device_id ==
+         base::SysCFStringRefToUTF8(device_model_name))) {
       break;
     }
   }
   if (!decklink_local.get()) {
     SendErrorString(FROM_HERE, "Device id not found in the system");
     return;
   }
 
   ScopedDeckLinkPtr<IDeckLinkInput> decklink_input_local;
   if (decklink_local->QueryInterface(
@@ skipping 174 matching lines @@
 namespace media {
 
 static std::string JoinDeviceNameAndFormat(CFStringRef name,
                                            CFStringRef format) {
   return base::SysCFStringRefToUTF8(name) + " - " +
          base::SysCFStringRefToUTF8(format);
 }
 
 // static
 void VideoCaptureDeviceDeckLinkMac::EnumerateDevices(
-    VideoCaptureDevice::Names* device_names) {
+    VideoCaptureDeviceDescriptors* device_descriptors) {
   scoped_refptr<IDeckLinkIterator> decklink_iter(
       CreateDeckLinkIteratorInstance());
   // At this point, not being able to create a DeckLink iterator means that
   // there are no Blackmagic DeckLink devices in the system, don't print error.
   DVLOG_IF(1, !decklink_iter.get()) << "Could not create DeckLink iterator";
   if (!decklink_iter.get())
     return;
 
   ScopedDeckLinkPtr<IDeckLink> decklink;
   while (decklink_iter->Next(decklink.Receive()) == S_OK) {
@@ skipping 22 matching lines @@
     ScopedDeckLinkPtr<IDeckLinkDisplayModeIterator> display_mode_iter;
     if (decklink_input->GetDisplayModeIterator(display_mode_iter.Receive()) !=
         S_OK) {
       continue;
     }
 
     ScopedDeckLinkPtr<IDeckLinkDisplayMode> display_mode;
     while (display_mode_iter->Next(display_mode.Receive()) == S_OK) {
       CFStringRef format_name = NULL;
       if (display_mode->GetName(&format_name) == S_OK) {
-        VideoCaptureDevice::Name name(
-            JoinDeviceNameAndFormat(device_display_name, format_name),
-            JoinDeviceNameAndFormat(device_model_name, format_name),
-            VideoCaptureDevice::Name::DECKLINK,
-            VideoCaptureDevice::Name::OTHER_TRANSPORT);
-        device_names->push_back(name);
-        DVLOG(1) << "Blackmagic camera enumerated: " << name.name();
+        VideoCaptureDeviceDescriptor descriptor;
+        descriptor.display_name =
+            JoinDeviceNameAndFormat(device_display_name, format_name);
+        descriptor.device_id =
+            JoinDeviceNameAndFormat(device_model_name, format_name);
+        descriptor.capture_api = VideoCaptureApi::MACOSX_DECKLINK;
+        descriptor.transport_type = VideoCaptureTransportType::OTHER_TRANSPORT;
+        device_descriptors->push_back(descriptor);
+        DVLOG(1) << "Blackmagic camera enumerated: " << descriptor.display_name;
       }
       display_mode.Release();
     }
   }
 }
 
 // static
 void VideoCaptureDeviceDeckLinkMac::EnumerateDeviceCapabilities(
-    const VideoCaptureDevice::Name& device,
+    const VideoCaptureDeviceDescriptor& device,
     VideoCaptureFormats* supported_formats) {
   scoped_refptr<IDeckLinkIterator> decklink_iter(
       CreateDeckLinkIteratorInstance());
   DLOG_IF(ERROR, !decklink_iter.get()) << "Error creating DeckLink iterator";
   if (!decklink_iter.get())
     return;
 
   ScopedDeckLinkPtr<IDeckLink> decklink;
   while (decklink_iter->Next(decklink.Receive()) == S_OK) {
     ScopedDeckLinkPtr<IDeckLink> decklink_local;
@@ skipping 13 matching lines @@
     }
 
     CFStringRef device_model_name = NULL;
     if (decklink_local->GetModelName(&device_model_name) != S_OK)
       continue;
 
     ScopedDeckLinkPtr<IDeckLinkDisplayMode> display_mode;
     while (display_mode_iter->Next(display_mode.Receive()) == S_OK) {
       CFStringRef format_name = NULL;
       if (display_mode->GetName(&format_name) == S_OK &&
-          device.id() !=
+          device.device_id !=
               JoinDeviceNameAndFormat(device_model_name, format_name)) {
         display_mode.Release();
         continue;
       }
 
       // IDeckLinkDisplayMode does not have information on pixel format, this
       // is only available on capture.
       const media::VideoCaptureFormat format(
           gfx::Size(display_mode->GetWidth(), display_mode->GetHeight()),
           GetDisplayModeFrameRate(display_mode),
           PIXEL_FORMAT_UNKNOWN);
       supported_formats->push_back(format);
-      DVLOG(2) << device.name() << " " << VideoCaptureFormat::ToString(format);
+      DVLOG(2) << device.display_name << " "
+               << VideoCaptureFormat::ToString(format);
       display_mode.Release();
     }
     return;
   }
 }
 
 VideoCaptureDeviceDeckLinkMac::VideoCaptureDeviceDeckLinkMac(
-    const Name& device_name)
+    const VideoCaptureDeviceDescriptor& device_descriptor)
     : decklink_capture_delegate_(
-          new DeckLinkCaptureDelegate(device_name, this)) {
-}
+          new DeckLinkCaptureDelegate(device_descriptor, this)) {}
 
 VideoCaptureDeviceDeckLinkMac::~VideoCaptureDeviceDeckLinkMac() {
   decklink_capture_delegate_->ResetVideoCaptureDeviceReference();
 }
 
 void VideoCaptureDeviceDeckLinkMac::OnIncomingCapturedData(
     const uint8_t* data,
     size_t length,
     const VideoCaptureFormat& frame_format,
     int rotation,  // Clockwise.
@@ skipping 30 matching lines @@
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->AllocateAndStart(params);
 }
 
 void VideoCaptureDeviceDeckLinkMac::StopAndDeAllocate() {
   if (decklink_capture_delegate_.get())
     decklink_capture_delegate_->StopAndDeAllocate();
 }
 
 }  // namespace media