Apply new-style constraints to video_source.

third_party/WebKit/Source/platform/exported/WebMediaConstraints.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 168 matching lines @@
         return false;
     }
     return true;
 }
 
 bool LongConstraint::isEmpty() const
 {
     return !m_hasMin && !m_hasMax && !m_hasExact && !m_hasIdeal;
 }
 
+bool LongConstraint::hasMandatory() const
+{
+    return m_hasMin || m_hasMax || m_hasExact;
+}
+
 double DoubleConstraint::kConstraintEpsilon = 0.00001;
 
 DoubleConstraint::DoubleConstraint(const char* name)
     : BaseConstraint(name)
     , m_min()
     , m_max()
     , m_exact()
     , m_ideal()
     , m_hasMin(false)
     , m_hasMax(false)
@@ skipping 14 matching lines @@
         return false;
     }
     return true;
 }
 
 bool DoubleConstraint::isEmpty() const
 {
     return !m_hasMin && !m_hasMax && !m_hasExact && !m_hasIdeal;
 }
 
+bool DoubleConstraint::hasMandatory() const
+{
+    return m_hasMin || m_hasMax || m_hasExact;
+}
+
 StringConstraint::StringConstraint(const char* name)
     : BaseConstraint(name)
     , m_exact()
     , m_ideal()
 {
 }
 
 bool StringConstraint::matches(WebString value) const
 {
     if (m_exact.isEmpty()) {
         return true;
     }
     for (const auto& choice : m_exact) {
         if (value == choice) {
             return true;
         }
     }
     return false;
 }
 
 bool StringConstraint::isEmpty() const
 {
     return m_exact.isEmpty() && m_ideal.isEmpty();
 }
 
+bool StringConstraint::hasMandatory() const
+{
+    return !m_exact.isEmpty();
+}
+
 const WebVector<WebString>& StringConstraint::exact() const
 {
     return m_exact;
 }
 
 const WebVector<WebString>& StringConstraint::ideal() const
 {
     return m_ideal;
 }
 
@@ skipping 12 matching lines @@
         return false;
     }
     return true;
 }
 
 bool BooleanConstraint::isEmpty() const
 {
     return !m_hasIdeal && !m_hasExact;
 }
 
+bool BooleanConstraint::hasMandatory() const
+{
+    return m_hasExact;
+}
+
 WebMediaTrackConstraintSet::WebMediaTrackConstraintSet()
     : width("width")
     , height("height")
     , aspectRatio("aspectRatio")
     , frameRate("frameRate")
     , facingMode("facingMode")
     , volume("volume")
     , sampleRate("sampleRate")
     , sampleSize("sampleSize")
     , echoCancellation("echoCancellation")
@@ skipping 35 matching lines @@
     , googCpuUnderuseThreshold("googCpuUnderuseThreshold")
     , googCpuOveruseThreshold("googCpuOveruseThreshold")
     , googCpuUnderuseEncodeRsdThreshold("googCpuUnderuseEncodeRsdThreshold")
     , googCpuOveruseEncodeRsdThreshold("googCpuOveruseEncodeRsdThreshold")
     , googCpuOveruseEncodeUsage("googCpuOveruseEncodeUsage")
     , googHighStartBitrate("googHighStartBitrate")
     , googPayloadPadding("googPayloadPadding")
 {
 }
 
+std::vector<const BaseConstraint*> WebMediaTrackConstraintSet::allConstraints() const
+{
+    const BaseConstraint* temp[] = {
+        &width, &height, &aspectRatio, &frameRate, &facingMode, &volume,
+        &sampleRate, &sampleSize, &echoCancellation, &latency, &channelCount,
+        &deviceId, &groupId, &mediaStreamSource, &renderToAssociatedSink,
+        &hotwordEnabled, &googEchoCancellation,
+        &googExperimentalEchoCancellation, &googAutoGainControl,
+        &googExperimentalAutoGainControl, &googNoiseSuppression,
+        &googHighpassFilter, &googTypingNoiseDetection,
+        &googExperimentalNoiseSuppression, &googBeamforming,
+        &googArrayGeometry, &googAudioMirroring, &googDAEchoCancellation,
+        &googAecDump, &googNoiseReduction, &offerToReceiveAudio,
+        &offerToReceiveVideo, &voiceActivityDetection, &iceRestart,
+        &googUseRtpMux, &enableDtlsSrtp, &enableRtpDataChannels,
+        &enableDscp, &enableIPv6, &googEnableVideoSuspendBelowMinBitrate,
+        &googNumUnsignalledRecvStreams, &googCombinedAudioVideoBwe,
+        &googScreencastMinBitrate, &googCpuOveruseDetection,
+        &googCpuUnderuseThreshold, &googCpuOveruseThreshold,
+        &googCpuUnderuseEncodeRsdThreshold, &googCpuOveruseEncodeRsdThreshold,
+        &googCpuOveruseEncodeUsage, &googHighStartBitrate, &googPayloadPadding
+    };
+    const int elementCount = sizeof(temp) / sizeof(temp[0]);
+    return std::vector<const BaseConstraint*>(&temp[0], &temp[elementCount]);
+}
+
 bool WebMediaTrackConstraintSet::isEmpty() const
 {
-    return width.isEmpty() && height.isEmpty() && aspectRatio.isEmpty()
-        && frameRate.isEmpty() && facingMode.isEmpty() && volume.isEmpty()
-        && sampleRate.isEmpty() && sampleSize.isEmpty()
-        && echoCancellation.isEmpty() && latency.isEmpty()
-        && channelCount.isEmpty() && deviceId.isEmpty() && groupId.isEmpty()
-        && mediaStreamSource.isEmpty() && renderToAssociatedSink.isEmpty()
-        && hotwordEnabled.isEmpty() && googEchoCancellation.isEmpty()
-        && googExperimentalEchoCancellation.isEmpty()
-        && googAutoGainControl.isEmpty()
-        && googExperimentalAutoGainControl.isEmpty()
-        && googNoiseSuppression.isEmpty()
-        && googHighpassFilter.isEmpty()
-        && googTypingNoiseDetection.isEmpty()
-        && googExperimentalNoiseSuppression.isEmpty()
-        && googBeamforming.isEmpty() && googArrayGeometry.isEmpty()
-        && googAudioMirroring.isEmpty();
+    for (const auto& constraint : allConstraints()) {
+        if (!constraint->isEmpty())
+            return false;
+    }
+    return true;
+}
+
+bool WebMediaTrackConstraintSet::hasMandatoryOutsideSet(const std::vector<std::string>& goodNames, std::string& foundName) const
+{
+    for (const auto& constraint : allConstraints()) {
+        if (constraint->hasMandatory()) {
+            const auto& result = std::find(goodNames.begin(), goodNames.end(), constraint->name());
+            if (result == goodNames.end()) {

[mcasas, 2016/01/26 16:08:02]

No need for |result|?

[hta - Chromium, 2016/01/26 19:35:25]

I thought so, but it turned out not to be the case. Folded.

+                foundName = constraint->name();
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+bool WebMediaTrackConstraintSet::hasMandatory() const
+{
+    std::string dummyString;
+    return hasMandatoryOutsideSet(std::vector<std::string>(), dummyString);
 }
 
 // WebMediaConstraints
 
 void WebMediaConstraints::assign(const WebMediaConstraints& other)
 {
     m_private = other.m_private;
 }
 
 void WebMediaConstraints::reset()
@@ skipping 54 matching lines @@
     return m_private->basic();
 }
 
 const WebVector<WebMediaTrackConstraintSet>& WebMediaConstraints::advanced() const
 {
     ASSERT(!isNull());
     return m_private->advanced();
 }
 
 } // namespace blink