Spec compliant video constraints for getUserMedia behind flag.

content/renderer/media/webrtc/media_stream_video_webrtc_sink.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/webrtc/media_stream_video_webrtc_sink.h"
 
+#include <algorithm>
+#include <memory>
+#include <string>
+
+#include "base/feature_list.h"
 #include "base/location.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/timer/timer.h"
 #include "content/common/media/media_stream_options.h"
+#include "content/public/common/content_features.h"
 #include "content/public/renderer/media_stream_utils.h"
 #include "content/renderer/media/media_stream_constraints_util.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 #include "media/base/limits.h"
 #include "third_party/webrtc/api/videosourceproxy.h"
 #include "third_party/webrtc/api/videotracksource.h"
 
 namespace content {
 
+namespace {
+
+rtc::Optional<bool> ToRtcOptional(const base::Optional<bool>& value) {
+  return value ? rtc::Optional<bool>(*value) : rtc::Optional<bool>();
+}
+
+}  // namespace
+
 class MediaStreamVideoWebRtcSink::WebRtcVideoSource
     : public webrtc::VideoTrackSource {
  public:
   WebRtcVideoSource(WebRtcVideoCapturerAdapter* capture_adapter,
                     bool is_screencast,
                     rtc::Optional<bool> needs_denoising)
       : VideoTrackSource(capture_adapter, false),
         capture_adapter_(capture_adapter),
         is_screencast_(is_screencast),
         needs_denoising_(needs_denoising) {}
@@ skipping 207 matching lines @@
   DCHECK(libjingle_worker_thread_->BelongsToCurrentThread());
   base::AutoLock auto_lock(capture_adapter_stop_lock_);
   if (capture_adapter_)
     capture_adapter_->OnFrameCaptured(frame);
 }
 
 MediaStreamVideoWebRtcSink::MediaStreamVideoWebRtcSink(
     const blink::WebMediaStreamTrack& track,
     PeerConnectionDependencyFactory* factory)
     : weak_factory_(this) {
-  DCHECK(MediaStreamVideoTrack::GetVideoTrack(track));
-  const blink::WebMediaConstraints& constraints =
-      MediaStreamVideoTrack::GetVideoTrack(track)->constraints();
+  MediaStreamVideoTrack* video_track =
+      MediaStreamVideoTrack::GetVideoTrack(track);
+  DCHECK(video_track);
+  rtc::Optional<bool> needs_denoising;
+  bool is_screencast = false;
+  double min_frame_rate = 0.0;
+  double max_frame_rate = 0.0;
 
-  // Check for presence of mediaStreamSource constraint. The value is ignored.
-  std::string value;
-  bool is_screencast = GetConstraintValueAsString(
-      constraints, &blink::WebMediaTrackConstraintSet::mediaStreamSource,
-      &value);
+  if (IsOldVideoConstraints()) {
+    const blink::WebMediaConstraints& constraints = video_track->constraints();
 
-  // Extract denoising preference, if no value is set this currently falls back
-  // to a codec-specific default inside webrtc, hence the tri-state of {on, off
-  // unset}.
-  // TODO(pbos): Add tests that make sure that googNoiseReduction has properly
-  // propagated from getUserMedia down to a VideoTrackSource.
-  rtc::Optional<bool> needs_denoising;
-  bool denoising_value;
-  if (GetConstraintValueAsBoolean(
-          constraints, &blink::WebMediaTrackConstraintSet::googNoiseReduction,
-          &denoising_value)) {
-    needs_denoising = rtc::Optional<bool>(denoising_value);
+    // Check for presence of mediaStreamSource constraint. The value is ignored.
+    std::string value;
+    is_screencast = GetConstraintValueAsString(
+        constraints, &blink::WebMediaTrackConstraintSet::mediaStreamSource,
+        &value);
+
+    // Extract denoising preference, if no value is set this currently falls
+    // back to a codec-specific default inside webrtc, hence the tri-state of
+    // {on, off unset}.
+    // TODO(pbos): Add tests that make sure that googNoiseReduction has properly
+    // propagated from getUserMedia down to a VideoTrackSource.
+    bool denoising_value;
+    if (GetConstraintValueAsBoolean(
+            constraints, &blink::WebMediaTrackConstraintSet::googNoiseReduction,
+            &denoising_value)) {
+      needs_denoising = rtc::Optional<bool>(denoising_value);
+    }
+    GetConstraintMinAsDouble(constraints,
+                             &blink::WebMediaTrackConstraintSet::frameRate,
+                             &min_frame_rate);
+    GetConstraintMaxAsDouble(constraints,
+                             &blink::WebMediaTrackConstraintSet::frameRate,
+                             &max_frame_rate);
+  } else {
+    needs_denoising = ToRtcOptional(video_track->noise_reduction());
+    is_screencast = video_track->is_screencast();
+    min_frame_rate = video_track->min_frame_rate();
+    max_frame_rate = video_track->adapter_settings().max_frame_rate;
   }
 
   // Enable automatic frame refreshes for the screen capture sources, which will
   // stop producing frames whenever screen content is not changing. Check the
   // frameRate constraint to determine the rate of refreshes. If a minimum
   // frameRate is provided, use that. Otherwise, use the maximum frameRate if it
   // happens to be less than the default.
   base::TimeDelta refresh_interval = base::TimeDelta::FromMicroseconds(0);
   if (is_screencast) {
     // Start with the default refresh interval, and refine based on constraints.
     refresh_interval =
         base::TimeDelta::FromMicroseconds(kDefaultRefreshIntervalMicros);
-    double value = 0.0;
-    if (GetConstraintMinAsDouble(
-            constraints, &blink::WebMediaTrackConstraintSet::frameRate,
-            &value) &&
-        value > 0.0) {
+    if (min_frame_rate > 0.0) {
       refresh_interval =
           base::TimeDelta::FromMicroseconds(base::saturated_cast<int64_t>(
-              base::Time::kMicrosecondsPerSecond / value));
+              base::Time::kMicrosecondsPerSecond / min_frame_rate));
     }
-    if (GetConstraintMaxAsDouble(
-            constraints, &blink::WebMediaTrackConstraintSet::frameRate,
-            &value) &&
-        value > 0.0) {
+    if (max_frame_rate > 0.0) {
       const base::TimeDelta alternate_refresh_interval =
           base::TimeDelta::FromMicroseconds(base::saturated_cast<int64_t>(
-              base::Time::kMicrosecondsPerSecond / value));
+              base::Time::kMicrosecondsPerSecond / max_frame_rate));
       refresh_interval = std::max(refresh_interval, alternate_refresh_interval);
     }
     if (refresh_interval.InMicroseconds() < kLowerBoundRefreshIntervalMicros) {
       refresh_interval =
           base::TimeDelta::FromMicroseconds(kLowerBoundRefreshIntervalMicros);
     }
   }
 
   // TODO(pbos): Consolidate WebRtcVideoCapturerAdapter into WebRtcVideoSource
   // by removing the need for and dependency on a cricket::VideoCapturer.
@@ skipping 54 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   content::RequestRefreshFrameFromVideoTrack(connected_track());
 }
 
 rtc::Optional<bool> MediaStreamVideoWebRtcSink::SourceNeedsDenoisingForTesting()
     const {
   return video_source_->needs_denoising();
 }
 
 }  // namespace content