Implement ConstraintNotSatisfiedError for getusermedia

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 <string>
 
@@ skipping 202 matching lines @@
       format_it = formats->erase(format_it);
     } else {
       ++format_it;
     }
   }
 }
 
 // Returns the media::VideoCaptureFormats that matches |constraints|.
 media::VideoCaptureFormats FilterFormats(
     const blink::WebMediaConstraints& constraints,
-    const media::VideoCaptureFormats& supported_formats) {
+    const media::VideoCaptureFormats& supported_formats,
+    blink::WebString* unsatisfied_constraint) {
   if (constraints.isNull()) {
     return supported_formats;
   }
 
   double max_aspect_ratio;
   double min_aspect_ratio;
   GetDesiredMinAndMaxAspectRatio(constraints,
                                  &min_aspect_ratio,
                                  &max_aspect_ratio);
 
@@ skipping 29 matching lines @@
       DLOG(WARNING) << "Wrong requested frame rate.";
       return media::VideoCaptureFormats();
     }
   }
 
   blink::WebVector<blink::WebMediaConstraint> mandatory;
   blink::WebVector<blink::WebMediaConstraint> optional;
   constraints.getMandatoryConstraints(mandatory);
   constraints.getOptionalConstraints(optional);
   media::VideoCaptureFormats candidates = supported_formats;
-  for (size_t i = 0; i < mandatory.size(); ++i)
+  for (size_t i = 0; i < mandatory.size(); ++i) {
     FilterFormatsByConstraint(mandatory[i], true, &candidates);
-
-  if (candidates.empty())
-    return candidates;
+    // Here we record the name of constraint that causes

[miu, 2014/07/30 19:37:23]

This comment is stating the obvious, so you should just get rid of it.

[jiajia.qin, 2014/07/31 13:43:01]

Done.

+    // the ConstraintNotSatisfiedError
+    if (candidates.empty()) {
+      *unsatisfied_constraint = mandatory[i].m_name;
+      return candidates;

[miu, 2014/07/30 19:37:23]

Sanity-check: With this change, you're now aborting the loop early on the first
constraint that eliminates all candidates.  Before, the code would loop through
all constraints unconditionally.  Are you sure there aren't any INTENDED side
effects that you've eliminated with this behavior change?

[jiajia.qin, 2014/07/31 13:43:01]

Yes, I am sure. According to the spec, 'ConstraintNotSatisfiedError: One of the
mandatory constraints could not be satisfied' says if one of mandatory
constraints is not satisfied, ConstraintNotSatisfiedError will be thrown.

+    }
+  }
 
   // Ok - all mandatory checked and we still have candidates.
   // Let's try filtering using the optional constraints. The optional
   // constraints must be filtered in the order they occur in |optional|.
   // But if a constraint produce zero candidates, the constraint is ignored and
   // the next constraint is tested.
   // http://dev.w3.org/2011/webrtc/editor/getusermedia.html#idl-def-Constraints
   for (size_t i = 0; i < optional.size(); ++i) {
     media::VideoCaptureFormats current_candidates = candidates;
     FilterFormatsByConstraint(optional[i], false, &current_candidates);
@@ skipping 110 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.
-      FinalizeAddTrack();
+      FinalizeAddTrack(MEDIA_DEVICE_OK);
     }
   }
 }
 
 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());
   tracks_.erase(it);
@@ skipping 36 matching lines @@
     const media::VideoCaptureFormats& formats) {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(RETRIEVING_CAPABILITIES, state_);
 
   supported_formats_ = formats;
   if (!FindBestFormatWithConstraints(supported_formats_,
                                      &current_format_)) {
     SetReadyState(blink::WebMediaStreamSource::ReadyStateEnded);
     // This object can be deleted after calling FinalizeAddTrack. See comment
     // in the header file.
-    FinalizeAddTrack();
+    FinalizeAddTrack(MEDIA_DEVICE_CONSTRAINT_NOT_SATISFIED);

[miu, 2014/07/30 19:37:23]

re: My comment in the .h file:

The call to FindBestFormatWithConstraints() (a few lines above) should have an
unsatisfied_constraint string output argument, and then you can pass it to
FinalizeAddTrack() here.

[jiajia.qin, 2014/07/31 13:43:01]

Done.

     return;
   }
 
   state_ = STARTING;
   DVLOG(3) << "Starting the capturer with"
            << " width = " << current_format_.frame_size.width()
            << " height = " << current_format_.frame_size.height()
            << " frame rate = " << current_format_.frame_rate
            << " pixel format = "
            << media::VideoCaptureFormat::PixelFormatToString(
@@ skipping 18 matching lines @@
         request_it->constraints;
 
     // If the source doesn't support capability enumeration it is still ok if
     // no mandatory constraints have been specified. That just means that
     // we will start with whatever format is native to the source.
     if (formats.empty() && !HasMandatoryConstraints(requested_constraints)) {
       *best_format = media::VideoCaptureFormat();
       return true;
     }
     media::VideoCaptureFormats filtered_formats =
-        FilterFormats(requested_constraints, formats);
+        FilterFormats(requested_constraints, formats, &unsatisfied_constraint_);
     if (filtered_formats.size() > 0) {
       // A request with constraints that can be fulfilled.
       GetBestCaptureFormat(filtered_formats,
                            requested_constraints,
                            best_format);
       return true;
     }
   }
   return false;
 }
 
-void MediaStreamVideoSource::OnStartDone(bool success) {
+void MediaStreamVideoSource::OnStartDone(MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
-  DVLOG(3) << "OnStartDone({success =" << success << "})";
-  if (success) {
+  DVLOG(3) << "OnStartDone({result =" << result << "})";
+  if (result == MEDIA_DEVICE_OK) {
     DCHECK_EQ(STARTING, state_);
     state_ = STARTED;
     SetReadyState(blink::WebMediaStreamSource::ReadyStateLive);
   } else {
     StopSource();
   }
 
   // This object can be deleted after calling FinalizeAddTrack. See comment in
   // the header file.
-  FinalizeAddTrack();
+  FinalizeAddTrack(result);
 }
 
-void MediaStreamVideoSource::FinalizeAddTrack() {
+void MediaStreamVideoSource::FinalizeAddTrack(MediaStreamRequestResult result) {
   DCHECK(CalledOnValidThread());
   media::VideoCaptureFormats formats;
   formats.push_back(current_format_);
 
   std::vector<RequestedConstraints> callbacks;
   callbacks.swap(requested_constraints_);
   for (std::vector<RequestedConstraints>::iterator it = callbacks.begin();
        it != callbacks.end(); ++it) {
-    // The track has been added successfully if the source has started and
-    // there are either no mandatory constraints and the source doesn't expose
-    // its format capabilities, or the constraints and the format match.
-    // For example, a remote source doesn't expose its format capabilities.
-    bool success =
-        state_ == STARTED &&
-        ((!current_format_.IsValid() && !HasMandatoryConstraints(
-            it->constraints)) ||
-         !FilterFormats(it->constraints, formats).empty());
-
-    if (success) {
+    if (result == MEDIA_DEVICE_OK) {
       int max_width;
       int max_height;
       GetDesiredMaxWidthAndHeight(it->constraints, &max_width, &max_height);
       double max_aspect_ratio;
       double min_aspect_ratio;
       GetDesiredMinAndMaxAspectRatio(it->constraints,
                                      &min_aspect_ratio,
                                      &max_aspect_ratio);
       double max_frame_rate = 0.0f;
       GetConstraintValueAsDouble(it->constraints,
                                  kMaxFrameRate, &max_frame_rate);
 
       VideoTrackAdapter::OnMutedCallback on_mute_callback =
           media::BindToCurrentLoop(base::Bind(
               &MediaStreamVideoSource::SetMutedState,
               weak_factory_.GetWeakPtr()));
       track_adapter_->AddTrack(it->track, it->frame_callback,
                                max_width, max_height,
                                min_aspect_ratio, max_aspect_ratio,
                                max_frame_rate, current_format_.frame_rate,
                                on_mute_callback);
     }
 
-    DVLOG(3) << "FinalizeAddTrack() success " << success;
+    DVLOG(3) << "FinalizeAddTrack() result " << result;
 
     if (!it->callback.is_null())
-      it->callback.Run(this, success);
+      it->callback.Run(this, result, unsatisfied_constraint_);
   }
 }
 
 void MediaStreamVideoSource::SetReadyState(
     blink::WebMediaStreamSource::ReadyState state) {
   DVLOG(3) << "MediaStreamVideoSource::SetReadyState state " << state;
   DCHECK(CalledOnValidThread());
   if (!owner().isNull()) {
     owner().setReadyState(state);
   }
@@ skipping 21 matching lines @@
     : track(track),
       frame_callback(frame_callback),
       constraints(constraints),
       callback(callback) {
 }
 
 MediaStreamVideoSource::RequestedConstraints::~RequestedConstraints() {
 }
 
 }  // namespace content