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 21 matching lines @@
 VideoCaptureManager::DeviceEntry::DeviceEntry(
     MediaStreamType stream_type,
     const std::string& id,
     scoped_ptr<VideoCaptureController> controller)
     : stream_type(stream_type),
       id(id),
       video_capture_controller(controller.Pass()) {}
 
 VideoCaptureManager::DeviceEntry::~DeviceEntry() {}
 
+VideoCaptureManager::DeviceInfo::DeviceInfo() {}
+
+VideoCaptureManager::DeviceInfo::DeviceInfo(
+    const media::VideoCaptureDevice::Name& name,
+    const media::VideoCaptureCapabilities& capabilities)
+    : name_(name), capabilities_(capabilities) {}
+
+VideoCaptureManager::DeviceInfo::~DeviceInfo() {}
+
 VideoCaptureManager::VideoCaptureManager()
     : listener_(NULL),
       new_capture_session_id_(1),
       use_fake_device_(false) {
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
 }
 
@@ skipping 85 matching lines @@
     scoped_ptr<media::VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());
 
   scoped_ptr<media::VideoCaptureDevice> video_capture_device;
   switch (entry->stream_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(entry->id);
+      class DeviceInfo* found = FindDeviceInfoById(entry->id);
       if (found) {
         video_capture_device.reset(use_fake_device_ ?
-            media::FakeVideoCaptureDevice::Create(*found) :
-            media::VideoCaptureDevice::Create(*found));
+            media::FakeVideoCaptureDevice::Create(found->name_) :
+            media::VideoCaptureDevice::Create(found->name_));
+
+        // After opening a device, we currently assume that it cannot be opened
+        // in any other format than the actual, so we clear the capabilities.
+        found->capabilities_.clear();
+        found->capabilities_.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 82 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) << "EnumerateDeviceCapabilites for: " << 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();
+    // When the device is closed, its capabilities are reread from the device
+    // to reflect that all are possible.
+    class DeviceInfo* device_info = FindDeviceInfoById(entry->id);
+    if (device_info) {
+      if (!use_fake_device_) {
+        media::VideoCaptureDevice::GetDeviceSupportedFormats(
+            device_info->name_, &(device_info->capabilities_));
+      } else {
+        media::FakeVideoCaptureDevice::GetDeviceSupportedFormats(
+            device_info->name_, &(device_info->capabilities_));
+      }
+    }
   }
   entry->video_capture_device.reset();
 }
 
 void VideoCaptureManager::OnOpened(MediaStreamType stream_type,
                                    int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Opened(stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnClosed(MediaStreamType stream_type,
                                    int capture_session_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!listener_) {
     // Listener has been removed.
     return;
   }
   listener_->Closed(stream_type, capture_session_id);
 }
 
 void VideoCaptureManager::OnDevicesEnumerated(
     MediaStreamType stream_type,
     const media::VideoCaptureDevice::Names& device_names) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
   if (!listener_) {
     // Listener has been removed.
     return;
   }
 
   // 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;
+  }
+  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;
+  media::VideoCaptureDevice::Names names;
 
   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);
+        media::VideoCaptureDevice::GetDeviceNames(&names);
+        // Walk the |names|, retrieve the capabilities and add all information
+        // to the local device info cache.
+        media::VideoCaptureCapabilities capabilities;
+        media::VideoCaptureDevice::Names::iterator name_it;
+        for (name_it = names.begin(); name_it != names.end(); ++name_it) {
+          media::VideoCaptureDevice::GetDeviceSupportedFormats(*name_it,

[perkj_chrome, 2013/10/29 12:13:36]

In the previous Cl we said that
media::VideoCaptureDevice::GetDeviceSupportedFormats will not be called on a
capture device that has already been started. So can we make sure to only query
capabilities for new devices? 

+                                                               &capabilities);
+          devices_info_cache_.push_back(DeviceInfo(*name_it, capabilities));
+        }
       } else {
-        media::FakeVideoCaptureDevice::GetDeviceNames(&result);
+        media::FakeVideoCaptureDevice::GetDeviceNames(&names);
+        // Walk the |names|, retrieve the capabilities and add all information
+        // to the local device info cache.
+        media::VideoCaptureCapabilities capabilities;
+        media::VideoCaptureDevice::Names::iterator name_it;
+        for (name_it = names.begin(); name_it != names.end(); ++name_it) {
+          media::FakeVideoCaptureDevice::GetDeviceSupportedFormats(
+              *name_it, &capabilities);
+          devices_info_cache_.push_back(DeviceInfo(*name_it, capabilities));
+        }
       }
 
-      // TODO(nick): The correctness of device start depends on this cache being
+      // TODO(nick): The correctness of device start depends on the 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;
+  return names;
+}
+
+media::VideoCaptureCapabilities
+VideoCaptureManager::GetDeviceCapabilitiesOnDeviceThread(
+    const StreamDeviceInfo& device_info) {
+  DCHECK(IsOnDeviceThread());
+
+  // Find the device we are looking for and return its associated capabilities.
+  class DeviceInfo* device = FindDeviceInfoById(device_info.device.id);
+  if (device)
+    return device->capabilities_;
+  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;
@@ skipping 60 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;
 }
 
+class VideoCaptureManager::DeviceInfo*

[perkj_chrome, 2013/10/29 12:13:36]

remove class

+VideoCaptureManager::FindDeviceInfoById(const std::string& id) {
+  std::vector<class DeviceInfo>::iterator it;
+  for (it = devices_info_cache_.begin();
+       it != devices_info_cache_.end();
+       ++it) {
+    if (it->name_.id() == id)
+      return &(*it);
+  }
+  return NULL;
+}
+
 }  // namespace content