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.
+        media::VideoCaptureCapabilities& formats =

[perkj_chrome, 2013/10/23 13:19:45]

What happen after the camera has been stopped? Then you can restart the camera
with all capabilities.

+            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 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);
 }
 
+const media::VideoCaptureCapabilities*
+VideoCaptureManager::EnumerateDeviceCapabilities(
+    const StreamDeviceInfo& device_info) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));

[perkj_chrome, 2013/10/23 13:19:45]

What is the plan when it comes to multiple opening of a camera - maybe from
multiple processes?

Shouln't the |device_info| that actually started the device also continue to get
the full capability list?

[perkj_chrome, 2013/10/23 13:19:45]

So this is done on the IO thread but you modify |video_capture_capabilities_| on
the device thread, thats a no no.

On what thread will the request for the cabilities come from? I suspect the IO
thread. Can you do all processing of |video_capture_capabilities_| on the IO
thread? 

+
+  // Find the device we are looking for and return its associated capabilities.
+  std::map<std::string, media::VideoCaptureCapabilities>::iterator it =
+      video_capture_capabilities_.find(device_info.device.id);
+  if ( it != video_capture_capabilities_.end())
+    return &(it->second);
+  return NULL;
+}
+
 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 49 matching lines @@
   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.
+        media::VideoCaptureDevice::Names::iterator name_it;

[perkj_chrome, 2013/10/23 13:19:45]

See how GetAvailableDevicesOnDeviceThread is used for an idea of how to get the
capabilities to the IO thread. 

I think you will need a separate function for retrieving the capabilities back
to the IO thread. 

+        for (name_it = result.begin(); name_it != result.end(); ++name_it) {
+          media::VideoCaptureDevice::GetDeviceSupportedFormats(
+              *name_it, &video_capture_capabilities_[name_it->id()] );
+        }
       } 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()] );
+        }
       }
 
       // 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.
@@ skipping 78 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