Remove old-style constraints from Chrome internals

content/renderer/media/media_stream_constraints_util.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_constraints_util.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
 
 namespace {
 
-// Convert a string ("true", "false") to a boolean.
-bool ConvertStringToBoolean(const std::string& string, bool* value) {
-  static const char kValueTrue[] = "true";
-  static const char kValueFalse[] = "false";
+template <typename P, typename T>
+bool ScanConstraintsForExactValue(const blink::WebMediaConstraints& constraints,
+                                  P picker,
+                                  T* value) {
+  const auto& the_field = constraints.basic().*picker;
+  if (the_field.hasExact()) {
+    *value = the_field.exact();
+    return true;
+  }
+  for (const auto& advanced_constraint : constraints.advanced()) {
+    const auto& the_field = advanced_constraint.*picker;
+    if (the_field.hasExact()) {
+      *value = the_field.exact();
+      return true;
+    }
+  }
+  return false;
+}
 
-  *value = (string == kValueTrue);
-  return *value || (string == kValueFalse);
+template <typename P, typename T>
+bool ScanConstraintsForMaxValue(const blink::WebMediaConstraints& constraints,
+                                P picker,
+                                T* value) {
+  const auto& the_field = constraints.basic().*picker;
+  if (the_field.hasMax()) {
+    *value = the_field.max();
+    return true;
+  }
+  for (const auto& advanced_constraint : constraints.advanced()) {
+    const auto& the_field = advanced_constraint.*picker;
+    if (the_field.hasMax()) {
+      *value = the_field.max();
+      return true;
+    }
+  }
+  return false;
+}
+
+template <typename P, typename T>
+bool ScanConstraintsForMinValue(const blink::WebMediaConstraints& constraints,
+                                P picker,
+                                T* value) {
+  const auto& the_field = constraints.basic().*picker;
+  if (the_field.hasMin()) {
+    *value = the_field.min();
+    return true;
+  }
+  for (const auto& advanced_constraint : constraints.advanced()) {
+    const auto& the_field = advanced_constraint.*picker;
+    if (the_field.hasMin()) {
+      *value = the_field.min();
+      return true;
+    }
+  }
+  return false;
 }
 
 }  // namespace
 
-bool GetConstraintValueAsBoolean(const blink::WebMediaConstraints& constraints,
-                                 const std::string& name,
-                                 bool* value) {
-  return GetMandatoryConstraintValueAsBoolean(constraints, name, value) ||
-         GetOptionalConstraintValueAsBoolean(constraints, name, value);
+bool GetConstraintValueAsBoolean(
+    const blink::WebMediaConstraints& constraints,
+    const blink::BooleanConstraint blink::WebMediaTrackConstraintSet::*picker,
+    bool* value) {
+  return ScanConstraintsForExactValue(constraints, picker, value);
 }
 
-bool GetConstraintValueAsInteger(const blink::WebMediaConstraints& constraints,
-                                 const std::string& name,
-                                 int* value) {
-  return GetMandatoryConstraintValueAsInteger(constraints, name, value) ||
-         GetOptionalConstraintValueAsInteger(constraints, name, value);
+bool GetConstraintValueAsInteger(
+    const blink::WebMediaConstraints& constraints,
+    const blink::LongConstraint blink::WebMediaTrackConstraintSet::*picker,
+    int* value) {
+  return ScanConstraintsForExactValue(constraints, picker, value);
 }
 
-bool GetConstraintValueAsDouble(const blink::WebMediaConstraints& constraints,
-                                 const std::string& name,
-                                 double* value) {
-  return GetMandatoryConstraintValueAsDouble(constraints, name, value) ||
-         GetOptionalConstraintValueAsDouble(constraints, name, value);
+bool GetConstraintMinAsInteger(
+    const blink::WebMediaConstraints& constraints,
+    const blink::LongConstraint blink::WebMediaTrackConstraintSet::*picker,
+    int* value) {
+  return ScanConstraintsForMinValue(constraints, picker, value);
 }
 
-bool GetConstraintValueAsString(const blink::WebMediaConstraints& constraints,
-                                const std::string& name,
-                                std::string* value) {
-  blink::WebString value_str;
-  base::string16 name_16 = base::UTF8ToUTF16(name);
-  if (!constraints.getMandatoryConstraintValue(name_16, value_str) &&
-      !constraints.getOptionalConstraintValue(name_16, value_str)) {
-    return false;
-  }
-
-  *value = value_str.utf8();
-  return true;
+bool GetConstraintMaxAsInteger(
+    const blink::WebMediaConstraints& constraints,
+    const blink::LongConstraint blink::WebMediaTrackConstraintSet::*picker,
+    int* value) {
+  return ScanConstraintsForMaxValue(constraints, picker, value);
 }
 
-bool GetMandatoryConstraintValueAsBoolean(
+bool GetConstraintValueAsDouble(
     const blink::WebMediaConstraints& constraints,
-    const std::string& name,
-    bool* value) {
-  blink::WebString value_str;
-  if (!constraints.getMandatoryConstraintValue(base::UTF8ToUTF16(name),
-                                               value_str)) {
-    return false;
-  }
-
-  return ConvertStringToBoolean(value_str.utf8(), value);
+    const blink::DoubleConstraint blink::WebMediaTrackConstraintSet::*picker,
+    double* value) {
+  return ScanConstraintsForExactValue(constraints, picker, value);
 }
 
-bool GetMandatoryConstraintValueAsInteger(
+bool GetConstraintMaxAsDouble(
     const blink::WebMediaConstraints& constraints,
-    const std::string& name,
-    int* value) {
-  blink::WebString value_str;
-  if (!constraints.getMandatoryConstraintValue(base::UTF8ToUTF16(name),
-                                               value_str)) {
-    return false;
-  }
-
-  return base::StringToInt(value_str.utf8(), value);
+    const blink::DoubleConstraint blink::WebMediaTrackConstraintSet::*picker,
+    double* value) {
+  return ScanConstraintsForExactValue(constraints, picker, value);
 }
 
-bool GetMandatoryConstraintValueAsDouble(
+bool GetConstraintValueAsString(
     const blink::WebMediaConstraints& constraints,
-    const std::string& name,
-    double* value) {
-  blink::WebString value_str;
-  if (!constraints.getMandatoryConstraintValue(base::UTF8ToUTF16(name),
-                                               value_str)) {
-    return false;
+    const blink::StringConstraint blink::WebMediaTrackConstraintSet::*picker,
+    std::string* value) {
+  blink::WebVector<blink::WebString> return_value;
+  if (ScanConstraintsForExactValue(constraints, picker, &return_value)) {
+    *value = return_value[0].utf8();
+    return true;
   }
-  return base::StringToDouble(value_str.utf8(), value);
+  return false;
 }
 
-bool GetOptionalConstraintValueAsBoolean(
+rtc::Optional<bool> ConstraintToOptional(
     const blink::WebMediaConstraints& constraints,
-    const std::string& name,
-    bool* value) {
-  blink::WebString value_str;
-  if (!constraints.getOptionalConstraintValue(base::UTF8ToUTF16(name),
-                                              value_str)) {
-    return false;
+    const blink::BooleanConstraint blink::WebMediaTrackConstraintSet::*picker) {
+  bool value;
+  if (GetConstraintValueAsBoolean(constraints, picker, &value)) {
+    return rtc::Optional<bool>(value);
   }
-
-  return ConvertStringToBoolean(value_str.utf8(), value);
-}
-
-bool GetOptionalConstraintValueAsInteger(
-    const blink::WebMediaConstraints& constraints,
-    const std::string& name,
-    int* value) {
-  blink::WebString value_str;
-  if (!constraints.getOptionalConstraintValue(base::UTF8ToUTF16(name),
-                                              value_str)) {
-    return false;
-  }
-
-  return base::StringToInt(value_str.utf8(), value);
-}
-
-bool GetOptionalConstraintValueAsDouble(
-    const blink::WebMediaConstraints& constraints,
-    const std::string& name,
-    double* value) {
-  blink::WebString value_str;
-  if (!constraints.getOptionalConstraintValue(base::UTF8ToUTF16(name),
-                                              value_str)) {
-    return false;
-  }
-
-  return base::StringToDouble(value_str.utf8(), value);
+  return rtc::Optional<bool>();
 }
 
 }  // namespace content