Minor refactoring of support classes for video-device constraints.

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_source.h"
+#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_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("");
   }
 }
 
-template <typename ConstraintType>
-bool ConstraintHasMax(const ConstraintType& constraint) {
-  return constraint.hasMax() || constraint.hasExact();
-}
+struct VideoDeviceCaptureSourceSettings {
+ public:
+  VideoDeviceCaptureSourceSettings()
+      : facing_mode_(::mojom::FacingMode::NONE),
+        power_line_frequency_(media::PowerLineFrequency::FREQUENCY_DEFAULT) {}
 
-template <typename ConstraintType>
-bool ConstraintHasMin(const ConstraintType& constraint) {
-  return constraint.hasMin() || constraint.hasExact();
-}
+  VideoDeviceCaptureSourceSettings(
+      const std::string& device_id,
+      const media::VideoCaptureFormat& format,
+      ::mojom::FacingMode facing_mode,
+      media::PowerLineFrequency power_line_frequency)
+      : device_id_(device_id),
+        format_(format),
+        facing_mode_(facing_mode),
+        power_line_frequency_(power_line_frequency) {}
 
-template <typename ConstraintType>
-auto ConstraintMax(const ConstraintType& constraint)
-    -> decltype(constraint.max()) {
-  DCHECK(ConstraintHasMax(constraint));
-  return constraint.hasExact() ? constraint.exact() : constraint.max();
-}
+  VideoDeviceCaptureSourceSettings(
+      const VideoDeviceCaptureSourceSettings& other) = default;
+  VideoDeviceCaptureSourceSettings& operator=(
+      const VideoDeviceCaptureSourceSettings& other) = default;
+  VideoDeviceCaptureSourceSettings(VideoDeviceCaptureSourceSettings&& other) =
+      default;
+  VideoDeviceCaptureSourceSettings& operator=(
+      VideoDeviceCaptureSourceSettings&& other) = default;
+  ~VideoDeviceCaptureSourceSettings() = default;
 
-template <typename ConstraintType>
-auto ConstraintMin(const ConstraintType& constraint)
-    -> decltype(constraint.min()) {
-  DCHECK(ConstraintHasMin(constraint));
-  return constraint.hasExact() ? constraint.exact() : constraint.min();
+  // 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_);
+  }
+  long GetWidth() const { return format_.frame_size.width(); }
+  long GetHeight() const { return format_.frame_size.height(); }
+  double GetFrameRate() const { return format_.frame_rate; }
+  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_;
+  }
+
+ private:
+  std::string device_id_;
+  media::VideoCaptureFormat format_;
+  ::mojom::FacingMode facing_mode_;
+  media::PowerLineFrequency power_line_frequency_;
+};
+
+VideoDeviceCaptureSourceSelectionResult ResultFromSettings(
+    const VideoDeviceCaptureSourceSettings& settings) {
+  VideoDeviceCaptureSourceSelectionResult result;
+  result.capture_params.power_line_frequency = settings.power_line_frequency();
+  result.capture_params.requested_format = settings.format();
+  result.device_id = settings.device_id();
+  result.facing_mode = settings.facing_mode();
+  result.failed_constraint_name = nullptr;
+
+  return result;
 }
 
 // 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) /
@@ skipping 233 matching lines @@
                                         failed_constraint_name);
 }
 
 // Returns a custom distance between a set of candidate settings and a
 // constraint set. It is simply the sum of the distances for each individual
 // setting in |candidate|.
 // If |candidate| cannot satisfy constraint, the distance is HUGE_VAL.
 // Otherwise the distance is a finite value. Candidates with lower distance
 // satisfy |constraint_set| in a "better" way.
 double CandidateSourceDistance(
-    const VideoCaptureSourceSettings& candidate,
+    const VideoDeviceCaptureSourceSettings& candidate,
     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(), constraint_set,
                               failed_constraint_name) +
          PowerLineFrequencyConstraintSourceDistance(
              constraint_set.googPowerLineFrequency,
              candidate.power_line_frequency(), failed_constraint_name);
 }
@@ skipping 125 matching lines @@
     return 0.0;
 
   return 1.0;
 }
 
 // Returns the fitness distance between a settings candidate and a constraint
 // set. The returned value is the sum of the fitness distances between each
 // setting in |candidate| and the corresponding constraint in |constraint_set|.
 // Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance.
 double CandidateFitnessDistance(
-    const VideoCaptureSourceSettings& candidate,
+    const VideoDeviceCaptureSourceSettings& candidate,
     const blink::WebMediaTrackConstraintSet& constraint_set) {
   DCHECK(std::isfinite(
       CandidateSourceDistance(candidate, constraint_set, nullptr)));
   double fitness = 0.0;
   fitness += AspectRatioConstraintFitnessDistance(
       candidate.GetHeight(), candidate.GetWidth(), constraint_set.height,
       constraint_set.width, constraint_set.aspectRatio);
   fitness += StringConstraintFitnessDistance(candidate.GetDeviceId(),
                                              constraint_set.deviceId);
   fitness += StringConstraintFitnessDistance(candidate.GetFacingMode(),
@@ skipping 11 matching lines @@
 
   return fitness;
 }
 
 // Returns the native fitness distance between a settings candidate 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(
-    const VideoCaptureSourceSettings& candidate,
+    const VideoDeviceCaptureSourceSettings& candidate,
     const blink::WebMediaTrackConstraintSet& constraint_set) {
   DCHECK(std::isfinite(
       CandidateSourceDistance(candidate, constraint_set, nullptr)));
   double fitness = 0.0;
   fitness += FrameRateConstraintNativeFitnessDistance(candidate.GetFrameRate(),
                                                       constraint_set.frameRate);
   fitness += ResolutionConstraintNativeFitnessDistance(candidate.GetHeight(),
                                                        constraint_set.height);
   fitness += ResolutionConstraintNativeFitnessDistance(candidate.GetWidth(),
                                                        constraint_set.width);
 
   return fitness;
 }
 
 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 VideoCaptureSourceSettings& candidate,
-                               const VideoCaptureCapabilities& capabilities,
-                               DistanceVector* distance_vector) {
+void AppendDistanceFromDefault(
+    const VideoDeviceCaptureSourceSettings& 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;
     }
   }
 
   // Prefer default power-line frequency.
@@ skipping 23 matching lines @@
 
 }  // namespace
 
 blink::WebString GetVideoKindForFormat(
     const media::VideoCaptureFormat& format) {
   return (format.pixel_format == media::PIXEL_FORMAT_Y16)
              ? blink::WebString::fromASCII(kVideoKindDepth)
              : blink::WebString::fromASCII(kVideoKindColor);
 }
 
-VideoCaptureCapabilities::VideoCaptureCapabilities() = default;
-VideoCaptureCapabilities::VideoCaptureCapabilities(
-    VideoCaptureCapabilities&& other) = default;
-VideoCaptureCapabilities::~VideoCaptureCapabilities() = default;
-VideoCaptureCapabilities& VideoCaptureCapabilities::operator=(
-    VideoCaptureCapabilities&& other) = default;
-
-VideoCaptureSourceSettings::VideoCaptureSourceSettings(
-    const VideoCaptureSourceSettings& other) = default;
-VideoCaptureSourceSettings::VideoCaptureSourceSettings(
-    VideoCaptureSourceSettings&& other) = default;
-VideoCaptureSourceSettings::~VideoCaptureSourceSettings() = default;
-VideoCaptureSourceSettings& VideoCaptureSourceSettings::operator=(
-    const VideoCaptureSourceSettings& other) = default;
-VideoCaptureSourceSettings& VideoCaptureSourceSettings::operator=(
-    VideoCaptureSourceSettings&& other) = default;
-
-VideoCaptureSourceSettings::VideoCaptureSourceSettings()
-    : facing_mode_(::mojom::FacingMode::NONE),
-      power_line_frequency_(media::PowerLineFrequency::FREQUENCY_DEFAULT) {}
-
-VideoCaptureSourceSettings::VideoCaptureSourceSettings(
-    const std::string& device_id,
-    const media::VideoCaptureFormat& format,
-    ::mojom::FacingMode facing_mode,
-    media::PowerLineFrequency power_line_frequency)
-    : device_id_(device_id),
-      format_(format),
-      facing_mode_(facing_mode),
-      power_line_frequency_(power_line_frequency) {}
-
-blink::WebString VideoCaptureSourceSettings::GetFacingMode() const {
-  return ToWebString(facing_mode_);
-}
-
-long VideoCaptureSourceSettings::GetPowerLineFrequency() const {
-  return static_cast<long>(power_line_frequency_);
-}
-
-long VideoCaptureSourceSettings::GetWidth() const {
-  return format_.frame_size.width();
-}
-
-long VideoCaptureSourceSettings::GetHeight() const {
-  return format_.frame_size.height();
-}
-
-double VideoCaptureSourceSettings::GetFrameRate() const {
-  return format_.frame_rate;
-}
-
-blink::WebString VideoCaptureSourceSettings::GetDeviceId() const {
-  return blink::WebString::fromASCII(device_id_.data());
-}
-
-blink::WebString VideoCaptureSourceSettings::GetVideoKind() const {
-  return GetVideoKindForFormat(format_);
-}
+VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities() = default;
+VideoDeviceCaptureCapabilities::VideoDeviceCaptureCapabilities(
+    VideoDeviceCaptureCapabilities&& other) = default;
+VideoDeviceCaptureCapabilities::~VideoDeviceCaptureCapabilities() = default;
+VideoDeviceCaptureCapabilities& VideoDeviceCaptureCapabilities::operator=(
+    VideoDeviceCaptureCapabilities&& other) = default;
 
 const char kDefaultFailedConstraintName[] = "";
 
-VideoCaptureSourceSelectionResult::VideoCaptureSourceSelectionResult()
-    : failed_constraint_name(kDefaultFailedConstraintName) {}
-VideoCaptureSourceSelectionResult::VideoCaptureSourceSelectionResult(
-    const VideoCaptureSourceSelectionResult& other) = default;
-VideoCaptureSourceSelectionResult::VideoCaptureSourceSelectionResult(
-    VideoCaptureSourceSelectionResult&& other) = default;
-VideoCaptureSourceSelectionResult::~VideoCaptureSourceSelectionResult() =
-    default;
-VideoCaptureSourceSelectionResult& VideoCaptureSourceSelectionResult::operator=(
-    const VideoCaptureSourceSelectionResult& other) = default;
-VideoCaptureSourceSelectionResult& VideoCaptureSourceSelectionResult::operator=(
-    VideoCaptureSourceSelectionResult&& other) = default;
+VideoDeviceCaptureSourceSelectionResult::
+    VideoDeviceCaptureSourceSelectionResult()
+    : failed_constraint_name(kDefaultFailedConstraintName),
+      facing_mode(::mojom::FacingMode::NONE) {}
+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;
 
-VideoCaptureSourceSelectionResult SelectVideoCaptureSourceSettings(
-    const VideoCaptureCapabilities& capabilities,
+VideoDeviceCaptureSourceSelectionResult SelectVideoDeviceCaptureSourceSettings(
+    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);
-  VideoCaptureSourceSelectionResult result;
+  VideoDeviceCaptureSourceSelectionResult 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) {
@@ skipping 13 matching lines @@
         // The candidate satisfies the basic constraint set.
         double candidate_basic_custom_distance =
             basic_device_distance + basic_format_distance +
             basic_power_line_frequency_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;
-        VideoCaptureSourceSettings candidate(device->device_id, format,
-                                             device->facing_mode,
-                                             power_line_frequency);
+        VideoDeviceCaptureSourceSettings candidate(device->device_id, format,
+                                                   device->facing_mode,
+                                                   power_line_frequency);
         DistanceVector candidate_distance_vector;
         // First criteria for valid candidates is satisfaction of advanced
         // constraint sets.
         for (const auto& advanced : constraints.advanced()) {
           double custom_distance =
               CandidateSourceDistance(candidate, advanced, 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);
         }
@@ skipping 12 matching lines @@
         candidate_distance_vector.push_back(
             CandidateNativeFitnessDistance(candidate, 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.settings = std::move(candidate);
-          result.failed_constraint_name = nullptr;
+          result = ResultFromSettings(candidate);
         }
       }
     }
   }
 
-  if (!result.has_value())
+  if (!result.HasValue())
     result.failed_constraint_name = failed_constraint_name;
 
   return result;
 }
 
 }  // namespace content