Spec compliant video constraints for getUserMedia behind flag.

content/renderer/media/user_media_client_impl.cc

 // Copyright (c) 2012 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/user_media_client_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 229 matching lines @@
 
   UserMediaRequestInfo(int request_id,
                        const blink::WebUserMediaRequest& request,
                        bool is_processing_user_gesture,
                        const url::Origin& security_origin);
 
   void StartAudioTrack(const blink::WebMediaStreamTrack& track,
                        bool is_pending);
 
   blink::WebMediaStreamTrack CreateAndStartVideoTrack(
-      const blink::WebMediaStreamSource& source,
-      const blink::WebMediaConstraints& constraints);
+      const blink::WebMediaStreamSource& source);
 
   // Triggers |callback| when all sources used in this request have either
   // successfully started, or a source has failed to start.
   void CallbackOnTracksStarted(const ResourcesReady& callback);
 
   bool HasPendingSources() const;
 
   // Called when a local audio source has finished (or failed) initializing.
   void OnAudioSourceStarted(MediaStreamSource* source,
                             MediaStreamRequestResult result,
                             const blink::WebString& result_name);
 
   int request_id() const { return request_id_; }
 
   State state() const { return state_; }
   void set_state(State state) { state_ = state; }
 
   bool enable_automatic_output_device_selection() const {
     return enable_automatic_output_device_selection_;
   }
   void set_enable_automatic_output_device_selection(bool value) {
     enable_automatic_output_device_selection_ = value;
   }
+  const VideoCaptureSettings& video_capture_settings() const {
+    return video_capture_settings_;
+  }
+  void SetVideoCaptureSettings(const VideoCaptureSettings& settings,
+                               bool is_content_capture) {
+    DCHECK(settings.HasValue());
+    is_video_content_capture_ = is_content_capture;
+    video_capture_settings_ = settings;
+  }
 
   blink::WebMediaStream* web_stream() { return &web_stream_; }
 
   const blink::WebUserMediaRequest& request() const { return request_; }
 
   StreamControls* stream_controls() { return &stream_controls_; }
 
   bool is_processing_user_gesture() const {
     return is_processing_user_gesture_;
   }
 
   const url::Origin& security_origin() const { return security_origin_; }
 
  private:
   void OnTrackStarted(MediaStreamSource* source,
                       MediaStreamRequestResult result,
                       const blink::WebString& result_name);
 
   // Cheks if the sources for all tracks have been started and if so,
   // invoke the |ready_callback_|.  Note that the caller should expect
   // that |this| might be deleted when the function returns.
   void CheckAllTracksStarted();
 
   const int request_id_;
   State state_;
   bool enable_automatic_output_device_selection_;
+  VideoCaptureSettings video_capture_settings_;
+  bool is_video_content_capture_;
   blink::WebMediaStream web_stream_;
   const blink::WebUserMediaRequest request_;
   StreamControls stream_controls_;
   const bool is_processing_user_gesture_;
   const url::Origin security_origin_;
   ResourcesReady ready_callback_;
   MediaStreamRequestResult request_result_;
   blink::WebString request_result_name_;
   // Sources used in this request.
   std::vector<blink::WebMediaStreamSource> sources_;
@@ skipping 195 matching lines @@
     MediaStreamRequestResult result =
         failed_constraint_name.isEmpty()
             ? MEDIA_DEVICE_NO_HARDWARE
             : MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
     GetUserMediaRequestFailed(user_media_request, result,
                               failed_constraint_name);
     return;
   }
   current_request_info_->stream_controls()->video.device_id =
       settings.device_id();
+  current_request_info_->SetVideoCaptureSettings(
+      settings, false /* is_content_capture */);
   GenerateStreamForCurrentRequestInfo();
 }
 
 void UserMediaClientImpl::FinalizeSelectVideoContentSettings(
     const blink::WebUserMediaRequest& user_media_request,
     const VideoCaptureSettings& settings) {
   DCHECK(CalledOnValidThread());
   if (!IsCurrentRequestInfo(user_media_request))
     return;
 
   if (!settings.HasValue()) {
     blink::WebString failed_constraint_name =
         blink::WebString::fromASCII(settings.failed_constraint_name());
     DCHECK(!failed_constraint_name.isEmpty());
     blink::WebString device_id_constraint_name = blink::WebString::fromASCII(
         user_media_request.videoConstraints().basic().deviceId.name());
     GetUserMediaRequestFailed(user_media_request,
                               MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED,
                               failed_constraint_name);
     return;
   }
   current_request_info_->stream_controls()->video.device_id =
       settings.device_id();
+  current_request_info_->SetVideoCaptureSettings(settings,
+                                                 true /* is_content_capture */);
   GenerateStreamForCurrentRequestInfo();
 }
 
 void UserMediaClientImpl::GenerateStreamForCurrentRequestInfo() {
   DCHECK(CalledOnValidThread());
   DCHECK(current_request_info_);
 
   WebRtcLogMessage(base::StringPrintf(
       "MSI::requestUserMedia. request_id=%d"
       ", audio source id=%s"
@@ skipping 95 matching lines @@
 
   DCHECK(!current_request_info_->request().isNull());
   blink::WebVector<blink::WebMediaStreamTrack> audio_track_vector(
       audio_array.size());
   CreateAudioTracks(audio_array,
                     current_request_info_->request().audioConstraints(),
                     &audio_track_vector);
 
   blink::WebVector<blink::WebMediaStreamTrack> video_track_vector(
       video_array.size());
-  CreateVideoTracks(video_array,
-                    current_request_info_->request().videoConstraints(),
-                    &video_track_vector);
+  CreateVideoTracks(video_array, &video_track_vector);
 
   blink::WebString blink_id = blink::WebString::fromUTF8(label);
   current_request_info_->web_stream()->initialize(blink_id, audio_track_vector,
                                                   video_track_vector);
   current_request_info_->web_stream()->setExtraData(new MediaStream());
 
   // Wait for the tracks to be started successfully or to fail.
   current_request_info_->CallbackOnTracksStarted(
       base::Bind(&UserMediaClientImpl::OnCreateNativeTracksCompleted,
                  weak_factory_.GetWeakPtr(), label));
@@ skipping 116 matching lines @@
     return;
   }
   // By creating |source| it is guaranteed that the blink::WebMediaStreamSource
   // object is valid during the cleanup.
   blink::WebMediaStreamSource source(*source_ptr);
   StopLocalSource(source, false);
   RemoveLocalSource(source);
 }
 
 blink::WebMediaStreamSource UserMediaClientImpl::InitializeVideoSourceObject(
-    const StreamDeviceInfo& device,
-    const blink::WebMediaConstraints& constraints) {
+    const StreamDeviceInfo& device) {
   DCHECK(CalledOnValidThread());
+  DCHECK(current_request_info_);
 
   blink::WebMediaStreamSource source = FindOrInitializeSourceObject(device);
   if (!source.getExtraData()) {
     source.setExtraData(CreateVideoSource(
         device, base::Bind(&UserMediaClientImpl::OnLocalSourceStopped,
                            weak_factory_.GetWeakPtr())));
     local_sources_.push_back(source);
   }
   return source;
 }
@@ skipping 55 matching lines @@
   ProcessedLocalAudioSource* source = new ProcessedLocalAudioSource(
       RenderFrameObserver::routing_id(), device, constraints, source_ready,
       dependency_factory_);
   return source;
 }
 
 MediaStreamVideoSource* UserMediaClientImpl::CreateVideoSource(
     const StreamDeviceInfo& device,
     const MediaStreamSource::SourceStoppedCallback& stop_callback) {
   DCHECK(CalledOnValidThread());
-  content::MediaStreamVideoCapturerSource* ret =
-      new content::MediaStreamVideoCapturerSource(stop_callback, device,
-                                                  render_frame());
-  return ret;
+  DCHECK(current_request_info_);
+  if (IsOldVideoConstraints()) {
+    return new MediaStreamVideoCapturerSource(stop_callback, device,
+                                              render_frame());
+  }
+
+  DCHECK(current_request_info_->video_capture_settings().HasValue());
+  return new MediaStreamVideoCapturerSource(
+      stop_callback, device,
+      current_request_info_->video_capture_settings().capture_params(),
+      render_frame());
 }
 
 void UserMediaClientImpl::CreateVideoTracks(
     const StreamDeviceInfoArray& devices,
-    const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks) {
   DCHECK(CalledOnValidThread());
   DCHECK(current_request_info_);
   DCHECK_EQ(devices.size(), webkit_tracks->size());
 
   for (size_t i = 0; i < devices.size(); ++i) {
     blink::WebMediaStreamSource source =
-        InitializeVideoSourceObject(devices[i], constraints);
+        InitializeVideoSourceObject(devices[i]);
     (*webkit_tracks)[i] =
-        current_request_info_->CreateAndStartVideoTrack(source, constraints);
+        current_request_info_->CreateAndStartVideoTrack(source);
   }
 }
 
 void UserMediaClientImpl::CreateAudioTracks(
     const StreamDeviceInfoArray& devices,
     const blink::WebMediaConstraints& constraints,
     blink::WebVector<blink::WebMediaStreamTrack>* webkit_tracks) {
   DCHECK(CalledOnValidThread());
   DCHECK(current_request_info_);
   DCHECK_EQ(devices.size(), webkit_tracks->size());
@@ skipping 368 matching lines @@
 }
 
 UserMediaClientImpl::UserMediaRequestInfo::UserMediaRequestInfo(
     int request_id,
     const blink::WebUserMediaRequest& request,
     bool is_processing_user_gesture,
     const url::Origin& security_origin)
     : request_id_(request_id),
       state_(State::NOT_SENT_FOR_GENERATION),
       enable_automatic_output_device_selection_(false),
+      is_video_content_capture_(false),
       request_(request),
       is_processing_user_gesture_(is_processing_user_gesture),
       security_origin_(security_origin),
       request_result_(MEDIA_DEVICE_OK),
       request_result_name_("") {}
 
 void UserMediaClientImpl::UserMediaRequestInfo::StartAudioTrack(
     const blink::WebMediaStreamTrack& track,
     bool is_pending) {
   DCHECK(track.source().getType() == blink::WebMediaStreamSource::TypeAudio);
   MediaStreamAudioSource* native_source =
       MediaStreamAudioSource::From(track.source());
   // Add the source as pending since OnTrackStarted will expect it to be there.
   sources_waiting_for_callback_.push_back(native_source);
 
   sources_.push_back(track.source());
   bool connected = native_source->ConnectToTrack(track);
   if (!is_pending) {
     OnTrackStarted(
         native_source,
         connected ? MEDIA_DEVICE_OK : MEDIA_DEVICE_TRACK_START_FAILURE, "");
   }
 }
 
 blink::WebMediaStreamTrack
 UserMediaClientImpl::UserMediaRequestInfo::CreateAndStartVideoTrack(
-    const blink::WebMediaStreamSource& source,
-    const blink::WebMediaConstraints& constraints) {
+    const blink::WebMediaStreamSource& source) {
   DCHECK(source.getType() == blink::WebMediaStreamSource::TypeVideo);
+  DCHECK(request_.video());
+  DCHECK(video_capture_settings_.HasValue());
   MediaStreamVideoSource* native_source =
       MediaStreamVideoSource::GetVideoSource(source);
   DCHECK(native_source);
   sources_.push_back(source);
   sources_waiting_for_callback_.push_back(native_source);
+  if (IsOldVideoConstraints()) {
+    return MediaStreamVideoTrack::CreateVideoTrack(
+        native_source, request_.videoConstraints(),
+        base::Bind(&UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
+                   AsWeakPtr()),
+        true);
+  }
   return MediaStreamVideoTrack::CreateVideoTrack(
-      native_source, constraints, base::Bind(
-          &UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
-          AsWeakPtr()),
+      native_source, video_capture_settings_.track_adapter_settings(),
+      video_capture_settings_.noise_reduction(), is_video_content_capture_,
+      video_capture_settings_.min_frame_rate(),
+      base::Bind(&UserMediaClientImpl::UserMediaRequestInfo::OnTrackStarted,
+                 AsWeakPtr()),
       true);
 }
 
 void UserMediaClientImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
     const ResourcesReady& callback) {
   DCHECK(ready_callback_.is_null());
   ready_callback_ = callback;
   CheckAllTracksStarted();
 }
 
@@ skipping 35 matching lines @@
     const blink::WebString& result_name) {
   // Check if we're waiting to be notified of this source.  If not, then we'll
   // ignore the notification.
   auto found = std::find(sources_waiting_for_callback_.begin(),
                          sources_waiting_for_callback_.end(), source);
   if (found != sources_waiting_for_callback_.end())
     OnTrackStarted(source, result, result_name);
 }
 
 }  // namespace content