--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -1585,17 +1585,17 @@ GetMediaDevices(MediaEngine *aEngine,
 
 static auto& MediaManager_ToJSArray = MediaManager::ToJSArray;
 static auto& MediaManager_AnonymizeDevices = MediaManager::AnonymizeDevices;
 
 already_AddRefed<MediaManager::PledgeChar>
 MediaManager::SelectSettings(
     MediaStreamConstraints& aConstraints,
     bool aIsChrome,
-    RefPtr<Refcountable<UniquePtr<SourceSet>>>& aSources)
+    RefPtr<Refcountable<UniquePtr<MediaDeviceSet>>>& aSources)
 {
   MOZ_ASSERT(NS_IsMainThread());
   RefPtr<PledgeChar> p = new PledgeChar();
   uint32_t id = mOutstandingCharPledges.Append(*p);
 
   // Algorithm accesses device capabilities code and must run on media thread.
   // Modifies passed-in aSources.
 
@@ -1675,31 +1675,31 @@ public:
     const nsMainThreadPtrHandle<nsIDOMGetUserMediaSuccessCallback>& aOnSuccess,
     const nsMainThreadPtrHandle<nsIDOMGetUserMediaErrorCallback>& aOnFailure,
     uint64_t aWindowID,
     GetUserMediaWindowListener* aWindowListener,
     SourceListener* aSourceListener,
     MediaEnginePrefs& aPrefs,
     const ipc::PrincipalInfo& aPrincipalInfo,
     bool aIsChrome,
-    MediaManager::SourceSet* aSourceSet,
+    MediaManager::MediaDeviceSet* aMediaDeviceSet,
     bool aShouldFocusSource)
     : Runnable("GetUserMediaTask")
     , mConstraints(aConstraints)
     , mOnSuccess(aOnSuccess)
     , mOnFailure(aOnFailure)
     , mWindowID(aWindowID)
     , mWindowListener(aWindowListener)
     , mSourceListener(aSourceListener)
     , mPrefs(aPrefs)
     , mPrincipalInfo(aPrincipalInfo)
     , mIsChrome(aIsChrome)
     , mShouldFocusSource(aShouldFocusSource)
     , mDeviceChosen(false)
-    , mSourceSet(aSourceSet)
+    , mMediaDeviceSet(aMediaDeviceSet)
     , mManager(MediaManager::GetInstance())
   {}
 
   ~GetUserMediaTask() {
   }
 
   void
   Fail(MediaMgrError::Name aName,
@@ -1881,17 +1881,17 @@ private:
   RefPtr<MediaDevice> mVideoDevice;
   MediaEnginePrefs mPrefs;
   ipc::PrincipalInfo mPrincipalInfo;
   bool mIsChrome;
   bool mShouldFocusSource;
 
   bool mDeviceChosen;
 public:
-  nsAutoPtr<MediaManager::SourceSet> mSourceSet;
+  nsAutoPtr<MediaManager::MediaDeviceSet> mMediaDeviceSet;
 private:
   RefPtr<MediaManager> mManager; // get ref to this when creating the runnable
 };
 
 #if defined(ANDROID)
 class GetUserMediaRunnableWrapper : public Runnable
 {
 public:
@@ -1914,17 +1914,17 @@ private:
 };
 #endif
 
 /**
  * EnumerateRawDevices - Enumerate a list of audio & video devices that
  * satisfy passed-in constraints. List contains raw id's.
  */
 
-already_AddRefed<MediaManager::PledgeSourceSet>
+already_AddRefed<MediaManager::PledgeMediaDeviceSet>
 MediaManager::EnumerateRawDevices(uint64_t aWindowId,
                                   MediaSourceEnum aVideoInputType,
                                   MediaSourceEnum aAudioInputType,
                                   MediaSinkEnum aAudioOutputType,
                                   DeviceEnumerationType aVideoInputEnumType /* = DeviceEnumerationType::Normal */,
                                   DeviceEnumerationType aAudioInputEnumType /* = DeviceEnumerationType::Normal */)
 {
   MOZ_ASSERT(NS_IsMainThread());
@@ -1949,17 +1949,17 @@ MediaManager::EnumerateRawDevices(uint64
              aAudioInputType == MediaSourceEnum::Microphone,
              "If loopback audio is requested audio type should be microphone!");
 
   LOG(("%s: aWindowId=%" PRIu64 ", aVideoInputType=%" PRIu8 ", aAudioInputType=%" PRIu8
        ", aVideoInputEnumType=%" PRIu8 ", aAudioInputEnumType=%" PRIu8,
        __func__, aWindowId,
        static_cast<uint8_t>(aVideoInputType), static_cast<uint8_t>(aAudioInputType),
        static_cast<uint8_t>(aVideoInputEnumType), static_cast<uint8_t>(aAudioInputEnumType)));
-  RefPtr<PledgeSourceSet> p = new PledgeSourceSet();
+  RefPtr<PledgeMediaDeviceSet> p = new PledgeMediaDeviceSet();
   uint32_t id = mOutstandingPledges.Append(*p);
 
   bool hasVideo = aVideoInputType != MediaSourceEnum::Other;
   bool hasAudio = aAudioInputType != MediaSourceEnum::Other;
   bool hasAudioOutput = aAudioOutputType == MediaSinkEnum::Speaker;
 
   // True of at least one of video input or audio input is a fake device
   bool fakeDeviceRequested = (aVideoInputEnumType == DeviceEnumerationType::Fake && hasVideo) ||
@@ -1989,50 +1989,50 @@ MediaManager::EnumerateRawDevices(uint64
       fakeBackend = new MediaEngineDefault();
     }
     if (realDeviceRequested) {
       MediaManager* manager = MediaManager::GetIfExists();
       MOZ_RELEASE_ASSERT(manager); // Must exist while media thread is alive
       realBackend = manager->GetBackend(aWindowId);
     }
 
-    auto result = MakeUnique<SourceSet>();
+    auto result = MakeUnique<MediaDeviceSet>();
 
     if (hasVideo) {
-      SourceSet videos;
+      MediaDeviceSet videos;
       LOG(("EnumerateRawDevices Task: Getting video sources with %s backend",
            aVideoInputEnumType == DeviceEnumerationType::Fake ? "fake" : "real"));
       GetMediaDevices(aVideoInputEnumType == DeviceEnumerationType::Fake ? fakeBackend : realBackend,
                       aWindowId, aVideoInputType, videos, videoLoopDev.get());
       result->AppendElements(videos);
     }
     if (hasAudio) {
-      SourceSet audios;
+      MediaDeviceSet audios;
       LOG(("EnumerateRawDevices Task: Getting audio sources with %s backend",
            aAudioInputEnumType == DeviceEnumerationType::Fake ? "fake" : "real"));
       GetMediaDevices(aAudioInputEnumType == DeviceEnumerationType::Fake ? fakeBackend : realBackend,
                       aWindowId, aAudioInputType, audios, audioLoopDev.get());
       result->AppendElements(audios);
     }
     if (hasAudioOutput) {
-      SourceSet outputs;
+      MediaDeviceSet outputs;
       MOZ_ASSERT(realBackend);
       realBackend->EnumerateDevices(aWindowId,
                                     MediaSourceEnum::Other,
                                     MediaSinkEnum::Speaker,
                                     &outputs);
       result->AppendElements(outputs);
     }
 
     NS_DispatchToMainThread(NewRunnableFrom([id, result = std::move(result)]() mutable {
       MediaManager* mgr = MediaManager::GetIfExists();
       if (!mgr) {
         return NS_OK;
       }
-      RefPtr<PledgeSourceSet> p = mgr->mOutstandingPledges.Remove(id);
+      RefPtr<PledgeMediaDeviceSet> p = mgr->mOutstandingPledges.Remove(id);
       if (p) {
         p->Resolve(result.release());
       }
       return NS_OK;
     }));
   });
 
   if (realDeviceRequested &&
@@ -2359,22 +2359,22 @@ void MediaManager::OnDeviceChange() {
     if (sHasShutdown) {
       return NS_OK;
     }
     self->DeviceChangeCallback::OnDeviceChange();
 
     // On some Windows machine, if we call EnumerateRawDevices immediately after receiving
     // devicechange event, sometimes we would get outdated devices list.
     PR_Sleep(PR_MillisecondsToInterval(100));
-    RefPtr<PledgeSourceSet> p = self->EnumerateRawDevices(0,
-                                                          MediaSourceEnum::Camera,
-                                                          MediaSourceEnum::Microphone,
-                                                          MediaSinkEnum::Speaker);
-    p->Then([self](SourceSet*& aDevices) mutable {
-      UniquePtr<SourceSet> devices(aDevices);
+    RefPtr<PledgeMediaDeviceSet> p = self->EnumerateRawDevices(0,
+                                                               MediaSourceEnum::Camera,
+                                                               MediaSourceEnum::Microphone,
+                                                               MediaSinkEnum::Speaker);
+    p->Then([self](MediaDeviceSet*& aDevices) mutable {
+      UniquePtr<MediaDeviceSet> devices(aDevices);
       nsTArray<nsString> deviceIDs;
 
       for (auto& device : *devices) {
         nsString id;
         device->GetId(id);
         id.ReplaceSubstring(NS_LITERAL_STRING("default: "), NS_LITERAL_STRING(""));
         if (!deviceIDs.Contains(id)) {
           deviceIDs.AppendElement(id);
@@ -2870,29 +2870,29 @@ MediaManager::GetUserMedia(nsPIDOMWindow
        ", videoType=%" PRIu8 ", audioType=%" PRIu8
        ", videoEnumerationType=%" PRIu8 ", audioEnumerationType=%" PRIu8
        ", askPermission=%s",
        __func__, windowID,
        static_cast<uint8_t>(videoType), static_cast<uint8_t>(audioType),
        static_cast<uint8_t>(videoEnumerationType), static_cast<uint8_t>(audioEnumerationType),
        askPermission ? "true" : "false"));
 
-  RefPtr<PledgeSourceSet> p = EnumerateDevicesImpl(windowID,
-                                                   videoType,
-                                                   audioType,
-                                                   MediaSinkEnum::Other,
-                                                   videoEnumerationType,
-                                                   audioEnumerationType);
+  RefPtr<PledgeMediaDeviceSet> p = EnumerateDevicesImpl(windowID,
+                                                        videoType,
+                                                        audioType,
+                                                        MediaSinkEnum::Other,
+                                                        videoEnumerationType,
+                                                        audioEnumerationType);
   RefPtr<MediaManager> self = this;
   p->Then([self, onSuccess, onFailure, windowID, c, windowListener,
            sourceListener, askPermission, prefs, isHTTPS, isHandlingUserInput,
-           callID, principalInfo, isChrome, resistFingerprinting](SourceSet*& aDevices) mutable {
+           callID, principalInfo, isChrome, resistFingerprinting](MediaDeviceSet*& aDevices) mutable {
     LOG(("GetUserMedia: post enumeration pledge success callback starting"));
     // grab result
-    auto devices = MakeRefPtr<Refcountable<UniquePtr<SourceSet>>>(aDevices);
+    auto devices = MakeRefPtr<Refcountable<UniquePtr<MediaDeviceSet>>>(aDevices);
 
     // Ensure that our windowID is still good.
     if (!nsGlobalWindowInner::GetInnerWindowWithId(windowID)) {
       LOG(("GetUserMedia: bad windowID found in post enumeration pledge "
            " success callback! Bailing out!"));
       return;
     }
 
@@ -3005,17 +3005,17 @@ MediaManager::GetUserMedia(nsPIDOMWindow
   }, [onFailure](MediaStreamError*& reason) mutable {
     LOG(("GetUserMedia: post enumeration pledge failure callback called!"));
     onFailure->OnError(reason);
   });
   return NS_OK;
 }
 
 /* static */ void
-MediaManager::AnonymizeDevices(SourceSet& aDevices, const nsACString& aOriginKey)
+MediaManager::AnonymizeDevices(MediaDeviceSet& aDevices, const nsACString& aOriginKey)
 {
   if (!aOriginKey.IsEmpty()) {
     for (RefPtr<MediaDevice>& device : aDevices) {
       nsString id;
       device->GetId(id);
       nsString rawId(id);
       AnonymizeId(id, aOriginKey);
       device = new MediaDevice(device, id, rawId);
@@ -3066,17 +3066,17 @@ MediaManager::AnonymizeId(nsAString& aId
   }
 
   aId = NS_ConvertUTF8toUTF16(mac);
   return NS_OK;
 }
 
 /* static */
 already_AddRefed<nsIWritableVariant>
-MediaManager::ToJSArray(SourceSet& aDevices)
+MediaManager::ToJSArray(MediaDeviceSet& aDevices)
 {
   MOZ_ASSERT(NS_IsMainThread());
   RefPtr<nsVariantCC> var = new nsVariantCC();
   size_t len = aDevices.Length();
   if (len) {
     nsTArray<nsIMediaDevice*> tmp(len);
     for (auto& device : aDevices) {
       tmp.AppendElement(device);
@@ -3089,17 +3089,17 @@ MediaManager::ToJSArray(SourceSet& aDevi
       return nullptr;
     }
   } else {
     var->SetAsEmptyArray(); // because SetAsArray() fails on zero length arrays.
   }
   return var.forget();
 }
 
-already_AddRefed<MediaManager::PledgeSourceSet>
+already_AddRefed<MediaManager::PledgeMediaDeviceSet>
 MediaManager::EnumerateDevicesImpl(uint64_t aWindowId,
                                    MediaSourceEnum       aVideoInputType,
                                    MediaSourceEnum       aAudioInputType,
                                    MediaSinkEnum  aAudioOutputType,
                                    DeviceEnumerationType aVideoInputEnumType,
                                    DeviceEnumerationType aAudioInputEnumType)
 {
   MOZ_ASSERT(NS_IsMainThread());
@@ -3108,32 +3108,32 @@ MediaManager::EnumerateDevicesImpl(uint6
        ", aVideoInputEnumType=%" PRIu8 ", aAudioInputEnumType=%" PRIu8,
        __func__, aWindowId,
        static_cast<uint8_t>(aVideoInputType), static_cast<uint8_t>(aAudioInputType),
        static_cast<uint8_t>(aVideoInputEnumType), static_cast<uint8_t>(aAudioInputEnumType)));
   nsPIDOMWindowInner* window =
     nsGlobalWindowInner::GetInnerWindowWithId(aWindowId)->AsInner();
 
   // This function returns a pledge, a promise-like object with the future result
-  RefPtr<PledgeSourceSet> pledge = new PledgeSourceSet();
+  RefPtr<PledgeMediaDeviceSet> pledge = new PledgeMediaDeviceSet();
   uint32_t id = mOutstandingPledges.Append(*pledge);
 
   // To get a device list anonymized for a particular origin, we must:
   // 1. Get an origin-key (for either regular or private browsing)
   // 2. Get the raw devices list
   // 3. Anonymize the raw list with the origin-key.
 
   nsCOMPtr<nsIPrincipal> principal =
     nsGlobalWindowInner::Cast(window)->GetPrincipal();
   MOZ_ASSERT(principal);
 
   ipc::PrincipalInfo principalInfo;
   nsresult rv = PrincipalToPrincipalInfo(principal, &principalInfo);
   if (NS_WARN_IF(NS_FAILED(rv))) {
-    RefPtr<PledgeSourceSet> p = new PledgeSourceSet();
+    RefPtr<PledgeMediaDeviceSet> p = new PledgeMediaDeviceSet();
     RefPtr<MediaStreamError> error =
       new MediaStreamError(window, MediaStreamError::Name::NotAllowedError);
     p->Reject(error);
     return p.forget();
   }
 
   bool persist = IsActivelyCapturingOrHasAPermission(aWindowId);
 
@@ -3146,30 +3146,30 @@ MediaManager::EnumerateDevicesImpl(uint6
   p->Then([id, aWindowId, aVideoInputType, aAudioInputType,
           aVideoInputEnumType, aAudioInputEnumType, aAudioOutputType](const nsCString& aOriginKey) mutable {
     MOZ_ASSERT(NS_IsMainThread());
     MediaManager* mgr = MediaManager::GetIfExists();
     if (!mgr) {
       return;
     }
 
-    RefPtr<PledgeSourceSet> p = mgr->EnumerateRawDevices(aWindowId,
-                                                         aVideoInputType,
-                                                         aAudioInputType,
-                                                         aAudioOutputType,
-                                                         aVideoInputEnumType,
-                                                         aAudioInputEnumType);
+    RefPtr<PledgeMediaDeviceSet> p = mgr->EnumerateRawDevices(aWindowId,
+                                                              aVideoInputType,
+                                                              aAudioInputType,
+                                                              aAudioOutputType,
+                                                              aVideoInputEnumType,
+                                                              aAudioInputEnumType);
     p->Then([id,
              aWindowId,
              aOriginKey,
              aVideoInputEnumType,
              aAudioInputEnumType,
              aVideoInputType,
-             aAudioInputType](SourceSet*& aDevices) mutable {
-      UniquePtr<SourceSet> devices(aDevices); // secondary result
+             aAudioInputType](MediaDeviceSet*& aDevices) mutable {
+      UniquePtr<MediaDeviceSet> devices(aDevices); // secondary result
 
       // Only run if window is still on our active list.
       MediaManager* mgr = MediaManager::GetIfExists();
       if (!mgr) {
         return NS_OK;
       }
 
       // If we fetched any real cameras or mics, remove the "default" part of
@@ -3184,17 +3184,17 @@ MediaManager::EnumerateDevicesImpl(uint6
           device->GetId(id);
           id.ReplaceSubstring(NS_LITERAL_STRING("default: "), NS_LITERAL_STRING(""));
           if (!mgr->mDeviceIDs.Contains(id)) {
             mgr->mDeviceIDs.AppendElement(id);
           }
         }
       }
 
-      RefPtr<PledgeSourceSet> p = mgr->mOutstandingPledges.Remove(id);
+      RefPtr<PledgeMediaDeviceSet> p = mgr->mOutstandingPledges.Remove(id);
       if (!p || !mgr->IsWindowStillActive(aWindowId)) {
         return NS_OK;
       }
       MediaManager_AnonymizeDevices(*devices, aOriginKey);
       p->Resolve(devices.release());
       return NS_OK;
     });
   });
@@ -3261,24 +3261,24 @@ MediaManager::EnumerateDevices(nsPIDOMWi
       audioEnumerationType = DeviceEnumerationType::Fake;
     }
   }
 
   MediaSinkEnum audioOutputType = MediaSinkEnum::Other;
   if (Preferences::GetBool("media.setsinkid.enabled")) {
     audioOutputType = MediaSinkEnum::Speaker;
   }
-  RefPtr<PledgeSourceSet> p = EnumerateDevicesImpl(windowId,
-                                                   MediaSourceEnum::Camera,
-                                                   MediaSourceEnum::Microphone,
-                                                   audioOutputType,
-                                                   videoEnumerationType,
-                                                   audioEnumerationType);
-  p->Then([onSuccess, windowListener, sourceListener](SourceSet*& aDevices) mutable {
-    UniquePtr<SourceSet> devices(aDevices); // grab result
+  RefPtr<PledgeMediaDeviceSet> p = EnumerateDevicesImpl(windowId,
+                                                        MediaSourceEnum::Camera,
+                                                        MediaSourceEnum::Microphone,
+                                                        audioOutputType,
+                                                        videoEnumerationType,
+                                                        audioEnumerationType);
+  p->Then([onSuccess, windowListener, sourceListener](MediaDeviceSet*& aDevices) mutable {
+    UniquePtr<MediaDeviceSet> devices(aDevices); // grab result
     DebugOnly<bool> rv = windowListener->Remove(sourceListener);
     MOZ_ASSERT(rv);
     nsCOMPtr<nsIWritableVariant> array = MediaManager_ToJSArray(*devices);
     onSuccess->OnSuccess(array);
   }, [onFailure, windowListener, sourceListener](MediaStreamError*& reason) mutable {
     DebugOnly<bool> rv = windowListener->Remove(sourceListener);
     MOZ_ASSERT(rv);
     onFailure->OnError(reason);
@@ -3311,17 +3311,17 @@ MediaManager::GetUserMediaDevices(nsPIDO
   if (!mCallIds.Get(aWindowId, &callIDs)) {
     return NS_ERROR_UNEXPECTED;
   }
 
   for (auto& callID : *callIDs) {
     RefPtr<GetUserMediaTask> task;
     if (!aCallID.Length() || aCallID == callID) {
       if (mActiveCallbacks.Get(callID, getter_AddRefs(task))) {
-        nsCOMPtr<nsIWritableVariant> array = MediaManager_ToJSArray(*task->mSourceSet);
+        nsCOMPtr<nsIWritableVariant> array = MediaManager_ToJSArray(*task->mMediaDeviceSet);
         onSuccess->OnSuccess(array);
         return NS_OK;
       }
     }
   }
   return NS_ERROR_UNEXPECTED;
 }
 

--- a/dom/media/MediaManager.h
+++ b/dom/media/MediaManager.h
@@ -222,56 +222,56 @@ public:
                             dom::CallerType aCallerType);
 
   nsresult EnumerateDevices(nsPIDOMWindowInner* aWindow, dom::Promise& aPromise);
   void OnNavigation(uint64_t aWindowID);
   bool IsActivelyCapturingOrHasAPermission(uint64_t aWindowId);
 
   MediaEnginePrefs mPrefs;
 
-  typedef nsTArray<RefPtr<MediaDevice>> SourceSet;
+  typedef nsTArray<RefPtr<MediaDevice>> MediaDeviceSet;
 
   virtual int AddDeviceChangeCallback(DeviceChangeCallback* aCallback) override;
   virtual void OnDeviceChange() override;
 private:
-  typedef media::Pledge<SourceSet*, dom::MediaStreamError*> PledgeSourceSet;
+  typedef media::Pledge<MediaDeviceSet*, dom::MediaStreamError*> PledgeMediaDeviceSet;
   typedef media::Pledge<const char*, dom::MediaStreamError*> PledgeChar;
   typedef media::Pledge<bool, dom::MediaStreamError*> PledgeVoid;
 
   static nsresult GenerateUUID(nsAString& aResult);
   static nsresult AnonymizeId(nsAString& aId, const nsACString& aOriginKey);
 public: // TODO: make private once we upgrade to GCC 4.8+ on linux.
-  static void AnonymizeDevices(SourceSet& aDevices, const nsACString& aOriginKey);
-  static already_AddRefed<nsIWritableVariant> ToJSArray(SourceSet& aDevices);
+  static void AnonymizeDevices(MediaDeviceSet& aDevices, const nsACString& aOriginKey);
+  static already_AddRefed<nsIWritableVariant> ToJSArray(MediaDeviceSet& aDevices);
 private:
   enum class DeviceEnumerationType :uint8_t {
     Normal, // Enumeration should not return loopback or fake devices
     Fake, // Enumeration should return fake device(s)
     Loopback /* Enumeration should return loopback device(s) (possibly in
              addition to normal devices) */
   };
-  already_AddRefed<PledgeSourceSet>
+  already_AddRefed<PledgeMediaDeviceSet>
   EnumerateRawDevices(uint64_t aWindowId,
                       dom::MediaSourceEnum      aVideoInputType,
                       dom::MediaSourceEnum      aAudioInputType,
                       MediaSinkEnum             aAudioOutputType,
                       DeviceEnumerationType     aVideoInputEnumType = DeviceEnumerationType::Normal,
                       DeviceEnumerationType     aAudioInputEnumType = DeviceEnumerationType::Normal);
-  already_AddRefed<PledgeSourceSet>
+  already_AddRefed<PledgeMediaDeviceSet>
   EnumerateDevicesImpl(uint64_t aWindowId,
                        dom::MediaSourceEnum      aVideoInputType,
                        dom::MediaSourceEnum      aAudioInputType,
                        MediaSinkEnum             aAudioOutputType,
                        DeviceEnumerationType     aVideoInputEnumType,
                        DeviceEnumerationType     aAudioInputEnumType);
   already_AddRefed<PledgeChar>
   SelectSettings(
       dom::MediaStreamConstraints& aConstraints,
       bool aIsChrome,
-      RefPtr<media::Refcountable<UniquePtr<SourceSet>>>& aSources);
+      RefPtr<media::Refcountable<UniquePtr<MediaDeviceSet>>>& aSources);
 
   void GetPref(nsIPrefBranch *aBranch, const char *aPref,
                const char *aData, int32_t *aVal);
   void GetPrefBool(nsIPrefBranch *aBranch, const char *aPref,
                    const char *aData, bool *aVal);
   void GetPrefs(nsIPrefBranch *aBranch, const char *aData);
 
   // Make private because we want only one instance of this class
@@ -303,17 +303,17 @@ private:
   nsAutoPtr<base::Thread> mMediaThread;
   nsCOMPtr<nsIAsyncShutdownBlocker> mShutdownBlocker;
 
   // ONLY accessed from MediaManagerThread
   RefPtr<MediaEngine> mBackend;
 
   static StaticRefPtr<MediaManager> sSingleton;
 
-  media::CoatCheck<PledgeSourceSet> mOutstandingPledges;
+  media::CoatCheck<PledgeMediaDeviceSet> mOutstandingPledges;
   media::CoatCheck<PledgeChar> mOutstandingCharPledges;
   nsTArray<nsString> mDeviceIDs;
 public:
   media::CoatCheck<media::Pledge<nsCString>> mGetPrincipalKeyPledges;
   RefPtr<media::Parent<media::NonE10s>> mNonE10sParent;
 };
 
 } // namespace mozilla