Allow MediaStream constraints to specify higher than 30 FPS tab capture.

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"
@@ skipping 12 matching lines @@
 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};
 
+// Hard upper-bound frame rate for tab/desktop capture.
+const double kMaxScreenCastFrameRate = 120.0;
+
 }  // 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) {
   DVLOG(3) << "VideoCapturerDelegate::ctor";
 
   // NULL in unit test.
   if (RenderThreadImpl::current()) {
     VideoCaptureImplManager* manager =
         RenderThreadImpl::current()->video_capture_impl_manager();
     if (manager)
       release_device_cb_ = manager->UseDevice(session_id_);
   }
 }
 
 VideoCapturerDelegate::~VideoCapturerDelegate() {
   DVLOG(3) << "VideoCapturerDelegate::dtor";
   if (!release_device_cb_.is_null())
     release_device_cb_.Run();
 }
 
 void VideoCapturerDelegate::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
+    double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
-  DVLOG(3) << "GetCurrentSupportedFormats("
-           << " { max_requested_height = " << max_requested_height << "})"
-           << " { max_requested_width = " << max_requested_width << "})";
+  DVLOG(3)
+      << "GetCurrentSupportedFormats("
+      << " { max_requested_height = " << max_requested_height << "})"
+      << " { max_requested_width = " << max_requested_width << "})"
+      << " { max_requested_frame_rate = " << max_requested_frame_rate << "})";
 
   if (is_screen_cast_) {
-    media::VideoCaptureFormats formats;
     const int width = max_requested_width ?
         max_requested_width : MediaStreamVideoSource::kDefaultWidth;
     const int height = max_requested_height ?
         max_requested_height : MediaStreamVideoSource::kDefaultHeight;
-    formats.push_back(
-          media::VideoCaptureFormat(
-              gfx::Size(width, height),
-              MediaStreamVideoSource::kDefaultFrameRate,
-              media::PIXEL_FORMAT_I420));
-    callback.Run(formats);
+    callback.Run(media::VideoCaptureFormats(1, media::VideoCaptureFormat(
+        gfx::Size(width, height),
+        static_cast<float>(std::min(kMaxScreenCastFrameRate,
+                                    max_requested_frame_rate)),
+        media::PIXEL_FORMAT_I420)));
     return;
   }
 
   // NULL in unit test.
   if (!RenderThreadImpl::current())
     return;
   VideoCaptureImplManager* manager =
       RenderThreadImpl::current()->video_capture_impl_manager();
   if (!manager)
     return;
@@ skipping 120 matching lines @@
   SetDeviceInfo(device_info);
   SetStopCallback(stop_callback);
 }
 
 MediaStreamVideoCapturerSource::~MediaStreamVideoCapturerSource() {
 }
 
 void MediaStreamVideoCapturerSource::GetCurrentSupportedFormats(
     int max_requested_width,
     int max_requested_height,
+    double max_requested_frame_rate,
     const VideoCaptureDeviceFormatsCB& callback) {
   delegate_->GetCurrentSupportedFormats(
       max_requested_width,
       max_requested_height,
+      max_requested_frame_rate,
       callback);
 }
 
 void MediaStreamVideoCapturerSource::StartSourceImpl(
     const media::VideoCaptureParams& params,
     const VideoCaptureDeliverFrameCB& frame_callback) {
   media::VideoCaptureParams new_params(params);
   if (device_info().device.type == MEDIA_TAB_VIDEO_CAPTURE ||
       device_info().device.type == MEDIA_DESKTOP_VIDEO_CAPTURE) {
     new_params.allow_resolution_change = true;
   }
   delegate_->StartCapture(
       new_params,
       frame_callback,
       base::Bind(&MediaStreamVideoCapturerSource::OnStartDone,
                  base::Unretained(this)));
 }
 
 void MediaStreamVideoCapturerSource::StopSourceImpl() {
   delegate_->StopCapture();
 }
 
 }  // namespace content