Add "exact" constraint evaluation to video picker.

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 15 matching lines @@
 };
 
 // Returns true if |constraint| has mandatory constraints.
 bool HasMandatoryConstraints(const blink::WebMediaConstraints& constraints) {
   return constraints.basic().hasMandatory();
 }
 
 // Retrieve the desired max width and height from |constraints|. If not set,
 // the |desired_width| and |desired_height| are set to
 // std::numeric_limits<int>::max();
-// If either max width or height is set as a mandatory constraint, the optional
-// constraints are not checked.
+// If either max or exact width or height is set as a mandatory constraint,
+// the advanced constraints are not checked.
+//

[Guido Urdaneta, 2016/08/11 09:25:01]

nit: is this empty line with "//" intentional

[hta - Chromium, 2016/08/11 11:18:18]

No. Removed.

 void GetDesiredMaxWidthAndHeight(const blink::WebMediaConstraints& constraints,
                                  int* desired_width, int* desired_height) {
   *desired_width = std::numeric_limits<int>::max();
   *desired_height = std::numeric_limits<int>::max();
 
   const auto& basic_constraints = constraints.basic();
+  if (basic_constraints.width.hasExact() ||
+      basic_constraints.height.hasExact()) {

[Guido Urdaneta, 2016/08/11 09:25:01]

what if it has exact width and max height, but no exact height?

[hta - Chromium, 2016/08/11 11:18:18]

That is a correct question to ask. I merged the two "if" blocks, with a comment
that exact constraints override max constraints.

+    if (basic_constraints.width.hasExact())
+      *desired_width = basic_constraints.width.exact();
+    if (basic_constraints.height.hasExact())
+      *desired_height = basic_constraints.height.exact();
+    return;
+  }
+
   if (basic_constraints.width.hasMax() || basic_constraints.height.hasMax()) {
     if (basic_constraints.width.hasMax())
       *desired_width = basic_constraints.width.max();
     if (basic_constraints.height.hasMax())
       *desired_height = basic_constraints.height.max();
     return;
   }
 
   for (const auto& constraint_set : constraints.advanced()) {
     if (constraint_set.width.hasMax())
       *desired_width = constraint_set.width.max();
     if (constraint_set.height.hasMax())
       *desired_height = constraint_set.height.max();
+    if (constraint_set.width.hasExact())
+      *desired_width = constraint_set.width.exact();
+    if (constraint_set.height.hasExact())
+      *desired_height = constraint_set.height.exact();
   }
 }
 
 // Retrieve the desired max and min aspect ratio from |constraints|. If not set,
 // the |min_aspect_ratio| is set to 0 and |max_aspect_ratio| is set to
 // std::numeric_limits<double>::max();
 // If either min or max aspect ratio is set as a mandatory constraint, the
 // optional constraints are not checked.
 void GetDesiredMinAndMaxAspectRatio(
     const blink::WebMediaConstraints& constraints,
@@ skipping 37 matching lines @@
   DCHECK(format != NULL);
 
   if (!format->IsValid())
     return false;
 
   // The width and height are matched based on cropping occuring later:
   // min width/height has to be >= the size of the frame (no upscale).
   // max width/height just has to be > 0 (we can crop anything too large).
   if ((constraints.width.hasMin() &&
        constraints.width.min() > format->frame_size.width()) ||
-      (constraints.width.hasMax() && constraints.width.max() <= 0)) {
+      (constraints.width.hasMax() && constraints.width.max() <= 0) ||
+      (constraints.width.hasExact() &&
+       constraints.width.exact() != format->frame_size.width())) {
     *failing_constraint_name = constraints.width.name();
   } else if ((constraints.height.hasMin() &&
               constraints.height.min() > format->frame_size.height()) ||
-             (constraints.height.hasMax() && constraints.height.max() <= 0)) {
+             (constraints.height.hasMax() && constraints.height.max() <= 0) ||
+             (constraints.height.hasExact() &&
+              constraints.height.exact() != format->frame_size.height())) {
     *failing_constraint_name = constraints.height.name();
   } else if (!constraints.frameRate.matches(format->frame_rate)) {
     if (constraints.frameRate.hasMax()) {
       const double value = constraints.frameRate.max();
       // TODO(hta): Check if handling of max = 0.0 is relevant.
       // (old handling was to set rate to 1.0 if 0.0 was specified)
       if (constraints.frameRate.matches(value)) {
         format->frame_rate =
             (format->frame_rate > value) ? value : format->frame_rate;
         return true;
@@ skipping 440 matching lines @@
       callback(callback) {
 }
 
 MediaStreamVideoSource::TrackDescriptor::TrackDescriptor(
     const TrackDescriptor& other) = default;
 
 MediaStreamVideoSource::TrackDescriptor::~TrackDescriptor() {
 }
 
 }  // namespace content