--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -1479,24 +1479,26 @@ private:
   ipc::PrincipalInfo mPrincipalInfo;
   RefPtr<PeerIdentity> mPeerIdentity;
   RefPtr<MediaManager> mManager; // get ref to this when creating the runnable
 };
 
 // Source getter returning full list
 
 static void
-GetSources(MediaEngine *engine, MediaSourceEnum aSrcType,
+GetSources(MediaEngine *engine,
+           uint64_t aWindowId,
+           MediaSourceEnum aSrcType,
            nsTArray<RefPtr<MediaDevice>>& aResult,
            const char* media_device_name = nullptr)
 {
   MOZ_ASSERT(MediaManager::IsInMediaThread());
 
   nsTArray<RefPtr<MediaEngineSource>> sources;
-  engine->EnumerateDevices(aSrcType, &sources);
+  engine->EnumerateDevices(aWindowId, aSrcType, &sources);
 
   /*
    * We're allowing multiple tabs to access the same camera for parity
    * with Chrome.  See bug 811757 for some of the issues surrounding
    * this decision.  To disallow, we'd filter by IsAvailable() as we used
    * to.
    */
   if (media_device_name && *media_device_name)  {
@@ -1888,25 +1890,25 @@ MediaManager::EnumerateRawDevices(uint64
       MOZ_RELEASE_ASSERT(manager); // Must exist while media thread is alive
       realBackend = manager->GetBackend(aWindowId);
     }
 
     auto result = MakeUnique<SourceSet>();
 
     if (hasVideo) {
       nsTArray<RefPtr<MediaDevice>> videos;
-      GetSources(fakeCams? fakeBackend : realBackend, aVideoType,
+      GetSources(fakeCams? fakeBackend : realBackend, aWindowId, aVideoType,
                  videos, videoLoopDev.get());
       for (auto& source : videos) {
         result->AppendElement(source);
       }
     }
     if (hasAudio) {
       nsTArray<RefPtr<MediaDevice>> audios;
-      GetSources(fakeMics? fakeBackend : realBackend, aAudioType,
+      GetSources(fakeMics? fakeBackend : realBackend, aWindowId, aAudioType,
                  audios, audioLoopDev.get());
       for (auto& source : audios) {
         result->AppendElement(source);
       }
     }
     NS_DispatchToMainThread(NewRunnableFrom([id, result = Move(result)]() mutable {
       MediaManager* mgr = MediaManager::GetIfExists();
       if (!mgr) {

--- a/dom/media/webrtc/MediaEngine.h
+++ b/dom/media/webrtc/MediaEngine.h
@@ -39,17 +39,18 @@ public:
   {
     NS_ASSERT_OWNINGTHREAD(MediaEngine);
   }
 
   /**
    * Populate an array of sources of the requested type in the nsTArray.
    * Also include devices that are currently unavailable.
    */
-  virtual void EnumerateDevices(dom::MediaSourceEnum,
+  virtual void EnumerateDevices(uint64_t aWindowId,
+                                dom::MediaSourceEnum,
                                 nsTArray<RefPtr<MediaEngineSource>>*) = 0;
 
   virtual void Shutdown() = 0;
 
   virtual void SetFakeDeviceChangeEvents() {}
 
 protected:
   virtual ~MediaEngine() {}

--- a/dom/media/webrtc/MediaEngineDefault.cpp
+++ b/dom/media/webrtc/MediaEngineDefault.cpp
@@ -543,29 +543,29 @@ MediaEngineDefaultAudioSource::Pull(cons
   TrackTicks desired = aStream->TimeToTicksRoundUp(aStream->GraphRate(), aDesiredTime);
   TrackTicks delta = desired - mLastNotify;
   mLastNotify += delta;
   AppendToSegment(segment, delta, aPrincipalHandle);
   aStream->AppendToTrack(aTrackID, &segment);
 }
 
 void
-MediaEngineDefault::EnumerateDevices(dom::MediaSourceEnum aMediaSource,
+MediaEngineDefault::EnumerateDevices(uint64_t aWindowId,
+                                     dom::MediaSourceEnum aMediaSource,
                                      nsTArray<RefPtr<MediaEngineSource>>* aSources)
 {
   AssertIsOnOwningThread();
 
   switch (aMediaSource) {
     case dom::MediaSourceEnum::Camera: {
       // Only supports camera video sources. See Bug 1038241.
 
       // We once had code here to find a VideoSource with the same settings and
       // re-use that. This is no longer possible since the resolution gets set
       // in Allocate().
-
       auto newSource = MakeRefPtr<MediaEngineDefaultVideoSource>();
       mVSources.AppendElement(newSource);
       aSources->AppendElement(newSource);
       return;
     }
     case dom::MediaSourceEnum::Microphone: {
       for (const RefPtr<MediaEngineDefaultAudioSource>& source : mASources) {
         if (source->IsAvailable()) {

--- a/dom/media/webrtc/MediaEngineDefault.h
+++ b/dom/media/webrtc/MediaEngineDefault.h
@@ -182,17 +182,18 @@ protected:
 };
 
 
 class MediaEngineDefault : public MediaEngine
 {
 public:
   MediaEngineDefault() = default;
 
-  void EnumerateDevices(dom::MediaSourceEnum,
+  void EnumerateDevices(uint64_t aWindowId,
+                        dom::MediaSourceEnum,
                         nsTArray<RefPtr<MediaEngineSource>>*) override;
   void Shutdown() override;
 
 private:
   ~MediaEngineDefault() = default;
 
   nsTArray<RefPtr<MediaEngineDefaultVideoSource>> mVSources;
   nsTArray<RefPtr<MediaEngineDefaultAudioSource>> mASources;

--- a/dom/media/webrtc/MediaEngineWebRTC.cpp
+++ b/dom/media/webrtc/MediaEngineWebRTC.cpp
@@ -124,17 +124,18 @@ MediaEngineWebRTC::MediaEngineWebRTC(Med
 void
 MediaEngineWebRTC::SetFakeDeviceChangeEvents()
 {
   camera::GetChildAndCall(
     &camera::CamerasChild::SetFakeDeviceChangeEvents);
 }
 
 void
-MediaEngineWebRTC::EnumerateDevices(dom::MediaSourceEnum aMediaSource,
+MediaEngineWebRTC::EnumerateDevices(uint64_t aWindowId,
+                                    dom::MediaSourceEnum aMediaSource,
                                     nsTArray<RefPtr<MediaEngineSource> >* aSources)
 {
   if (MediaEngineSource::IsVideo(aMediaSource)) {
     // We spawn threads to handle gUM runnables, so we must protect the member vars
     MutexAutoLock lock(mMutex);
 
     mozilla::camera::CaptureEngine capEngine = mozilla::camera::InvalidEngine;
 

--- a/dom/media/webrtc/MediaEngineWebRTC.h
+++ b/dom/media/webrtc/MediaEngineWebRTC.h
@@ -617,17 +617,18 @@ public:
 
   // Clients should ensure to clean-up sources video/audio sources
   // before invoking Shutdown on this class.
   void Shutdown() override;
 
   // Returns whether the host supports duplex audio stream.
   bool SupportsDuplex();
 
-  void EnumerateDevices(dom::MediaSourceEnum,
+  void EnumerateDevices(uint64_t aWindowId,
+                        dom::MediaSourceEnum,
                         nsTArray<RefPtr<MediaEngineSource>>*) override;
 private:
   ~MediaEngineWebRTC() = default;
 
   nsCOMPtr<nsIThread> mThread;
 
   // gUM runnables can e.g. Enumerate from multiple threads
   Mutex mMutex;