Spec compliant video constraints for getUserMedia behind flag.

content/renderer/media/media_stream_video_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_source.h"
 
 #include <algorithm>
 #include <limits>
+#include <memory>
 #include <string>
+#include <utility>
 
+#include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/child/child_process.h"
+#include "content/public/common/content_features.h"
 #include "content/renderer/media/media_stream_constraints_util_video_device.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/video_track_adapter.h"
 
 namespace content {
 
 namespace {
 
 const char* const kLegalVideoConstraints[] = {"width",
                                               "height",
@@ skipping 274 matching lines @@
       std::min(max_width,
                static_cast<int>(MediaStreamVideoSource::kDefaultWidth)) *
       std::min(max_height,
                static_cast<int>(MediaStreamVideoSource::kDefaultHeight));
 
   return GetBestFormatBasedOnArea(formats, area);
 }
 
 }  // anonymous namespace
 
+bool IsOldVideoConstraints() {
+  return base::FeatureList::IsEnabled(
+      features::kMediaStreamOldVideoConstraints);
+}
+
 // static
 MediaStreamVideoSource* MediaStreamVideoSource::GetVideoSource(
     const blink::WebMediaStreamSource& source) {
   if (source.isNull() ||
       source.getType() != blink::WebMediaStreamSource::TypeVideo) {
     return nullptr;
   }
   return static_cast<MediaStreamVideoSource*>(source.getExtraData());
 }
 
 MediaStreamVideoSource::MediaStreamVideoSource()
     : state_(NEW),
       track_adapter_(
           new VideoTrackAdapter(ChildProcess::current()->io_task_runner())),
       weak_factory_(this) {}
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
   DCHECK(CalledOnValidThread());
 }
 
-void MediaStreamVideoSource::AddTrack(
+void MediaStreamVideoSource::AddTrackLegacy(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback) {
   DCHECK(CalledOnValidThread());
+  DCHECK(IsOldVideoConstraints());
   DCHECK(!constraints.isNull());
   DCHECK(std::find(tracks_.begin(), tracks_.end(), track) == tracks_.end());
   tracks_.push_back(track);
   secure_tracker_.Add(track, true);
 
   track_descriptors_.push_back(
       TrackDescriptor(track, frame_callback, constraints, callback));
 
   switch (state_) {
     case NEW: {
@@ skipping 24 matching lines @@
     }
     case STARTING:
     case RETRIEVING_CAPABILITIES: {
       // The |callback| will be triggered once the source has started or
       // the capabilities have been retrieved.
       break;
     }
     case ENDED:
     case STARTED: {
       // Currently, reconfiguring the source is not supported.
+      FinalizeAddTrackLegacy();
+    }
+  }
+}
+
+void MediaStreamVideoSource::AddTrack(
+    MediaStreamVideoTrack* track,
+    const VideoTrackAdapterSettings& track_adapter_settings,
+    const VideoCaptureDeliverFrameCB& frame_callback,
+    const ConstraintsCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(std::find(tracks_.begin(), tracks_.end(), track) == tracks_.end());
+  tracks_.push_back(track);
+  secure_tracker_.Add(track, true);
+
+  track_descriptors_.push_back(TrackDescriptor(
+      track, frame_callback,
+      base::MakeUnique<VideoTrackAdapterSettings>(track_adapter_settings),
+      callback));
+
+  switch (state_) {
+    case NEW: {
+      state_ = STARTING;
+      blink::WebMediaConstraints ignored_constraints;
+      StartSourceImpl(
+          media::VideoCaptureFormat() /* ignored */, ignored_constraints,
+          base::Bind(&VideoTrackAdapter::DeliverFrameOnIO, track_adapter_));
+      break;
+    }
+    case STARTING: {
+      break;
+    }
+    case RETRIEVING_CAPABILITIES: {
+      NOTREACHED();
+      break;
+    }
+    case ENDED:
+    case STARTED: {
+      // Currently, reconfiguring the source is not supported.
       FinalizeAddTrack();
     }
   }
 }
 
 void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
   DCHECK(CalledOnValidThread());
   std::vector<MediaStreamVideoTrack*>::iterator it =
       std::find(tracks_.begin(), tracks_.end(), video_track);
   DCHECK(it != tracks_.end());
@@ skipping 36 matching lines @@
   DCHECK(CalledOnValidThread());
   secure_tracker_.Update(track, is_secure);
   OnCapturingLinkSecured(secure_tracker_.is_capturing_secure());
 }
 
 base::SingleThreadTaskRunner* MediaStreamVideoSource::io_task_runner() const {
   DCHECK(CalledOnValidThread());
   return track_adapter_->io_task_runner();
 }
 
-const media::VideoCaptureFormat*
-    MediaStreamVideoSource::GetCurrentFormat() const {
+base::Optional<media::VideoCaptureFormat>
+MediaStreamVideoSource::GetCurrentFormat() const {
   DCHECK(CalledOnValidThread());
-  if (state_ == STARTING || state_ == STARTED)
-    return &current_format_;
-  return nullptr;
+  if (IsOldVideoConstraints()) {
+    if (state_ == STARTING || state_ == STARTED)
+      return current_format_;
+    return base::Optional<media::VideoCaptureFormat>();
+  } else {
+    return GetCurrentFormatImpl();
+  }
+}
+
+base::Optional<media::VideoCaptureFormat>
+MediaStreamVideoSource::GetCurrentFormatImpl() const {
+  return base::Optional<media::VideoCaptureFormat>();
 }
 
 void MediaStreamVideoSource::DoStopSource() {
   DCHECK(CalledOnValidThread());
   DVLOG(3) << "DoStopSource()";
   if (state_ == ENDED)
     return;
   track_adapter_->StopFrameMonitoring();
   StopSourceImpl();
   state_ = ENDED;
   SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
 }
 
 void MediaStreamVideoSource::OnSupportedFormats(
     const media::VideoCaptureFormats& formats) {
   DCHECK(CalledOnValidThread());
+  DCHECK(IsOldVideoConstraints());
   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
 
   supported_formats_ = formats;
   blink::WebMediaConstraints fulfilled_constraints;
   if (!FindBestFormatWithConstraints(supported_formats_,
                                      &current_format_,
                                      &fulfilled_constraints)) {
     SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
     DVLOG(3) << "OnSupportedFormats failed to find an usable format";
     // This object can be deleted after calling FinalizeAddTrack. See comment
     // in the header file.
-    FinalizeAddTrack();
+    FinalizeAddTrackLegacy();
     return;
   }
 
   state_ = STARTING;
   DVLOG(3) << "Starting the capturer with "
            << media::VideoCaptureFormat::ToString(current_format_);
 
   StartSourceImpl(
       current_format_,
       fulfilled_constraints,
@@ skipping 41 matching lines @@
   return false;
 }
 
 void MediaStreamVideoSource::OnStartDone(MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   DVLOG(3) << "OnStartDone({result =" << result << "})";
   if (result == MEDIA_DEVICE_OK) {
     DCHECK_EQ(STARTING, state_);
     state_ = STARTED;
     SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
-
+    double frame_rate =
+        GetCurrentFormat() ? GetCurrentFormat()->frame_rate : 0.0;
     track_adapter_->StartFrameMonitoring(
-        current_format_.frame_rate,
-        base::Bind(&MediaStreamVideoSource::SetMutedState,
-                   weak_factory_.GetWeakPtr()));
-
+        frame_rate, base::Bind(&MediaStreamVideoSource::SetMutedState,
+                               weak_factory_.GetWeakPtr()));
   } else {
     StopSource();
   }
 
   // This object can be deleted after calling FinalizeAddTrack. See comment in
   // the header file.
-  FinalizeAddTrack();
+  if (IsOldVideoConstraints())
+    FinalizeAddTrackLegacy();
+  else
+    FinalizeAddTrack();
 }
 
-void MediaStreamVideoSource::FinalizeAddTrack() {
+void MediaStreamVideoSource::FinalizeAddTrackLegacy() {
   DCHECK(CalledOnValidThread());
+  DCHECK(IsOldVideoConstraints());
   const media::VideoCaptureFormats formats(1, current_format_);
 
   std::vector<TrackDescriptor> track_descriptors;
   track_descriptors.swap(track_descriptors_);
   for (const auto& track : track_descriptors) {
     MediaStreamRequestResult result = MEDIA_DEVICE_OK;
     std::string unsatisfied_constraint;
 
     if (HasMandatoryConstraints(track.constraints) &&
         FilterFormats(track.constraints, formats, &unsatisfied_constraint)
             .empty()) {
       result = MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED;
-      DVLOG(3) << "FinalizeAddTrack() ignoring device on constraint "
+      DVLOG(3) << "FinalizeAddTrackLegacy() ignoring device on constraint "
                << unsatisfied_constraint;
     }
 
     if (state_ != STARTED && result == MEDIA_DEVICE_OK)
       result = MEDIA_DEVICE_TRACK_START_FAILURE;
 
     if (result == MEDIA_DEVICE_OK) {
       int max_width;
       int max_height;
       GetDesiredMaxWidthAndHeight(track.constraints, &max_width, &max_height);
@@ skipping 14 matching lines @@
                                     max_aspect_ratio, max_frame_rate));
       // Calculate resulting frame size if the source delivers frames
       // according to the current format. Note: Format may change later.
       gfx::Size desired_size;
       VideoTrackAdapter::CalculateTargetSize(
           current_format_.frame_size, gfx::Size(max_width, max_height),
           min_aspect_ratio, max_aspect_ratio, &desired_size);
       track.track->SetTargetSize(desired_size.width(), desired_size.height());
     }
 
-    DVLOG(3) << "FinalizeAddTrack() result " << result;
+    DVLOG(3) << "FinalizeAddTrackLegacy() result " << result;
 
     if (!track.callback.is_null())
       track.callback.Run(this, result,
                          blink::WebString::fromUTF8(unsatisfied_constraint));
   }
 }
 
+void MediaStreamVideoSource::FinalizeAddTrack() {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!IsOldVideoConstraints());
+  std::vector<TrackDescriptor> track_descriptors;
+  track_descriptors.swap(track_descriptors_);
+  for (const auto& track : track_descriptors) {
+    MediaStreamRequestResult result = MEDIA_DEVICE_OK;
+    if (state_ != STARTED)
+      result = MEDIA_DEVICE_TRACK_START_FAILURE;
+
+    if (result == MEDIA_DEVICE_OK) {
+      track_adapter_->AddTrack(track.track, track.frame_callback,
+                               *track.adapter_settings);
+
+      // Calculate resulting frame size if the source delivers frames
+      // according to the current format. Note: Format may change later.
+      gfx::Size desired_size;
+      VideoTrackAdapter::CalculateTargetSize(
+          GetCurrentFormat() ? GetCurrentFormat()->frame_size
+                             : gfx::Size(track.adapter_settings->max_width,
+                                         track.adapter_settings->max_height),
+          gfx::Size(track.adapter_settings->max_width,
+                    track.adapter_settings->max_height),
+          track.adapter_settings->min_aspect_ratio,
+          track.adapter_settings->max_aspect_ratio, &desired_size);
+      track.track->SetTargetSize(desired_size.width(), desired_size.height());
+    }
+
+    if (!track.callback.is_null())
+      track.callback.Run(this, result, blink::WebString());
+  }
+}
+
 void MediaStreamVideoSource::SetReadyState(
     blink::WebMediaStreamSource::ReadyState state) {
   DVLOG(3) << "MediaStreamVideoSource::SetReadyState state " << state;
   DCHECK(CalledOnValidThread());
   if (!owner().isNull())
     owner().setReadyState(state);
   for (auto* track : tracks_)
     track->OnReadyStateChanged(state);
 }
 
 void MediaStreamVideoSource::SetMutedState(bool muted_state) {
   DVLOG(3) << "MediaStreamVideoSource::SetMutedState state=" << muted_state;
   DCHECK(CalledOnValidThread());
   if (!owner().isNull()) {
     owner().setReadyState(muted_state
         ? blink::WebMediaStreamSource::ReadyStateMuted
         : blink::WebMediaStreamSource::ReadyStateLive);
   }
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     MediaStreamVideoTrack* track,
     const VideoCaptureDeliverFrameCB& frame_callback,
     const blink::WebMediaConstraints& constraints,
     const ConstraintsCallback& callback)
     : track(track),
       frame_callback(frame_callback),
       constraints(constraints),
       callback(callback) {
+  DCHECK(IsOldVideoConstraints());
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
-    const TrackDescriptor& other) = default;
+    MediaStreamVideoTrack* track,
+    const VideoCaptureDeliverFrameCB& frame_callback,
+    std::unique_ptr<VideoTrackAdapterSettings> adapter_settings,
+    const ConstraintsCallback& callback)
+    : track(track),
+      frame_callback(frame_callback),
+      adapter_settings(std::move(adapter_settings)),
+      callback(callback) {
+  DCHECK(!IsOldVideoConstraints());
+}
+
+MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
+    TrackDescriptor&& other) = default;
+MediaStreamVideoSource::TrackDescriptor&
+MediaStreamVideoSource::TrackDescriptor::operator=(
+    MediaStreamVideoSource::TrackDescriptor&& other) = default;
 
 MediaStreamVideoSource::TrackDescriptor::~TrackDescriptor() {
 }
 
 }  // namespace content