--- a/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
+++ b/dom/media/webrtc/MediaEngineRemoteVideoSource.cpp
@@ -179,23 +179,23 @@ MediaEngineRemoteVideoSource::Allocate(
 {
   LOG((__PRETTY_FUNCTION__));
   AssertIsOnOwningThread();
 
   MOZ_ASSERT(mInitDone);
   MOZ_ASSERT(mState == kReleased);
 
   NormalizedConstraints constraints(aConstraints);
-  LOG(("ChooseCapability(kFitness) for mTargetCapability and mCapability (Allocate) ++"));
-  if (!ChooseCapability(constraints, aPrefs, aDeviceId, mCapability, kFitness)) {
+  LOG(("ChooseCapability() for mTargetCapability and mCapability (Allocate) ++"));
+  if (!ChooseCapability(constraints, aPrefs, aDeviceId, mCapability)) {
     *aOutBadConstraint =
       MediaConstraintsHelper::FindBadConstraint(constraints, this, aDeviceId);
     return NS_ERROR_FAILURE;
   }
-  LOG(("ChooseCapability(kFitness) for mTargetCapability and mCapability (Allocate) --"));
+  LOG(("ChooseCapability() for mTargetCapability and mCapability (Allocate) --"));
 
   if (camera::GetChildAndCall(&camera::CamerasChild::AllocateCaptureDevice,
                               mCapEngine, mUniqueId.get(),
                               kMaxUniqueIdLength, mCaptureIndex,
                               aPrincipalInfo)) {
     return NS_ERROR_FAILURE;
   }
 
@@ -339,23 +339,23 @@ MediaEngineRemoteVideoSource::Reconfigur
 {
   LOG((__PRETTY_FUNCTION__));
   AssertIsOnOwningThread();
 
   MOZ_ASSERT(mInitDone);
 
   NormalizedConstraints constraints(aConstraints);
   webrtc::CaptureCapability newCapability;
-  LOG(("ChooseCapability(kFitness) for mTargetCapability (Reconfigure) ++"));
-  if (!ChooseCapability(constraints, aPrefs, aDeviceId, newCapability, kFitness)) {
+  LOG(("ChooseCapability() for mTargetCapability (Reconfigure) ++"));
+  if (!ChooseCapability(constraints, aPrefs, aDeviceId, newCapability)) {
     *aOutBadConstraint =
       MediaConstraintsHelper::FindBadConstraint(constraints, this, aDeviceId);
     return NS_ERROR_FAILURE;
   }
-  LOG(("ChooseCapability(kFitness) for mTargetCapability (Reconfigure) --"));
+  LOG(("ChooseCapability() for mTargetCapability (Reconfigure) --"));
 
   if (mCapability == newCapability) {
     return NS_OK;
   }
 
   // Start() applies mCapability on the device.
   mCapability = newCapability;
 
@@ -586,29 +586,16 @@ MediaEngineRemoteVideoSource::DeliverFra
 
   return 0;
 }
 
 uint32_t
 MediaEngineRemoteVideoSource::GetDistance(
     const webrtc::CaptureCapability& aCandidate,
     const NormalizedConstraintSet &aConstraints,
-    const nsString& aDeviceId,
-    const DistanceCalculation aCalculate) const
-{
-  if (aCalculate == kFeasibility) {
-    return GetFeasibilityDistance(aCandidate, aConstraints, aDeviceId);
-  }
-  return GetFitnessDistance(aCandidate, aConstraints, aDeviceId);
-}
-
-uint32_t
-MediaEngineRemoteVideoSource::GetFitnessDistance(
-    const webrtc::CaptureCapability& aCandidate,
-    const NormalizedConstraintSet &aConstraints,
     const nsString& aDeviceId) const
 {
   AssertIsOnOwningThread();
 
   // Treat width|height|frameRate == 0 on capability as "can do any".
   // This allows for orthogonal capabilities that are not in discrete steps.
 
   uint64_t distance =
@@ -640,17 +627,17 @@ MediaEngineRemoteVideoSource::GetBestFit
   }
 
   bool first = true;
   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 = GetDistance(cap, *ns, aDeviceId);
       if (distance == UINT32_MAX) {
         candidateSet.RemoveElementAt(i);
       } else {
         ++i;
         if (first) {
           candidate.mDistance = distance;
         }
       }
@@ -659,44 +646,16 @@ MediaEngineRemoteVideoSource::GetBestFit
   }
   if (!candidateSet.Length()) {
     return UINT32_MAX;
   }
   TrimLessFitCandidates(candidateSet);
   return candidateSet[0].mDistance;
 }
 
-uint32_t
-MediaEngineRemoteVideoSource::GetFeasibilityDistance(
-    const webrtc::CaptureCapability& aCandidate,
-    const NormalizedConstraintSet &aConstraints,
-    const nsString& aDeviceId) const
-{
-  AssertIsOnOwningThread();
-
-  // Treat width|height|frameRate == 0 on capability as "can do any".
-  // This allows for orthogonal capabilities that are not in discrete steps.
-
-  uint64_t distance =
-    uint64_t(MediaConstraintsHelper::FitnessDistance(
-                 aDeviceId, aConstraints.mDeviceId)) +
-    uint64_t(MediaConstraintsHelper::FitnessDistance(
-                 mFacingMode, aConstraints.mFacingMode)) +
-    uint64_t(aCandidate.width ? MediaConstraintsHelper::FeasibilityDistance(
-                                    int32_t(aCandidate.width),
-                                    aConstraints.mWidth) : 0) +
-    uint64_t(aCandidate.height ? MediaConstraintsHelper::FeasibilityDistance(
-                                     int32_t(aCandidate.height),
-                                     aConstraints.mHeight) : 0) +
-    uint64_t(aCandidate.maxFPS ? MediaConstraintsHelper::FeasibilityDistance(
-                                     double(aCandidate.maxFPS),
-                                     aConstraints.mFrameRate) : 0);
-  return uint32_t(std::min(distance, uint64_t(UINT32_MAX)));
-}
-
 // Find best capability by removing inferiors. May leave >1 of equal distance
 
 /* static */ void
 MediaEngineRemoteVideoSource::TrimLessFitCandidates(nsTArray<CapabilityCandidate>& set)
 {
   uint32_t best = UINT32_MAX;
   for (auto& candidate : set) {
     if (best > candidate.mDistance) {
@@ -787,18 +746,17 @@ LogCapability(const char* aHeader,
        aDistance));
 }
 
 bool
 MediaEngineRemoteVideoSource::ChooseCapability(
     const NormalizedConstraints& aConstraints,
     const MediaEnginePrefs& aPrefs,
     const nsString& aDeviceId,
-    webrtc::CaptureCapability& aCapability,
-    const DistanceCalculation aCalculate)
+    webrtc::CaptureCapability& aCapability)
 {
   LOG((__PRETTY_FUNCTION__));
   AssertIsOnOwningThread();
 
   if (MOZ_LOG_TEST(GetMediaManagerLog(), LogLevel::Debug)) {
     LOG(("ChooseCapability: prefs: %dx%d @%dfps",
          aPrefs.GetWidth(), aPrefs.GetHeight(),
          aPrefs.mFPS));
@@ -840,17 +798,17 @@ MediaEngineRemoteVideoSource::ChooseCapa
   }
 
   // First, filter capabilities by required constraints (min, max, exact).
 
   for (size_t i = 0; i < candidateSet.Length();) {
     auto& candidate = candidateSet[i];
     webrtc::CaptureCapability cap;
     GetCapability(candidate.mIndex, cap);
-    candidate.mDistance = GetDistance(cap, aConstraints, aDeviceId, aCalculate);
+    candidate.mDistance = GetDistance(cap, aConstraints, aDeviceId);
     LogCapability("Capability", cap, candidate.mDistance);
     if (candidate.mDistance == UINT32_MAX) {
       candidateSet.RemoveElementAt(i);
     } else {
       ++i;
     }
   }
 
@@ -862,17 +820,17 @@ MediaEngineRemoteVideoSource::ChooseCapa
   // Filter further with all advanced constraints (that don't overconstrain).
 
   for (const auto &cs : aConstraints.mAdvanced) {
     nsTArray<CapabilityCandidate> rejects;
     for (size_t i = 0; i < candidateSet.Length();) {
       auto& candidate = candidateSet[i];
       webrtc::CaptureCapability cap;
       GetCapability(candidate.mIndex, cap);
-      if (GetDistance(cap, cs, aDeviceId, aCalculate) == UINT32_MAX) {
+      if (GetDistance(cap, cs, aDeviceId) == UINT32_MAX) {
         rejects.AppendElement(candidate);
         candidateSet.RemoveElementAt(i);
       } else {
         ++i;
       }
     }
     if (!candidateSet.Length()) {
       candidateSet.AppendElements(Move(rejects));
@@ -893,17 +851,17 @@ MediaEngineRemoteVideoSource::ChooseCapa
     prefs.mWidth.SetAsLong() = aPrefs.GetWidth();
     prefs.mHeight.SetAsLong() = aPrefs.GetHeight();
     prefs.mFrameRate.SetAsDouble() = aPrefs.mFPS;
     NormalizedConstraintSet normPrefs(prefs, false);
 
     for (auto& candidate : candidateSet) {
       webrtc::CaptureCapability cap;
       GetCapability(candidate.mIndex, cap);
-      candidate.mDistance = GetDistance(cap, normPrefs, aDeviceId, aCalculate);
+      candidate.mDistance = GetDistance(cap, normPrefs, aDeviceId);
     }
     TrimLessFitCandidates(candidateSet);
   }
 
   // Any remaining multiples all have the same distance, but may vary on
   // format. Some formats are more desirable for certain use like WebRTC.
   // E.g. I420 over RGB24 can remove a needless format conversion.
 

--- a/dom/media/webrtc/MediaEngineRemoteVideoSource.h
+++ b/dom/media/webrtc/MediaEngineRemoteVideoSource.h
@@ -40,29 +40,16 @@
 #include "webrtc/modules/video_capture/video_capture_defines.h"
 
 namespace webrtc {
 using CaptureCapability = VideoCaptureCapability;
 }
 
 namespace mozilla {
 
-// Fitness distance is defined in
-// https://w3c.github.io/mediacapture-main/getusermedia.html#dfn-selectsettings
-
-// The main difference of feasibility and fitness distance is that if the
-// constraint is required ('max', or 'exact'), and the settings dictionary's value
-// for the constraint does not satisfy the constraint, the fitness distance is
-// positive infinity. Given a continuous space of settings dictionaries comprising
-// all discrete combinations of dimension and frame-rate related properties,
-// the feasibility distance is still in keeping with the constraints algorithm.
-enum DistanceCalculation {
-  kFitness,
-  kFeasibility
-};
 
 /**
  * The WebRTC implementation of the MediaEngine interface.
  */
 class MediaEngineRemoteVideoSource : public MediaEngineSource,
                                      public camera::FrameRelay
 {
   ~MediaEngineRemoteVideoSource() = default;
@@ -74,31 +61,21 @@ class MediaEngineRemoteVideoSource : pub
     size_t mIndex;
     uint32_t mDistance;
   };
   typedef nsTArray<CapabilityCandidate> CapabilitySet;
 
   bool ChooseCapability(const NormalizedConstraints& aConstraints,
                         const MediaEnginePrefs& aPrefs,
                         const nsString& aDeviceId,
-                        webrtc::CaptureCapability& aCapability,
-                        const DistanceCalculation aCalculate);
+                        webrtc::CaptureCapability& aCapability);
 
   uint32_t GetDistance(const webrtc::CaptureCapability& aCandidate,
                        const NormalizedConstraintSet &aConstraints,
-                       const nsString& aDeviceId,
-                       const DistanceCalculation aCalculate) const;
-
-  uint32_t GetFitnessDistance(const webrtc::CaptureCapability& aCandidate,
-                              const NormalizedConstraintSet &aConstraints,
-                              const nsString& aDeviceId) const;
-
-  uint32_t GetFeasibilityDistance(const webrtc::CaptureCapability& aCandidate,
-                              const NormalizedConstraintSet &aConstraints,
-                              const nsString& aDeviceId) const;
+                       const nsString& aDeviceId) const;
 
   static void TrimLessFitCandidates(CapabilitySet& set);
 
   uint32_t GetBestFitnessDistance(
       const nsTArray<const NormalizedConstraintSet*>& aConstraintSets,
       const nsString& aDeviceId) const override;
 
 public: