Remove support for some device constraints from SelectSettings.

content/renderer/media/media_stream_constraints_util_audio.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_audio.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "content/common/media/media_stream_options.h"
 #include "content/renderer/media/media_stream_constraints_util_sets.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "media/base/limits.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 namespace {
 
 // This class has the same data as ::mojom::AudioInputDeviceCapabilities, but
-// adds extra operations to simplify the device-selection code.
+// adds extra operations to simplify access to device parameters.
 class AudioDeviceInfo {
  public:
   // This constructor is intended for device capture.
   explicit AudioDeviceInfo(
       const ::mojom::AudioInputDeviceCapabilitiesPtr& device_info)
       : device_id_(device_info->device_id),
         parameters_(device_info->parameters) {
     DCHECK(parameters_.IsValid());
   }
 
@@ skipping 41 matching lines @@
     const char** failed_constraint_name) {
   std::vector<AudioDeviceInfo> result;
   *failed_constraint_name = "";
   for (auto& device_capabilities : capabilities) {
     if (!constraint_set.device_id.Matches(
             blink::WebString::FromASCII(device_capabilities->device_id))) {
       if (failed_constraint_name)
         *failed_constraint_name = constraint_set.device_id.GetName();
       continue;
     }
-    *failed_constraint_name =
-        IsOutsideConstraintRange(constraint_set.sample_rate,
-                                 device_capabilities->parameters.sample_rate());
-    if (*failed_constraint_name)
-      continue;
-
-    *failed_constraint_name = IsOutsideConstraintRange(
-        constraint_set.sample_size,
-        device_capabilities->parameters.bits_per_sample());
-    if (*failed_constraint_name)
-      continue;
-
-    *failed_constraint_name =
-        IsOutsideConstraintRange(constraint_set.channel_count,
-                                 device_capabilities->parameters.channels());
-    if (*failed_constraint_name)
-      continue;
-
     result.push_back(AudioDeviceInfo(device_capabilities));
   }
 
   if (!result.empty())
     *failed_constraint_name = nullptr;
 
-  return AudioDeviceSet(result);
+  return AudioDeviceSet(std::move(result));
 }
 
 AudioDeviceSet AudioDeviceSetForContentCapture(
     const blink::WebMediaTrackConstraintSet& constraint_set,
     const char** failed_constraint_name = nullptr) {
   if (!constraint_set.device_id.HasExact())
     return AudioDeviceSet::UniversalSet();
 
   std::vector<AudioDeviceInfo> result;
   for (auto& device_id : constraint_set.device_id.Exact())
     result.push_back(AudioDeviceInfo(device_id.Utf8()));
 
-  return AudioDeviceSet(result);
+  return AudioDeviceSet(std::move(result));
 }
 
 // This class represents a set of possible candidate settings.
 // The SelectSettings algorithm starts with a set containing all possible
 // candidates based on hardware capabilities and/or allowed values for supported
 // properties. The is then reduced progressively as the basic and advanced
 // constraint sets are applied.
 // In the end, if the set of candidates is empty, SelectSettings fails.
 // If not, the ideal values (if any) or tie breaker rules are used to select
 // the final settings based on the candidates that survived the application
@@ skipping 179 matching lines @@
           bool_sets_[GOOG_ECHO_CANCELLATION]);
   // echoCancellation and googEchoCancellation constraints should not
   // contradict each other. Mark the set as empty if they do.
   if (echo_cancellation_intersection.IsEmpty()) {
     failed_constraint_name_ =
         blink::WebMediaTrackConstraintSet().echo_cancellation.GetName();
   }
 }
 
 // Fitness function for constraints involved in device selection.
-//  Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance
+// Based on https://w3c.github.io/mediacapture-main/#dfn-fitness-distance
+// TODO(guidou): Add support for sampleRate, sampleSize and channelCount
+// constraints. http://crbug.com/
 double DeviceInfoFitness(
     bool is_device_capture,
     const AudioDeviceInfo& device_info,
     const blink::WebMediaTrackConstraintSet& basic_constraint_set) {
-  double fitness = 0.0;
-  fitness += StringConstraintFitnessDistance(
+  return StringConstraintFitnessDistance(
       blink::WebString::FromASCII(device_info.device_id()),
       basic_constraint_set.device_id);
-
-  if (!is_device_capture)
-    return fitness;
-
-  if (basic_constraint_set.sample_rate.HasIdeal()) {
-    fitness += NumericConstraintFitnessDistance(
-        device_info.SampleRate(), basic_constraint_set.sample_rate.Ideal());
-  }
-
-  if (basic_constraint_set.sample_size.HasIdeal()) {
-    fitness += NumericConstraintFitnessDistance(
-        device_info.SampleSize(), basic_constraint_set.sample_size.Ideal());
-  }
-
-  if (basic_constraint_set.channel_count.HasIdeal()) {
-    fitness += NumericConstraintFitnessDistance(
-        device_info.ChannelCount(), basic_constraint_set.channel_count.Ideal());
-  }
-
-  return fitness;
 }
 
 AudioDeviceInfo SelectDevice(
     const AudioDeviceSet& audio_device_set,
     const blink::WebMediaTrackConstraintSet& basic_constraint_set,
     const std::string& default_device_id,
     bool is_device_capture) {
   DCHECK(!audio_device_set.IsEmpty());
   if (audio_device_set.is_universal()) {
     DCHECK(!is_device_capture);
@@ skipping 243 matching lines @@
 
   std::string default_device_id;
   if (!capabilities.empty())
     default_device_id = (*capabilities.begin())->device_id;
 
   return SelectResult(candidates, constraints.Basic(), default_device_id,
                       media_stream_source);
 }
 
 }  // namespace content