--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -914,17 +914,17 @@ public:
     RefPtr<Wrapper> self = this;
     mTaskQueue->Dispatch(NS_NewRunnableFunction([self]() {
       self->mTrackDemuxer->Reset();
     }));
   }
 
   nsresult GetNextRandomAccessPoint(TimeUnit* aTime) override
   {
-    AutoLock lock(this, __func__);
+    MutexAutoLock lock(mMutex);
     if (NS_SUCCEEDED(mNextRandomAccessPointResult)) {
       *aTime = mNextRandomAccessPoint;
     }
     return mNextRandomAccessPointResult;
   }
 
   RefPtr<SkipAccessPointPromise>
   SkipToNextRandomAccessPoint(const media::TimeUnit& aTimeThreshold) override
@@ -938,83 +938,62 @@ public:
              })
       ->Then(mTaskQueue, __func__,
              [self]() { self->UpdateRandomAccessPoint(); },
              [self]() { self->UpdateRandomAccessPoint(); });
   }
 
   TimeIntervals GetBuffered() override
   {
-    AutoLock lock(this, __func__);
+    MutexAutoLock lock(mMutex);
     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;
     }
-    AutoLock lock(this, __func__);
+    MutexAutoLock lock(mMutex);
     mNextRandomAccessPointResult =
       mTrackDemuxer->GetNextRandomAccessPoint(&mNextRandomAccessPoint);
   }
 
   void UpdateBuffered()
   {
     MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
     if (!mTrackDemuxer) {
       // Detached.
       return;
     }
-    AutoLock lock(this, __func__);
+    MutexAutoLock lock(mMutex);
     mBuffered = mTrackDemuxer->GetBuffered();
   }
 };
 
 RefPtr<MediaDataDemuxer::InitPromise>
 MediaFormatReader::DemuxerProxy::Init()
 {
   RefPtr<Data> data = mData;