Refactor the VideoCaptureDevice::Name struct.

content/browser/renderer_host/media/video_capture_manager.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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 124 matching lines @@
   DCHECK(IsOnDeviceThread());
 
   media::VideoCaptureDevice::Names device_names;
   GetAvailableDevices(stream_type, &device_names);
 
   scoped_ptr<StreamDeviceInfoArray> devices(new StreamDeviceInfoArray());
   for (media::VideoCaptureDevice::Names::iterator it =
            device_names.begin(); it != device_names.end(); ++it) {
     bool opened = DeviceOpened(*it);
     devices->push_back(StreamDeviceInfo(
-        stream_type, it->device_name, it->unique_id, opened));
+        stream_type, it->name(), it->id(), opened));
   }
 
   PostOnDevicesEnumerated(stream_type, devices.Pass());
 }
 
 void VideoCaptureManager::OnOpen(int capture_session_id,
                                  const StreamDeviceInfo& device) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.OnOpenTime");
   DCHECK(IsOnDeviceThread());
   DCHECK(devices_.find(capture_session_id) == devices_.end());
   DVLOG(1) << "VideoCaptureManager::OnOpen, id " << capture_session_id;
 
   // Check if another session has already opened this device. If so, just
   // use that opened device.
   media::VideoCaptureDevice* video_capture_device = GetOpenedDevice(device);
   if (video_capture_device) {
     DeviceEntry& new_entry = devices_[capture_session_id];
     new_entry.stream_type = device.device.type;
     new_entry.capture_device = video_capture_device;
     PostOnOpened(device.device.type, capture_session_id);
     return;
   }
 
   // Open the device.
+
+  // FindById will return NULL on failure.
   media::VideoCaptureDevice::Name vc_device_name;
-  vc_device_name.device_name = device.device.name;
-  vc_device_name.unique_id = device.device.id;
+  if (device.device.type == MEDIA_DEVICE_VIDEO_CAPTURE) {
+    // We look up the device id from the renderer in our local enumeration
+    // since the renderer does not have all the information that might be
+    // held in the browser-side VideoCaptureDevice::Name structure.
+    media::VideoCaptureDevice::Names device_names;
+    GetAvailableDevices(device.device.type, &device_names);
+    media::VideoCaptureDevice::Name* found =
+        device_names.FindById(device.device.id);
+    if (found)
+      vc_device_name = *found;
+  }

[wjia(left Chromium), 2013/06/26 18:16:44]

What's the reason to add this logic (of enumeration) here? If the device is
detached, it will error out when trying to open the device.

It seems even though the device can't be found, we will use
Name(device.device.name, device.device.id) anyway as below.

[tommi (sloooow) - chröme, 2013/06/27 14:46:02]

Yes, currently that's going to be the case.  The reason this is like it is
though is to use the Name instance as it comes from the enumeration, where it
might have more information than just name and id.  On Windows we have an actual
need today to also store the API from which the enumeration comes.

Instead of doing this enumeration again here though, we can cache the video
capture device names in OnEnumerateDevices and refer to that list here.

Also, I've noticed that the 'use_fake_device_' flag should only apply to
MEDIA_DEVICE_VIDEO_CAPTURE, so I'm going to move that check to that switch case.

The vc_device_name variable should also only be used for
MEDIA_DEVICE_VIDEO_CAPTURE, so I'll reduce the scope of it to the same case
label.

+
+  if (vc_device_name.id().empty()) {
+    vc_device_name = media::VideoCaptureDevice::Name(
+        device.device.name, device.device.id);
+  }
 
   if (use_fake_device_) {
     video_capture_device =
         media::FakeVideoCaptureDevice::Create(vc_device_name);
   } else {
     switch (device.device.type) {
       case MEDIA_DEVICE_VIDEO_CAPTURE: {
         video_capture_device =
             media::VideoCaptureDevice::Create(vc_device_name);
         break;
       }
       case MEDIA_TAB_VIDEO_CAPTURE: {
         video_capture_device = WebContentsVideoCaptureDevice::Create(
-            vc_device_name.unique_id);
+            vc_device_name.id());
         break;
       }
       case MEDIA_SCREEN_VIDEO_CAPTURE: {
 #if defined(ENABLE_SCREEN_CAPTURE)
         scoped_refptr<base::SequencedWorkerPool> blocking_pool =
             BrowserThread::GetBlockingPool();
         video_capture_device = new ScreenCaptureDevice(
             blocking_pool->GetSequencedTaskRunner(
                 blocking_pool->GetSequenceToken()));
 #endif  // defined(ENABLE_SCREEN_CAPTURE)
         break;
       }
       default: {
         NOTIMPLEMENTED();
         break;
       }
     }
   }
+
   if (!video_capture_device) {
     PostOnError(capture_session_id, kDeviceNotAvailable);
     return;
   }
 
   DeviceEntry& new_entry = devices_[capture_session_id];
   new_entry.stream_type = device.device.type;
   new_entry.capture_device = video_capture_device;
   PostOnOpened(device.device.type, capture_session_id);
 }
@@ skipping 209 matching lines @@
       break;
   }
 }
 
 bool VideoCaptureManager::DeviceOpened(
     const media::VideoCaptureDevice::Name& device_name) {
   DCHECK(IsOnDeviceThread());
 
   for (VideoCaptureDevices::iterator it = devices_.begin();
        it != devices_.end(); ++it) {
-    if (device_name.unique_id ==
-            it->second.capture_device->device_name().unique_id) {
+    if (device_name.id() == it->second.capture_device->device_name().id()) {
       // We've found the device!
       return true;
     }
   }
   return false;
 }
 
 media::VideoCaptureDevice* VideoCaptureManager::GetOpenedDevice(
     const StreamDeviceInfo& device_info) {
   DCHECK(IsOnDeviceThread());
 
   for (VideoCaptureDevices::iterator it = devices_.begin();
        it != devices_.end(); it++) {
     if (device_info.device.id ==
-            it->second.capture_device->device_name().unique_id) {
+            it->second.capture_device->device_name().id()) {
       return it->second.capture_device;
     }
   }
   return NULL;
 }
 
 bool VideoCaptureManager::DeviceInUse(
     const media::VideoCaptureDevice* video_capture_device) {
   DCHECK(IsOnDeviceThread());
 
@@ skipping 87 matching lines @@
   // Solution for not using MediaStreamManager.
   // This session id won't be returned by Open().
   if (capture_session_id == kStartOpenSessionId) {
     media::VideoCaptureDevice::Names device_names;
     GetAvailableDevices(MEDIA_DEVICE_VIDEO_CAPTURE, &device_names);
     if (device_names.empty()) {
       // No devices available.
       return NULL;
     }
     StreamDeviceInfo device(MEDIA_DEVICE_VIDEO_CAPTURE,
-                            device_names.front().device_name,
-                            device_names.front().unique_id, false);
+                            device_names.front().name(),
+                            device_names.front().id(),
+                            false);
 
     // Call OnOpen to open using the first device in the list.
     OnOpen(capture_session_id, device);
 
     VideoCaptureDevices::iterator dit = devices_.find(capture_session_id);
     if (dit != devices_.end()) {
       return dit->second.capture_device;
     }
   }
   return NULL;
 }
 
 }  // namespace content