Change class VideoCaptureDevice::Name to struct VideoCaptureDeviceDescriptor

media/capture/video/mac/video_capture_device_mac.mm

 // 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 "media/capture/video/mac/video_capture_device_mac.h"
 
 #include <IOKit/IOCFPlugIn.h>
 #include <IOKit/usb/IOUSBLib.h>
 #include <IOKit/usb/USBSpec.h>
 #include <stddef.h>
@@ skipping 274 matching lines @@
                                                     &video_control_interface)) {
       return;
     }
     base::mac::ScopedIOPluginInterface<IOCFPlugInInterface>
         plugin_interface_ref(video_control_interface);
 
     SetAntiFlickerInVideoControlInterface(video_control_interface, frequency);
   }
 }
 
-const std::string VideoCaptureDevice::Name::GetModel() const {
-  // Skip the AVFoundation's not USB nor built-in devices.
-  if (capture_api_type() == AVFOUNDATION && transport_type() != USB_OR_BUILT_IN)
-    return "";
-  if (capture_api_type() == DECKLINK)
-    return "";
-  // Both PID and VID are 4 characters.
-  if (unique_id_.size() < 2 * kVidPidSize)
-    return "";
-
-  // The last characters of device id is a concatenation of VID and then PID.
-  const size_t vid_location = unique_id_.size() - 2 * kVidPidSize;
-  std::string id_vendor = unique_id_.substr(vid_location, kVidPidSize);
-  const size_t pid_location = unique_id_.size() - kVidPidSize;
-  std::string id_product = unique_id_.substr(pid_location, kVidPidSize);
-
-  return id_vendor + ":" + id_product;
-}
-
-VideoCaptureDeviceMac::VideoCaptureDeviceMac(const Name& device_name)
-    : device_name_(device_name),
+VideoCaptureDeviceMac::VideoCaptureDeviceMac(
+    const VideoCaptureDeviceDescriptor& device_descriptor)
+    : device_descriptor_(device_descriptor),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       state_(kNotInitialized),
       capture_device_(nil),
-      weak_factory_(this) {
-}
+      weak_factory_(this) {}
 
 VideoCaptureDeviceMac::~VideoCaptureDeviceMac() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 }
 
 void VideoCaptureDeviceMac::AllocateAndStart(
     const VideoCaptureParams& params,
     std::unique_ptr<VideoCaptureDevice::Client> client) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   if (state_ != kIdle) {
     return;
   }
 
   client_ = std::move(client);
-  if (device_name_.capture_api_type() == Name::AVFOUNDATION)
-    LogMessage("Using AVFoundation for device: " + device_name_.name());
+  if (device_descriptor_.capture_api == VideoCaptureApi::MACOSX_AVFOUNDATION)
+    LogMessage("Using AVFoundation for device: " +
+               device_descriptor_.display_name);
 
   NSString* deviceId =
-      [NSString stringWithUTF8String:device_name_.id().c_str()];
+      [NSString stringWithUTF8String:device_descriptor_.device_id.c_str()];
 
   [capture_device_ setFrameReceiver:this];
 
   if (![capture_device_ setCaptureDevice:deviceId]) {
     SetErrorState(FROM_HERE, "Could not open capture device.");
     return;
   }
 
   capture_format_.frame_size = params.requested_format.frame_size;
   capture_format_.frame_rate =
       std::max(kMinFrameRate,
                std::min(params.requested_format.frame_rate, kMaxFrameRate));
   // Leave the pixel format selection to AVFoundation. The pixel format
   // will be passed to |ReceiveFrame|.
   capture_format_.pixel_format = PIXEL_FORMAT_UNKNOWN;
 
   if (!UpdateCaptureResolution())
     return;
 
   // Try setting the power line frequency removal (anti-flicker). The built-in
   // cameras are normally suspended so the configuration must happen right
   // before starting capture and during configuration.
-  const std::string& device_model = device_name_.GetModel();
+  const std::string device_model = GetDeviceModelId(
+      device_descriptor_.device_id, device_descriptor_.capture_api,
+      device_descriptor_.transport_type);
   if (device_model.length() > 2 * kVidPidSize) {
     std::string vendor_id = device_model.substr(0, kVidPidSize);
     std::string model_id = device_model.substr(kVidPidSize + 1);
     int vendor_id_as_int, model_id_as_int;
     if (base::HexStringToInt(base::StringPiece(vendor_id), &vendor_id_as_int) &&
         base::HexStringToInt(base::StringPiece(model_id), &model_id_as_int)) {
       SetAntiFlickerInUsbDevice(vendor_id_as_int, model_id_as_int,
                                 GetPowerLineFrequency(params));
     }
   }
@@ skipping 20 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(state_ == kCapturing) << state_;
 
   if (photo_callback_)  // Only one picture can be in flight at a time.
     return;
 
   photo_callback_.reset(new TakePhotoCallback(std::move(callback)));
   [capture_device_ takePhoto];
 }
 
-bool VideoCaptureDeviceMac::Init(
-    VideoCaptureDevice::Name::CaptureApiType capture_api_type) {
+bool VideoCaptureDeviceMac::Init(VideoCaptureApi capture_api_type) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kNotInitialized);
 
-  if (capture_api_type != Name::AVFOUNDATION)
+  if (capture_api_type != VideoCaptureApi::MACOSX_AVFOUNDATION)
     return false;
 
   capture_device_.reset(
       [[VideoCaptureDeviceAVFoundation alloc] initWithFrameReceiver:this]);
 
   if (!capture_device_)
     return false;
 
   state_ = kIdle;
   return true;
@@ skipping 38 matching lines @@
 }
 
 void VideoCaptureDeviceMac::ReceiveError(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoCaptureDeviceMac::SetErrorState,
                             weak_factory_.GetWeakPtr(), from_here, reason));
 }
 
+void VideoCaptureDeviceMac::LogMessage(const std::string& message) {
+  DCHECK(task_runner_->BelongsToCurrentThread());
+  if (client_)
+    client_->OnLog(message);
+}
+
+// static
+std::string VideoCaptureDeviceMac::GetDeviceModelId(
+    const std::string& device_id,
+    VideoCaptureApi capture_api,
+    VideoCaptureTransportType transport_type) {
+  // Skip the AVFoundation's not USB nor built-in devices.
+  if (capture_api == VideoCaptureApi::MACOSX_AVFOUNDATION &&
+      transport_type != VideoCaptureTransportType::MACOSX_USB_OR_BUILT_IN)
+    return "";
+  if (capture_api == VideoCaptureApi::MACOSX_DECKLINK)
+    return "";
+  // Both PID and VID are 4 characters.
+  if (device_id.size() < 2 * kVidPidSize)
+    return "";
+
+  // The last characters of device id is a concatenation of VID and then PID.
+  const size_t vid_location = device_id.size() - 2 * kVidPidSize;
+  std::string id_vendor = device_id.substr(vid_location, kVidPidSize);
+  const size_t pid_location = device_id.size() - kVidPidSize;
+  std::string id_product = device_id.substr(pid_location, kVidPidSize);
+
+  return id_vendor + ":" + id_product;
+}
+
 void VideoCaptureDeviceMac::SetErrorState(
     const tracked_objects::Location& from_here,
     const std::string& reason) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   state_ = kError;
   client_->OnError(from_here, reason);
 }
 
-void VideoCaptureDeviceMac::LogMessage(const std::string& message) {
-  DCHECK(task_runner_->BelongsToCurrentThread());
-  if (client_)
-    client_->OnLog(message);
-}
-
 bool VideoCaptureDeviceMac::UpdateCaptureResolution() {
   if (![capture_device_ setCaptureHeight:capture_format_.frame_size.height()
                                    width:capture_format_.frame_size.width()
                                frameRate:capture_format_.frame_rate]) {
     ReceiveError(FROM_HERE, "Could not configure capture device.");
     return false;
   }
   return true;
 }
 
 }  // namespace media