Bug 1213517 - Normalize even more of the constraints code. r=padenot

MozReview-Commit-ID: 1XjdHXKYOmP

--HG--
extra : rebase_source : 6e6c05b9ffe6722decb6918667b83a3f9d6bfd8b

dom/media/MediaManager.cpp

@@ -786,11 +786,9 @@ MediaDevice::FitnessDistance(nsString aN,
   }
 }
 
-// Reminder: add handling for new constraints both here and in GetSources below!
-
 uint32_t
 MediaDevice::GetBestFitnessDistance(
-    const nsTArray<const MediaTrackConstraintSet*>& aConstraintSets)
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets)
 {
   nsString mediaSource;
   GetMediaSource(mediaSource);
@@ -800,7 +798,8 @@ MediaDevice::GetBestFitnessDistance(
   // webidl, we ignore it for audio here.
   if (!mediaSource.EqualsASCII("microphone")) {
     for (const auto& constraint : aConstraintSets) {
-      if (mediaSource != constraint->mMediaSource) {
+      if (constraint->mMediaSource.mIdeal.find(mediaSource) ==
+          constraint->mMediaSource.mIdeal.end()) {
         return UINT32_MAX;
       }
     }

dom/media/MediaManager.h

@@ -70,7 +70,7 @@ public:
 
   void SetId(const nsAString& aID);
   virtual uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets);
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets);
   virtual Source* GetSource() = 0;
   nsresult Allocate(const dom::MediaTrackConstraints &aConstraints,
                     const MediaEnginePrefs &aPrefs,

dom/media/webrtc/MediaEngine.h

@@ -194,7 +194,7 @@ public:
                             const char** aOutBadConstraint) = 0;
 
   virtual uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) = 0;
 
 protected:

dom/media/webrtc/MediaEngineCameraVideoSource.cpp

@@ -103,7 +103,7 @@ MediaEngineCameraVideoSource::TrimLessFitCandidates(CapabilitySet& set) {
 
 uint32_t
 MediaEngineCameraVideoSource::GetBestFitnessDistance(
-    const nsTArray<const MediaTrackConstraintSet*>& aConstraintSets,
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
     const nsString& aDeviceId)
 {
   size_t num = NumCapabilities();
@@ -114,13 +114,12 @@ MediaEngineCameraVideoSource::GetBestFitnessDistance(
   }
 
   bool first = true;
-  for (const MediaTrackConstraintSet* cs : aConstraintSets) {
-    NormalizedConstraintSet ns(*cs, !first);
+  for (const NormalizedConstraintSet* ns : aConstraintSets) {
     for (size_t i = 0; i < candidateSet.Length();  ) {
       auto& candidate = candidateSet[i];
       webrtc::CaptureCapability cap;
       GetCapability(candidate.mIndex, cap);
-      uint32_t distance = GetFitnessDistance(cap, ns, aDeviceId);
+      uint32_t distance = GetFitnessDistance(cap, *ns, aDeviceId);
       if (distance == UINT32_MAX) {
         candidateSet.RemoveElementAt(i);
       } else {
@@ -245,6 +244,11 @@ MediaEngineCameraVideoSource::ChooseCapability(
     }
   }
 
+  if (!candidateSet.Length()) {
+    LOG(("failed to find capability match from %d choices",num));
+    return false;
+  }
+
   // Filter further with all advanced constraints (that don't overconstrain).
 
   for (const auto &cs : aConstraints.mAdvanced) {
@@ -264,10 +268,8 @@ MediaEngineCameraVideoSource::ChooseCapability(
       candidateSet.AppendElements(Move(rejects));
     }
   }
-  if (!candidateSet.Length()) {
-    LOG(("failed to find capability match from %d choices",num));
-    return false;
-  }
+  MOZ_ASSERT(candidateSet.Length(),
+             "advanced constraints filtering step can't reduce candidates to zero");
 
   // Remaining algorithm is up to the UA.
 

dom/media/webrtc/MediaEngineCameraVideoSource.h

@@ -49,7 +49,7 @@ public:
   }
 
   uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) override;
 
   void Shutdown() override {};

dom/media/webrtc/MediaEngineDefault.cpp

@@ -72,13 +72,13 @@ MediaEngineDefaultVideoSource::GetUUID(nsACString& aUUID)
 
 uint32_t
 MediaEngineDefaultVideoSource::GetBestFitnessDistance(
-    const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
     const nsString& aDeviceId)
 {
   uint32_t distance = 0;
 #ifdef MOZ_WEBRTC
-  for (const dom::MediaTrackConstraintSet* cs : aConstraintSets) {
-    distance = GetMinimumFitnessDistance(*cs, false, aDeviceId);
+  for (const auto* cs : aConstraintSets) {
+    distance = GetMinimumFitnessDistance(*cs, aDeviceId);
     break; // distance is read from first entry only
   }
 #endif
@@ -400,13 +400,13 @@ MediaEngineDefaultAudioSource::GetUUID(nsACString& aUUID)
 
 uint32_t
 MediaEngineDefaultAudioSource::GetBestFitnessDistance(
-    const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
     const nsString& aDeviceId)
 {
   uint32_t distance = 0;
 #ifdef MOZ_WEBRTC
-  for (const dom::MediaTrackConstraintSet* cs : aConstraintSets) {
-    distance = GetMinimumFitnessDistance(*cs, false, aDeviceId);
+  for (const auto* cs : aConstraintSets) {
+    distance = GetMinimumFitnessDistance(*cs, aDeviceId);
     break; // distance is read from first entry only
   }
 #endif

dom/media/webrtc/MediaEngineDefault.h

@@ -65,7 +65,7 @@ public:
                   StreamTime aDesiredTime,
                   const PrincipalHandle& aPrincipalHandle) override;
   uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) override;
 
   bool IsFake() override {
@@ -174,7 +174,7 @@ public:
   }
 
   uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) override;
 
   NS_DECL_THREADSAFE_ISUPPORTS

dom/media/webrtc/MediaEngineTabVideoSource.h

@@ -43,7 +43,7 @@ class MediaEngineTabVideoSource : public MediaEngineVideoSource, nsIDOMEventList
       return dom::MediaSourceEnum::Browser;
     }
     uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) override
     {
       return 0;

dom/media/webrtc/MediaEngineWebRTC.h

@@ -135,7 +135,7 @@ public:
     return NS_ERROR_NOT_IMPLEMENTED;
   }
   uint32_t GetBestFitnessDistance(
-    const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
     const nsString& aDeviceId) override;
 
 protected:
@@ -502,7 +502,7 @@ public:
   }
 
   uint32_t GetBestFitnessDistance(
-      const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+      const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) override;
 
   // VoEMediaProcess.

dom/media/webrtc/MediaEngineWebRTCAudio.cpp

@@ -206,13 +206,13 @@ MediaEngineWebRTCMicrophoneSource::GetUUID(nsACString& aUUID)
 // A finite result may be used to calculate this device's ranking as a choice.
 
 uint32_t MediaEngineWebRTCMicrophoneSource::GetBestFitnessDistance(
-    const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
     const nsString& aDeviceId)
 {
   uint32_t distance = 0;
 
-  for (const MediaTrackConstraintSet* cs : aConstraintSets) {
-    distance = GetMinimumFitnessDistance(*cs, false, aDeviceId);
+  for (const auto* cs : aConstraintSets) {
+    distance = GetMinimumFitnessDistance(*cs, aDeviceId);
     break; // distance is read from first entry only
   }
   return distance;
@@ -859,7 +859,7 @@ MediaEngineWebRTCAudioCaptureSource::Restart(
 
 uint32_t
 MediaEngineWebRTCAudioCaptureSource::GetBestFitnessDistance(
-    const nsTArray<const dom::MediaTrackConstraintSet*>& aConstraintSets,
+    const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
     const nsString& aDeviceId)
 {
   // There is only one way of capturing audio for now, and it's always adequate.

dom/media/webrtc/MediaTrackConstraints.cpp

@@ -355,13 +355,10 @@ FlattenedConstraints::FlattenedConstraints(const NormalizedConstraints& aOther)
 
 uint32_t
 MediaConstraintsHelper::GetMinimumFitnessDistance(
-    const dom::MediaTrackConstraintSet &aConstraints,
-    bool aAdvanced,
+    const NormalizedConstraintSet &aConstraints,
     const nsString& aDeviceId)
 {
-  NormalizedConstraintSet ns(aConstraints, aAdvanced);
-
-  return FitnessDistance(aDeviceId, ns.mDeviceId);
+  return FitnessDistance(aDeviceId, aConstraints.mDeviceId);
 }
 
 template<class ValueType, class NormalizedRange>

dom/media/webrtc/MediaTrackConstraints.h

@@ -251,8 +251,8 @@ template<> void NormalizedConstraintSet::Range<bool>::FinalizeMerge();
 // Used instead of MediaTrackConstraints in lower-level code.
 struct NormalizedConstraints : public NormalizedConstraintSet
 {
-  explicit NormalizedConstraints(const dom::MediaTrackConstraints& aOther,
-                                 nsTArray<MemberPtrType>* aList = nullptr);
+  NormalizedConstraints(const dom::MediaTrackConstraints& aOther,
+                        nsTArray<MemberPtrType>* aList = nullptr);
 
   // Merge constructor
   explicit NormalizedConstraints(
@@ -282,21 +282,20 @@ protected:
       const NormalizedConstraintSet::StringRange& aConstraint);
 
   static uint32_t
-  GetMinimumFitnessDistance(const dom::MediaTrackConstraintSet &aConstraints,
-                            bool aAdvanced,
+  GetMinimumFitnessDistance(const NormalizedConstraintSet &aConstraints,
                             const nsString& aDeviceId);
 
   template<class DeviceType>
   static bool
-  SomeSettingsFit(const dom::MediaTrackConstraints &aConstraints,
+  SomeSettingsFit(const NormalizedConstraints &aConstraints,
                   nsTArray<RefPtr<DeviceType>>& aSources)
   {
-    nsTArray<const dom::MediaTrackConstraintSet*> aggregateConstraints;
-    aggregateConstraints.AppendElement(&aConstraints);
+    nsTArray<const NormalizedConstraintSet*> sets;
+    sets.AppendElement(&aConstraints);
 
     MOZ_ASSERT(aSources.Length());
     for (auto& source : aSources) {
-      if (source->GetBestFitnessDistance(aggregateConstraints) != UINT32_MAX) {
+      if (source->GetBestFitnessDistance(sets) != UINT32_MAX) {
         return true;
       }
     }
@@ -308,7 +307,7 @@ public:
 
   template<class DeviceType>
   static const char*
-  SelectSettings(const dom::MediaTrackConstraints &aConstraints,
+  SelectSettings(const NormalizedConstraints &aConstraints,
                  nsTArray<RefPtr<DeviceType>>& aSources)
   {
     auto& c = aConstraints;
@@ -319,7 +318,7 @@ public:
     // whole stack must be re-satisfied each time a capability-set is ruled out
     // (this avoids storing state or pushing algorithm into the lower-level code).
     nsTArray<RefPtr<DeviceType>> unsatisfactory;
-    nsTArray<const dom::MediaTrackConstraintSet*> aggregateConstraints;
+    nsTArray<const NormalizedConstraintSet*> aggregateConstraints;
     aggregateConstraints.AppendElement(&c);
 
     std::multimap<uint32_t, RefPtr<DeviceType>> ordered;
@@ -336,50 +335,7 @@ public:
       }
     }
     if (!aSources.Length()) {
-      // None selected. The spec says to report a constraint that satisfies NONE
-      // of the sources. Unfortunately, this is a bit laborious to find out, and
-      // requires updating as new constraints are added!
-
-      if (!unsatisfactory.Length() ||
-          !SomeSettingsFit(dom::MediaTrackConstraints(), unsatisfactory)) {
-        return "";
-      }
-      if (c.mDeviceId.IsConstrainDOMStringParameters()) {
-        dom::MediaTrackConstraints fresh;
-        fresh.mDeviceId = c.mDeviceId;
-        if (!SomeSettingsFit(fresh, unsatisfactory)) {
-          return "deviceId";
-        }
-      }
-      if (c.mWidth.IsConstrainLongRange()) {
-        dom::MediaTrackConstraints fresh;
-        fresh.mWidth = c.mWidth;
-        if (!SomeSettingsFit(fresh, unsatisfactory)) {
-          return "width";
-        }
-      }
-      if (c.mHeight.IsConstrainLongRange()) {
-        dom::MediaTrackConstraints fresh;
-        fresh.mHeight = c.mHeight;
-        if (!SomeSettingsFit(fresh, unsatisfactory)) {
-          return "height";
-        }
-      }
-      if (c.mFrameRate.IsConstrainDoubleRange()) {
-        dom::MediaTrackConstraints fresh;
-        fresh.mFrameRate = c.mFrameRate;
-        if (!SomeSettingsFit(fresh, unsatisfactory)) {
-          return "frameRate";
-        }
-      }
-      if (c.mFacingMode.IsConstrainDOMStringParameters()) {
-        dom::MediaTrackConstraints fresh;
-        fresh.mFacingMode = c.mFacingMode;
-        if (!SomeSettingsFit(fresh, unsatisfactory)) {
-          return "facingMode";
-        }
-      }
-      return "";
+      return FindBadConstraint(c, unsatisfactory);
     }
 
     // Order devices by shortest distance
@@ -390,28 +346,77 @@ public:
 
     // Then apply advanced constraints.
 
-    if (c.mAdvanced.WasPassed()) {
-      auto &array = c.mAdvanced.Value();
-
-      for (int i = 0; i < int(array.Length()); i++) {
-        aggregateConstraints.AppendElement(&array[i]);
-        nsTArray<RefPtr<DeviceType>> rejects;
-        for (uint32_t j = 0; j < aSources.Length();) {
-          if (aSources[j]->GetBestFitnessDistance(aggregateConstraints) == UINT32_MAX) {
-            rejects.AppendElement(aSources[j]);
-            aSources.RemoveElementAt(j);
-          } else {
-            ++j;
-          }
-        }
-        if (!aSources.Length()) {
-          aSources.AppendElements(Move(rejects));
-          aggregateConstraints.RemoveElementAt(aggregateConstraints.Length() - 1);
+    for (int i = 0; i < int(c.mAdvanced.Length()); i++) {
+      aggregateConstraints.AppendElement(&c.mAdvanced[i]);
+      nsTArray<RefPtr<DeviceType>> rejects;
+      for (uint32_t j = 0; j < aSources.Length();) {
+        if (aSources[j]->GetBestFitnessDistance(aggregateConstraints) == UINT32_MAX) {
+          rejects.AppendElement(aSources[j]);
+          aSources.RemoveElementAt(j);
+        } else {
+          ++j;
         }
       }
+      if (!aSources.Length()) {
+        aSources.AppendElements(Move(rejects));
+        aggregateConstraints.RemoveElementAt(aggregateConstraints.Length() - 1);
+      }
     }
     return nullptr;
   }
+
+  template<class DeviceType>
+  static const char*
+  FindBadConstraint(const NormalizedConstraints& aConstraints,
+                    nsTArray<RefPtr<DeviceType>>& aSources)
+  {
+    // The spec says to report a constraint that satisfies NONE
+    // of the sources. Unfortunately, this is a bit laborious to find out, and
+    // requires updating as new constraints are added!
+    auto& c = aConstraints;
+    dom::MediaTrackConstraints empty;
+
+    if (!aSources.Length() ||
+        !SomeSettingsFit(NormalizedConstraints(empty), aSources)) {
+      return "";
+    }
+    {
+      NormalizedConstraints fresh(empty);
+      fresh.mDeviceId = c.mDeviceId;
+      if (!SomeSettingsFit(fresh, aSources)) {
+        return "deviceId";
+      }
+    }
+    {
+      NormalizedConstraints fresh(empty);
+      fresh.mWidth = c.mWidth;
+      if (!SomeSettingsFit(fresh, aSources)) {
+        return "width";
+      }
+    }
+    {
+      NormalizedConstraints fresh(empty);
+      fresh.mHeight = c.mHeight;
+      if (!SomeSettingsFit(fresh, aSources)) {
+        return "height";
+      }
+    }
+    {
+      NormalizedConstraints fresh(empty);
+      fresh.mFrameRate = c.mFrameRate;
+      if (!SomeSettingsFit(fresh, aSources)) {
+        return "frameRate";
+      }
+    }
+    {
+      NormalizedConstraints fresh(empty);
+      fresh.mFacingMode = c.mFacingMode;
+      if (!SomeSettingsFit(fresh, aSources)) {
+        return "facingMode";
+      }
+    }
+    return "";
+  }
 };
 
 } // namespace mozilla