Refactor the VideoCaptureDevice::Name struct.

media/video/capture/linux/video_capture_device_linux.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 "media/video/capture/linux/video_capture_device_linux.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #if defined(OS_OPENBSD)
 #include <sys/videoio.h>
@@ skipping 91 matching lines @@
   // Empty the name list.
   device_names->clear();
 
   base::FilePath path("/dev/");
   base::FileEnumerator enumerator(
       path, false, base::FileEnumerator::FILES, "video*");
 
   while (!enumerator.Next().empty()) {
     base::FileEnumerator::FileInfo info = enumerator.GetInfo();
 
-    Name name;
-    name.unique_id = path.value() + info.GetName().value();
-    if ((fd = open(name.unique_id.c_str() , O_RDONLY)) < 0) {
+    std::string unique_id = path.value() + info.GetName().value();
+    if ((fd = open(unique_id.c_str() , O_RDONLY)) < 0) {
       // Failed to open this device.
       continue;
     }
     // Test if this is a V4L2 capture device.
     v4l2_capability cap;
     if ((ioctl(fd, VIDIOC_QUERYCAP, &cap) == 0) &&
         (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
         !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT)) {
       // This is a V4L2 video capture device
       if (HasUsableFormats(fd)) {
-        name.device_name = base::StringPrintf("%s", cap.card);
-        device_names->push_back(name);
+        Name device_name(base::StringPrintf("%s", cap.card), unique_id);
+        device_names->push_back(device_name);
       } else {
         DVLOG(1) << "No usable formats reported by " << info.GetName().value();
       }
     }
     close(fd);
   }
 }
 
 VideoCaptureDevice* VideoCaptureDevice::Create(const Name& device_name) {
   VideoCaptureDeviceLinux* self = new VideoCaptureDeviceLinux(device_name);
   if (!self)
     return NULL;
   // 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.
-  int fd = open(device_name.unique_id.c_str(), O_RDONLY);
+  int fd = open(device_name.id().c_str(), O_RDONLY);
   if (fd < 0) {
     DVLOG(1) << "Cannot open device";
     delete self;
     return NULL;
   }
   close(fd);
 
   return self;
 }
 
@@ skipping 74 matching lines @@
 
 void VideoCaptureDeviceLinux::OnAllocate(int width,
                                          int height,
                                          int frame_rate,
                                          EventHandler* observer) {
   DCHECK_EQ(v4l2_thread_.message_loop(), base::MessageLoop::current());
 
   observer_ = observer;
 
   // Need to open camera with O_RDWR after Linux kernel 3.3.
-  if ((device_fd_ = open(device_name_.unique_id.c_str(), O_RDWR)) < 0) {
+  if ((device_fd_ = open(device_name_.id().c_str(), O_RDWR)) < 0) {
     SetErrorState("Failed to open V4L2 device driver.");
     return;
   }
 
   // Test if this is a V4L2 capture device.
   v4l2_capability cap;
   if (!((ioctl(device_fd_, VIDIOC_QUERYCAP, &cap) == 0) &&
       (cap.capabilities & V4L2_CAP_VIDEO_CAPTURE) &&
       !(cap.capabilities & V4L2_CAP_VIDEO_OUTPUT))) {
     // This is not a V4L2 video capture device.
@@ skipping 285 matching lines @@
   buffer_pool_size_ = 0;
 }
 
 void VideoCaptureDeviceLinux::SetErrorState(const std::string& reason) {
   DVLOG(1) << reason;
   state_ = kError;
   observer_->OnError();
 }
 
 }  // namespace media