--- a/dom/media/webrtc/MediaEngineCameraVideoSource.cpp
+++ b/dom/media/webrtc/MediaEngineCameraVideoSource.cpp
@@ -209,18 +209,18 @@ MediaEngineCameraVideoSource::ChooseCapa
     const MediaEnginePrefs &aPrefs,
     const nsString& aDeviceId)
 {
   if (MOZ_LOG_TEST(GetMediaManagerLog(), LogLevel::Debug)) {
     LOG(("ChooseCapability: prefs: %dx%d @%d-%dfps",
          aPrefs.GetWidth(), aPrefs.GetHeight(),
          aPrefs.mFPS, aPrefs.mMinFPS));
     LogConstraints(aConstraints);
-    if (aConstraints.mAdvanced.Length()) {
-      LOG(("Advanced array[%u]:", aConstraints.mAdvanced.Length()));
+    if (aConstraints.mAdvanced.size()) {
+      LOG(("Advanced array[%u]:", aConstraints.mAdvanced.size()));
       for (auto& advanced : aConstraints.mAdvanced) {
         LogConstraints(advanced);
       }
     }
   }
 
   size_t num = NumCapabilities();
 

--- a/dom/media/webrtc/MediaTrackConstraints.cpp
+++ b/dom/media/webrtc/MediaTrackConstraints.cpp
@@ -274,17 +274,17 @@ NormalizedConstraintSet::StringRange::Me
 NormalizedConstraints::NormalizedConstraints(
     const dom::MediaTrackConstraints& aOther,
     nsTArray<MemberPtrType>* aList)
   : NormalizedConstraintSet(aOther, false, aList)
   , mBadConstraint(nullptr)
 {
   if (aOther.mAdvanced.WasPassed()) {
     for (auto& entry : aOther.mAdvanced.Value()) {
-      mAdvanced.AppendElement(NormalizedConstraintSet(entry, true));
+      mAdvanced.push_back(NormalizedConstraintSet(entry, true));
     }
   }
 }
 
 // Merge constructor. Create net constraints out of merging a set of others.
 // This is only used to resolve competing constraints from concurrent requests,
 // something the spec doesn't cover.
 
@@ -308,17 +308,17 @@ NormalizedConstraints::NormalizedConstra
 
       if (!member.Merge(otherMember)) {
         mBadConstraint = member.mName;
         return;
       }
     }
 
     for (auto& entry : other.mAdvanced) {
-      mAdvanced.AppendElement(entry);
+      mAdvanced.push_back(entry);
     }
   }
   for (auto& memberPtr : list) {
     (this->*memberPtr).FinalizeMerge();
   }
 
   // ...except for resolution and frame rate where we take the highest ideal.
   // This is a bit of a hack based on the perception that people would be more

--- a/dom/media/webrtc/MediaTrackConstraints.h
+++ b/dom/media/webrtc/MediaTrackConstraints.h
@@ -268,17 +268,17 @@ struct NormalizedConstraints : public No
 {
   explicit NormalizedConstraints(const dom::MediaTrackConstraints& aOther,
                         nsTArray<MemberPtrType>* aList = nullptr);
 
   // Merge constructor
   explicit NormalizedConstraints(
       const nsTArray<const NormalizedConstraints*>& aOthers);
 
-  nsTArray<NormalizedConstraintSet> mAdvanced;
+  std::vector<NormalizedConstraintSet> mAdvanced;
   const char* mBadConstraint;
 };
 
 // Flattened version is used in low-level code with orthogonal constraints only.
 struct FlattenedConstraints : public NormalizedConstraintSet
 {
   explicit FlattenedConstraints(const NormalizedConstraints& aOther);
 
@@ -356,17 +356,17 @@ public:
     // Order devices by shortest distance
     for (auto& ordinal : ordered) {
       aDevices.RemoveElement(ordinal.second);
       aDevices.AppendElement(ordinal.second);
     }
 
     // Then apply advanced constraints.
 
-    for (int i = 0; i < int(c.mAdvanced.Length()); i++) {
+    for (int i = 0; i < int(c.mAdvanced.size()); i++) {
       aggregateConstraints.AppendElement(&c.mAdvanced[i]);
       nsTArray<RefPtr<DeviceType>> rejects;
       for (uint32_t j = 0; j < aDevices.Length();) {
         if (aDevices[j]->GetBestFitnessDistance(aggregateConstraints) == UINT32_MAX) {
           rejects.AppendElement(aDevices[j]);
           aDevices.RemoveElementAt(j);
         } else {
           ++j;