--- a/dom/media/MediaManager.cpp
+++ b/dom/media/MediaManager.cpp
@@ -1056,29 +1056,30 @@ public:
     }
 
     MediaStreamGraph::GraphDriverType graphDriverType =
       mAudioDevice ? MediaStreamGraph::AUDIO_THREAD_DRIVER
                    : MediaStreamGraph::SYSTEM_THREAD_DRIVER;
     MediaStreamGraph* msg =
       MediaStreamGraph::GetInstance(graphDriverType, window);
 
-    RefPtr<DOMMediaStream> domStream;
+    nsMainThreadPtrHandle<DOMMediaStream> domStream;
     RefPtr<SourceMediaStream> stream;
     // AudioCapture is a special case, here, in the sense that we're not really
     // using the audio source and the SourceMediaStream, which acts as
     // placeholders. We re-route a number of stream internaly in the MSG and mix
     // them down instead.
     if (mAudioDevice &&
         mAudioDevice->GetMediaSource() == MediaSourceEnum::AudioCapture) {
       // It should be possible to pipe the capture stream to anything. CORS is
       // not a problem here, we got explicit user content.
       nsCOMPtr<nsIPrincipal> principal = window->GetExtantDoc()->NodePrincipal();
-      domStream =
-        DOMMediaStream::CreateAudioCaptureStreamAsInput(window, principal, msg);
+      domStream = new nsMainThreadPtrHolder<DOMMediaStream>(
+        "GetUserMediaStreamRunnable::AudioCaptureDOMStreamMainThreadHolder",
+        DOMMediaStream::CreateAudioCaptureStreamAsInput(window, principal, msg));
 
       stream = msg->CreateSourceStream(); // Placeholder
       msg->RegisterCaptureStreamForWindow(
             mWindowID, domStream->GetInputStream()->AsProcessedStream());
       window->SetAudioCapture(true);
     } else {
       class LocalTrackSource : public MediaStreamTrackSource
       {
@@ -1163,19 +1164,20 @@ public:
         principal = NullPrincipal::CreateWithInheritedAttributes(window->GetExtantDoc()->NodePrincipal());
       } else {
         principal = window->GetExtantDoc()->NodePrincipal();
       }
 
       // Normal case, connect the source stream to the track union stream to
       // avoid us blocking. Pass a simple TrackSourceGetter for potential
       // fake tracks. Apart from them gUM never adds tracks dynamically.
-      domStream =
+      domStream = new nsMainThreadPtrHolder<DOMMediaStream>(
+        "GetUserMediaStreamRunnable::DOMMediaStreamMainThreadHolder",
         DOMLocalMediaStream::CreateSourceStreamAsInput(window, msg,
-                                                       new FakeTrackSourceGetter(principal));
+                                                       new FakeTrackSourceGetter(principal)));
       stream = domStream->GetInputStream()->AsSourceStream();
 
       if (mAudioDevice) {
         nsString audioDeviceName;
         mAudioDevice->GetName(audioDeviceName);
         const MediaSourceEnum source =
           mAudioDevice->GetSource()->GetMediaSource();
         RefPtr<MediaStreamTrackSource> audioSource =
@@ -1218,18 +1220,25 @@ public:
     }
 
     // Activate our source listener. We'll call Start() on the source when we
     // get a callback that the MediaStream has started consuming. The listener
     // is freed when the page is invalidated (on navigation or close).
     mWindowListener->Activate(mSourceListener, stream, mAudioDevice, mVideoDevice);
 
     // Note: includes JS callbacks; must be released on MainThread
-    auto callback = MakeRefPtr<Refcountable<UniquePtr<OnTracksAvailableCallback>>>(
-        new TracksAvailableCallback(mManager, mOnSuccess.forget(), mWindowID, domStream));
+    typedef Refcountable<UniquePtr<TracksAvailableCallback>> Callback;
+    nsMainThreadPtrHandle<Callback> callback(
+      new nsMainThreadPtrHolder<Callback>(
+        "GetUserMediaStreamRunnable::TracksAvailableCallbackMainThreadHolder",
+        MakeAndAddRef<Callback>(
+          new TracksAvailableCallback(mManager,
+                                      mOnSuccess.forget(),
+                                      mWindowID,
+                                      domStream))));
 
     // Dispatch to the media thread to ask it to start the sources,
     // because that can take a while.
     // Pass ownership of domStream through the lambda to the nested chrome
     // notification lambda to ensure it's kept alive until that lambda runs or is discarded.
     RefPtr<GetUserMediaStreamRunnable> self = this;
     MediaManager::PostTask(NewTaskFrom([self, domStream, callback]() mutable {
       MOZ_ASSERT(MediaManager::IsInMediaThread());
@@ -1259,20 +1268,16 @@ public:
         if (NS_FAILED(rv)) {
           nsString log;
           log.AssignASCII("Starting video failed");
           error = new MediaMgrError(NS_LITERAL_STRING("InternalError"), log);
         }
       }
 
       if (error) {
-        // The DOM stream and track callback must be released on main thread.
-        NS_DispatchToMainThread(do_AddRef(new ReleaseMediaOperationResource(
-          domStream.forget(), callback.forget())));
-
         // Dispatch the error callback on main thread.
         nsCOMPtr<nsIDOMGetUserMediaSuccessCallback> onSuccess;
         NS_DispatchToMainThread(do_AddRef(
           new ErrorCallbackRunnable<nsIDOMGetUserMediaSuccessCallback>(
             Move(onSuccess), Move(self->mOnFailure), *error, self->mWindowID)));
 
         // This should be empty now
         MOZ_ASSERT(!self->mOnFailure);

--- a/dom/media/MediaManager.h
+++ b/dom/media/MediaManager.h
@@ -122,40 +122,16 @@ class AudioDevice : public MediaDevice
 public:
   typedef MediaEngineAudioSource Source;
 
   explicit AudioDevice(Source* aSource);
   NS_IMETHOD GetType(nsAString& aType) override;
   Source* GetSource() override;
 };
 
-typedef enum {
-  MEDIA_STOP,
-  MEDIA_STOP_TRACK,
-  MEDIA_DIRECT_LISTENERS,
-} MediaOperation;
-
-class ReleaseMediaOperationResource : public Runnable
-{
-public:
-  ReleaseMediaOperationResource(
-    already_AddRefed<DOMMediaStream> aStream,
-    already_AddRefed<media::Refcountable<UniquePtr<OnTracksAvailableCallback>>>
-      aOnTracksAvailableCallback)
-    : Runnable("ReleaseMediaOperationResource")
-    , mStream(aStream)
-    , mOnTracksAvailableCallback(aOnTracksAvailableCallback)
-  {
-  }
-  NS_IMETHOD Run() override {return NS_OK;}
-private:
-  RefPtr<DOMMediaStream> mStream;
-  RefPtr<media::Refcountable<UniquePtr<OnTracksAvailableCallback>>> mOnTracksAvailableCallback;
-};
-
 typedef nsRefPtrHashtable<nsUint64HashKey, GetUserMediaWindowListener> WindowTable;
 
 // we could add MediaManager if needed
 typedef void (*WindowListenerCallback)(MediaManager *aThis,
                                        uint64_t aWindowID,
                                        GetUserMediaWindowListener *aListener,
                                        void *aData);