Introduce SelectSettings algorithm for MediaStream video tracks.

content/renderer/media/media_stream_constraints_util_video_device.cc

 // Copyright 2017 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_constraints_util_video_device.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "content/renderer/media/media_stream_constraints_util.h"
+#include "content/renderer/media/media_stream_constraints_util_sets.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 namespace {
 
 // Number of default settings to be used as final tie-breaking criteria for
 // settings that are equally good at satisfying constraints:
@@ skipping 19 matching lines @@
       return blink::WebString::fromASCII("environment");
     case ::mojom::FacingMode::LEFT:
       return blink::WebString::fromASCII("left");
     case ::mojom::FacingMode::RIGHT:
       return blink::WebString::fromASCII("right");
     default:
       return blink::WebString::fromASCII("");
   }
 }
 
-struct VideoDeviceCaptureSourceSettings {
+struct Candidate {
  public:
-  VideoDeviceCaptureSourceSettings(
-      const std::string& device_id,
-      const media::VideoCaptureFormat& format,
-      ::mojom::FacingMode facing_mode,
-      media::PowerLineFrequency power_line_frequency,
-      const rtc::Optional<bool>& noise_reduction)
+  Candidate(const std::string& device_id,
+            const media::VideoCaptureFormat& format,
+            ::mojom::FacingMode facing_mode,
+            media::PowerLineFrequency power_line_frequency,
+            const base::Optional<bool>& noise_reduction)
       : device_id_(device_id),
         format_(format),
         facing_mode_(facing_mode),
         power_line_frequency_(power_line_frequency),
         noise_reduction_(noise_reduction) {}
 
-  VideoDeviceCaptureSourceSettings(
-      const VideoDeviceCaptureSourceSettings& other) = default;
-  VideoDeviceCaptureSourceSettings& operator=(
-      const VideoDeviceCaptureSourceSettings& other) = default;
-  VideoDeviceCaptureSourceSettings(VideoDeviceCaptureSourceSettings&& other) =
-      default;
-  VideoDeviceCaptureSourceSettings& operator=(
-      VideoDeviceCaptureSourceSettings&& other) = default;
-  ~VideoDeviceCaptureSourceSettings() = default;
-
   // These accessor-like methods transform types to what Blink constraint
   // classes expect.
   blink::WebString GetFacingMode() const { return ToWebString(facing_mode_); }
   long GetPowerLineFrequency() const {
     return static_cast<long>(power_line_frequency_);
   }
   blink::WebString GetDeviceId() const {
     return blink::WebString::fromASCII(device_id_.data());
   }
   blink::WebString GetVideoKind() const {
     return GetVideoKindForFormat(format_);
   }
 
   // Accessors.
   const media::VideoCaptureFormat& format() const { return format_; }
   const std::string& device_id() const { return device_id_; }
   ::mojom::FacingMode facing_mode() const { return facing_mode_; }
   media::PowerLineFrequency power_line_frequency() const {
     return power_line_frequency_;
   }
-  const rtc::Optional<bool>& noise_reduction() const {
+  const base::Optional<bool>& noise_reduction() const {
     return noise_reduction_;
   }
 
  private:
   std::string device_id_;
   media::VideoCaptureFormat format_;
   ::mojom::FacingMode facing_mode_;
   media::PowerLineFrequency power_line_frequency_;
-  rtc::Optional<bool> noise_reduction_;
+  base::Optional<bool> noise_reduction_;
 };
 
 // The ConstrainedFormat class keeps track of the effect of constraint sets on
 // the range of values supported by a video-capture format while iterating over
 // the constraint sets.
 // For example, suppose a device supports a width of 1024. Then, in principle,
 // it can support any width below 1024 using cropping.
 // Suppose the first advanced constraint set requests a maximum width of 640,
 // and the second advanced constraint set requests a minimum of 800.
 // Separately, the camera supports both advanced sets. However, if the first
 // set is supported, the second set can no longer be supported because width can
 // no longer exceed 640. The ConstrainedFormat class keeps track of this.
 class ConstrainedFormat {
  public:
   explicit ConstrainedFormat(const media::VideoCaptureFormat& format)
       : native_height_(format.frame_size.height()),
-        min_height_(1),
-        max_height_(format.frame_size.height()),
         native_width_(format.frame_size.width()),
-        min_width_(1),
-        max_width_(format.frame_size.width()),
         native_frame_rate_(format.frame_rate),
-        min_frame_rate_(1),
-        max_frame_rate_(format.frame_rate) {}
+        constrained_resolution_(1,
+                                format.frame_size.height(),
+                                1,
+                                format.frame_size.width(),
+                                0.0,
+                                HUGE_VAL),
+        constrained_frame_rate_(1, format.frame_rate) {}
 
   long native_height() const { return native_height_; }
-  long min_height() const { return min_height_; }
-  long max_height() const { return max_height_; }
   long native_width() const { return native_width_; }
-  long min_width() const { return min_width_; }
-  long max_width() const { return max_width_; }
-  long native_frame_rate() const { return native_frame_rate_; }
-  long min_frame_rate() const { return min_frame_rate_; }
-  long max_frame_rate() const { return max_frame_rate_; }
+  double native_frame_rate() const { return native_frame_rate_; }
+  const ResolutionSet& constrained_resolution() const {
+    return constrained_resolution_;
+  }
+  const NumericRangeSet<double>& constrained_frame_rate() const {
+    return constrained_frame_rate_;
+  }
 
-  void ApplyConstraintSet(
+  long MinHeight() const { return constrained_resolution_.min_height(); }
+  long MaxHeight() const { return constrained_resolution_.max_height(); }
+  long MinWidth() const { return constrained_resolution_.min_width(); }
+  long MaxWidth() const { return constrained_resolution_.max_width(); }
+  double MinAspectRatio() const {
+    return constrained_resolution_.min_aspect_ratio();
+  }
+  double MaxAspectRatio() const {
+    return constrained_resolution_.max_aspect_ratio();
+  }
+  double MinFrameRate() const { return constrained_frame_rate_.Min(); }
+  double MaxFrameRate() const { return constrained_frame_rate_.Max(); }
+
+  // Returns true if the application of |constraint_set| is successful and
+  // results in a nonempty set. Returns true otherwise.
+  bool ApplyConstraintSet(
       const blink::WebMediaTrackConstraintSet& constraint_set) {
-    if (ConstraintHasMin(constraint_set.width))
-      min_width_ = std::max(min_width_, ConstraintMin(constraint_set.width));
-    if (ConstraintHasMax(constraint_set.width))
-      max_width_ = std::min(max_width_, ConstraintMax(constraint_set.width));
-
-    if (ConstraintHasMin(constraint_set.height))
-      min_height_ = std::max(min_height_, ConstraintMin(constraint_set.height));
-    if (ConstraintHasMax(constraint_set.height))
-      max_height_ = std::min(max_height_, ConstraintMax(constraint_set.height));
-
-    if (ConstraintHasMin(constraint_set.frameRate))
-      min_frame_rate_ =
-          std::max(min_frame_rate_, ConstraintMin(constraint_set.frameRate));
-    if (ConstraintHasMax(constraint_set.frameRate))
-      max_frame_rate_ =
-          std::min(max_frame_rate_, ConstraintMax(constraint_set.frameRate));
+    constrained_resolution_ = constrained_resolution_.Intersection(
+        ResolutionSet::FromConstraintSet(constraint_set));
+    constrained_frame_rate_ = constrained_frame_rate_.Intersection(
+        NumericRangeSet<double>::FromConstraint(constraint_set.frameRate));
+    DCHECK(!constrained_resolution_.IsEmpty());
+    DCHECK(!constrained_frame_rate_.IsEmpty());
+    return true;
   }
 
  private:
   // Using long for compatibility with Blink constraint classes.
   long native_height_;
-  long min_height_;
-  long max_height_;
   long native_width_;
-  long min_width_;
-  long max_width_;
   double native_frame_rate_;
-  double min_frame_rate_;
-  double max_frame_rate_;
+  ResolutionSet constrained_resolution_;
+  NumericRangeSet<double> constrained_frame_rate_;
 };
 
-VideoDeviceCaptureSourceSelectionResult ResultFromSettings(
-    const VideoDeviceCaptureSourceSettings& settings) {
+VideoCaptureSettings ComputeVideoDeviceCaptureSettings(
+    const Candidate& candidate,
+    const ConstrainedFormat& constrained_format,
+    const blink::WebMediaTrackConstraintSet& basic_constraint_set) {
   media::VideoCaptureParams capture_params;
-  capture_params.requested_format = settings.format();
-  capture_params.power_line_frequency = settings.power_line_frequency();
+  capture_params.requested_format = candidate.format();
+  capture_params.power_line_frequency = candidate.power_line_frequency();
+  auto track_adapter_settings = SelectVideoTrackAdapterSettings(
+      basic_constraint_set, constrained_format.constrained_resolution(),
+      constrained_format.constrained_frame_rate(),
+      capture_params.requested_format);
 
-  return VideoDeviceCaptureSourceSelectionResult(
-      settings.device_id(), settings.facing_mode(), capture_params,
-      settings.noise_reduction());
+  return VideoCaptureSettings(
+      candidate.device_id(), capture_params, candidate.noise_reduction(),
+      track_adapter_settings,
+      constrained_format.constrained_frame_rate().Min());
 }
 
 // Generic distance function between two numeric values. Based on the fitness
 // distance function described in
 // https://w3c.github.io/mediacapture-main/#dfn-fitness-distance
 double Distance(double value1, double value2) {
   if (std::fabs(value1 - value2) <= blink::DoubleConstraint::kConstraintEpsilon)
     return 0.0;
 
   return std::fabs(value1 - value2) /
          std::max(std::fabs(value1), std::fabs(value2));
 }
 
 // Returns a pair with the minimum and maximum aspect ratios supported by the
 // candidate format |constrained_format|, subject to given width and height
 // constraints.
 void GetSourceAspectRatioRange(const ConstrainedFormat& constrained_format,
                                const blink::LongConstraint& height_constraint,
                                const blink::LongConstraint& width_constraint,
                                double* min_source_aspect_ratio,
                                double* max_source_aspect_ratio) {
-  long min_height = constrained_format.min_height();
+  long min_height = constrained_format.MinHeight();
   if (ConstraintHasMin(height_constraint))
     min_height = std::max(min_height, ConstraintMin(height_constraint));
 
-  long max_height = constrained_format.max_height();
+  long max_height = constrained_format.MaxHeight();
   if (ConstraintHasMax(height_constraint))
     max_height = std::min(max_height, ConstraintMax(height_constraint));
 
-  long min_width = constrained_format.min_width();
+  long min_width = constrained_format.MinWidth();
   if (ConstraintHasMin(width_constraint))
     min_width = std::max(min_width, ConstraintMin(width_constraint));
 
-  long max_width = constrained_format.max_width();
+  long max_width = constrained_format.MaxWidth();
   if (ConstraintHasMax(width_constraint))
     max_width = std::min(max_width, ConstraintMax(width_constraint));
 
-  *min_source_aspect_ratio =
+  *min_source_aspect_ratio = std::max(
+      constrained_format.MinAspectRatio(),
       std::max(static_cast<double>(min_width) / static_cast<double>(max_height),
-               kMinSourceAspectRatio);
-  *max_source_aspect_ratio =
+               kMinSourceAspectRatio));
+  *max_source_aspect_ratio = std::min(
+      constrained_format.MaxAspectRatio(),
       std::max(static_cast<double>(max_width) / static_cast<double>(min_height),
-               kMinSourceAspectRatio);
+               kMinSourceAspectRatio));
 }
 
 // Returns a custom distance between a string and a string constraint.
 // Returns 0 if |value| satisfies |constraint|. HUGE_VAL otherwise.
 double StringConstraintSourceDistance(const blink::WebString& value,
                                       const blink::StringConstraint& constraint,
                                       const char** failed_constraint_name) {
   if (constraint.matches(value))
     return 0.0;
 
@@ skipping 57 matching lines @@
 double FrameRateConstraintSourceDistance(
     const ConstrainedFormat& constrained_format,
     const blink::DoubleConstraint& constraint,
     const char** failed_constraint_name) {
   bool constraint_has_min = ConstraintHasMin(constraint);
   double constraint_min = constraint_has_min ? ConstraintMin(constraint) : -1.0;
   bool constraint_has_max = ConstraintHasMax(constraint);
   double constraint_max = constraint_has_max ? ConstraintMax(constraint) : -1.0;
 
   if ((constraint_has_max &&
-       constrained_format.min_frame_rate() >
+       constrained_format.MinFrameRate() >
            constraint_max + blink::DoubleConstraint::kConstraintEpsilon) ||
       (constraint_has_min &&
-       constrained_format.max_frame_rate() <
+       constrained_format.MaxFrameRate() <
            constraint_min - blink::DoubleConstraint::kConstraintEpsilon)) {
     if (failed_constraint_name)
       *failed_constraint_name = constraint.name();
     return HUGE_VAL;
   }
 
   // Compute the cost using the native rate.
   if (constraint_has_max &&
       constrained_format.native_frame_rate() > constraint_max)
     return Distance(constrained_format.native_frame_rate(), constraint_max);
@@ skipping 76 matching lines @@
 
   return 0.0;
 }
 
 // Returns a custom distance function suitable for the googNoiseReduction
 // constraint, given  a |constraint| and a candidate value |value|.
 // The distance is HUGE_VAL if |candidate_value| cannot satisfy |constraint|.
 // Otherwise, the distance is zero.
 double NoiseReductionConstraintSourceDistance(
     const blink::BooleanConstraint& constraint,
-    const rtc::Optional<bool>& value,
+    const base::Optional<bool>& value,
     const char** failed_constraint_name) {
   if (!constraint.hasExact())
     return 0.0;
 
   if (value && *value == constraint.exact())
     return 0.0;
 
   if (failed_constraint_name)
     *failed_constraint_name = constraint.name();
   return HUGE_VAL;
@@ skipping 20 matching lines @@
 // |constraint_set| cannot be satisfied together with previous constraint sets,
 // but will not influence the numeric value returned if it is not infinite.
 // Formats with lower distance satisfy |constraint_set| with lower resource
 // usage.
 double FormatSourceDistance(
     const media::VideoCaptureFormat& format,
     const ConstrainedFormat& constrained_format,
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name) {
   return ResolutionConstraintSourceDistance(
-             constrained_format.native_height(),
-             constrained_format.min_height(), constrained_format.max_height(),
-             constraint_set.height, failed_constraint_name) +
+             constrained_format.native_height(), constrained_format.MinHeight(),
+             constrained_format.MaxHeight(), constraint_set.height,
+             failed_constraint_name) +
          ResolutionConstraintSourceDistance(
-             constrained_format.native_width(), constrained_format.min_width(),
-             constrained_format.max_width(), constraint_set.width,
+             constrained_format.native_width(), constrained_format.MinWidth(),
+             constrained_format.MaxWidth(), constraint_set.width,
              failed_constraint_name) +
          AspectRatioConstraintSourceDistance(
              constrained_format, constraint_set.height, constraint_set.width,
              constraint_set.aspectRatio, failed_constraint_name) +
          FrameRateConstraintSourceDistance(constrained_format,
                                            constraint_set.frameRate,
                                            failed_constraint_name) +
          StringConstraintSourceDistance(GetVideoKindForFormat(format),
                                         constraint_set.videoKind,
                                         failed_constraint_name);
 }
 
 // Returns a custom distance between |constraint_set| and |candidate|, given
 // that the configuration is already constrained by |constrained_format|.
 // |constrained_format| may cause the distance to be infinite if
 // |constraint_set| cannot be satisfied together with previous constraint sets,
 // but will not influence the numeric value returned if it is not infinite.
 // Candidates with lower distance satisfy |constraint_set| with lower resource
 // usage.
 double CandidateSourceDistance(
-    const VideoDeviceCaptureSourceSettings& candidate,
+    const Candidate& candidate,
     const ConstrainedFormat& constrained_format,
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name) {
   return DeviceSourceDistance(candidate.device_id(), candidate.facing_mode(),
                               constraint_set, failed_constraint_name) +
          FormatSourceDistance(candidate.format(), constrained_format,
                               constraint_set, failed_constraint_name) +
          PowerLineFrequencyConstraintSourceDistance(
              constraint_set.googPowerLineFrequency,
              candidate.power_line_frequency(), failed_constraint_name) +
@@ skipping 124 matching lines @@
   if (value == constraint.ideal())
     return 0.0;
 
   return 1.0;
 }
 
 // Returns the fitness distance between |value| and |constraint| for the
 // googNoiseReduction constraint.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double NoiseReductionConstraintFitnessDistance(
-    const rtc::Optional<bool>& value,
+    const base::Optional<bool>& value,
     const blink::BooleanConstraint& constraint) {
   if (!constraint.hasIdeal())
     return 0.0;
 
   if (value && value == constraint.ideal())
     return 0.0;
 
   return 1.0;
 }
 
 // Returns the fitness distance between |constraint_set| and |candidate| given
 // that the configuration is already constrained by |constrained_format|.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double CandidateFitnessDistance(
-    const VideoDeviceCaptureSourceSettings& candidate,
+    const Candidate& candidate,
     const ConstrainedFormat& constrained_format,
     const blink::WebMediaTrackConstraintSet& constraint_set) {
   DCHECK(std::isfinite(CandidateSourceDistance(candidate, constrained_format,
                                                constraint_set, nullptr)));
   double fitness = 0.0;
   fitness += AspectRatioConstraintFitnessDistance(
       constrained_format, constraint_set.height, constraint_set.width,
       constraint_set.aspectRatio);
   fitness += StringConstraintFitnessDistance(candidate.GetDeviceId(),
                                              constraint_set.deviceId);
   fitness += StringConstraintFitnessDistance(candidate.GetFacingMode(),
                                              constraint_set.facingMode);
   fitness += StringConstraintFitnessDistance(candidate.GetVideoKind(),
                                              constraint_set.videoKind);
   fitness += PowerLineFrequencyConstraintFitnessDistance(
       candidate.GetPowerLineFrequency(), constraint_set.googPowerLineFrequency);
   fitness += NoiseReductionConstraintFitnessDistance(
       candidate.noise_reduction(), constraint_set.googNoiseReduction);
   // No need to pass minimum value to compute fitness for range-based
   // constraints because all candidates start out with the same minimum and are
   // subject to the same constraints.
-  fitness += ResolutionConstraintFitnessDistance(
-      constrained_format.max_height(), constraint_set.height);
-  fitness += ResolutionConstraintFitnessDistance(constrained_format.max_width(),
+  fitness += ResolutionConstraintFitnessDistance(constrained_format.MaxHeight(),
+                                                 constraint_set.height);
+  fitness += ResolutionConstraintFitnessDistance(constrained_format.MaxWidth(),
                                                  constraint_set.width);
   fitness += FrameRateConstraintFitnessDistance(
-      constrained_format.max_frame_rate(), constraint_set.frameRate);
+      constrained_format.MaxFrameRate(), constraint_set.frameRate);
 
   return fitness;
 }
 
 // Returns the native fitness distance between a candidate format and a
 // constraint set. The returned value is the sum of the fitness distances for
 // the native values of settings that support a range of values (i.e., width,
 // height and frame rate).
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double CandidateNativeFitnessDistance(
@@ skipping 11 matching lines @@
 }
 
 using DistanceVector = std::vector<double>;
 
 // This function appends additional entries to |distance_vector| based on
 // custom distance metrics between |candidate| and some default settings.
 // These entries are to be used as the final tie breaker for candidates that
 // are equally good according to the spec and the custom distance functions
 // between candidates and constraints.
 void AppendDistanceFromDefault(
-    const VideoDeviceCaptureSourceSettings& candidate,
+    const Candidate& candidate,
     const VideoDeviceCaptureCapabilities& capabilities,
     DistanceVector* distance_vector) {
   // Favor IDs that appear first in the enumeration.
   for (size_t i = 0; i < capabilities.device_capabilities.size(); ++i) {
     if (candidate.device_id() ==
         capabilities.device_capabilities[i]->device_id) {
       distance_vector->push_back(i);
       break;
     }
   }
@@ skipping 38 matching lines @@
              : blink::WebString::fromASCII(kVideoKindColor);
 }
 
 VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities() = default;
 VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities(
     VideoDeviceCaptureCapabilities&& other) = default;
 VideoDeviceCaptureCapabilities::~VideoDeviceCaptureCapabilities() = default;
 VideoDeviceCaptureCapabilities& VideoDeviceCaptureCapabilities::operator=(
     VideoDeviceCaptureCapabilities&& other) = default;
 
-VideoDeviceCaptureSourceSelectionResult::
-    VideoDeviceCaptureSourceSelectionResult()
-    : VideoDeviceCaptureSourceSelectionResult("") {}
-
-VideoDeviceCaptureSourceSelectionResult::
-    VideoDeviceCaptureSourceSelectionResult(const char* failed_constraint_name)
-    : failed_constraint_name_(failed_constraint_name) {}
-
-VideoDeviceCaptureSourceSelectionResult::
-    VideoDeviceCaptureSourceSelectionResult(
-        const std::string& device_id,
-        ::mojom::FacingMode facing_mode,
-        media::VideoCaptureParams capture_params,
-        rtc::Optional<bool> noise_reduction)
-    : failed_constraint_name_(nullptr),
-      device_id_(device_id),
-      facing_mode_(facing_mode),
-      capture_params_(capture_params),
-      noise_reduction_(noise_reduction) {}
-
-VideoDeviceCaptureSourceSelectionResult::
-    VideoDeviceCaptureSourceSelectionResult(
-        const VideoDeviceCaptureSourceSelectionResult& other) = default;
-VideoDeviceCaptureSourceSelectionResult::
-    VideoDeviceCaptureSourceSelectionResult(
-        VideoDeviceCaptureSourceSelectionResult&& other) = default;
-VideoDeviceCaptureSourceSelectionResult::
-    ~VideoDeviceCaptureSourceSelectionResult() = default;
-VideoDeviceCaptureSourceSelectionResult&
-VideoDeviceCaptureSourceSelectionResult::operator=(
-    const VideoDeviceCaptureSourceSelectionResult& other) = default;
-VideoDeviceCaptureSourceSelectionResult&
-VideoDeviceCaptureSourceSelectionResult::operator=(
-    VideoDeviceCaptureSourceSelectionResult&& other) = default;
-
-VideoDeviceCaptureSourceSelectionResult SelectVideoDeviceCaptureSourceSettings(
+VideoCaptureSettings SelectSettingsVideoDeviceCapture(
     const VideoDeviceCaptureCapabilities& capabilities,
     const blink::WebMediaConstraints& constraints) {
   // This function works only if infinity is defined for the double type.
   DCHECK(std::numeric_limits<double>::has_infinity);
 
   // A distance vector contains:
   // a) For each advanced constraint set, a 0/1 value indicating if the
   //    candidate satisfies the corresponding constraint set.
   // b) Fitness distance for the candidate based on support for the ideal values
   //    of the basic constraint set.
   // c) A custom distance value based on how "well" a candidate satisfies each
   //    constraint set, including basic and advanced sets.
   // d) Native fitness distance for the candidate based on support for the
   //    ideal values of the basic constraint set using native values for
   //    settings that can support a range of values.
   // e) A custom distance value based on how close the candidate is to default
   //    settings.
   // Parts (a) and (b) are according to spec. Parts (c) to (e) are
   // implementation specific and used to break ties.
   DistanceVector best_distance(2 * constraints.advanced().size() + 3 +
                                kNumDefaultDistanceEntries);
   std::fill(best_distance.begin(), best_distance.end(), HUGE_VAL);
-  VideoDeviceCaptureSourceSelectionResult result;
+  VideoCaptureSettings result;
   const char* failed_constraint_name = result.failed_constraint_name();
 
   for (auto& device : capabilities.device_capabilities) {
     double basic_device_distance =
         DeviceSourceDistance(device->device_id, device->facing_mode,
                              constraints.basic(), &failed_constraint_name);
     if (!std::isfinite(basic_device_distance))
       continue;
 
     for (auto& format : device->formats) {
       ConstrainedFormat constrained_format(format);
       double basic_format_distance =
           FormatSourceDistance(format, constrained_format, constraints.basic(),
                                &failed_constraint_name);
       if (!std::isfinite(basic_format_distance))
         continue;
       constrained_format.ApplyConstraintSet(constraints.basic());
+      DCHECK(!constrained_format.constrained_resolution().IsEmpty());
+      DCHECK(!constrained_format.constrained_frame_rate().IsEmpty());
 
       for (auto& power_line_frequency : capabilities.power_line_capabilities) {
         double basic_power_line_frequency_distance =
             PowerLineFrequencyConstraintSourceDistance(
                 constraints.basic().googPowerLineFrequency,
                 power_line_frequency, &failed_constraint_name);
         if (!std::isfinite(basic_power_line_frequency_distance))
           continue;
 
         for (auto& noise_reduction :
              capabilities.noise_reduction_capabilities) {
           double basic_noise_reduction_distance =
               NoiseReductionConstraintSourceDistance(
                   constraints.basic().googNoiseReduction, noise_reduction,
                   &failed_constraint_name);
           if (!std::isfinite(basic_noise_reduction_distance))
             continue;
 
           // The candidate satisfies the basic constraint set.
           double candidate_basic_custom_distance =
               basic_device_distance + basic_format_distance +
               basic_power_line_frequency_distance +
               basic_noise_reduction_distance;
           DCHECK(std::isfinite(candidate_basic_custom_distance));
 
           // Temporary vector to save custom distances for advanced constraints.
           // Custom distances must be added to the candidate distance vector
           // after all the spec-mandated values.
           DistanceVector advanced_custom_distance_vector;
-          VideoDeviceCaptureSourceSettings candidate(
-              device->device_id, format, device->facing_mode,
-              power_line_frequency, noise_reduction);
+          Candidate candidate(device->device_id, format, device->facing_mode,
+                              power_line_frequency, noise_reduction);
           DistanceVector candidate_distance_vector;
           // First criteria for valid candidates is satisfaction of advanced
           // constraint sets.
           for (const auto& advanced_set : constraints.advanced()) {
             double custom_distance = CandidateSourceDistance(
                 candidate, constrained_format, advanced_set, nullptr);
             advanced_custom_distance_vector.push_back(custom_distance);
             double spec_distance = std::isfinite(custom_distance) ? 0 : 1;
             candidate_distance_vector.push_back(spec_distance);
             if (std::isfinite(custom_distance))
@@ skipping 14 matching lines @@
           candidate_distance_vector.push_back(CandidateNativeFitnessDistance(
               constrained_format, constraints.basic()));
 
           // Final criteria are custom distances to default settings.
           AppendDistanceFromDefault(candidate, capabilities,
                                     &candidate_distance_vector);
 
           DCHECK_EQ(best_distance.size(), candidate_distance_vector.size());
           if (candidate_distance_vector < best_distance) {
             best_distance = candidate_distance_vector;
-            result = ResultFromSettings(candidate);
+            result = ComputeVideoDeviceCaptureSettings(
+                candidate, constrained_format, constraints.basic());
           }
         }
       }
     }
   }
 
   if (!result.HasValue())
-    return VideoDeviceCaptureSourceSelectionResult(failed_constraint_name);
+    return VideoCaptureSettings(failed_constraint_name);
 
   return result;
 }
 
 }  // namespace content