Accept up to 60fps frame rate in MediaStreamVideoCapturerSource

content/renderer/media/media_stream_video_capturer_source.cc

 // Copyright 2014 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/renderer/media/media_stream_video_capturer_source.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "content/renderer/media/video_capture_impl_manager.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/video_frame.h"
 
 namespace {
 
-struct SourceVideoFormat {
+struct SourceVideoResolution {
   int width;
   int height;
-  int frame_rate;
 };
 
-// List of formats used if the source doesn't support capability enumeration.
-const SourceVideoFormat kVideoFormats[] = {{1920, 1080, 30},
-                                           {1280, 720, 30},
-                                           {960, 720, 30},
-                                           {640, 480, 30},
-                                           {640, 360, 30},
-                                           {320, 240, 30},
-                                           {320, 180, 30}};
+// Resolutions used if the source doesn't support capability enumeration.
+const SourceVideoResolution kVideoResolutions[] = {{1920, 1080},
+                                                   {1280, 720},
+                                                   {960, 720},
+                                                   {640, 480},
+                                                   {640, 360},
+                                                   {320, 240},
+                                                   {320, 180}};
+// Frame rates for sources with no support for capability enumeration.
+const int kVideoFrameRates[] = {30, 60};
 
 }  // namespace
 
 namespace content {
 
 VideoCapturerDelegate::VideoCapturerDelegate(
     const StreamDeviceInfo& device_info)
     : session_id_(device_info.session_id),
       is_screen_cast_(device_info.device.type == MEDIA_TAB_VIDEO_CAPTURE ||
                       device_info.device.type == MEDIA_DESKTOP_VIDEO_CAPTURE),
@@ skipping 142 matching lines @@
   // StopCapture() might have destroyed |source_formats_callback_| before
   // arriving here.
   if (source_formats_callback_.is_null())
     return;
   if (formats.size()) {
     source_formats_callback_.Run(formats);
   } else {
     // The capture device doesn't seem to support capability enumeration,
     // compose a fallback list of capabilities.
     media::VideoCaptureFormats default_formats;
-    for (size_t i = 0; i < arraysize(kVideoFormats); ++i) {
-      default_formats.push_back(media::VideoCaptureFormat(
-          gfx::Size(kVideoFormats[i].width, kVideoFormats[i].height),
-          kVideoFormats[i].frame_rate,
-          media::PIXEL_FORMAT_I420));
+    for (size_t i = 0; i < arraysize(kVideoResolutions); ++i) {
+      for (size_t j = 0; j < arraysize(kVideoFrameRates); ++j) {
+        default_formats.push_back(media::VideoCaptureFormat(
+            gfx::Size(kVideoResolutions[i].width, kVideoResolutions[i].height),
+            kVideoFrameRates[j], media::PIXEL_FORMAT_I420));
+      }
     }
     source_formats_callback_.Run(default_formats);
   }
   source_formats_callback_.Reset();
 }
 
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const StreamDeviceInfo& device_info,
     const SourceStoppedCallback& stop_callback,
     const scoped_refptr<VideoCapturerDelegate>& delegate)
@@ skipping 28 matching lines @@
       frame_callback,
       base::Bind(&MediaStreamVideoCapturerSource::OnStartDone,
                  base::Unretained(this)));
 }
 
 void MediaStreamVideoCapturerSource::StopSourceImpl() {
   delegate_->StopCapture();
 }
 
 }  // namespace content