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.
-  media::VideoCaptureDevice::Name vc_device_name;
-  vc_device_name.device_name = device.device.name;
-  vc_device_name.unique_id = 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;
+  switch (device.device.type) {
+    case 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::Name* found =
+          video_capture_devices_.FindById(device.device.id);
+      if (found) {
+        video_capture_device = use_fake_device_ ?
+            media::FakeVideoCaptureDevice::Create(*found) :
+            media::VideoCaptureDevice::Create(*found);
       }
-      case MEDIA_TAB_VIDEO_CAPTURE: {
-        video_capture_device = WebContentsVideoCaptureDevice::Create(
-            vc_device_name.unique_id);
-        break;
-      }
-      case MEDIA_SCREEN_VIDEO_CAPTURE: {
+      break;
+    }
+    case MEDIA_TAB_VIDEO_CAPTURE: {
+      video_capture_device = WebContentsVideoCaptureDevice::Create(
+          device.device.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()));
+      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;
-      }
+      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 186 matching lines @@
   return device_loop_->BelongsToCurrentThread();
 }
 
 void VideoCaptureManager::GetAvailableDevices(
     MediaStreamType stream_type,
     media::VideoCaptureDevice::Names* device_names) {
   DCHECK(IsOnDeviceThread());
 
   switch (stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE:
+      // Cache the latest enumeration of video capture devices.
+      // We'll refer to this list again in OnOpen to avoid having to
+      // enumerate the devices again.
+      video_capture_devices_.clear();
       if (!use_fake_device_) {
-        media::VideoCaptureDevice::GetDeviceNames(device_names);
+        media::VideoCaptureDevice::GetDeviceNames(&video_capture_devices_);
       } else {
-        media::FakeVideoCaptureDevice::GetDeviceNames(device_names);
+        media::FakeVideoCaptureDevice::GetDeviceNames(&video_capture_devices_);
       }
+      *device_names = video_capture_devices_;
       break;
 
     case MEDIA_SCREEN_VIDEO_CAPTURE:
       device_names->clear();
       break;
 
     default:
       NOTREACHED();
       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