Change class VideoCaptureDevice::Name to struct VideoCaptureDeviceDescriptor

media/capture/video/linux/video_capture_device_factory_linux.cc

 // 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/linux/video_capture_device_factory_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stdint.h>
 #include <sys/ioctl.h>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/scoped_file.h"
 #include "base/posix/eintr_wrapper.h"
+#include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 
 #if defined(OS_OPENBSD)
 #include <sys/videoio.h>
 #else
 #include <linux/videodev2.h>
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "media/capture/video/linux/video_capture_device_chromeos.h"
 #endif
 #include "media/capture/video/linux/video_capture_device_linux.h"
 
 namespace media {
 
+// USB VID and PID are both 4 bytes long.
+static const size_t kVidPidSize = 4;
+
+// /sys/class/video4linux/video{N}/device is a symlink to the corresponding
+// USB device info directory.
+static const char kVidPathTemplate[] =
+    "/sys/class/video4linux/%s/device/../idVendor";
+static const char kPidPathTemplate[] =
+    "/sys/class/video4linux/%s/device/../idProduct";
+
+static bool ReadIdFile(const std::string& path, std::string* id) {
+  char id_buf[kVidPidSize];
+  FILE* file = fopen(path.c_str(), "rb");
+  if (!file)
+    return false;
+  const bool success = fread(id_buf, kVidPidSize, 1, file) == 1;
+  fclose(file);
+  if (!success)
+    return false;
+  id->append(id_buf, kVidPidSize);
+  return true;
+}
+
 static bool HasUsableFormats(int fd, uint32_t capabilities) {
   if (!(capabilities & V4L2_CAP_VIDEO_CAPTURE))
     return false;
 
   const std::list<uint32_t>& usable_fourccs =
       VideoCaptureDeviceLinux::GetListOfUsableFourCCs(false);
   v4l2_fmtdesc fmtdesc = {};
   fmtdesc.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   for (; HANDLE_EINTR(ioctl(fd, VIDIOC_ENUM_FMT, &fmtdesc)) == 0;
        ++fmtdesc.index) {
@@ skipping 82 matching lines @@
 
 VideoCaptureDeviceFactoryLinux::VideoCaptureDeviceFactoryLinux(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner)
     : ui_task_runner_(ui_task_runner) {
 }
 
 VideoCaptureDeviceFactoryLinux::~VideoCaptureDeviceFactoryLinux() {
 }
 
 std::unique_ptr<VideoCaptureDevice> VideoCaptureDeviceFactoryLinux::Create(
-    const VideoCaptureDevice::Name& device_name) {
+    const VideoCaptureDeviceDescriptor& device_descriptor) {
   DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(OS_CHROMEOS)
   VideoCaptureDeviceChromeOS* self =
-      new VideoCaptureDeviceChromeOS(ui_task_runner_, device_name);
+      new VideoCaptureDeviceChromeOS(ui_task_runner_, device_descriptor);
 #else
-  VideoCaptureDeviceLinux* self = new VideoCaptureDeviceLinux(device_name);
+  VideoCaptureDeviceLinux* self =
+      new VideoCaptureDeviceLinux(device_descriptor);
 #endif
   if (!self)
     return std::unique_ptr<VideoCaptureDevice>();
   // Test opening the device driver. This is to make sure it is available.
   // We will reopen it again in our worker thread when someone
   // allocates the camera.
-  base::ScopedFD fd(HANDLE_EINTR(open(device_name.id().c_str(), O_RDONLY)));
+  base::ScopedFD fd(
+      HANDLE_EINTR(open(device_descriptor.device_id.c_str(), O_RDONLY)));
   if (!fd.is_valid()) {
     DLOG(ERROR) << "Cannot open device";
     delete self;
     return std::unique_ptr<VideoCaptureDevice>();
   }
 
   return std::unique_ptr<VideoCaptureDevice>(self);
 }
 
-void VideoCaptureDeviceFactoryLinux::GetDeviceNames(
-    VideoCaptureDevice::Names* const device_names) {
+void VideoCaptureDeviceFactoryLinux::GetDeviceDescriptors(
+    VideoCaptureDeviceDescriptors* device_descriptors) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(device_names->empty());
+  DCHECK(device_descriptors->empty());
   const base::FilePath path("/dev/");
   base::FileEnumerator enumerator(path, false, base::FileEnumerator::FILES,
                                   "video*");
 
   while (!enumerator.Next().empty()) {
     const base::FileEnumerator::FileInfo info = enumerator.GetInfo();
     const std::string unique_id = path.value() + info.GetName().value();
     const base::ScopedFD fd(HANDLE_EINTR(open(unique_id.c_str(), O_RDONLY)));
     if (!fd.is_valid()) {
       DLOG(ERROR) << "Couldn't open " << info.GetName().value();
       continue;
     }
     // Test if this is a V4L2 capture device and if it has at least one
     // supported capture format. Devices that have capture and output
     // capabilities at the same time are memory-to-memory and are skipped, see
     // http://crbug.com/139356.
     v4l2_capability cap;
     if ((HANDLE_EINTR(ioctl(fd.get(), VIDIOC_QUERYCAP, &cap)) == 0) &&
         (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE &&
          !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) &&
         HasUsableFormats(fd.get(), cap.capabilities)) {
-      device_names->push_back(VideoCaptureDevice::Name(
-          reinterpret_cast<char*>(cap.card), unique_id,
-          VideoCaptureDevice::Name::V4L2_SINGLE_PLANE));
+      VideoCaptureDeviceDescriptor descriptor;
+      descriptor.friendly_name = reinterpret_cast<char*>(cap.card);
+      descriptor.device_id = unique_id;
+      descriptor.capture_api = VideoCaptureApiType::LINUX_V4L2_SINGLE_PLANE;
+      device_descriptors->push_back(descriptor);
     }
   }
 }
 
+void VideoCaptureDeviceFactoryLinux::GetDeviceInfo(
+    const VideoCaptureDeviceDescriptor& device_descriptor,
+    VideoCaptureDeviceInfo* device_info) {
+  DCHECK(device_info);
+  device_info->descriptor = device_descriptor;
+  GetDeviceSupportedFormats(device_descriptor,
+                            &(device_info->supported_formats));
+  device_info->model_id = GetDeviceModelId(device_descriptor);
+}
+
 void VideoCaptureDeviceFactoryLinux::GetDeviceSupportedFormats(
-    const VideoCaptureDevice::Name& device,
+    const VideoCaptureDeviceDescriptor& device,
     VideoCaptureFormats* supported_formats) {
   DCHECK(thread_checker_.CalledOnValidThread());
-  if (device.id().empty())
+  if (device.device_id.empty())
     return;
-  base::ScopedFD fd(HANDLE_EINTR(open(device.id().c_str(), O_RDONLY)));
+  base::ScopedFD fd(HANDLE_EINTR(open(device.device_id.c_str(), O_RDONLY)));
   if (!fd.is_valid())  // Failed to open this device.
     return;
   supported_formats->clear();
 
-  DCHECK_NE(device.capture_api_type(),
-            VideoCaptureDevice::Name::API_TYPE_UNKNOWN);
+  DCHECK_NE(device.capture_api, VideoCaptureApiType::API_TYPE_UNKNOWN);
   GetSupportedFormatsForV4L2BufferType(fd.get(), supported_formats);
 }
 
+std::string VideoCaptureDeviceFactoryLinux::GetDeviceModelId(
+    const VideoCaptureDeviceDescriptor& device) {
+  // |unique_id| is of the form "/dev/video2".  |file_name| is "video2".
+  const std::string dev_dir = "/dev/";
+  DCHECK_EQ(0, device.device_id.compare(0, dev_dir.length(), dev_dir));
+  const std::string file_name =
+      device.device_id.substr(dev_dir.length(), device.device_id.length());
+
+  const std::string vidPath =
+      base::StringPrintf(kVidPathTemplate, file_name.c_str());
+  const std::string pidPath =
+      base::StringPrintf(kPidPathTemplate, file_name.c_str());
+
+  std::string usb_id;
+  if (!ReadIdFile(vidPath, &usb_id))
+    return "";
+  usb_id.append(":");
+  if (!ReadIdFile(pidPath, &usb_id))
+    return "";
+
+  return usb_id;
+}
+
 // static
 VideoCaptureDeviceFactory*
 VideoCaptureDeviceFactory::CreateVideoCaptureDeviceFactory(
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return new VideoCaptureDeviceFactoryLinux(ui_task_runner);
 }
 
 }  // namespace media