--- a/dom/media/Benchmark.cpp
+++ b/dom/media/Benchmark.cpp
@@ -26,16 +26,18 @@ VP9Benchmark::IsVP9DecodeFast()
   bool hasPref = Preferences::HasUserValue(sBenchmarkFpsPref);
 
   if (!sHasRunTest && !hasPref) {
     sHasRunTest = true;
 
     RefPtr<WebMDemuxer> demuxer =
       new WebMDemuxer(new BufferMediaResource(sWebMSample, sizeof(sWebMSample), nullptr,
                                               NS_LITERAL_CSTRING("video/webm")));
+    PDMFactory::Init();
+
     RefPtr<Benchmark> estimiser =
       new Benchmark(demuxer,
                     {
                       Preferences::GetInt("media.benchmark.frames", 300), // frames to measure
                       1, // start benchmarking after decoding this frame.
                       8, // loop after decoding that many frames.
                       TimeDuration::FromMilliseconds(
                         Preferences::GetUint("media.benchmark.timeout", 1000))
@@ -56,70 +58,79 @@ VP9Benchmark::IsVP9DecodeFast()
   uint32_t decodeFps = Preferences::GetUint(sBenchmarkFpsPref);
   uint32_t threshold =
     Preferences::GetUint("media.benchmark.vp9.threshold", 150);
 
   return decodeFps >= threshold;
 }
 
 Benchmark::Benchmark(MediaDataDemuxer* aDemuxer, const Parameters& aParameters)
-  : QueueObject(AbstractThread::MainThread())
+  : QueueObject(AbstractThread::GetCurrent())
   , mParameters(aParameters)
   , mKeepAliveUntilComplete(this)
   , mPlaybackState(this, aDemuxer)
 {
   MOZ_COUNT_CTOR(Benchmark);
-  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(Thread(), "Must be run in task queue");
 }
 
 Benchmark::~Benchmark()
 {
   MOZ_COUNT_DTOR(Benchmark);
 }
 
 RefPtr<Benchmark::BenchmarkPromise>
 Benchmark::Run()
 {
+  MOZ_ASSERT(OnThread());
+
   RefPtr<BenchmarkPromise> p = mPromise.Ensure(__func__);
   RefPtr<Benchmark> self = this;
   mPlaybackState.Dispatch(
     NS_NewRunnableFunction([self]() { self->mPlaybackState.DemuxSamples(); }));
   return p;
 }
 
 void
 Benchmark::ReturnResult(uint32_t aDecodeFps)
 {
-  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(OnThread());
 
   mPromise.ResolveIfExists(aDecodeFps, __func__);
 }
 
 void
 Benchmark::Dispose()
 {
-  MOZ_ASSERT(NS_IsMainThread());
+  MOZ_ASSERT(OnThread());
 
   mKeepAliveUntilComplete = nullptr;
   mPromise.RejectIfExists(false, __func__);
 }
 
+void
+Benchmark::Init()
+{
+  MOZ_ASSERT(NS_IsMainThread());
+
+  PDMFactory::Init();
+}
+
 BenchmarkPlayback::BenchmarkPlayback(Benchmark* aMainThreadState,
                                      MediaDataDemuxer* aDemuxer)
   : QueueObject(new TaskQueue(GetMediaThreadPool(MediaThreadType::PLAYBACK)))
   , mMainThreadState(aMainThreadState)
   , mDecoderTaskQueue(new FlushableTaskQueue(GetMediaThreadPool(
                         MediaThreadType::PLATFORM_DECODER)))
   , mDemuxer(aDemuxer)
   , mSampleIndex(0)
   , mFrameCount(0)
   , mFinished(false)
 {
-  MOZ_ASSERT(NS_IsMainThread());
-  PDMFactory::Init();
+  MOZ_ASSERT(static_cast<Benchmark*>(mMainThreadState)->OnThread());
 }
 
 void
 BenchmarkPlayback::DemuxSamples()
 {
   MOZ_ASSERT(OnThread());
 
   RefPtr<Benchmark> ref(mMainThreadState);

--- a/dom/media/Benchmark.h
+++ b/dom/media/Benchmark.h
@@ -17,47 +17,48 @@
 
 namespace mozilla {
 
 class FlushableTaskQueue;
 class Benchmark;
 
 class BenchmarkPlayback : public QueueObject, private MediaDataDecoderCallback
 {
-public:
+  friend class Benchmark;
   explicit BenchmarkPlayback(Benchmark* aMainThreadState, MediaDataDemuxer* aDemuxer);
   void DemuxSamples();
   void DemuxNextSample();
   void MainThreadShutdown();
   void InitDecoder(TrackInfo&& aInfo);
 
   // MediaDataDecoderCallback
   // Those methods are called on the MediaDataDecoder's task queue.
   void Output(MediaData* aData) override;
   void Error() override;
   void InputExhausted() override;
   void DrainComplete() override;
   bool OnReaderTaskQueue() override;
 
-private:
   Atomic<Benchmark*> mMainThreadState;
 
   RefPtr<FlushableTaskQueue> mDecoderTaskQueue;
   RefPtr<MediaDataDecoder> mDecoder;
 
   // Object only accessed on Thread()
   RefPtr<MediaDataDemuxer> mDemuxer;
   RefPtr<MediaTrackDemuxer> mTrackDemuxer;
   nsTArray<RefPtr<MediaRawData>> mSamples;
   size_t mSampleIndex;
   TimeStamp mDecodeStartTime;
   uint32_t mFrameCount;
   bool mFinished;
 };
 
+// Init() must have been called at least once prior on the
+// main thread.
 class Benchmark : public QueueObject
 {
 public:
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Benchmark)
 
   struct Parameters
   {
     Parameters()
@@ -79,23 +80,25 @@ public:
     const Maybe<int32_t> mStopAtFrame;
     const TimeDuration mTimeout;
   };
 
   typedef MozPromise<uint32_t, bool, /* IsExclusive = */ true> BenchmarkPromise;
 
   explicit Benchmark(MediaDataDemuxer* aDemuxer, const Parameters& aParameters = Parameters());
   RefPtr<BenchmarkPromise> Run();
+
+  static void Init();
+
+private:
+  friend class BenchmarkPlayback;
+  virtual ~Benchmark();
   void ReturnResult(uint32_t aDecodeFps);
   void Dispose();
-
   const Parameters mParameters;
-
-private:
-  virtual ~Benchmark();
   RefPtr<Benchmark> mKeepAliveUntilComplete;
   BenchmarkPlayback mPlaybackState;
   MozPromiseHolder<BenchmarkPromise> mPromise;
 };
 
 class VP9Benchmark
 {
 public: