Bug 1341555 - Consolidate use of the MSG's AbstractMainThread, and stop having AbstractMainThread on MediaStreams. r=pehrsons

MozReview-Commit-ID: 5hGDQcfpH6a

dom/html/HTMLMediaElement.cpp

@@ -4869,8 +4869,7 @@ public:
     mBlocked(false),
     mFinished(false),
     mMutex(aName),
-    mPendingNotifyOutput(false),
+    mPendingNotifyOutput(false)
-    mAbstractMainThread(aElement->AbstractMainThread())
   {}
   void Forget()
   {
@@ -4938,14 +4937,12 @@ public:
         this,
         &StreamListener::DoNotifyUnblocked);
     }
-    aGraph->DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+    aGraph->DispatchToMainThreadAfterStreamStateUpdate(event.forget());
-                                                       event.forget());
   }
   virtual void NotifyHasCurrentData(MediaStreamGraph* aGraph) override
   {
     MutexAutoLock lock(mMutex);
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-      mAbstractMainThread,
       NewRunnableMethod(
         "dom::HTMLMediaElement::StreamListener::DoNotifyHaveCurrentData",
         this,
@@ -4959,7 +4956,6 @@ public:
       return;
     mPendingNotifyOutput = true;
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-      mAbstractMainThread,
       NewRunnableMethod("dom::HTMLMediaElement::StreamListener::DoNotifyOutput",
                         this,
                         &StreamListener::DoNotifyOutput));
@@ -4975,7 +4971,6 @@ private:
   // mMutex protects the fields below; they can be accessed on any thread
   Mutex mMutex;
   bool mPendingNotifyOutput;
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 class HTMLMediaElement::MediaStreamTracksAvailableCallback:

dom/media/AudioCaptureStream.cpp

@@ -30,8 +30,11 @@ namespace mozilla
 // We are mixing to mono until PeerConnection can accept stereo
 static const uint32_t MONO = 1;
 
-AudioCaptureStream::AudioCaptureStream(TrackID aTrackId, AbstractThread* aMainThread)
+AudioCaptureStream::AudioCaptureStream(TrackID aTrackId)
-  : ProcessedMediaStream(aMainThread), mTrackId(aTrackId), mStarted(false), mTrackCreated(false)
+  : ProcessedMediaStream()
+  , mTrackId(aTrackId)
+  , mStarted(false)
+  , mTrackCreated(false)
 {
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_COUNT_CTOR(AudioCaptureStream);

dom/media/AudioCaptureStream.h

@@ -24,7 +24,7 @@ class AudioCaptureStream : public ProcessedMediaStream,
                            public MixerCallbackReceiver
 {
 public:
-  AudioCaptureStream(TrackID aTrackId, AbstractThread* aMainThread);
+  AudioCaptureStream(TrackID aTrackId);
   virtual ~AudioCaptureStream();
 
   void Start();

dom/media/DOMMediaStream.cpp

@@ -143,7 +143,6 @@ class DOMMediaStream::OwnedStreamListener : public MediaStreamListener {
 public:
   explicit OwnedStreamListener(DOMMediaStream* aStream)
     : mStream(aStream)
-    , mAbstractMainThread(aStream->mAbstractMainThread)
   {}
 
   void Forget() { mStream = nullptr; }
@@ -224,7 +223,6 @@ public:
   {
     if (aTrackEvents & TrackEventCommand::TRACK_EVENT_CREATED) {
       aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-        mAbstractMainThread,
         NewRunnableMethod<TrackID,
                           MediaSegment::Type,
                           RefPtr<MediaStream>,
@@ -238,7 +236,6 @@ public:
           aInputTrackID));
     } else if (aTrackEvents & TrackEventCommand::TRACK_EVENT_ENDED) {
       aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-        mAbstractMainThread,
         NewRunnableMethod<RefPtr<MediaStream>, TrackID, TrackID>(
           "DOMMediaStream::OwnedStreamListener::DoNotifyTrackEnded",
           this,
@@ -252,8 +249,6 @@ public:
 private:
   // These fields may only be accessed on the main thread
   DOMMediaStream* mStream;
-
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 /**
@@ -265,7 +260,6 @@ class DOMMediaStream::PlaybackStreamListener : public MediaStreamListener {
 public:
   explicit PlaybackStreamListener(DOMMediaStream* aStream)
     : mStream(aStream)
-    , mAbstractMainThread(aStream->mAbstractMainThread)
   {}
 
   void Forget()
@@ -309,7 +303,6 @@ public:
   void NotifyFinishedTrackCreation(MediaStreamGraph* aGraph) override
   {
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-      mAbstractMainThread,
       NewRunnableMethod(
         "DOMMediaStream::PlaybackStreamListener::DoNotifyFinishedTrackCreation",
         this,
@@ -322,7 +315,6 @@ public:
   {
     if (event == MediaStreamGraphEvent::EVENT_FINISHED) {
       aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-        mAbstractMainThread,
         NewRunnableMethod(
           "DOMMediaStream::PlaybackStreamListener::DoNotifyFinished",
           this,
@@ -333,8 +325,6 @@ public:
 private:
   // These fields may only be accessed on the main thread
   DOMMediaStream* mStream;
-
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 class DOMMediaStream::PlaybackTrackListener : public MediaStreamTrackConsumer
@@ -436,8 +426,7 @@ DOMMediaStream::DOMMediaStream(nsPIDOMWindowInner* aWindow,
     mTracksPendingRemoval(0), mTrackSourceGetter(aTrackSourceGetter),
     mPlaybackTrackListener(MakeAndAddRef<PlaybackTrackListener>(this)),
     mTracksCreated(false), mNotifiedOfMediaStreamGraphShutdown(false),
-    mActive(false), mSetInactiveOnFinish(false),
+    mActive(false), mSetInactiveOnFinish(false)
-    mAbstractMainThread(aWindow ? aWindow->GetDocGroup()->AbstractMainThreadFor(TaskCategory::Other) : nullptr)
 {
   nsresult rv;
   nsCOMPtr<nsIUUIDGenerator> uuidgen =
@@ -881,8 +870,7 @@ DOMMediaStream::SetInactiveOnFinish()
 void
 DOMMediaStream::InitSourceStream(MediaStreamGraph* aGraph)
 {
-  MOZ_ASSERT(mAbstractMainThread);
+  InitInputStreamCommon(aGraph->CreateSourceStream(), aGraph);
-  InitInputStreamCommon(aGraph->CreateSourceStream(mAbstractMainThread), aGraph);
   InitOwnedStreamCommon(aGraph);
   InitPlaybackStreamCommon(aGraph);
 }
@@ -890,8 +878,7 @@ DOMMediaStream::InitSourceStream(MediaStreamGraph* aGraph)
 void
 DOMMediaStream::InitTrackUnionStream(MediaStreamGraph* aGraph)
 {
-  MOZ_ASSERT(mAbstractMainThread);
+  InitInputStreamCommon(aGraph->CreateTrackUnionStream(), aGraph);
-  InitInputStreamCommon(aGraph->CreateTrackUnionStream(mAbstractMainThread), aGraph);
   InitOwnedStreamCommon(aGraph);
   InitPlaybackStreamCommon(aGraph);
 }
@@ -899,14 +886,13 @@ DOMMediaStream::InitTrackUnionStream(MediaStreamGraph* aGraph)
 void
 DOMMediaStream::InitAudioCaptureStream(nsIPrincipal* aPrincipal, MediaStreamGraph* aGraph)
 {
-  MOZ_ASSERT(mAbstractMainThread);
   const TrackID AUDIO_TRACK = 1;
 
   RefPtr<BasicTrackSource> audioCaptureSource =
     new BasicTrackSource(aPrincipal, MediaSourceEnum::AudioCapture);
 
   AudioCaptureStream* audioCaptureStream =
-    static_cast<AudioCaptureStream*>(aGraph->CreateAudioCaptureStream(AUDIO_TRACK, mAbstractMainThread));
+    static_cast<AudioCaptureStream*>(aGraph->CreateAudioCaptureStream(AUDIO_TRACK));
   InitInputStreamCommon(audioCaptureStream, aGraph);
   InitOwnedStreamCommon(aGraph);
   InitPlaybackStreamCommon(aGraph);
@@ -930,10 +916,9 @@ DOMMediaStream::InitInputStreamCommon(MediaStream* aStream,
 void
 DOMMediaStream::InitOwnedStreamCommon(MediaStreamGraph* aGraph)
 {
-  MOZ_ASSERT(mAbstractMainThread);
   MOZ_ASSERT(!mPlaybackStream, "Owned stream must be initialized before playback stream");
 
-  mOwnedStream = aGraph->CreateTrackUnionStream(mAbstractMainThread);
+  mOwnedStream = aGraph->CreateTrackUnionStream();
   mOwnedStream->SetAutofinish(true);
   mOwnedStream->RegisterUser();
   if (mInputStream) {
@@ -948,8 +933,7 @@ DOMMediaStream::InitOwnedStreamCommon(MediaStreamGraph* aGraph)
 void
 DOMMediaStream::InitPlaybackStreamCommon(MediaStreamGraph* aGraph)
 {
-  MOZ_ASSERT(mAbstractMainThread);
+  mPlaybackStream = aGraph->CreateTrackUnionStream();
-  mPlaybackStream = aGraph->CreateTrackUnionStream(mAbstractMainThread);
   mPlaybackStream->SetAutofinish(true);
   mPlaybackStream->RegisterUser();
   if (mOwnedStream) {

dom/media/DOMMediaStream.h

@@ -590,8 +590,6 @@ public:
   // a dead pointer. Main thread only.
   void UnregisterTrackListener(TrackListener* aListener);
 
-  AbstractThread* AbstractMainThread() const { return mAbstractMainThread; }
-
 protected:
   virtual ~DOMMediaStream();
 
@@ -756,7 +754,6 @@ private:
   nsCOMPtr<nsIPrincipal> mVideoPrincipal;
   nsTArray<dom::PrincipalChangeObserver<DOMMediaStream>*> mPrincipalChangeObservers;
   CORSMode mCORSMode;
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 NS_DEFINE_STATIC_IID_ACCESSOR(DOMMediaStream,

dom/media/MediaManager.cpp

@@ -1084,8 +1084,7 @@ public:
       domStream =
         DOMMediaStream::CreateAudioCaptureStreamAsInput(window, principal, msg);
 
-      stream = msg->CreateSourceStream(
+      stream = msg->CreateSourceStream(); // Placeholder
-        globalWindow->AbstractMainThreadFor(TaskCategory::Other)); // Placeholder
       msg->RegisterCaptureStreamForWindow(
             mWindowID, domStream->GetInputStream()->AsProcessedStream());
       window->SetAudioCapture(true);

dom/media/MediaRecorder.cpp

@@ -433,7 +433,6 @@ public:
     , mIsStartEventFired(false)
     , mNeedSessionEndTask(true)
     , mSelectedVideoTrackID(TRACK_NONE)
-    , mAbstractMainThread(aRecorder->mAbstractMainThread)
   {
     MOZ_ASSERT(NS_IsMainThread());
 
@@ -489,7 +488,7 @@ public:
     // Create a Track Union Stream
     MediaStreamGraph* gm = mRecorder->GetSourceMediaStream()->Graph();
     TrackRate trackRate = gm->GraphRate();
-    mTrackUnionStream = gm->CreateTrackUnionStream(mAbstractMainThread);
+    mTrackUnionStream = gm->CreateTrackUnionStream();
     MOZ_ASSERT(mTrackUnionStream, "CreateTrackUnionStream failed");
 
     mTrackUnionStream->SetAutofinish(true);
@@ -952,7 +951,6 @@ private:
   // Main thread only.
   bool mNeedSessionEndTask;
   TrackID mSelectedVideoTrackID;
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 NS_IMPL_ISUPPORTS(MediaRecorder::Session, nsIObserver)
@@ -971,7 +969,6 @@ MediaRecorder::MediaRecorder(DOMMediaStream& aSourceMediaStream,
                              nsPIDOMWindowInner* aOwnerWindow)
   : DOMEventTargetHelper(aOwnerWindow)
   , mState(RecordingState::Inactive)
-  , mAbstractMainThread(aSourceMediaStream.AbstractMainThread())
 {
   MOZ_ASSERT(aOwnerWindow);
   MOZ_ASSERT(aOwnerWindow->IsInnerWindow());
@@ -985,7 +982,6 @@ MediaRecorder::MediaRecorder(AudioNode& aSrcAudioNode,
                              nsPIDOMWindowInner* aOwnerWindow)
   : DOMEventTargetHelper(aOwnerWindow)
   , mState(RecordingState::Inactive)
-  , mAbstractMainThread(aSrcAudioNode.AbstractMainThread())
 {
   MOZ_ASSERT(aOwnerWindow);
   MOZ_ASSERT(aOwnerWindow->IsInnerWindow());

dom/media/MediaRecorder.h

@@ -159,7 +159,6 @@ protected:
   uint32_t mVideoBitsPerSecond;
   uint32_t mBitsPerSecond;
 
-  const RefPtr<AbstractThread> mAbstractMainThread;
 private:
   // Register MediaRecorder into Document to listen the activity changes.
   void RegisterActivityObserver();

dom/media/MediaStreamGraph.cpp

@@ -1012,9 +1012,11 @@ MediaStreamGraphImpl::OpenAudioInput(int aID,
 {
   // So, so, so annoying.  Can't AppendMessage except on Mainthread
   if (!NS_IsMainThread()) {
-    RefPtr<nsIRunnable> runnable = WrapRunnable(this,
+    RefPtr<nsIRunnable> runnable =
-                                  &MediaStreamGraphImpl::OpenAudioInput,
+      WrapRunnable(this,
-                                  aID, RefPtr<AudioDataListener>(aListener));
+                   &MediaStreamGraphImpl::OpenAudioInput,
+                   aID,
+                   RefPtr<AudioDataListener>(aListener));
     mAbstractMainThread->Dispatch(runnable.forget());
     return NS_OK;
   }
@@ -1083,9 +1085,10 @@ MediaStreamGraphImpl::CloseAudioInput(AudioDataListener *aListener)
 {
   // So, so, so annoying.  Can't AppendMessage except on Mainthread
   if (!NS_IsMainThread()) {
-    RefPtr<nsIRunnable> runnable = WrapRunnable(this,
+    RefPtr<nsIRunnable> runnable =
-                                                &MediaStreamGraphImpl::CloseAudioInput,
+      WrapRunnable(this,
-                                                RefPtr<AudioDataListener>(aListener));
+                   &MediaStreamGraphImpl::CloseAudioInput,
+                   RefPtr<AudioDataListener>(aListener));
     mAbstractMainThread->Dispatch(runnable.forget());
     return;
   }
@@ -1889,7 +1892,7 @@ MediaStreamGraphImpl::Dispatch(already_AddRefed<nsIRunnable>&& aRunnable)
   mAbstractMainThread->Dispatch(Move(aRunnable));
 }
 
-MediaStream::MediaStream(AbstractThread* aMainThread)
+MediaStream::MediaStream()
   : mTracksStartTime(0)
   , mStartBlocking(GRAPH_TIME_MAX)
   , mSuspendedCount(0)
@@ -1905,7 +1908,6 @@ MediaStream::MediaStream(AbstractThread* aMainThread)
   , mNrOfMainThreadUsers(0)
   , mGraph(nullptr)
   , mAudioChannelType(dom::AudioChannel::Normal)
-  , mAbstractMainThread(aMainThread)
 {
   MOZ_COUNT_CTOR(MediaStream);
 }
@@ -2553,18 +2555,14 @@ MediaStream::RunAfterPendingUpdates(already_AddRefed<nsIRunnable> aRunnable)
 
   class Message : public ControlMessage {
   public:
-    Message(MediaStream* aStream,
+    Message(MediaStream* aStream, already_AddRefed<nsIRunnable> aRunnable)
-            already_AddRefed<nsIRunnable> aRunnable,
-            AbstractThread* aMainThread)
       : ControlMessage(aStream)
       , mRunnable(aRunnable)
-      , mAbstractMainThread(aMainThread)
+    {}
-      {}
     void Run() override
     {
-      mStream->Graph()->
+      mStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-        DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+        mRunnable.forget());
-                                                   mRunnable.forget());
     }
     void RunDuringShutdown() override
     {
@@ -2575,11 +2573,9 @@ MediaStream::RunAfterPendingUpdates(already_AddRefed<nsIRunnable> aRunnable)
     }
   private:
     nsCOMPtr<nsIRunnable> mRunnable;
-    const RefPtr<AbstractThread> mAbstractMainThread;
   };
 
-  graph->AppendMessage(
+  graph->AppendMessage(MakeUnique<Message>(this, runnable.forget()));
-    MakeUnique<Message>(this, runnable.forget(), mAbstractMainThread));
 }
 
 void
@@ -2691,16 +2687,16 @@ MediaStream::AddMainThreadListener(MainThreadMediaStreamListener* aListener)
   };
 
   nsCOMPtr<nsIRunnable> runnable = new NotifyRunnable(this);
-  mAbstractMainThread->Dispatch(runnable.forget());
+  GraphImpl()->Dispatch(runnable.forget());
 }
 
-SourceMediaStream::SourceMediaStream(AbstractThread* aMainThread) :
+SourceMediaStream::SourceMediaStream()
-  MediaStream(aMainThread),
+  : MediaStream()
-  mMutex("mozilla::media::SourceMediaStream"),
+  , mMutex("mozilla::media::SourceMediaStream")
-  mUpdateKnownTracksTime(0),
+  , mUpdateKnownTracksTime(0)
-  mPullEnabled(false),
+  , mPullEnabled(false)
-  mUpdateFinished(false),
+  , mUpdateFinished(false)
-  mNeedsMixing(false)
+  , mNeedsMixing(false)
 {
 }
 
@@ -3290,18 +3286,20 @@ MediaInputPort::BlockSourceTrackId(TrackID aTrackId, BlockingMode aBlockingMode)
     Message(MediaInputPort* aPort,
             TrackID aTrackId,
             BlockingMode aBlockingMode,
-            already_AddRefed<nsIRunnable> aRunnable,
+            already_AddRefed<nsIRunnable> aRunnable)
-            AbstractThread* aMainThread)
+      : ControlMessage(aPort->GetDestination())
-      : ControlMessage(aPort->GetDestination()),
+      , mPort(aPort)
-        mPort(aPort), mTrackId(aTrackId), mBlockingMode(aBlockingMode),
+      , mTrackId(aTrackId)
-        mRunnable(aRunnable), mAbstractMainThread(aMainThread) {}
+      , mBlockingMode(aBlockingMode)
+      , mRunnable(aRunnable)
+    {
+    }
     void Run() override
     {
       mPort->BlockSourceTrackIdImpl(mTrackId, mBlockingMode);
       if (mRunnable) {
-        mStream->Graph()->
+        mStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          mRunnable.forget());
-                                                     mRunnable.forget());
       }
     }
     void RunDuringShutdown() override
@@ -3312,7 +3310,6 @@ MediaInputPort::BlockSourceTrackId(TrackID aTrackId, BlockingMode aBlockingMode)
     TrackID mTrackId;
     BlockingMode mBlockingMode;
     nsCOMPtr<nsIRunnable> mRunnable;
-    const RefPtr<AbstractThread> mAbstractMainThread;
   };
 
   MOZ_ASSERT(IsTrackIDExplicit(aTrackId),
@@ -3324,9 +3321,8 @@ MediaInputPort::BlockSourceTrackId(TrackID aTrackId, BlockingMode aBlockingMode)
     pledge->Resolve(true);
     return NS_OK;
   });
-  GraphImpl()->AppendMessage(MakeUnique<Message>(this, aTrackId, aBlockingMode,
+  GraphImpl()->AppendMessage(
-                                                 runnable.forget(),
+    MakeUnique<Message>(this, aTrackId, aBlockingMode, runnable.forget()));
-                                                 mAbstractMainThread));
   return pledge.forget();
 }
 
@@ -3364,9 +3360,8 @@ ProcessedMediaStream::AllocateInputPort(MediaStream* aStream, TrackID aTrackID,
              "Only TRACK_ANY and explicit ID are allowed for destination track");
   MOZ_ASSERT(aTrackID != TRACK_ANY || aDestTrackID == TRACK_ANY,
              "Generic MediaInputPort cannot produce a single destination track");
-  RefPtr<MediaInputPort> port =
+  RefPtr<MediaInputPort> port = new MediaInputPort(
-    new MediaInputPort(aStream, aTrackID, this, aDestTrackID,
+    aStream, aTrackID, this, aDestTrackID, aInputNumber, aOutputNumber);
-                       aInputNumber, aOutputNumber, mAbstractMainThread);
   if (aBlockedTracks) {
     for (TrackID trackID : *aBlockedTracks) {
       port->BlockSourceTrackIdImpl(trackID, BlockingMode::CREATION);
@@ -3449,6 +3444,7 @@ MediaStreamGraphImpl::MediaStreamGraphImpl(GraphDriverType aDriverRequested,
   , mNonRealtimeProcessing(false)
   , mStreamOrderDirty(false)
   , mLatencyLog(AsyncLatencyLogger::Get())
+  , mAbstractMainThread(aMainThread)
 #ifdef MOZ_WEBRTC
   , mFarendObserverRef(nullptr)
 #endif
@@ -3457,7 +3453,6 @@ MediaStreamGraphImpl::MediaStreamGraphImpl(GraphDriverType aDriverRequested,
   , mCanRunMessagesSynchronously(false)
 #endif
   , mAudioChannel(aChannel)
-  , mAbstractMainThread(aMainThread)
 {
   if (mRealtime) {
     if (aDriverRequested == AUDIO_THREAD_DRIVER) {
@@ -3475,6 +3470,13 @@ MediaStreamGraphImpl::MediaStreamGraphImpl(GraphDriverType aDriverRequested,
   RegisterWeakAsyncMemoryReporter(this);
 }
 
+AbstractThread*
+MediaStreamGraph::AbstractMainThread()
+{
+  MOZ_ASSERT(static_cast<MediaStreamGraphImpl*>(this)->mAbstractMainThread);
+  return static_cast<MediaStreamGraphImpl*>(this)->mAbstractMainThread;
+}
+
 void
 MediaStreamGraphImpl::Destroy()
 {
@@ -3580,11 +3582,11 @@ MediaStreamGraph::CreateNonRealtimeInstance(TrackRate aSampleRate,
   NS_ASSERTION(NS_IsMainThread(), "Main thread only");
 
   nsCOMPtr<nsIGlobalObject> parentObject = do_QueryInterface(aWindow);
-  MediaStreamGraphImpl* graph =
+  MediaStreamGraphImpl* graph = new MediaStreamGraphImpl(
-    new MediaStreamGraphImpl(OFFLINE_THREAD_DRIVER,
+    OFFLINE_THREAD_DRIVER,
-                             aSampleRate,
+    aSampleRate,
-                             AudioChannel::Normal,
+    AudioChannel::Normal,
-                             parentObject->AbstractMainThreadFor(TaskCategory::Other));
+    parentObject->AbstractMainThreadFor(TaskCategory::Other));
 
   LOG(LogLevel::Debug, ("Starting up Offline MediaStreamGraph %p", graph));
 
@@ -3755,25 +3757,25 @@ FinishCollectReports(nsIHandleReportCallback* aHandleReport, nsISupports* aData,
 }
 
 SourceMediaStream*
-MediaStreamGraph::CreateSourceStream(AbstractThread* aMainThread)
+MediaStreamGraph::CreateSourceStream()
 {
-  SourceMediaStream* stream = new SourceMediaStream(aMainThread);
+  SourceMediaStream* stream = new SourceMediaStream();
   AddStream(stream);
   return stream;
 }
 
 ProcessedMediaStream*
-MediaStreamGraph::CreateTrackUnionStream(AbstractThread* aMainThread)
+MediaStreamGraph::CreateTrackUnionStream()
 {
-  TrackUnionStream* stream = new TrackUnionStream(aMainThread);
+  TrackUnionStream* stream = new TrackUnionStream();
   AddStream(stream);
   return stream;
 }
 
 ProcessedMediaStream*
-MediaStreamGraph::CreateAudioCaptureStream(TrackID aTrackId, AbstractThread* aMainThread)
+MediaStreamGraph::CreateAudioCaptureStream(TrackID aTrackId)
 {
-  AudioCaptureStream* stream = new AudioCaptureStream(aTrackId, aMainThread);
+  AudioCaptureStream* stream = new AudioCaptureStream(aTrackId);
   AddStream(stream);
   return stream;
 }
@@ -4176,14 +4178,12 @@ MediaStreamGraphImpl::ConnectToCaptureStream(uint64_t aWindowId,
 }
 
 void
-MediaStreamGraph::
+MediaStreamGraph::DispatchToMainThreadAfterStreamStateUpdate(
-DispatchToMainThreadAfterStreamStateUpdate(AbstractThread* aMainThread,
+  already_AddRefed<nsIRunnable> aRunnable)
-                                           already_AddRefed<nsIRunnable> aRunnable)
 {
-  MOZ_ASSERT(aMainThread);
   AssertOnGraphThreadOrNotRunning();
   *mPendingUpdateRunnables.AppendElement() =
-    aMainThread->CreateDirectTaskDrainer(Move(aRunnable));
+    AbstractMainThread()->CreateDirectTaskDrainer(Move(aRunnable));
 }
 
 } // namespace mozilla

dom/media/MediaStreamGraph.h

@@ -77,7 +77,6 @@ namespace media {
  * reprocess it. This is triggered automatically by the MediaStreamGraph.
  */
 
-class AbstractThread;
 class AudioNodeEngine;
 class AudioNodeExternalInputStream;
 class AudioNodeStream;
@@ -255,7 +254,7 @@ class MediaStream : public mozilla::LinkedListElement<MediaStream>
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(MediaStream)
 
-  explicit MediaStream(AbstractThread* aMainThread);
+  explicit MediaStream();
 
 protected:
   // Protected destructor, to discourage deletion outside of Release():
@@ -665,8 +664,6 @@ protected:
   MediaStreamGraphImpl* mGraph;
 
   dom::AudioChannel mAudioChannelType;
-
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 /**
@@ -678,7 +675,7 @@ protected:
 class SourceMediaStream : public MediaStream
 {
 public:
-  explicit SourceMediaStream(AbstractThread* aMainThread);
+  explicit SourceMediaStream();
 
   SourceMediaStream* AsSourceStream() override { return this; }
 
@@ -957,10 +954,12 @@ class MediaInputPort final
 {
 private:
   // Do not call this constructor directly. Instead call aDest->AllocateInputPort.
-  MediaInputPort(MediaStream* aSource, TrackID& aSourceTrack,
+  MediaInputPort(MediaStream* aSource,
-                 ProcessedMediaStream* aDest, TrackID& aDestTrack,
+                 TrackID& aSourceTrack,
-                 uint16_t aInputNumber, uint16_t aOutputNumber,
+                 ProcessedMediaStream* aDest,
-                 AbstractThread* aMainThread)
+                 TrackID& aDestTrack,
+                 uint16_t aInputNumber,
+                 uint16_t aOutputNumber)
     : mSource(aSource)
     , mSourceTrack(aSourceTrack)
     , mDest(aDest)
@@ -968,7 +967,6 @@ private:
     , mInputNumber(aInputNumber)
     , mOutputNumber(aOutputNumber)
     , mGraph(nullptr)
-    , mAbstractMainThread(aMainThread)
   {
     MOZ_COUNT_CTOR(MediaInputPort);
   }
@@ -1111,8 +1109,6 @@ private:
 
   // Our media stream graph
   MediaStreamGraphImpl* mGraph;
-
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 /**
@@ -1123,8 +1119,10 @@ private:
 class ProcessedMediaStream : public MediaStream
 {
 public:
-  explicit ProcessedMediaStream(AbstractThread* aMainThread)
+  explicit ProcessedMediaStream()
-    : MediaStream(aMainThread), mAutofinish(false), mCycleMarker(0)
+    : MediaStream()
+    , mAutofinish(false)
+    , mCycleMarker(0)
   {}
 
   // Control API.
@@ -1248,7 +1246,7 @@ protected:
 };
 
 /**
- * There can be multiple MediaStreamGraph per process: one per AudioChannel.
+ * There is a single MediaStreamGraph per window.
  * Additionaly, each OfflineAudioContext object creates its own MediaStreamGraph
  * object too..
  */
@@ -1277,8 +1275,14 @@ public:
   static MediaStreamGraph* GetInstance(GraphDriverType aGraphDriverRequested,
                                        dom::AudioChannel aChannel,
                                        nsPIDOMWindowInner* aWindow);
-  static MediaStreamGraph* CreateNonRealtimeInstance(TrackRate aSampleRate,
+  static MediaStreamGraph* CreateNonRealtimeInstance(
-                                                     nsPIDOMWindowInner* aWindowId);
+    TrackRate aSampleRate,
+    nsPIDOMWindowInner* aWindowId);
+
+  // Return the correct main thread for this graph. This always returns
+  // something that is valid. Thread safe.
+  AbstractThread* AbstractMainThread();
+
   // Idempotent
   static void DestroyNonRealtimeInstance(MediaStreamGraph* aGraph);
 
@@ -1293,7 +1297,7 @@ public:
    * Create a stream that a media decoder (or some other source of
    * media data, such as a camera) can write to.
    */
-  SourceMediaStream* CreateSourceStream(AbstractThread* aMainThread);
+  SourceMediaStream* CreateSourceStream();
   /**
    * Create a stream that will form the union of the tracks of its input
    * streams.
@@ -1308,12 +1312,11 @@ public:
    * TODO at some point we will probably need to add API to select
    * particular tracks of each input stream.
    */
-  ProcessedMediaStream* CreateTrackUnionStream(AbstractThread* aMainThread);
+  ProcessedMediaStream* CreateTrackUnionStream();
   /**
    * Create a stream that will mix all its audio input.
    */
-  ProcessedMediaStream* CreateAudioCaptureStream(TrackID aTrackId,
+  ProcessedMediaStream* CreateAudioCaptureStream(TrackID aTrackId);
-                                                 AbstractThread* aMainThread);
 
   /**
    * Add a new stream to the graph.  Main thread.
@@ -1351,19 +1354,9 @@ public:
    *
    * Should only be called during MediaStreamListener callbacks or during
    * ProcessedMediaStream::ProcessInput().
-   *
-   * |aMainThread| is the corresponding AbstractThread on the main thread to
-   * drain the direct tasks generated by |aRunnable|.
-   * Note: The reasons for assigning proper |aMainThread| are
-   * - MSG serves media elements in multiple windows run on main thread.
-   * - DocGroup-specific AbstractMainThread is introduced to cluster the tasks
-   *   of the same window for prioritizing tasks among different windows.
-   * - Proper |aMainThread| ensures that tasks dispatched to the main thread are
-   *   clustered to the right queue and are executed in right order.
    */
-  virtual void
+  virtual void DispatchToMainThreadAfterStreamStateUpdate(
-  DispatchToMainThreadAfterStreamStateUpdate(AbstractThread* aMainThread,
+    already_AddRefed<nsIRunnable> aRunnable);
-                                             already_AddRefed<nsIRunnable> aRunnable);
 
   /**
    * Returns graph sample rate in Hz.

dom/media/MediaStreamGraphImpl.h

@@ -812,6 +812,7 @@ public:
    */
   RefPtr<AsyncLatencyLogger> mLatencyLog;
   AudioMixer mMixer;
+  const RefPtr<AbstractThread> mAbstractMainThread;
 #ifdef MOZ_WEBRTC
   RefPtr<AudioOutputObserver> mFarendObserverRef;
 #endif
@@ -853,7 +854,6 @@ private:
 #endif
 
   dom::AudioChannel mAudioChannel;
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 } // namespace mozilla

dom/media/MediaStreamTrack.cpp

@@ -88,7 +88,6 @@ class MediaStreamTrack::PrincipalHandleListener : public MediaStreamTrackListene
 public:
   explicit PrincipalHandleListener(MediaStreamTrack* aTrack)
     : mTrack(aTrack)
-    , mAbstractMainThread(aTrack->mOwningStream->AbstractMainThread())
     {}
 
   void Forget()
@@ -112,7 +111,6 @@ public:
                                     const PrincipalHandle& aNewPrincipalHandle) override
   {
     aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-      mAbstractMainThread,
       NewRunnableMethod<StoreCopyPassByConstLRef<PrincipalHandle>>(
         "dom::MediaStreamTrack::PrincipalHandleListener::"
         "DoNotifyPrincipalHandleChanged",
@@ -124,7 +122,6 @@ public:
 protected:
   // These fields may only be accessed on the main thread
   MediaStreamTrack* mTrack;
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 MediaStreamTrack::MediaStreamTrack(DOMMediaStream* aStream, TrackID aTrackID,

dom/media/TrackUnionStream.cpp

@@ -46,8 +46,9 @@ namespace mozilla {
 LazyLogModule gTrackUnionStreamLog("TrackUnionStream");
 #define STREAM_LOG(type, msg) MOZ_LOG(gTrackUnionStreamLog, type, msg)
 
-TrackUnionStream::TrackUnionStream(AbstractThread* aMainThread) :
+TrackUnionStream::TrackUnionStream()
-  ProcessedMediaStream(aMainThread), mNextAvailableTrackID(1)
+  : ProcessedMediaStream()
+  , mNextAvailableTrackID(1)
 {
 }
 

dom/media/TrackUnionStream.h

@@ -17,7 +17,7 @@ namespace mozilla {
  */
 class TrackUnionStream : public ProcessedMediaStream {
 public:
-  explicit TrackUnionStream(AbstractThread* aMainThread);
+  explicit TrackUnionStream();
 
   virtual TrackUnionStream* AsTrackUnionStream() override { return this; }
   friend class DOMMediaStream;

dom/media/mediasink/DecodedStream.cpp

@@ -59,7 +59,6 @@ public:
   {
     if (event == MediaStreamGraphEvent::EVENT_FINISHED) {
       aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-        mAbstractMainThread,
         NewRunnableMethod("DecodedStreamGraphListener::DoNotifyFinished",
                           this,
                           &DecodedStreamGraphListener::DoNotifyFinished));
@@ -183,7 +182,7 @@ DecodedStreamData::DecodedStreamData(OutputStreamManager* aOutputStreamManager,
   , mHaveSentFinish(false)
   , mHaveSentFinishAudio(false)
   , mHaveSentFinishVideo(false)
-  , mStream(aOutputStreamManager->Graph()->CreateSourceStream(aMainThread))
+  , mStream(aOutputStreamManager->Graph()->CreateSourceStream())
   // DecodedStreamGraphListener will resolve this promise.
   , mListener(new DecodedStreamGraphListener(mStream, Move(aPromise), aMainThread))
   // mPlaying is initially true because MDSM won't start playback until playing

dom/media/webaudio/AudioDestinationNode.cpp

@@ -168,8 +168,7 @@ public:
 
     aNode->ResolvePromise(renderedBuffer);
 
-    mAbstractMainThread->Dispatch(do_AddRef(new OnCompleteTask(context,
+    context->Dispatch(do_AddRef(new OnCompleteTask(context, renderedBuffer)));
-                                                               renderedBuffer)));
 
     context->OnStateChanged(nullptr, AudioContextState::Closed);
   }
@@ -261,9 +260,8 @@ public:
 
       RefPtr<InputMutedRunnable> runnable =
         new InputMutedRunnable(aStream, newInputMuted);
-      aStream->Graph()->
+      aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-        DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+        runnable.forget());
-                                                   runnable.forget());
     }
   }
 
@@ -336,9 +334,11 @@ AudioDestinationNode::AudioDestinationNode(AudioContext* aContext,
   , mAudible(AudioChannelService::AudibleState::eAudible)
 {
   nsPIDOMWindowInner* window = aContext->GetParentObject();
-  MediaStreamGraph* graph = aIsOffline ?
+  MediaStreamGraph* graph =
-                            MediaStreamGraph::CreateNonRealtimeInstance(aSampleRate, window) :
+    aIsOffline
-                            MediaStreamGraph::GetInstance(MediaStreamGraph::AUDIO_THREAD_DRIVER, aChannel, window);
+      ? MediaStreamGraph::CreateNonRealtimeInstance(aSampleRate, window)
+      : MediaStreamGraph::GetInstance(
+          MediaStreamGraph::AUDIO_THREAD_DRIVER, aChannel, window);
   AudioNodeEngine* engine = aIsOffline ?
                             new OfflineDestinationNodeEngine(this, aNumberOfChannels,
                                                              aLength, aSampleRate) :

dom/media/webaudio/AudioNodeExternalInputStream.cpp

@@ -15,8 +15,9 @@ using namespace mozilla::dom;
 namespace mozilla {
 
 AudioNodeExternalInputStream::AudioNodeExternalInputStream(
-  AudioNodeEngine* aEngine, TrackRate aSampleRate, AbstractThread* aMainThread)
+  AudioNodeEngine* aEngine,
-  : AudioNodeStream(aEngine, NO_STREAM_FLAGS, aSampleRate, aMainThread)
+  TrackRate aSampleRate)
+  : AudioNodeStream(aEngine, NO_STREAM_FLAGS, aSampleRate)
 {
   MOZ_COUNT_CTOR(AudioNodeExternalInputStream);
 }
@@ -28,15 +29,14 @@ AudioNodeExternalInputStream::~AudioNodeExternalInputStream()
 
 /* static */ already_AddRefed<AudioNodeExternalInputStream>
 AudioNodeExternalInputStream::Create(MediaStreamGraph* aGraph,
-                                     AudioNodeEngine* aEngine,
+                                     AudioNodeEngine* aEngine)
-                                     AbstractThread* aMainThread)
 {
   AudioContext* ctx = aEngine->NodeMainThread()->Context();
   MOZ_ASSERT(NS_IsMainThread());
   MOZ_ASSERT(aGraph->GraphRate() == ctx->SampleRate());
 
   RefPtr<AudioNodeExternalInputStream> stream =
-    new AudioNodeExternalInputStream(aEngine, aGraph->GraphRate(), aMainThread);
+    new AudioNodeExternalInputStream(aEngine, aGraph->GraphRate());
   stream->mSuspendedCount += ctx->ShouldSuspendNewStream();
   aGraph->AddStream(stream);
   return stream.forget();

dom/media/webaudio/AudioNodeExternalInputStream.h

@@ -23,12 +23,12 @@ class AbstractThread;
 class AudioNodeExternalInputStream final : public AudioNodeStream
 {
 public:
-  static already_AddRefed<AudioNodeExternalInputStream>
+  static already_AddRefed<AudioNodeExternalInputStream> Create(
-  Create(MediaStreamGraph* aGraph, AudioNodeEngine* aEngine, AbstractThread* aMainThread);
+    MediaStreamGraph* aGraph,
+    AudioNodeEngine* aEngine);
 
 protected:
-  AudioNodeExternalInputStream(AudioNodeEngine* aEngine, TrackRate aSampleRate,
+  AudioNodeExternalInputStream(AudioNodeEngine* aEngine, TrackRate aSampleRate);
-                               AbstractThread* aMainThread);
   ~AudioNodeExternalInputStream();
 
 public:

dom/media/webaudio/AudioNodeStream.cpp

@@ -29,17 +29,16 @@ namespace mozilla {
 
 AudioNodeStream::AudioNodeStream(AudioNodeEngine* aEngine,
                                  Flags aFlags,
-                                 TrackRate aSampleRate,
+                                 TrackRate aSampleRate)
-                                 AbstractThread* aMainThread)
+  : ProcessedMediaStream()
-  : ProcessedMediaStream(aMainThread),
+  , mEngine(aEngine)
-    mEngine(aEngine),
+  , mSampleRate(aSampleRate)
-    mSampleRate(aSampleRate),
+  , mFlags(aFlags)
-    mFlags(aFlags),
+  , mNumberOfInputChannels(2)
-    mNumberOfInputChannels(2),
+  , mIsActive(aEngine->IsActive())
-    mIsActive(aEngine->IsActive()),
+  , mMarkAsFinishedAfterThisBlock(false)
-    mMarkAsFinishedAfterThisBlock(false),
+  , mAudioParamStream(false)
-    mAudioParamStream(false),
+  , mPassThrough(false)
-    mPassThrough(false)
 {
   MOZ_ASSERT(NS_IsMainThread());
   mSuspendedCount = !(mIsActive || mFlags & EXTERNAL_OUTPUT);
@@ -78,8 +77,7 @@ AudioNodeStream::Create(AudioContext* aCtx, AudioNodeEngine* aEngine,
   AudioNode* node = aEngine->NodeMainThread();
 
   RefPtr<AudioNodeStream> stream =
-    new AudioNodeStream(aEngine, aFlags, aGraph->GraphRate(),
+    new AudioNodeStream(aEngine, aFlags, aGraph->GraphRate());
-      aCtx->GetOwnerGlobal()->AbstractMainThreadFor(TaskCategory::Other));
   stream->mSuspendedCount += aCtx->ShouldSuspendNewStream();
   if (node) {
     stream->SetChannelMixingParametersImpl(node->ChannelCount(),

dom/media/webaudio/AudioNodeStream.h

@@ -76,8 +76,7 @@ protected:
    */
   AudioNodeStream(AudioNodeEngine* aEngine,
                   Flags aFlags,
-                  TrackRate aSampleRate,
+                  TrackRate aSampleRate);
-                  AbstractThread* aMainThread);
 
   ~AudioNodeStream();
 

dom/media/webaudio/BiquadFilterNode.cpp

@@ -159,9 +159,8 @@ public:
 
           RefPtr<PlayingRefChangeHandler> refchanged =
             new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::RELEASE);
-          aStream->Graph()->
+          aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-            DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+            refchanged.forget());
-                                                       refchanged.forget());
         }
 
         aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
@@ -174,9 +173,8 @@ public:
       if (mBiquads.IsEmpty()) {
         RefPtr<PlayingRefChangeHandler> refchanged =
           new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::ADDREF);
-        aStream->Graph()->
+        aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          refchanged.forget());
-                                                     refchanged.forget());
       } else { // Help people diagnose bug 924718
         WebAudioUtils::LogToDeveloperConsole(mWindowID,
                                              "BiquadFilterChannelCountChangeWarning");

dom/media/webaudio/ConvolverNode.cpp

@@ -125,9 +125,8 @@ public:
           aStream->ScheduleCheckForInactive();
           RefPtr<PlayingRefChanged> refchanged =
             new PlayingRefChanged(aStream, PlayingRefChanged::RELEASE);
-          aStream->Graph()->
+          aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-            DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+            refchanged.forget());
-                                                       refchanged.forget());
         }
         aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
         return;
@@ -147,9 +146,8 @@ public:
       if (mLeftOverData <= 0) {
         RefPtr<PlayingRefChanged> refchanged =
           new PlayingRefChanged(aStream, PlayingRefChanged::ADDREF);
-        aStream->Graph()->
+        aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          refchanged.forget());
-                                                     refchanged.forget());
       }
       mLeftOverData = mBufferLength;
       MOZ_ASSERT(mLeftOverData > 0);

dom/media/webaudio/DelayNode.cpp

@@ -82,9 +82,8 @@ public:
       if (mLeftOverData <= 0) {
         RefPtr<PlayingRefChanged> refchanged =
           new PlayingRefChanged(aStream, PlayingRefChanged::ADDREF);
-        aStream->Graph()->
+        aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          refchanged.forget());
-                                                     refchanged.forget());
       }
       mLeftOverData = mBuffer.MaxDelayTicks();
     } else if (mLeftOverData > 0) {
@@ -99,9 +98,8 @@ public:
 
         RefPtr<PlayingRefChanged> refchanged =
           new PlayingRefChanged(aStream, PlayingRefChanged::RELEASE);
-        aStream->Graph()->
+        aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          refchanged.forget());
-                                                     refchanged.forget());
       }
       aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
       return;

dom/media/webaudio/IIRFilterNode.cpp

@@ -56,9 +56,8 @@ public:
 
           RefPtr<PlayingRefChangeHandler> refchanged =
             new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::RELEASE);
-          aStream->Graph()->
+          aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-            DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+            refchanged.forget());
-                                                       refchanged.forget());
 
           aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
           return;
@@ -70,9 +69,8 @@ public:
       if (mIIRFilters.IsEmpty()) {
         RefPtr<PlayingRefChangeHandler> refchanged =
           new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::ADDREF);
-        aStream->Graph()->
+        aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          refchanged.forget());
-                                                     refchanged.forget());
       } else {
         WebAudioUtils::LogToDeveloperConsole(mWindowID,
                                              "IIRFilterChannelCountChangeWarning");

dom/media/webaudio/MediaStreamAudioSourceNode.cpp

@@ -84,9 +84,7 @@ MediaStreamAudioSourceNode::Init(DOMMediaStream* aMediaStream, ErrorResult& aRv)
 
   mInputStream = aMediaStream;
   AudioNodeEngine* engine = new MediaStreamAudioSourceNodeEngine(this);
-  mStream =
+  mStream = AudioNodeExternalInputStream::Create(graph, engine);
-    AudioNodeExternalInputStream::Create(graph, engine,
-                                         aMediaStream->AbstractMainThread());
   mInputStream->AddConsumerToKeepAlive(static_cast<nsIDOMEventTarget*>(this));
 
   mInputStream->RegisterTrackListener(this);

dom/media/webaudio/PannerNode.cpp

@@ -208,9 +208,8 @@ public:
 
           RefPtr<PlayingRefChangeHandler> refchanged =
             new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::RELEASE);
-          aStream->Graph()->
+          aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+            refchanged.forget());
-                                                     refchanged.forget());
         }
         aOutput->SetNull(WEBAUDIO_BLOCK_SIZE);
         return;
@@ -219,9 +218,8 @@ public:
       if (mLeftOverData == INT_MIN) {
         RefPtr<PlayingRefChangeHandler> refchanged =
           new PlayingRefChangeHandler(aStream, PlayingRefChangeHandler::ADDREF);
-        aStream->Graph()->
+        aStream->Graph()->DispatchToMainThreadAfterStreamStateUpdate(
-          DispatchToMainThreadAfterStreamStateUpdate(mAbstractMainThread,
+          refchanged.forget());
-                                                     refchanged.forget());
       }
       mLeftOverData = mHRTFPanner->maxTailFrames();
     }

dom/media/webspeech/synth/nsSpeechTask.cpp

@@ -37,7 +37,6 @@ public:
     : mSpeechTask(aSpeechTask)
     , mStream(aStream)
     , mStarted(false)
-    , mAbstractMainThread(aMainThread)
   {
   }
 
@@ -65,14 +64,12 @@ public:
           if (!mStarted) {
             mStarted = true;
             aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-              mAbstractMainThread,
               NewRunnableMethod("dom::SynthStreamListener::DoNotifyStarted",
                                 this,
                                 &SynthStreamListener::DoNotifyStarted));
           }
 
           aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-            mAbstractMainThread,
             NewRunnableMethod("dom::SynthStreamListener::DoNotifyFinished",
                               this,
                               &SynthStreamListener::DoNotifyFinished));
@@ -93,7 +90,6 @@ public:
     if (aBlocked == MediaStreamListener::UNBLOCKED && !mStarted) {
       mStarted = true;
       aGraph->DispatchToMainThreadAfterStreamStateUpdate(
-        mAbstractMainThread,
         NewRunnableMethod("dom::SynthStreamListener::DoNotifyStarted",
                           this,
                           &SynthStreamListener::DoNotifyStarted));
@@ -108,8 +104,6 @@ private:
   RefPtr<MediaStream> mStream;
 
   bool mStarted;
-
-  const RefPtr<AbstractThread> mAbstractMainThread;
 };
 
 // nsSpeechTask
@@ -176,7 +170,7 @@ nsSpeechTask::InitDirectAudio()
   // This is a global MSG.
   mStream = MediaStreamGraph::GetInstance(MediaStreamGraph::AUDIO_THREAD_DRIVER,
                                           AudioChannel::Normal, nullptr)->
-    CreateSourceStream(AbstractThread::MainThread() /* Non DocGroup-version for the task in parent. */);
+    CreateSourceStream();
   mIndirectAudio = false;
   mInited = true;
 }

media/webrtc/signaling/gtest/mediapipeline_unittest.cpp

@@ -43,7 +43,7 @@ class FakeSourceMediaStream : public mozilla::SourceMediaStream {
 public:
 
   FakeSourceMediaStream()
-    : SourceMediaStream(nullptr)
+    : SourceMediaStream()
   {
   }