Merge VideoCaptureDevice::Capability with media::VideoCaptureCapability

This is a second patch as the follow up of http://codereview.chromium.org/10108009/, just to facilitate code review
1. Move VideoCaptureDevice::Format to VideoCaptureCapability::Format.
2. Fix a code style issue in media_stream_device_settings.h.
3. Remove the TODO comments in media_stream_device_settings.h, since the media stream infobar is already implemented in linux and windows.

BUG=123738
TEST=content_unittests, media_unittests

Review URL: http://codereview.chromium.org/10035054

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@134415 0039d316-1c4b-4281-b951-d872f2087c98

15 files changed, 91 insertions, 81 deletions

diff --git a/media/video/capture/fake_video_capture_device.cc b/media/video/capture/fake_video_capture_device.cc
index acbd83a..ec64d60 100644
--- a/media/video/capture/fake_video_capture_device.cc
+++ b/media/video/capture/fake_video_capture_device.cc
@@ -60,8 +60,10 @@ void FakeVideoCaptureDevice::Allocate(int width,
   }
 
   observer_ = observer;
-  Capability current_settings;
-  current_settings.color = kI420;
+  VideoCaptureCapability current_settings;
+  current_settings.color = VideoCaptureCapability::kI420;
+  current_settings.expected_capture_delay = 0;
+  current_settings.interlaced = false;
   if (width > 320) {  // VGA
     current_settings.width = 640;
     current_settings.height = 480;
diff --git a/media/video/capture/linux/video_capture_device_linux.cc b/media/video/capture/linux/video_capture_device_linux.cc
index 7b99c204..4c3420a 100644
--- a/media/video/capture/linux/video_capture_device_linux.cc
+++ b/media/video/capture/linux/video_capture_device_linux.cc
@@ -50,18 +50,18 @@ static const int32 kV4l2Fmts[] = {
   V4L2_PIX_FMT_YUYV
 };
 
-static VideoCaptureDevice::Format V4l2ColorToVideoCaptureColorFormat(
+static VideoCaptureCapability::Format V4l2ColorToVideoCaptureColorFormat(
     int32 v4l2_fourcc) {
-  VideoCaptureDevice::Format result = VideoCaptureDevice::kColorUnknown;
+  VideoCaptureCapability::Format result = VideoCaptureCapability::kColorUnknown;
   switch (v4l2_fourcc) {
     case V4L2_PIX_FMT_YUV420:
-      result = VideoCaptureDevice::kI420;
+      result = VideoCaptureCapability::kI420;
       break;
     case V4L2_PIX_FMT_YUYV:
-      result = VideoCaptureDevice::kYUY2;
+      result = VideoCaptureCapability::kYUY2;
       break;
   }
-  DCHECK_NE(result, VideoCaptureDevice::kColorUnknown);
+  DCHECK_NE(result, VideoCaptureCapability::kColorUnknown);
   return result;
 }
 
@@ -248,12 +248,14 @@ void VideoCaptureDeviceLinux::OnAllocate(int width,
   }
 
   // Store our current width and height.
-  Capability current_settings;
+  VideoCaptureCapability current_settings;
   current_settings.color = V4l2ColorToVideoCaptureColorFormat(
       video_fmt.fmt.pix.pixelformat);
   current_settings.width  = video_fmt.fmt.pix.width;
   current_settings.height = video_fmt.fmt.pix.height;
   current_settings.frame_rate = frame_rate;
+  current_settings.expected_capture_delay = 0;
+  current_settings.interlaced = false;
 
   state_ = kAllocated;
   // Report the resulting frame size to the observer.
diff --git a/media/video/capture/linux/video_capture_device_linux.h b/media/video/capture/linux/video_capture_device_linux.h
index 5fc3a44..d1d2a19 100644
--- a/media/video/capture/linux/video_capture_device_linux.h
+++ b/media/video/capture/linux/video_capture_device_linux.h
@@ -14,6 +14,7 @@
 
 #include "base/threading/thread.h"
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/video_capture_types.h"
 
 namespace media {
 
diff --git a/media/video/capture/mac/video_capture_device_mac.h b/media/video/capture/mac/video_capture_device_mac.h
index c15fcec..95d78e0 100644
--- a/media/video/capture/mac/video_capture_device_mac.h
+++ b/media/video/capture/mac/video_capture_device_mac.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -11,6 +11,7 @@
 
 #include "base/compiler_specific.h"
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/video_capture_types.h"
 
 @class VideoCaptureDeviceQTKit;
 
@@ -37,7 +38,7 @@ class VideoCaptureDeviceMac : public VideoCaptureDevice {
 
   // Called to deliver captured video frames.
   void ReceiveFrame(const uint8* video_frame, int video_frame_length,
-                    const Capability& frame_info);
+                    const VideoCaptureCapability& frame_info);
 
  private:
   void SetErrorState(const std::string& reason);
diff --git a/media/video/capture/mac/video_capture_device_mac.mm b/media/video/capture/mac/video_capture_device_mac.mm
index cff3933..6d5637a 100644
--- a/media/video/capture/mac/video_capture_device_mac.mm
+++ b/media/video/capture/mac/video_capture_device_mac.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -68,11 +68,13 @@ void VideoCaptureDeviceMac::Allocate(int width, int height, int frame_rate,
   }
 
   state_ = kAllocated;
-  Capability current_settings;
-  current_settings.color = kARGB;
+  VideoCaptureCapability current_settings;
+  current_settings.color = VideoCaptureCapability::kARGB;
   current_settings.width = width;
   current_settings.height = height;
   current_settings.frame_rate = frame_rate;
+  current_settings.expected_capture_delay = 0;
+  current_settings.interlaced = false;
 
   observer_->OnFrameInfo(current_settings);
 }
@@ -128,9 +130,10 @@ bool VideoCaptureDeviceMac::Init() {
   return false;
 }
 
-void VideoCaptureDeviceMac::ReceiveFrame(const uint8* video_frame,
-                                         int video_frame_length,
-                                         const Capability& frame_info) {
+void VideoCaptureDeviceMac::ReceiveFrame(
+    const uint8* video_frame,
+    int video_frame_length,
+    const VideoCaptureCapability& frame_info) {
   observer_->OnIncomingCapturedFrame(video_frame, video_frame_length,
                                      base::Time::Now());
 }
diff --git a/media/video/capture/mac/video_capture_device_qtkit_mac.mm b/media/video/capture/mac/video_capture_device_qtkit_mac.mm
index f909bda..67cddfd 100644
--- a/media/video/capture/mac/video_capture_device_qtkit_mac.mm
+++ b/media/video/capture/mac/video_capture_device_qtkit_mac.mm
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -9,6 +9,7 @@
 #include "base/logging.h"
 #include "media/video/capture/mac/video_capture_device_mac.h"
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/video_capture_types.h"
 
 @implementation VideoCaptureDeviceQTKit
 
@@ -169,11 +170,13 @@
     size_t bytesPerRow = CVPixelBufferGetBytesPerRow(videoFrame);
     int frameHeight = CVPixelBufferGetHeight(videoFrame);
     int frameSize = bytesPerRow * frameHeight;
-    media::VideoCaptureDevice::Capability captureCapability;
+    media::VideoCaptureCapability captureCapability;
     captureCapability.width = frameWidth_;
     captureCapability.height = frameHeight_;
     captureCapability.frame_rate = frameRate_;
-    captureCapability.color = media::VideoCaptureDevice::kARGB;
+    captureCapability.color = media::VideoCaptureCapability::kARGB;
+    captureCapability.expected_capture_delay = 0;
+    captureCapability.interlaced = false;
 
     // Deliver the captured video frame.
     frameReceiver_->ReceiveFrame(static_cast<UInt8*>(baseAddress), frameSize,
diff --git a/media/video/capture/video_capture_device.h b/media/video/capture/video_capture_device.h
index 91d0bf4..2700144 100644
--- a/media/video/capture/video_capture_device.h
+++ b/media/video/capture/video_capture_device.h
@@ -17,6 +17,7 @@
 
 #include "base/time.h"
 #include "media/base/media_export.h"
+#include "media/video/capture/video_capture_types.h"
 
 namespace media {
 
@@ -33,32 +34,6 @@ class MEDIA_EXPORT VideoCaptureDevice {
   };
   typedef std::list<Name> Names;
 
-  // Color formats from camera.
-  enum Format {
-    kColorUnknown,  // Color format not set.
-    kI420,
-    kYUY2,
-    kUYVY,
-    kRGB24,
-    kARGB,
-    kMJPEG,  // Currently only supported on Windows.
-    kNV21,
-    kYV12,
-  };
-
-  // Describes the format a camera capture video in.
-  struct Capability {
-    Capability()
-        : width(0),
-          height(0),
-          frame_rate(0),
-          color(kColorUnknown) {}
-    int width;
-    int height;
-    int frame_rate;
-    Format color;
-  };
-
   class EventHandler {
    public:
     // Captured a new video frame.
@@ -70,7 +45,7 @@ class MEDIA_EXPORT VideoCaptureDevice {
     virtual void OnError() = 0;
     // Called when VideoCaptureDevice::Allocate has been called
     // to inform of the resulting frame size and color format.
-    virtual void OnFrameInfo(const Capability& info) = 0;
+    virtual void OnFrameInfo(const VideoCaptureCapability& info) = 0;
 
    protected:
     virtual ~EventHandler() {}
diff --git a/media/video/capture/video_capture_device_unittest.cc b/media/video/capture/video_capture_device_unittest.cc
index 1524204..5ad9b26 100644
--- a/media/video/capture/video_capture_device_unittest.cc
+++ b/media/video/capture/video_capture_device_unittest.cc
@@ -39,7 +39,7 @@ class MockFrameObserver : public media::VideoCaptureDevice::EventHandler {
   }
 
   virtual void OnFrameInfo(
-      const VideoCaptureDevice::Capability& info) OVERRIDE {
+      const VideoCaptureCapability& info) OVERRIDE {
     OnFrameInfo(info.width, info.height, info.frame_rate);
   }
 
diff --git a/media/video/capture/video_capture_types.h b/media/video/capture/video_capture_types.h
index d5f3fdf..165acc9 100644
--- a/media/video/capture/video_capture_types.h
+++ b/media/video/capture/video_capture_types.h
@@ -23,10 +23,23 @@ struct VideoCaptureParams {
 
 // Capabilities describe the format a camera capture video in.
 struct VideoCaptureCapability {
+  // Color formats from camera.
+  enum Format {
+    kColorUnknown,  // Color format not set.
+    kI420,
+    kYUY2,
+    kUYVY,
+    kRGB24,
+    kARGB,
+    kMJPEG,  // Currently only supported on Windows.
+    kNV21,
+    kYV12,
+  };
+
   int width;  // Desired width.
   int height;  // Desired height.
   int frame_rate;  // Desired frame rate.
-  media::VideoFrame::Format color;  // Desired video type.
+  Format color;  // Desired video type.
   int expected_capture_delay;  // Expected delay in millisecond.
   bool interlaced;  // Need interlace format.
 };
diff --git a/media/video/capture/win/sink_filter_win.cc b/media/video/capture/win/sink_filter_win.cc
index 605d557..c3fc410 100644
--- a/media/video/capture/win/sink_filter_win.cc
+++ b/media/video/capture/win/sink_filter_win.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -29,11 +29,11 @@ SinkFilter::~SinkFilter() {
 }
 
 void SinkFilter::SetRequestedMediaCapability(
-    const VideoCaptureDevice::Capability& capability) {
+    const VideoCaptureCapability& capability) {
   input_pin_->SetRequestedMediaCapability(capability);
 }
 
-const VideoCaptureDevice::Capability& SinkFilter::ResultingCapability() {
+const VideoCaptureCapability& SinkFilter::ResultingCapability() {
   return input_pin_->ResultingCapability();
 }
 
diff --git a/media/video/capture/win/sink_filter_win.h b/media/video/capture/win/sink_filter_win.h
index 5145cd4..c87a6d2 100644
--- a/media/video/capture/win/sink_filter_win.h
+++ b/media/video/capture/win/sink_filter_win.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -12,6 +12,7 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/video_capture_types.h"
 #include "media/video/capture/win/filter_base_win.h"
 #include "media/video/capture/win/sink_filter_observer_win.h"
 
@@ -32,10 +33,10 @@ class __declspec(uuid("88cdbbdc-a73b-4afa-acbf-15d5e2ce12c3"))
   virtual ~SinkFilter();
 
   void SetRequestedMediaCapability(
-      const VideoCaptureDevice::Capability& capability);
+      const VideoCaptureCapability& capability);
   // Returns the capability that is negotiated when this
   // filter is connected to a media filter.
-  const VideoCaptureDevice::Capability& ResultingCapability();
+  const VideoCaptureCapability& ResultingCapability();
 
   // Implement FilterBase.
   virtual size_t NoOfPins();
diff --git a/media/video/capture/win/sink_input_pin_win.cc b/media/video/capture/win/sink_input_pin_win.cc
index 20a49d6..997d6e2 100644
--- a/media/video/capture/win/sink_input_pin_win.cc
+++ b/media/video/capture/win/sink_input_pin_win.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -110,17 +110,17 @@ bool SinkInputPin::IsMediaTypeValid(const AM_MEDIA_TYPE* media_type) {
   }
   if (sub_type == kMediaSubTypeI420 &&
       pvi->bmiHeader.biCompression == MAKEFOURCC('I', '4', '2', '0')) {
-    resulting_capability_.color = VideoCaptureDevice::kI420;
+    resulting_capability_.color = VideoCaptureCapability::kI420;
     return true;  // This format is acceptable.
   }
   if (sub_type == MEDIASUBTYPE_YUY2 &&
       pvi->bmiHeader.biCompression == MAKEFOURCC('Y', 'U', 'Y', '2')) {
-    resulting_capability_.color = VideoCaptureDevice::kYUY2;
+    resulting_capability_.color = VideoCaptureCapability::kYUY2;
     return true;  // This format is acceptable.
   }
   if (sub_type == MEDIASUBTYPE_RGB24 &&
       pvi->bmiHeader.biCompression == BI_RGB) {
-    resulting_capability_.color = VideoCaptureDevice::kRGB24;
+    resulting_capability_.color = VideoCaptureCapability::kRGB24;
     return true;  // This format is acceptable.
   }
   return false;
@@ -137,12 +137,17 @@ HRESULT SinkInputPin::Receive(IMediaSample* sample) {
 }
 
 void SinkInputPin::SetRequestedMediaCapability(
-    const VideoCaptureDevice::Capability& capability) {
+    const VideoCaptureCapability& capability) {
   requested_capability_ = capability;
-  resulting_capability_ = VideoCaptureDevice::Capability();
+  resulting_capability_.width = 0;
+  resulting_capability_.height = 0;
+  resulting_capability_.frame_rate = 0;
+  resulting_capability_.color = VideoCaptureCapability::kColorUnknown;
+  resulting_capability_.expected_capture_delay = 0;
+  resulting_capability_.interlaced = false;
 }
 
-const VideoCaptureDevice::Capability& SinkInputPin::ResultingCapability() {
+const VideoCaptureCapability& SinkInputPin::ResultingCapability() {
   return resulting_capability_;
 }
 
diff --git a/media/video/capture/win/sink_input_pin_win.h b/media/video/capture/win/sink_input_pin_win.h
index 839661d..83679d2 100644
--- a/media/video/capture/win/sink_input_pin_win.h
+++ b/media/video/capture/win/sink_input_pin_win.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -10,6 +10,7 @@
 #pragma once
 
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/video_capture_types.h"
 #include "media/video/capture/win/pin_base_win.h"
 #include "media/video/capture/win/sink_filter_win.h"
 
@@ -24,11 +25,10 @@ class SinkInputPin : public PinBase {
   SinkInputPin(IBaseFilter* filter, SinkFilterObserver* observer);
   virtual ~SinkInputPin();
 
-  void SetRequestedMediaCapability(
-      const VideoCaptureDevice::Capability& capability);
+  void SetRequestedMediaCapability(const VideoCaptureCapability& capability);
   // Returns the capability that is negotiated when this
   // pin is connected to a media filter.
-  const VideoCaptureDevice::Capability& ResultingCapability();
+  const VideoCaptureCapability& ResultingCapability();
 
   // Implement PinBase.
   virtual bool IsMediaTypeValid(const AM_MEDIA_TYPE* media_type);
@@ -37,8 +37,8 @@ class SinkInputPin : public PinBase {
   STDMETHOD(Receive)(IMediaSample* media_sample);
 
  private:
-  VideoCaptureDevice::Capability requested_capability_;
-  VideoCaptureDevice::Capability resulting_capability_;
+  VideoCaptureCapability requested_capability_;
+  VideoCaptureCapability resulting_capability_;
   SinkFilterObserver* observer_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(SinkInputPin);
diff --git a/media/video/capture/win/video_capture_device_win.cc b/media/video/capture/win/video_capture_device_win.cc
index d073d21..67b7cdb 100644
--- a/media/video/capture/win/video_capture_device_win.cc
+++ b/media/video/capture/win/video_capture_device_win.cc
@@ -148,7 +148,7 @@ struct ResolutionDiff {
   int diff_height;
   int diff_width;
   int diff_frame_rate;
-  media::VideoCaptureDevice::Format color;
+  media::VideoCaptureCapability::Format color;
 };
 
 bool CompareHeight(const ResolutionDiff& item1, const ResolutionDiff& item2) {
@@ -338,7 +338,7 @@ void VideoCaptureDeviceWin::Allocate(
   // Get the camera capability that best match the requested resolution.
   const int capability_index = GetBestMatchedCapability(width, height,
                                                         frame_rate);
-  Capability capability = capabilities_[capability_index];
+  VideoCaptureCapability capability = capabilities_[capability_index];
 
   // Reduce the frame rate if the requested frame rate is lower
   // than the capability.
@@ -373,7 +373,8 @@ void VideoCaptureDeviceWin::Allocate(
   if (FAILED(hr))
     SetErrorState("Failed to set capture device output format");
 
-  if (capability.color == VideoCaptureDevice::kMJPEG && !mjpg_filter_.get()) {
+  if (capability.color == VideoCaptureCapability::kMJPEG &&
+      !mjpg_filter_.get()) {
     // Create MJPG filter if we need it.
     hr = mjpg_filter_.CreateInstance(CLSID_MjpegDec, NULL, CLSCTX_INPROC);
 
@@ -391,7 +392,8 @@ void VideoCaptureDeviceWin::Allocate(
     }
   }
 
-  if (capability.color == VideoCaptureDevice::kMJPEG && mjpg_filter_.get()) {
+  if (capability.color == VideoCaptureCapability::kMJPEG &&
+      mjpg_filter_.get()) {
     // Connect the camera to the MJPEG decoder.
     hr = graph_builder_->ConnectDirect(output_capture_pin_, input_mjpg_pin_,
                                        NULL);
@@ -417,7 +419,8 @@ void VideoCaptureDeviceWin::Allocate(
 
   // Get the capability back from the sink filter after the filter have been
   // connected.
-  const Capability& used_capability = sink_filter_->ResultingCapability();
+  const VideoCaptureCapability& used_capability
+      = sink_filter_->ResultingCapability();
   observer_->OnFrameInfo(used_capability);
 
   state_ = kAllocated;
@@ -515,7 +518,7 @@ bool VideoCaptureDeviceWin::CreateCapabilityMap() {
 
     if (media_type->majortype == MEDIATYPE_Video &&
         media_type->formattype == FORMAT_VideoInfo) {
-      Capability capability;
+      VideoCaptureCapability capability;
       REFERENCE_TIME time_per_frame = 0;
 
       VIDEOINFOHEADER* h =
@@ -559,16 +562,16 @@ bool VideoCaptureDeviceWin::CreateCapabilityMap() {
 
       // We can't switch MEDIATYPE :~(.
       if (media_type->subtype == kMediaSubTypeI420) {
-        capability.color = VideoCaptureDevice::kI420;
+        capability.color = VideoCaptureCapability::kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_IYUV) {
         // This is identical to kI420.
-        capability.color = VideoCaptureDevice::kI420;
+        capability.color = VideoCaptureCapability::kI420;
       } else if (media_type->subtype == MEDIASUBTYPE_RGB24) {
-        capability.color = VideoCaptureDevice::kRGB24;
+        capability.color = VideoCaptureCapability::kRGB24;
       } else if (media_type->subtype == MEDIASUBTYPE_YUY2) {
-        capability.color = VideoCaptureDevice::kYUY2;
+        capability.color = VideoCaptureCapability::kYUY2;
       } else if (media_type->subtype == MEDIASUBTYPE_MJPG) {
-        capability.color = VideoCaptureDevice::kMJPEG;
+        capability.color = VideoCaptureCapability::kMJPEG;
       } else {
         WCHAR guid_str[128];
         StringFromGUID2(media_type->subtype, guid_str, arraysize(guid_str));
@@ -598,7 +601,7 @@ int VideoCaptureDeviceWin::GetBestMatchedCapability(int requested_width,
   for (CapabilityMap::iterator iterator = capabilities_.begin();
        iterator != capabilities_.end();
        ++iterator) {
-    Capability capability = iterator->second;
+    VideoCaptureCapability capability = iterator->second;
 
     ResolutionDiff diff;
     diff.capability_index = iterator->first;
diff --git a/media/video/capture/win/video_capture_device_win.h b/media/video/capture/win/video_capture_device_win.h
index c016e97..1f7e03a 100644
--- a/media/video/capture/win/video_capture_device_win.h
+++ b/media/video/capture/win/video_capture_device_win.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -21,6 +21,7 @@
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/scoped_comptr.h"
 #include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/video_capture_types.h"
 #include "media/video/capture/win/sink_filter_win.h"
 #include "media/video/capture/win/sink_input_pin_win.h"
 
@@ -54,7 +55,7 @@ class VideoCaptureDeviceWin
     kError  // Error accessing HW functions.
             // User needs to recover by destroying the object.
   };
-  typedef std::map<int, Capability> CapabilityMap;
+  typedef std::map<int, VideoCaptureCapability> CapabilityMap;
 
   // Implements SinkFilterObserver.
   virtual void FrameReceived(const uint8* buffer, int length);