--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -915,17 +915,17 @@ public:
     RefPtr<Wrapper> self = this;
     mTaskQueue->Dispatch(NS_NewRunnableFunction([self]() {
       self->mTrackDemuxer->Reset();
     }));
   }
 
   nsresult GetNextRandomAccessPoint(TimeUnit* aTime) override
   {
-    MutexAutoLock lock(mMutex);
+    AutoLock lock(this, __func__);
     if (NS_SUCCEEDED(mNextRandomAccessPointResult)) {
       *aTime = mNextRandomAccessPoint;
     }
     return mNextRandomAccessPointResult;
   }
 
   RefPtr<SkipAccessPointPromise>
   SkipToNextRandomAccessPoint(const media::TimeUnit& aTimeThreshold) override
@@ -939,62 +939,83 @@ public:
              })
       ->Then(mTaskQueue, __func__,
              [self]() { self->UpdateRandomAccessPoint(); },
              [self]() { self->UpdateRandomAccessPoint(); });
   }
 
   TimeIntervals GetBuffered() override
   {
-    MutexAutoLock lock(mMutex);
+    AutoLock lock(this, __func__);
     return mBuffered;
   }
 
   void BreakCycles() override { }
 
 private:
+  class AutoLock : public MutexAutoLock
+  {
+  public:
+    AutoLock(Wrapper* aThis, const char* aCallSite)
+      : MutexAutoLock(aThis->mMutex)
+      , mThis(aThis)
+    {
+      mThis->mCallSite = aCallSite;
+    }
+    ~AutoLock()
+    {
+      mThis->mCallSite = nullptr;
+    }
+  private:
+    Wrapper* const mThis;
+  };
+
   Mutex mMutex;
+  const char* mCallSite = nullptr;
   const RefPtr<AutoTaskQueue> mTaskQueue;
   const bool mGetSamplesMayBlock;
   const UniquePtr<TrackInfo> mInfo;
   // mTrackDemuxer is only ever accessed on demuxer's task queue.
   RefPtr<MediaTrackDemuxer> mTrackDemuxer;
   // All following members are protected by mMutex
   nsresult mNextRandomAccessPointResult = NS_OK;
   TimeUnit mNextRandomAccessPoint;
   TimeIntervals mBuffered;
   friend class DemuxerProxy;
 
   ~Wrapper()
   {
+    if (mCallSite != nullptr) {
+      MOZ_CRASH_UNSAFE_PRINTF("destroying a still-owned lock! callsite=%s", mCallSite);
+    }
     RefPtr<MediaTrackDemuxer> trackDemuxer = mTrackDemuxer.forget();
     mTaskQueue->Dispatch(NS_NewRunnableFunction(
       [trackDemuxer]() { trackDemuxer->BreakCycles(); }));
   }
 
   void UpdateRandomAccessPoint()
   {
     MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
     if (!mTrackDemuxer) {
       // Detached.
       return;
     }
-    MutexAutoLock lock(mMutex);
+    AutoLock lock(this, __func__);
     mNextRandomAccessPointResult =
       mTrackDemuxer->GetNextRandomAccessPoint(&mNextRandomAccessPoint);
   }
 
   void UpdateBuffered()
   {
     MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
     if (!mTrackDemuxer) {
       // Detached.
       return;
     }
-    MutexAutoLock lock(mMutex);
+    AutoLock lock(this, __func__);
     mBuffered = mTrackDemuxer->GetBuffered();
   }
 };
 
 RefPtr<MediaDataDemuxer::InitPromise>
 MediaFormatReader::DemuxerProxy::Init()
 {
   RefPtr<Data> data = mData;