Added video capture capabilities retrieval and caching to VideoCaptureManager

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 132 matching lines @@
     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(entry->id);
       if (found) {
         video_capture_device.reset(use_fake_device_ ?
             media::FakeVideoCaptureDevice::Create(*found) :
             media::VideoCaptureDevice::Create(*found));
+
+        // Filter capture capabilities: remove all except the current one.

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

why? (usually that's more important to document than the 'what')

[mcasas, 2013/10/28 12:50:08]

Done.

+        media::VideoCaptureCapabilities& formats =
+            video_capture_capabilities_[entry->id];
+        formats.clear();
+        formats.push_back(capture_params);
       }
       break;
     }
     case MEDIA_TAB_VIDEO_CAPTURE: {
       video_capture_device.reset(
           WebContentsVideoCaptureDevice::Create(entry->id));
       break;
     }
     case MEDIA_DESKTOP_VIDEO_CAPTURE: {
 #if defined(ENABLE_SCREEN_CAPTURE)
@@ skipping 83 matching lines @@
 
   // Detach client from controller.
   int session_id = controller->RemoveClient(client_id, client_handler);
   DVLOG(1) << "VideoCaptureManager::StopCaptureForClient, session_id = "
            << session_id;
 
   // If controller has no more clients, delete controller and device.
   DestroyDeviceEntryIfNoClients(entry);
 }
 
+void VideoCaptureManager::EnumerateDeviceCapabilities(
+    const StreamDeviceInfo& device_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  DVLOG(1) << "VideoCaptureManager::EnumerateDeviceCapabilites for device: "
+           << device_info.device.name;
+  DCHECK(listener_);
+  base::PostTaskAndReplyWithResult(
+      device_loop_,
+      FROM_HERE,
+      base::Bind(&VideoCaptureManager::GetDeviceCapabilitiesOnDeviceThread,
+                 this,
+                 device_info),
+      base::Bind(&VideoCaptureManager::OnDeviceCapabilitiesEnumerated,
+                 this,
+                 device_info));
+}
+
 void VideoCaptureManager::DoStopDeviceOnDeviceThread(DeviceEntry* entry) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StopDeviceTime");
   DCHECK(IsOnDeviceThread());
   if (entry->video_capture_device) {
     entry->video_capture_device->StopAndDeAllocate();
   }
   entry->video_capture_device.reset();
 }
 
 void VideoCaptureManager::OnOpened(MediaStreamType stream_type,
@@ skipping 18 matching lines @@
 
 void VideoCaptureManager::OnDevicesEnumerated(
     MediaStreamType stream_type,
     const media::VideoCaptureDevice::Names& device_names) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!listener_) {
     // Listener has been removed.
     return;
   }
+  DVLOG(1) << "OnDevicesEnumerated";

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

nit: above the listener check

[mcasas, 2013/10/28 12:50:08]

Done.

 
   // Transform from VCD::Name to StreamDeviceInfo.
   StreamDeviceInfoArray devices;
   for (media::VideoCaptureDevice::Names::const_iterator it =
            device_names.begin(); it != device_names.end(); ++it) {
     devices.push_back(StreamDeviceInfo(
         stream_type, it->GetNameAndModel(), it->id()));
   }
 
   listener_->DevicesEnumerated(stream_type, devices);
 }
 
+void VideoCaptureManager::OnDeviceCapabilitiesEnumerated(
+    const StreamDeviceInfo& device_info,
+    const media::VideoCaptureCapabilities& capabilities) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (!listener_) {
+    // Listener has been removed.
+    return;
+  }
+  DVLOG(1) << "OnDeviceCapabilitiesEnumerated device: "

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

nit: move this DLOG above the listener_ check so that we can see that the
notification arrived regardless of there being a listener.

[mcasas, 2013/10/28 12:50:08]

Done.

+           << device_info.device.id;
+  listener_->DeviceCapabilitiesEnumerated(device_info, capabilities);
+}
+
 bool VideoCaptureManager::IsOnDeviceThread() const {
   return device_loop_->BelongsToCurrentThread();
 }
 
 media::VideoCaptureDevice::Names
 VideoCaptureManager::GetAvailableDevicesOnDeviceThread(
     MediaStreamType stream_type) {
   SCOPED_UMA_HISTOGRAM_TIMER(
       "Media.VideoCaptureManager.GetAvailableDevicesTime");
   DCHECK(IsOnDeviceThread());
   media::VideoCaptureDevice::Names result;
 
   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.
       if (!use_fake_device_) {
         media::VideoCaptureDevice::GetDeviceNames(&result);
+        // Add to the cache the devices' supported capture formats.

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

nit: sentence structure - it feels more natural to say "Add the capture formats
of the devices to the cache."  The opposite way (as it is now) feels like
structure from a different language and is less readable (I had to read it more
than once).

[mcasas, 2013/10/28 12:50:08]

Done.

+        media::VideoCaptureDevice::Names::iterator name_it;
+        for (name_it = result.begin(); name_it != result.end(); ++name_it) {
+          media::VideoCaptureDevice::GetDeviceSupportedFormats(
+              *name_it, &video_capture_capabilities_[name_it->id()] );

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

before sending a pointer to the entry in the map, can we have a DCHECK to make
sure that that entry does not already exist? (i.e. that find() returns end())

[mcasas, 2013/10/28 12:50:08]

I guess this doesn't apply since the map is gone.

+        }
       } else {
         media::FakeVideoCaptureDevice::GetDeviceNames(&result);
+        // Add to the cache the devices' supported capture formats.
+        media::VideoCaptureDevice::Names::iterator name_it;
+        media::VideoCaptureCapabilities formats;
+        for (name_it = result.begin(); name_it != result.end(); ++name_it) {
+          media::FakeVideoCaptureDevice::GetDeviceSupportedFormats(
+              *name_it, &video_capture_capabilities_[name_it->id()] );

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

same here

[mcasas, 2013/10/28 12:50:08]

dixit.

+        }
       }
 
       // TODO(nick): The correctness of device start depends on this cache being
       // maintained, but it seems a little odd to keep a cache here. Can we
       // eliminate it?
       video_capture_devices_ = result;
       break;
 
     case MEDIA_DESKTOP_VIDEO_CAPTURE:
       // Do nothing.
       break;
 
     default:
       NOTREACHED();
       break;
   }
   return result;
 }
 
+media::VideoCaptureCapabilities
+VideoCaptureManager::GetDeviceCapabilitiesOnDeviceThread(
+    const StreamDeviceInfo& device_info) const {
+  DCHECK(IsOnDeviceThread());
+
+  // Find the device we are looking for and return its associated capabilities.
+  std::map<std::string, media::VideoCaptureCapabilities>::const_iterator it =
+      video_capture_capabilities_.find(device_info.device.id);
+  if ( it != video_capture_capabilities_.end())

[tommi (sloooow) - chröme, 2013/10/25 14:15:34]

fix spaces

[mcasas, 2013/10/28 12:50:08]

Done.

+    return it->second;
+  return media::VideoCaptureCapabilities();
+}
+
 VideoCaptureManager::DeviceEntry*
 VideoCaptureManager::GetDeviceEntryForMediaStreamDevice(
     const MediaStreamDevice& device_info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   for (DeviceEntries::iterator it = devices_.begin();
        it != devices_.end(); ++it) {
     DeviceEntry* device = *it;
     if (device_info.type == device->stream_type &&
         device_info.id == device->id) {
@@ skipping 59 matching lines @@
   scoped_ptr<VideoCaptureController> video_capture_controller(
       new VideoCaptureController());
   DeviceEntry* new_device = new DeviceEntry(device_info.type,
                                             device_info.id,
                                             video_capture_controller.Pass());
   devices_.insert(new_device);
   return new_device;
 }
 
 }  // namespace content