Spec compliant video constraints for getUserMedia behind flag.

content/renderer/media/media_stream_video_track.cc

 // Copyright 2013 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_track.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/renderer/media/media_stream_constraints_util_video_device.h"
+#include "media/capture/video_capture_types.h"
 
 namespace content {
 
 namespace {
 void ResetCallback(std::unique_ptr<VideoCaptureDeliverFrameCB> callback) {
   // |callback| will be deleted when this exits.
 }
 
 // Empty method used for keeping a reference to the original media::VideoFrame.
 // The reference to |frame| is kept in the closure that calls this method.
@@ skipping 169 matching lines @@
 
   return wrapped_black_frame;
 }
 
 // static
 blink::WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
     MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
     bool enabled) {
+  DCHECK(IsOldVideoConstraints());
   blink::WebMediaStreamTrack track;
   track.initialize(source->owner());
   track.setTrackData(
       new MediaStreamVideoTrack(source, constraints, callback, enabled));
   return track;
 }
 
 // static
+blink::WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
+    MediaStreamVideoSource* source,
+    const MediaStreamVideoSource::ConstraintsCallback& callback,
+    bool enabled) {
+  blink::WebMediaStreamTrack track;
+  track.initialize(source->owner());
+  track.setTrackData(new MediaStreamVideoTrack(source, callback, enabled));
+  return track;
+}
+
+// static
+blink::WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
+    MediaStreamVideoSource* source,
+    const VideoTrackAdapterSettings& adapter_settings,
+    const base::Optional<bool>& noise_reduction,
+    bool is_screencast,
+    double min_frame_rate,
+    const MediaStreamVideoSource::ConstraintsCallback& callback,
+    bool enabled) {
+  blink::WebMediaStreamTrack track;
+  track.initialize(source->owner());
+  track.setTrackData(new MediaStreamVideoTrack(
+      source, adapter_settings, noise_reduction, is_screencast, min_frame_rate,
+      callback, enabled));
+  return track;
+}
+
+// static
 MediaStreamVideoTrack* MediaStreamVideoTrack::GetVideoTrack(
      const blink::WebMediaStreamTrack& track) {
   if (track.isNull() ||
       track.source().getType() != blink::WebMediaStreamSource::TypeVideo) {
     return nullptr;
   }
   return static_cast<MediaStreamVideoTrack*>(track.getTrackData());
 }
 
 MediaStreamVideoTrack::MediaStreamVideoTrack(
     MediaStreamVideoSource* source,
+    const MediaStreamVideoSource::ConstraintsCallback& callback,
+    bool enabled)
+    : MediaStreamTrack(true),
+      frame_deliverer_(
+          new MediaStreamVideoTrack::FrameDeliverer(source->io_task_runner(),
+                                                    enabled)),
+      adapter_settings_(base::MakeUnique<VideoTrackAdapterSettings>(
+          VideoTrackAdapterSettings())),
+      is_screencast_(false),
+      min_frame_rate_(0.0),
+      source_(source->GetWeakPtr()) {
+  if (IsOldVideoConstraints()) {
+    blink::WebMediaConstraints constraints;
+    constraints.initialize();
+    source->AddTrackLegacy(
+        this,
+        base::Bind(&MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
+                   frame_deliverer_),
+        constraints, callback);
+  } else {
+    source->AddTrack(
+        this, VideoTrackAdapterSettings(),
+        base::Bind(&MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
+                   frame_deliverer_),
+        callback);
+  }
+}
+
+MediaStreamVideoTrack::MediaStreamVideoTrack(
+    MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
     bool enabled)
     : MediaStreamTrack(true),
       frame_deliverer_(
           new MediaStreamVideoTrack::FrameDeliverer(source->io_task_runner(),
                                                     enabled)),
       constraints_(constraints),
       source_(source->GetWeakPtr()) {
+  DCHECK(IsOldVideoConstraints());
   DCHECK(!constraints.isNull());
-  source->AddTrack(this,
-                   base::Bind(
-                       &MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
-                       frame_deliverer_),
-                   constraints, callback);
+  source->AddTrackLegacy(
+      this,
+      base::Bind(&MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
+                 frame_deliverer_),
+      constraints, callback);
+}
+
+MediaStreamVideoTrack::MediaStreamVideoTrack(
+    MediaStreamVideoSource* source,
+    const VideoTrackAdapterSettings& adapter_settings,
+    const base::Optional<bool>& noise_reduction,
+    bool is_screen_cast,
+    double min_frame_rate,
+    const MediaStreamVideoSource::ConstraintsCallback& callback,
+    bool enabled)
+    : MediaStreamTrack(true),
+      frame_deliverer_(
+          new MediaStreamVideoTrack::FrameDeliverer(source->io_task_runner(),
+                                                    enabled)),
+      adapter_settings_(
+          base::MakeUnique<VideoTrackAdapterSettings>(adapter_settings)),
+      noise_reduction_(noise_reduction),
+      is_screencast_(is_screen_cast),
+      min_frame_rate_(min_frame_rate),
+      source_(source->GetWeakPtr()) {
+  DCHECK(!IsOldVideoConstraints());
+  source->AddTrack(
+      this, adapter_settings,
+      base::Bind(&MediaStreamVideoTrack::FrameDeliverer::DeliverFrameOnIO,
+                 frame_deliverer_),
+      callback);
 }
 
 MediaStreamVideoTrack::~MediaStreamVideoTrack() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(sinks_.empty());
   Stop();
   DVLOG(3) << "~MediaStreamVideoTrack()";
 }
 
 void MediaStreamVideoTrack::AddSink(MediaStreamVideoSink* sink,
@@ skipping 47 matching lines @@
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (source_) {
     source_->RemoveTrack(this);
     source_ = NULL;
   }
   OnReadyStateChanged(blink::WebMediaStreamSource::ReadyStateEnded);
 }
 
 void MediaStreamVideoTrack::getSettings(
     blink::WebMediaStreamTrack::Settings& settings) {
-  const media::VideoCaptureFormat* format = source_->GetCurrentFormat();
+  base::Optional<media::VideoCaptureFormat> format =
+      source_->GetCurrentFormat();
   if (format) {
     settings.frameRate = format->frame_rate;
     settings.videoKind = GetVideoKindForFormat(*format);
   }
   if (width_ && height_) {
     settings.width = width_;
     settings.height = height_;
   }
   switch (source_->device_info().device.video_facing) {
     case media::MEDIA_VIDEO_FACING_NONE:
@@ skipping 20 matching lines @@
 }
 
 void MediaStreamVideoTrack::OnReadyStateChanged(
     blink::WebMediaStreamSource::ReadyState state) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   for (auto* sink : sinks_)
     sink->OnReadyStateChanged(state);
 }
 
 }  // namespace content