Added video capture capabilities retrieval and caching to VideoCaptureManager

content/browser/renderer_host/media/video_capture_manager.h

 // 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.
 
 // VideoCaptureManager is used to open/close, start/stop, enumerate available
 // video capture devices, and manage VideoCaptureController's.
 // All functions are expected to be called from Browser::IO thread. Some helper
 // functions (*OnDeviceThread) will dispatch operations to the device thread.
 // VideoCaptureManager will open OS dependent instances of VideoCaptureDevice.
 // A device can only be opened once.
@@ skipping 41 matching lines @@
   virtual void Close(int capture_session_id) OVERRIDE;
 
   // Used by unit test to make sure a fake device is used instead of a real
   // video capture device. Due to timing requirements, the function must be
   // called before EnumerateDevices and Open.
   void UseFakeDevice();
 
   // Called by VideoCaptureHost to locate a capture device for |capture_params|,
   // adding the Host as a client of the device's controller if successful. The
   // value of |capture_params.session_id| controls which device is selected;
-  // this value should be a session id previously returned by Open().
+  // this value should be a session id previously returned by Open(). The device
+  // capabilities are reduced to |capture_params|.
   //
   // If the device is not already started (i.e., no other client is currently
   // capturing from this device), this call will cause a VideoCaptureController
   // and VideoCaptureDevice to be created, possibly asynchronously.
   //
   // On success, the controller is returned via calling |done_cb|, indicating
   // that the client was successfully added. A NULL controller is passed to
   // the callback on failure.
   void StartCaptureForClient(const media::VideoCaptureParams& capture_params,
                              base::ProcessHandle client_render_process,
                              VideoCaptureControllerID client_id,
                              VideoCaptureControllerEventHandler* client_handler,
                              const DoneCB& done_cb);
 
   // Called by VideoCaptureHost to remove |client_handler|. If this is the last
   // client of the device, the |controller| and its VideoCaptureDevice may be
   // destroyed. The client must not access |controller| after calling this
   // function.
   void StopCaptureForClient(VideoCaptureController* controller,
                             VideoCaptureControllerID client_id,
                             VideoCaptureControllerEventHandler* client_handler);
 
+  // Retrieve the available capture capabilities for a particular device. The
+  // capabilities are cached during device(s) enumeration and updated as clients
+  // open the device(s). This call is asynchronous but expected to return fast
+  // since the capabilities are cached; the reply will be received in
+  // listener_->DeviceCapabilitiesEnumerated().

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

This is not what we discussed. You want to access the capabilities from the
VideoCaptureHost as we talked about and as you wrote in your email. 
Also - since you have already cached the capabilities you should be able make
this syncronous.

The actual device is identified in the same way as when you start a capture
device, according to the comments in StartCaptureForClient it is
|capture_params.session_id|.

+  void EnumerateDeviceCapabilities(const StreamDeviceInfo& device_info);
+
  private:
   virtual ~VideoCaptureManager();
   struct DeviceEntry;
 
   // Check to see if |entry| has no clients left on its controller. If so,
   // remove it from the list of devices, and delete it asynchronously. |entry|
   // may be freed by this function.
   void DestroyDeviceEntryIfNoClients(DeviceEntry* entry);
 
   // Helpers to report an event to our Listener.
   void OnOpened(MediaStreamType type, int capture_session_id);
   void OnClosed(MediaStreamType type, int capture_session_id);
   void OnDevicesEnumerated(MediaStreamType stream_type,
                            const media::VideoCaptureDevice::Names& names);
+  void OnDeviceCapabilitiesEnumerated(
+      const StreamDeviceInfo& device_info,
+      const media::VideoCaptureCapabilities& capabilities);
 
   // Find a DeviceEntry by its device ID and type, if it is already opened.
   DeviceEntry* GetDeviceEntryForMediaStreamDevice(
       const MediaStreamDevice& device_info);
 
   // Find a DeviceEntry entry for the indicated session, creating a fresh one
   // if necessary. Returns NULL if the session id is invalid.
   DeviceEntry* GetOrCreateDeviceEntry(int capture_session_id);
 
   // Find the DeviceEntry that owns a particular controller pointer.
   DeviceEntry* GetDeviceEntryForController(
       const VideoCaptureController* controller);
 
   bool IsOnDeviceThread() const;
 
   // Queries and returns the available device IDs.
   media::VideoCaptureDevice::Names GetAvailableDevicesOnDeviceThread(
       MediaStreamType stream_type);
 
+  // Queries and returns the video capture capabilities of a device.
+  media::VideoCaptureCapabilities GetDeviceCapabilitiesOnDeviceThread(
+      const StreamDeviceInfo& device_info);
+
   // Create and Start a new VideoCaptureDevice, storing the result in
   // |entry->video_capture_device|. Ownership of |client| passes to
   // the device.
   void DoStartDeviceOnDeviceThread(
       DeviceEntry* entry,
       const media::VideoCaptureCapability& capture_params,
       scoped_ptr<media::VideoCaptureDevice::Client> client);
 
   // Stop and destroy the VideoCaptureDevice held in
   // |entry->video_capture_device|.
@@ skipping 36 matching lines @@
     // The capture device. Only used from the device thread.
     scoped_ptr<media::VideoCaptureDevice> video_capture_device;
   };
   typedef std::set<DeviceEntry*> DeviceEntries;
   DeviceEntries devices_;
 
   // Set to true if using fake video capture devices for testing, false by
   // default. This is only used for the MEDIA_DEVICE_VIDEO_CAPTURE device type.
   bool use_fake_device_;
 
-  // We cache the enumerated video capture devices in
-  // GetAvailableDevicesOnDeviceThread() and then later look up the requested ID
-  // when a device is created in DoStartDeviceOnDeviceThread(). Used only on the
-  // device thread.
-  media::VideoCaptureDevice::Names video_capture_devices_;
+  // This class is a convenient wrap of a devices' name and associated video
+  // capture capabilities.
+  class DeviceInfo {

[miu, 2013/10/29 18:43:27]

C++ style: struct, not class

+   public:
+    DeviceInfo();
+    DeviceInfo(const media::VideoCaptureDevice::Name& name,
+               const media::VideoCaptureCapabilities& capabilities);
+    ~DeviceInfo();
+
+    media::VideoCaptureDevice::Name name_;
+    media::VideoCaptureCapabilities capabilities_;
+  };
+  // Local cache of the enumerated video capture devices' names and capture
+  // capabilities. This cache is created in GetAvailableDevicesOnDeviceThread()
+  // and used via requested ID lookup when a device is created in
+  // DoStartDeviceOnDeviceThread(). The cache is only used in device thread.
+  // The capabilities are retrieved via EnumerateDeviceCapabilities().
+  std::vector<class DeviceInfo> devices_info_cache_;

[miu, 2013/10/29 18:43:27]

remove "class "

[miu, 2013/10/29 18:43:27]

Consider making this a vector<DeviceInfo*> instead, to avoid unnecessary copying
of the struct.

[tommi (sloooow) - chröme, 2013/10/29 20:26:24]

+1.
base::ScopedVector could come in handy:
https://code.google.com/p/chromium/codesearch#chromium/src/base/memory/scoped...

+  class DeviceInfo* FindDeviceInfoById(const std::string& id);

[miu, 2013/10/29 18:43:27]

remove "class "

[miu, 2013/10/29 18:43:27]

C++ style: Move this method up (before data members).

+
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManager);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_MEDIA_VIDEO_CAPTURE_MANAGER_H_