Avoid float-cast-overflow in content::VideoCapturerSource::GetCurrentSupportedFormats

content/renderer/media/canvas_capture_handler.cc

 // Copyright 2015 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/canvas_capture_handler.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/public/renderer/render_thread.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc_uma_histograms.h"
 #include "content/renderer/render_thread_impl.h"
+#include "media/base/limits.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/libyuv/include/libyuv.h"
 #include "third_party/skia/include/core/SkImage.h"
 
 namespace {
 
 using media::VideoFrame;
 
 const size_t kArgbBytesPerPixel = 4;
 
 }  // namespace
 
 namespace content {
 
 // Implementation VideoCapturerSource that is owned by
 // MediaStreamVideoCapturerSource and delegates the Start/Stop calls to
 // CanvasCaptureHandler.
 // This class is single threaded and pinned to main render thread.
 class VideoCapturerSource : public media::VideoCapturerSource {
  public:
-  explicit VideoCapturerSource(base::WeakPtr<CanvasCaptureHandler>
-                                   canvas_handler,
-                               double frame_rate)
-      : frame_rate_(frame_rate),
-        canvas_handler_(canvas_handler) {}
+  VideoCapturerSource(base::WeakPtr<CanvasCaptureHandler> canvas_handler,
+                      double frame_rate)
+      : frame_rate_(static_cast<float>(
+            std::min(static_cast<double>(media::limits::kMaxFramesPerSecond),
+                     frame_rate))),
+        canvas_handler_(canvas_handler) {
+    DCHECK_LE(0, frame_rate_);
+  }
 
  protected:
   void GetCurrentSupportedFormats(
       int max_requested_width,
       int max_requested_height,
       double max_requested_frame_rate,
       const VideoCaptureDeviceFormatsCB& callback) override {
     DCHECK(main_render_thread_checker_.CalledOnValidThread());
     const blink::WebSize& size = canvas_handler_->GetSourceSize();
     media::VideoCaptureFormats formats;
@@ skipping 16 matching lines @@
     DCHECK(main_render_thread_checker_.CalledOnValidThread());
     canvas_handler_->RequestRefreshFrame();
   }
   void StopCapture() override {
     DCHECK(main_render_thread_checker_.CalledOnValidThread());
     if (canvas_handler_.get())
       canvas_handler_->StopVideoCapture();
   }
 
  private:
-  const double frame_rate_;
+  const float frame_rate_;
   // Bound to Main Render thread.
   base::ThreadChecker main_render_thread_checker_;
   // CanvasCaptureHandler is owned by CanvasDrawListener in blink and might be
   // destroyed before StopCapture() call.
   base::WeakPtr<CanvasCaptureHandler> canvas_handler_;
 };
 
 class CanvasCaptureHandler::CanvasCaptureHandlerDelegate {
  public:
   explicit CanvasCaptureHandlerDelegate(
@@ skipping 175 matching lines @@
 
   web_track->initialize(webkit_source);
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   web_track->setTrackData(new MediaStreamVideoTrack(
       media_stream_source.release(), constraints,
       MediaStreamVideoSource::ConstraintsCallback(), true));
 }
 
 }  // namespace content