--- a/accessible/ipc/win/HandlerProvider.h
+++ b/accessible/ipc/win/HandlerProvider.h
@@ -110,17 +110,17 @@ class HandlerProvider final : public IGe
                                 IA2TextSegment** aAttribRuns,
                                 long* aNAttribRuns, HRESULT* result);
   void GetRelationsInfoMainThread(IARelationData** aRelations,
                                   long* aNRelations, HRESULT* result);
   void GetAllChildrenMainThread(AccChildData** aChildren, ULONG* aNChildren,
                                 HRESULT* result);
 
   Atomic<uint32_t> mRefCnt;
-  Mutex mMutex;  // Protects mSerializer
+  Mutex mMutex MOZ_UNANNOTATED;  // Protects mSerializer
   const IID mTargetUnkIid;
   mscom::InterceptorTargetPtr<IUnknown>
       mTargetUnk;  // Constant, main thread only
   UniquePtr<mscom::StructToStream> mSerializer;
   RefPtr<IUnknown> mFastMarshalUnk;
 
   struct IA2PayloadDeleter {
     void operator()(IA2Payload* aPayload) {
@@ -131,15 +131,15 @@ class HandlerProvider final : public IGe
       delete aPayload;
     }
   };
   using IA2PayloadPtr = UniquePtr<IA2Payload, IA2PayloadDeleter>;
 
   // Used when the payload is built prior to marshaling the object by a bulk
   // fetch operation. See prebuildPayload().
   IA2PayloadPtr mPayload;
-  Mutex mPayloadMutex;  // Protects mPayload
+  Mutex mPayloadMutex MOZ_UNANNOTATED;  // Protects mPayload
 };
 
 }  // namespace a11y
 }  // namespace mozilla
 
 #endif  // mozilla_a11y_HandlerProvider_h

--- a/docshell/base/timeline/MarkersStorage.h
+++ b/docshell/base/timeline/MarkersStorage.h
@@ -35,14 +35,14 @@ class MarkersStorage : public LinkedList
   virtual void ClearMarkers() = 0;
   virtual void PopMarkers(JSContext* aCx,
                           nsTArray<dom::ProfileTimelineMarker>& aStore) = 0;
 
  protected:
   Mutex& GetLock();
 
  private:
-  Mutex mLock;
+  Mutex mLock MOZ_UNANNOTATED;
 };
 
 }  // namespace mozilla
 
 #endif /* mozilla_MarkersStorage_h_ */

--- a/docshell/base/timeline/TimelineConsumers.h
+++ b/docshell/base/timeline/TimelineConsumers.h
@@ -118,14 +118,14 @@ class TimelineConsumers : public nsIObse
   static Atomic<bool> sInShutdown;
 
   // Counter for how many timelines are currently interested in markers,
   // and a list of the MarkersStorage interfaces representing them.
   unsigned long mActiveConsumers;
   LinkedList<MarkersStorage> mMarkersStores;
 
   // Protects this class's data structures.
-  static StaticMutex sMutex;
+  static StaticMutex sMutex MOZ_UNANNOTATED;
 };
 
 }  // namespace mozilla
 
 #endif /* mozilla_TimelineConsumers_h_ */

--- a/dom/base/BodyStream.h
+++ b/dom/base/BodyStream.h
@@ -222,17 +222,17 @@ class BodyStream final : public nsIInput
 
     // Operation completed.
     eClosed,
   };
 
   // We need a mutex because JS engine can release BodyStream on a non-owning
   // thread. We must be sure that the releasing of resources doesn't trigger
   // race conditions.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   // Protected by mutex.
   State mState;
 
   nsCOMPtr<nsIGlobalObject> mGlobal;
   RefPtr<BodyStreamHolder> mStreamHolder;
   nsCOMPtr<nsIEventTarget> mOwningEventTarget;
 

--- a/dom/cache/Manager.cpp
+++ b/dom/cache/Manager.cpp
@@ -1096,17 +1096,17 @@ class Manager::CachePutAllAction final :
   nsresult mAsyncResult;
   nsTArray<nsID> mBodyIdWrittenList;
 
   // Written to on target thread, accessed on initiating thread after target
   // thread activity is guaranteed complete
   nsTArray<nsID> mDeletedBodyIdList;
 
   // accessed from any thread while mMutex locked
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   nsTArray<nsCOMPtr<nsISupports>> mCopyContextList;
 
   Maybe<CacheDirectoryMetadata> mDirectoryMetadata;
   // Track how much pad amount has been added for new entries so that it can be
   // removed if an error occurs.
   int64_t mUpdatedPaddingSize;
   // Track any pad amount associated with overwritten entries.
   int64_t mDeletedPaddingSize;

--- a/dom/cache/ReadStream.cpp
+++ b/dom/cache/ReadStream.cpp
@@ -100,17 +100,17 @@ class ReadStream::Inner final : public R
   Atomic<State> mState;
   Atomic<bool> mHasEverBeenRead;
   bool mAsyncOpenStarted;
 
   // The wrapped stream objects may not be threadsafe.  We need to be able
   // to close a stream on our owning thread while an IO thread is simultaneously
   // reading the same stream.  Therefore, protect all access to these stream
   // objects with a mutex.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   CondVar mCondVar;
   nsCOMPtr<nsIInputStream> mStream;
   nsCOMPtr<nsIInputStream> mSnappyStream;
 };
 
 // ----------------------------------------------------------------------------
 
 // Runnable to notify actors that the ReadStream has closed.  This must

--- a/dom/canvas/HostWebGLContext.cpp
+++ b/dom/canvas/HostWebGLContext.cpp
@@ -27,17 +27,17 @@
 #include "WebGLQuery.h"
 
 #include "mozilla/StaticMutex.h"
 
 namespace mozilla {
 
 // -
 
-static StaticMutex sContextSetLock;
+static StaticMutex sContextSetLock MOZ_UNANNOTATED;
 
 static std::unordered_set<HostWebGLContext*>& DeferredStaticContextSet() {
   static std::unordered_set<HostWebGLContext*> sContextSet;
   return sContextSet;
 }
 
 LockedOutstandingContexts::LockedOutstandingContexts()
     : contexts(DeferredStaticContextSet()) {

--- a/dom/canvas/ImageBitmap.cpp
+++ b/dom/canvas/ImageBitmap.cpp
@@ -1470,17 +1470,17 @@ class CreateImageBitmapFromBlob final : 
   nsresult DecodeAndCropBlob(const nsACString& aMimeType);
 
   // This is called on the main-thread only.
   nsresult GetMimeTypeSync(nsACString& aMimeType);
 
   // This is called on the main-thread only.
   nsresult GetMimeTypeAsync();
 
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   // The access to this object is protected by mutex but is always nullified on
   // the owning thread.
   RefPtr<ThreadSafeWorkerRef> mWorkerRef;
 
   // Touched only on the owning thread.
   RefPtr<Promise> mPromise;
 

--- a/dom/canvas/OffscreenCanvasDisplayHelper.h
+++ b/dom/canvas/OffscreenCanvasDisplayHelper.h
@@ -57,17 +57,17 @@ class OffscreenCanvasDisplayHelper final
   void MaybeQueueInvalidateElement();
   void InvalidateElement();
 
   bool TransformSurface(const gfx::DataSourceSurface::ScopedMap& aSrcMap,
                         const gfx::DataSourceSurface::ScopedMap& aDstMap,
                         gfx::SurfaceFormat aFormat, const gfx::IntSize& aSize,
                         bool aNeedsPremult, gl::OriginPos aOriginPos) const;
 
-  mutable Mutex mMutex;
+  mutable Mutex mMutex MOZ_UNANNOTATED;
   HTMLCanvasElement* MOZ_NON_OWNING_REF mCanvasElement;
   RefPtr<layers::ImageContainer> mImageContainer;
   RefPtr<gfx::SourceSurface> mFrontBufferSurface;
 
   OffscreenCanvasDisplayData mData;
   CanvasContextType mType = CanvasContextType::NoContext;
   Maybe<uint32_t> mContextManagerId;
   Maybe<int32_t> mContextChildId;

--- a/dom/console/ConsoleReportCollector.h
+++ b/dom/console/ConsoleReportCollector.h
@@ -73,17 +73,17 @@ class ConsoleReportCollector final : pub
     const nsContentUtils::PropertiesFile mPropertiesFile;
     const nsCString mSourceFileURI;
     const uint32_t mLineNumber;
     const uint32_t mColumnNumber;
     const nsCString mMessageName;
     const CopyableTArray<nsString> mStringParams;
   };
 
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   // protected by mMutex
   nsTArray<PendingReport> mPendingReports;
 
  public:
   NS_DECL_THREADSAFE_ISUPPORTS
 };
 

--- a/dom/file/FileBlobImpl.h
+++ b/dom/file/FileBlobImpl.h
@@ -126,17 +126,17 @@ class FileBlobImpl : public BlobImpl {
                                          const nsAString& aContentType,
                                          ErrorResult& aRv) override;
 
   class GetTypeRunnable;
   void GetTypeInternal(nsAString& aType, const MutexAutoLock& aProofOfLock);
 
   // FileBlobImpl has getter methods with lazy initialization. Because any
   // BlobImpl must work thread-safe, we use a mutex.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   nsCOMPtr<nsIFile> mFile;
 
   nsString mContentType;
   nsString mName;
   nsString mPath;  // The path relative to a directory chosen by the user
   nsString mMozFullPath;
 

--- a/dom/file/MemoryBlobImpl.h
+++ b/dom/file/MemoryBlobImpl.h
@@ -92,17 +92,17 @@ class MemoryBlobImpl final : public Base
     }
 
    public:
     static void EnsureMemoryReporterRegistered();
 
     // sDataOwners and sMemoryReporterRegistered may only be accessed while
     // holding sDataOwnerMutex!  You also must hold the mutex while touching
     // elements of the linked list that DataOwner inherits from.
-    static mozilla::StaticMutex sDataOwnerMutex;
+    static mozilla::StaticMutex sDataOwnerMutex MOZ_UNANNOTATED;
     static mozilla::StaticAutoPtr<mozilla::LinkedList<DataOwner> > sDataOwners;
     static bool sMemoryReporterRegistered;
 
     void* mData;
     uint64_t mLength;
   };
 
   class DataOwnerAdapter final : public StreamBufferSource {

--- a/dom/file/MutableBlobStorage.h
+++ b/dom/file/MutableBlobStorage.h
@@ -87,17 +87,17 @@ class MutableBlobStorage final {
                                 uint64_t aSize) const;
 
   bool MaybeCreateTemporaryFile(const MutexAutoLock& aProofOfLock);
   void MaybeCreateTemporaryFileOnMainThread(const MutexAutoLock& aProofOfLock);
 
   [[nodiscard]] nsresult DispatchToIOThread(
       already_AddRefed<nsIRunnable> aRunnable);
 
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   // All these variables are touched on the main thread only or in the
   // retargeted thread when used by Append(). They are protected by mMutex.
 
   void* mData;
   uint64_t mDataLen;
   uint64_t mDataBufferLen;
 

--- a/dom/file/ipc/RemoteLazyInputStream.h
+++ b/dom/file/ipc/RemoteLazyInputStream.h
@@ -110,14 +110,14 @@ class RemoteLazyInputStream final : publ
 
   // These 2 values are set only when nsIAsyncInputStreamLength::asyncWait() is
   // called.
   nsCOMPtr<nsIInputStreamLengthCallback> mLengthCallback;
   nsCOMPtr<nsIEventTarget> mLengthCallbackEventTarget;
 
   // Any member of this class is protected by mutex because touched on
   // multiple threads.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 };
 
 }  // namespace mozilla
 
 #endif  // mozilla_RemoteLazyInputStream_h

--- a/dom/file/ipc/RemoteLazyInputStreamChild.h
+++ b/dom/file/ipc/RemoteLazyInputStreamChild.h
@@ -73,17 +73,17 @@ class RemoteLazyInputStreamChild final :
   ~RemoteLazyInputStreamChild();
 
   // Raw pointers because these streams keep this actor alive. When the last
   // stream is unregister, the actor will be deleted. This list is protected by
   // mutex.
   nsTArray<RemoteLazyInputStream*> mStreams;
 
   // This mutex protects mStreams because that can be touched in any thread.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   const nsID mID;
   const uint64_t mSize;
 
   ActorState mState;
 
   // This struct and the array are used for creating streams when needed.
   struct PendingOperation {

--- a/dom/file/uri/BlobURLInputStream.h
+++ b/dom/file/uri/BlobURLInputStream.h
@@ -55,17 +55,17 @@ class BlobURLInputStream final : public 
   void NotifyWaitTargets(const MutexAutoLock& aProofOfLock);
   void ReleaseUnderlyingStream(const MutexAutoLock& aProofOfLock);
 
   RefPtr<BlobURLChannel> mChannel;
   const nsCString mBlobURLSpec;
 
   // Non-recursive mutex introduced in order to guard access to mState, mError
   // and mAsyncInputStream
-  Mutex mStateMachineMutex;
+  Mutex mStateMachineMutex MOZ_UNANNOTATED;
   State mState;
   // Stores the error code if stream is in error state
   nsresult mError;
 
   int64_t mBlobSize;
 
   nsCOMPtr<nsIAsyncInputStream> mAsyncInputStream;
   nsCOMPtr<nsIInputStreamCallback> mAsyncWaitCallback;

--- a/dom/file/uri/BlobURLProtocolHandler.cpp
+++ b/dom/file/uri/BlobURLProtocolHandler.cpp
@@ -82,17 +82,17 @@ struct DataInfo {
   // When a blobURL is revoked, we keep it alive for RELEASING_TIMER
   // milliseconds in order to support pending operations such as navigation,
   // download and so on.
   bool mRevoked;
 };
 
 // The mutex is locked whenever gDataTable is changed, or if gDataTable
 // is accessed off-main-thread.
-static StaticMutex sMutex;
+static StaticMutex sMutex MOZ_UNANNOTATED;
 
 // All changes to gDataTable must happen on the main thread, while locking
 // sMutex. Reading from gDataTable on the main thread may happen without
 // locking, since no changes are possible. Reading it from another thread
 // must also lock sMutex to prevent data races.
 static nsClassHashtable<nsCStringHashKey, mozilla::dom::DataInfo>* gDataTable;
 
 static mozilla::dom::DataInfo* GetDataInfo(const nsACString& aUri,

--- a/dom/filesystem/GetFilesHelper.h
+++ b/dom/filesystem/GetFilesHelper.h
@@ -113,17 +113,17 @@ class GetFilesHelper : public Runnable, 
   nsString mDirectoryPath;
 
   // Error code to propagate.
   nsresult mErrorResult;
 
   nsTArray<RefPtr<Promise>> mPromises;
   nsTArray<RefPtr<GetFilesCallback>> mCallbacks;
 
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   // This variable is protected by mutex.
   bool mCanceled;
 };
 
 class GetFilesHelperChild final : public GetFilesHelper {
  public:
   explicit GetFilesHelperChild(bool aRecursiveFlag)

--- a/dom/gamepad/GamepadPlatformService.h
+++ b/dom/gamepad/GamepadPlatformService.h
@@ -136,17 +136,17 @@ class GamepadPlatformService final {
 
   // mChannelParents stores all the GamepadEventChannelParent instances
   // which may be accessed by both background thread and monitor thread
   // simultaneously, so we have a mutex to prevent race condition
   nsTArray<RefPtr<GamepadEventChannelParent>> mChannelParents;
 
   // This mutex protects mChannelParents from race condition
   // between background and monitor thread
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   std::map<GamepadHandle, GamepadAdded> mGamepadAdded;
 };
 
 }  // namespace dom
 }  // namespace mozilla
 
 #endif

--- a/dom/indexedDB/ActorsParent.cpp
+++ b/dom/indexedDB/ActorsParent.cpp
@@ -1492,17 +1492,17 @@ class ConnectionPool final {
     }
 
     bool operator<(const IdleThreadInfo& aOther) const {
       return mIdleTime < aOther.mIdleTime;
     }
   };
 
   // This mutex guards mDatabases, see below.
-  Mutex mDatabasesMutex;
+  Mutex mDatabasesMutex MOZ_UNANNOTATED;
 
   nsTArray<IdleThreadInfo> mIdleThreads;
   nsTArray<IdleDatabaseInfo> mIdleDatabases;
   nsTArray<NotNull<DatabaseInfo*>> mDatabasesPerformingIdleMaintenance;
   nsCOMPtr<nsITimer> mIdleTimer;
   TimeStamp mTargetIdleTime;
 
   // Only modifed on the owning thread, but read on multiple threads. Therefore
@@ -6587,17 +6587,17 @@ nsresult DispatchAndReturnFileReferences
   MOZ_ASSERT(aMemRefCnt);
   MOZ_ASSERT(aDBRefCnt);
   MOZ_ASSERT(aResult);
 
   *aResult = false;
   *aMemRefCnt = -1;
   *aDBRefCnt = -1;
 
-  mozilla::Monitor monitor(__func__);
+  mozilla::Monitor monitor MOZ_ANNOTATED(__func__);
   bool waiting = true;
 
   auto lambda = [&] {
     AssertIsOnIOThread();
 
     {
       IndexedDatabaseManager* const mgr = IndexedDatabaseManager::Get();
       MOZ_ASSERT(mgr);
@@ -6753,17 +6753,17 @@ class DeserializeIndexValueHelper final 
 
   void OperationCompleted(nsresult aStatus) {
     mStatus = aStatus;
 
     MonitorAutoLock lock(mMonitor);
     lock.Notify();
   }
 
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 
   const int64_t mIndexID;
   const KeyPath& mKeyPath;
   const bool mMultiEntry;
   const nsCString mLocale;
   StructuredCloneReadInfoParent& mCloneReadInfo;
   nsTArray<IndexUpdateInfo>& mUpdateInfoArray;
   nsresult mStatus;
@@ -21677,17 +21677,17 @@ class FileHelper::ReadCallback final : p
     }
 
     return NS_OK;
   }
 
  private:
   ~ReadCallback() = default;
 
-  mozilla::Mutex mMutex;
+  mozilla::Mutex mMutex MOZ_UNANNOTATED;
   mozilla::CondVar mCondVar;
   bool mInputAvailable;
 };
 
 NS_IMPL_ADDREF(FileHelper::ReadCallback);
 NS_IMPL_RELEASE(FileHelper::ReadCallback);
 
 NS_INTERFACE_MAP_BEGIN(FileHelper::ReadCallback)

--- a/dom/indexedDB/SchemaUpgrades.cpp
+++ b/dom/indexedDB/SchemaUpgrades.cpp
@@ -2837,17 +2837,17 @@ class DeserializeUpgradeValueHelper fina
 
   void OperationCompleted(nsresult aStatus) {
     mStatus = aStatus;
 
     MonitorAutoLock lock(mMonitor);
     lock.Notify();
   }
 
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
   StructuredCloneReadInfoParent& mCloneReadInfo;
   nsresult mStatus;
 };
 
 nsresult DeserializeUpgradeValueToFileIds(
     StructuredCloneReadInfoParent& aCloneReadInfo, nsAString& aFileIds) {
   MOZ_ASSERT(!NS_IsMainThread());
 

--- a/dom/ipc/ProcessHangMonitor.cpp
+++ b/dom/ipc/ProcessHangMonitor.cpp
@@ -143,17 +143,17 @@ class HangMonitorChild : public PProcess
   static Atomic<bool, SequentiallyConsistent> sInitializing;
 
  private:
   void ShutdownOnThread();
 
   static Atomic<HangMonitorChild*, SequentiallyConsistent> sInstance;
 
   const RefPtr<ProcessHangMonitor> mHangMonitor;
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 
   // Main thread-only.
   bool mSentReport;
 
   // These fields must be accessed with mMonitor held.
   bool mTerminateScript;
   bool mStartDebugger;
   bool mFinishedStartingDebugger;
@@ -277,25 +277,25 @@ class HangMonitorParent : public PProces
 
   void ShutdownOnThread();
 
   const RefPtr<ProcessHangMonitor> mHangMonitor;
 
   // This field is only accessed on the hang thread.
   bool mIPCOpen;
 
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 
   // Must be accessed with mMonitor held.
   RefPtr<HangMonitoredProcess> mProcess;
   bool mShutdownDone;
   // Map from plugin ID to crash dump ID. Protected by
   // mBrowserCrashDumpHashLock.
   nsTHashMap<nsUint32HashKey, nsString> mBrowserCrashDumpIds;
-  Mutex mBrowserCrashDumpHashLock;
+  Mutex mBrowserCrashDumpHashLock MOZ_UNANNOTATED;
   mozilla::ipc::TaskFactory<HangMonitorParent> mMainThreadTaskFactory;
 };
 
 }  // namespace
 
 /* HangMonitorChild implementation */
 
 HangMonitorChild::HangMonitorChild(ProcessHangMonitor* aMonitor)

--- a/dom/ipc/RefMessageBodyService.h
+++ b/dom/ipc/RefMessageBodyService.h
@@ -91,17 +91,17 @@ class RefMessageBody final {
  private:
   ~RefMessageBody();
 
   const nsID mPortID;
 
   // In case the RefMessageBody is shared and refcounted (see mCount/mMaxCount),
   // we must enforce that the reading does not happen simultaneously on
   // different threads.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   UniquePtr<ipc::StructuredCloneData> mCloneData;
 
   // When mCount reaches mMaxCount, this object is released by the service.
   Maybe<uint32_t> mMaxCount;
   uint32_t mCount;
 };
 

--- a/dom/localstorage/ActorsParent.cpp
+++ b/dom/localstorage/ActorsParent.cpp
@@ -1363,17 +1363,17 @@ class Connection final : public CachingD
  * connection on demand. This is necessary because we attempt to defer the
  * creation of the origin directory and the database until absolutely needed,
  * but the directory creation and origin initialization must happen on the QM
  * IO thread for invariant reasons. (We can't just use a mutex because there
  * could be logic on the IO thread that also wants to deal with the same
  * origin, so we need to queue a runnable and wait our turn.)
  */
 class Connection::InitTemporaryOriginHelper final : public Runnable {
-  mozilla::Monitor mMonitor;
+  mozilla::Monitor mMonitor MOZ_UNANNOTATED;
   const OriginMetadata mOriginMetadata;
   nsString mOriginDirectoryPath;
   nsresult mIOThreadResultCode;
   bool mWaiting;
 
  public:
   explicit InitTemporaryOriginHelper(const OriginMetadata& aOriginMetadata)
       : Runnable("dom::localstorage::Connection::InitTemporaryOriginHelper"),
@@ -2609,17 +2609,17 @@ class ArchivedOriginScope {
 };
 
 class QuotaClient final : public mozilla::dom::quota::Client {
   class Observer;
   class MatchFunction;
 
   static QuotaClient* sInstance;
 
-  Mutex mShadowDatabaseMutex;
+  Mutex mShadowDatabaseMutex MOZ_UNANNOTATED;
   bool mShutdownRequested;
 
  public:
   QuotaClient();
 
   static nsresult Initialize();
 
   static QuotaClient* GetInstance() {

--- a/dom/media/AudioStream.h
+++ b/dom/media/AudioStream.h
@@ -324,17 +324,17 @@ class AudioStream final {
   template <typename Function, typename... Args>
   int InvokeCubeb(Function aFunction, Args&&... aArgs);
   bool CheckThreadIdChanged();
   void AssertIsOnAudioThread() const;
 
   soundtouch::SoundTouch* mTimeStretcher;
 
   // The monitor is held to protect all access to member variables below.
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 
   const uint32_t mOutChannels;
   const AudioConfig::ChannelLayout::ChannelMap mChannelMap;
   AudioClock mAudioClock;
 
   WavDumper mDumpFile;
 
   // Owning reference to a cubeb_stream.

--- a/dom/media/Benchmark.cpp
+++ b/dom/media/Benchmark.cpp
@@ -74,17 +74,17 @@ uint32_t VP9Benchmark::MediaBenchmarkVp9
 // static
 bool VP9Benchmark::IsVP9DecodeFast(bool aDefault) {
 #if defined(MOZ_WIDGET_ANDROID)
   return false;
 #else
   if (!ShouldRun()) {
     return false;
   }
-  static StaticMutex sMutex;
+  static StaticMutex sMutex MOZ_UNANNOTATED;
   uint32_t decodeFps = StaticPrefs::media_benchmark_vp9_fps();
   uint32_t hadRecentUpdate = StaticPrefs::media_benchmark_vp9_versioncheck();
   bool needBenchmark;
   {
     StaticMutexAutoLock lock(sMutex);
     needBenchmark = !sHasRunTest &&
                     (decodeFps == 0 || hadRecentUpdate != sBenchmarkVersionID);
     sHasRunTest = true;

--- a/dom/media/ChannelMediaResource.h
+++ b/dom/media/ChannelMediaResource.h
@@ -181,17 +181,17 @@ class ChannelMediaResource
     NS_DECL_NSISTREAMLISTENER
     NS_DECL_NSICHANNELEVENTSINK
     NS_DECL_NSIINTERFACEREQUESTOR
     NS_DECL_NSITHREADRETARGETABLESTREAMLISTENER
 
     void Revoke();
 
    private:
-    Mutex mMutex;
+    Mutex mMutex MOZ_UNANNOTATED;
     // mResource should only be modified on the main thread with the lock.
     // So it can be read without lock on the main thread or on other threads
     // with the lock.
     RefPtr<ChannelMediaResource> mResource;
 
     const int64_t mOffset;
     const uint32_t mLoadID;
   };

--- a/dom/media/CloneableWithRangeMediaResource.cpp
+++ b/dom/media/CloneableWithRangeMediaResource.cpp
@@ -108,17 +108,17 @@ class InputStreamReader final : public n
 
         lock.Wait();
       }
     }
   }
 
   nsCOMPtr<nsIInputStream> mStream;
   nsCOMPtr<nsIAsyncInputStream> mAsyncStream;
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 };
 
 NS_IMPL_ADDREF(InputStreamReader);
 NS_IMPL_RELEASE(InputStreamReader);
 
 NS_INTERFACE_MAP_BEGIN(InputStreamReader)
   NS_INTERFACE_MAP_ENTRY(nsIInputStreamCallback)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIInputStreamCallback)

--- a/dom/media/FileBlockCache.h
+++ b/dom/media/FileBlockCache.h
@@ -135,17 +135,17 @@ class FileBlockCache : public MediaBlock
   void Close();
 
   // Performs block writes and block moves on its own thread.
   void PerformBlockIOs();
 
   // Mutex which controls access to mFD and mFDCurrentPos. Don't hold
   // mDataMutex while holding mFileMutex! mFileMutex must be owned
   // while accessing any of the following data fields or methods.
-  Mutex mFileMutex;
+  Mutex mFileMutex MOZ_UNANNOTATED;
   // Moves a block already committed to file.
   nsresult MoveBlockInFile(int32_t aSourceBlockIndex, int32_t aDestBlockIndex);
   // Seeks file pointer.
   nsresult Seek(int64_t aOffset);
   // Reads data from file offset.
   nsresult ReadFromFile(int64_t aOffset, uint8_t* aDest, int32_t aBytesToRead,
                         int32_t& aBytesRead);
   nsresult WriteBlockToFile(int32_t aBlockIndex, const uint8_t* aBlockData);
@@ -154,17 +154,17 @@ class FileBlockCache : public MediaBlock
   PRFileDesc* mFD;
   // The current file offset in the file.
   int64_t mFDCurrentPos;
 
   // Mutex which controls access to all data in this class, except mFD
   // and mFDCurrentPos. Don't hold mDataMutex while holding mFileMutex!
   // mDataMutex must be owned while accessing any of the following data
   // fields or methods.
-  Mutex mDataMutex;
+  Mutex mDataMutex MOZ_UNANNOTATED;
   // Ensures we either are running the event to preform IO, or an event
   // has been dispatched to preform the IO.
   // mDataMutex must be owned while calling this.
   void EnsureWriteScheduled();
 
   // Array of block changes to made. If mBlockChanges[offset/BLOCK_SIZE] ==
   // nullptr, then the block has no pending changes to be written, but if
   // mBlockChanges[offset/BLOCK_SIZE] != nullptr, then either there's a block

--- a/dom/media/FileMediaResource.h
+++ b/dom/media/FileMediaResource.h
@@ -104,17 +104,17 @@ class FileMediaResource : public BaseMed
   // Can be used from any thread.
   int64_t mSize;
 
   // This lock handles synchronisation between calls to Close() and
   // the Read, Seek, etc calls. Close must not be called while a
   // Read or Seek is in progress since it resets various internal
   // values to null.
   // This lock protects mSeekable, mInput, mSize, and mSizeInitialized.
-  Mutex mLock;
+  Mutex mLock MOZ_UNANNOTATED;
 
   // Seekable stream interface to file. This can be used from any
   // thread.
   nsCOMPtr<nsISeekableStream> mSeekable;
 
   // Input stream for the media data. This can be used from any
   // thread.
   nsCOMPtr<nsIInputStream> mInput;

--- a/dom/media/FrameStatistics.h
+++ b/dom/media/FrameStatistics.h
@@ -166,16 +166,16 @@ class FrameStatistics {
    private:
     FrameStatistics* mFrameStats;
   };
 
  private:
   ~FrameStatistics() = default;
 
   // ReentrantMonitor to protect access of playback statistics.
-  mutable ReentrantMonitor mReentrantMonitor;
+  mutable ReentrantMonitor mReentrantMonitor MOZ_UNANNOTATED;
 
   FrameStatisticsData mFrameStatisticsData;
 };
 
 }  // namespace mozilla
 
 #endif  // FrameStatistics_h_

--- a/dom/media/GraphDriver.h
+++ b/dom/media/GraphDriver.h
@@ -372,17 +372,17 @@ class GraphDriver {
 
 class MediaTrackGraphInitThreadRunnable;
 
 /**
  * This class is a driver that manages its own thread.
  */
 class ThreadedDriver : public GraphDriver {
   class IterationWaitHelper {
-    Monitor mMonitor;
+    Monitor mMonitor MOZ_UNANNOTATED;
     // The below members are guarded by mMonitor.
     bool mNeedAnotherIteration = false;
     TimeStamp mWakeTime;
 
    public:
     IterationWaitHelper() : mMonitor("IterationWaitHelper::mMonitor") {}
 
     /**

--- a/dom/media/GraphRunner.h
+++ b/dom/media/GraphRunner.h
@@ -75,17 +75,17 @@ class GraphRunner final : public Runnabl
     IterationState& operator=(const IterationState& aOther) = default;
     GraphTime StateTime() const { return mStateTime; }
     GraphTime IterationEnd() const { return mIterationEnd; }
     AudioMixer* Mixer() const { return mMixer; }
   };
 
   // Monitor used for yielding mThread through Wait(), and scheduling mThread
   // through Signal() from a GraphDriver.
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
   // The MediaTrackGraph we're running. Weakptr beecause this graph owns us and
   // guarantees that our lifetime will not go beyond that of itself.
   MediaTrackGraphImpl* const mGraph;
   // State being handed over to the graph through OneIteration. Protected by
   // mMonitor.
   Maybe<IterationState> mIterationState;
   // Result from mGraph's OneIteration. Protected by mMonitor.
   IterationResult mIterationResult;

--- a/dom/media/MediaCache.cpp
+++ b/dom/media/MediaCache.cpp
@@ -438,17 +438,17 @@ class MediaCache {
 
   // This member is main-thread only. It's used to allocate unique
   // resource IDs to streams.
   int64_t mNextResourceID = 0;
 
   // The monitor protects all the data members here. Also, off-main-thread
   // readers that need to block will Wait() on this monitor. When new
   // data becomes available in the cache, we NotifyAll() on this monitor.
-  mozilla::Monitor mMonitor;
+  mozilla::Monitor mMonitor MOZ_UNANNOTATED;
   // This must always be accessed when the monitor is held.
   nsTArray<MediaCacheStream*> mStreams;
   // The Blocks describing the cache entries.
   nsTArray<Block> mIndex;
 
   RefPtr<MediaBlockCacheBase> mBlockCache;
   // The list of free blocks; they are not ordered.
   BlockList mFreeBlocks;

--- a/dom/media/MediaEventSource.h
+++ b/dom/media/MediaEventSource.h
@@ -470,17 +470,17 @@ class MediaEventSourceImpl {
         mListeners.RemoveElementAt(i);
         continue;
       }
       l->Dispatch(std::forward<Ts>(aEvents)...);
     }
   }
 
  private:
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   nsTArray<RefPtr<Listener>> mListeners;
 };
 
 template <typename... Es>
 using MediaEventSource =
     MediaEventSourceImpl<ListenerPolicy::NonExclusive, Es...>;
 
 template <typename... Es>

--- a/dom/media/MediaFormatReader.cpp
+++ b/dom/media/MediaFormatReader.cpp
@@ -713,17 +713,17 @@ class MediaFormatReader::DemuxerProxy::W
   TimeIntervals GetBuffered() override {
     MutexAutoLock lock(mMutex);
     return mBuffered;
   }
 
   void BreakCycles() override {}
 
  private:
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   const RefPtr<TaskQueue> 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;

--- a/dom/media/MediaFormatReader.h
+++ b/dom/media/MediaFormatReader.h
@@ -387,17 +387,17 @@ class MediaFormatReader final
     // TaskQueue on which decoder can choose to decode.
     // Only non-null up until the decoder is created.
     RefPtr<TaskQueue> mTaskQueue;
 
     // Mutex protecting mDescription, mDecoder, mTrackDemuxer and mWorkingInfo
     // as those can be read outside the TaskQueue.
     // They are only written on the TaskQueue however, as such mMutex doesn't
     // need to be held when those members are read on the TaskQueue.
-    Mutex mMutex;
+    Mutex mMutex MOZ_UNANNOTATED;
     // The platform decoder.
     RefPtr<MediaDataDecoder> mDecoder;
     nsCString mDescription;
     void ShutdownDecoder();
 
     // Only accessed from reader's task queue.
     bool mUpdateScheduled;
     bool mDemuxEOS;

--- a/dom/media/MediaManager.h
+++ b/dom/media/MediaManager.h
@@ -386,17 +386,17 @@ class MediaManager final : public nsIMed
   // Always exists
   const RefPtr<TaskQueue> mMediaThread;
   nsCOMPtr<nsIAsyncShutdownBlocker> mShutdownBlocker;
 
   // ONLY accessed from MediaManagerThread
   RefPtr<MediaEngine> mBackend;
 
   static StaticRefPtr<MediaManager> sSingleton;
-  static StaticMutex sSingletonMutex;
+  static StaticMutex sSingletonMutex MOZ_UNANNOTATED;
 
   // Connect/Disconnect on media thread only
   MediaEventListener mDeviceListChangeListener;
 
   MediaEventProducer<void> mDeviceListChangeEvent;
 
  public:
   RefPtr<media::Parent<media::NonE10s>> mNonE10sParent;

--- a/dom/media/MediaQueue.h
+++ b/dom/media/MediaQueue.h
@@ -174,17 +174,17 @@ class MediaQueue : private nsRefPtrDeque
     for (; i < GetSize(); ++i) {
       RefPtr<T> elem = nsRefPtrDeque<T>::ObjectAt(i);
       if (elem->GetEndTime().ToMicroseconds() > aTime) {
         aResult->AppendElement(elem);
       }
     }
   }
 
-  mutable RecursiveMutex mRecursiveMutex;
+  mutable RecursiveMutex mRecursiveMutex MOZ_UNANNOTATED;
   MediaEventProducer<RefPtr<T>> mPopFrontEvent;
   MediaEventProducer<RefPtr<T>> mPushEvent;
   MediaEventProducer<void> mFinishEvent;
   // True when we've decoded the last frame of data in the
   // bitstream for which we're queueing frame data.
   bool mEndOfStream;
 };
 

--- a/dom/media/MediaTimer.h
+++ b/dom/media/MediaTimer.h
@@ -90,17 +90,17 @@ class MediaTimer {
     // (i.e. the soonest).
     bool operator<(const Entry& aOther) const {
       return mTimeStamp > aOther.mTimeStamp;
     }
   };
 
   nsCOMPtr<nsIEventTarget> mThread;
   std::priority_queue<Entry> mEntries;
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
   nsCOMPtr<nsITimer> mTimer;
   TimeStamp mCurrentTimerTarget;
 
   // Timestamps only have relative meaning, so we need a base timestamp for
   // logging purposes.
   TimeStamp mCreationTimeStamp;
   int64_t RelativeMicroseconds(const TimeStamp& aTimeStamp) {
     return (int64_t)(aTimeStamp - mCreationTimeStamp).ToMicroseconds();

--- a/dom/media/MediaTrackGraph.h
+++ b/dom/media/MediaTrackGraph.h
@@ -728,17 +728,17 @@ class SourceMediaTrack : public MediaTra
     mUpdateTrack->mData->Clear();
   }
 
   virtual void AdvanceTimeVaryingValuesToCurrentTime(
       GraphTime aCurrentTime, GraphTime aBlockedTime) override;
 
   // This must be acquired *before* MediaTrackGraphImpl's lock, if they are
   // held together.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   // protected by mMutex
   float mVolume = 1.0;
   UniquePtr<TrackData> mUpdateTrack;
   nsTArray<RefPtr<DirectMediaTrackListener>> mDirectTrackListeners;
 };
 
 /**
  * A ref-counted wrapper of a MediaTrack that allows multiple users to share a

--- a/dom/media/MediaTrackGraphImpl.h
+++ b/dom/media/MediaTrackGraphImpl.h
@@ -762,17 +762,17 @@ class MediaTrackGraphImpl : public Media
   };
   AutoTArray<PendingResumeOperation, 1> mPendingResumeOperations;
 
   // mMonitor guards the data below.
   // MediaTrackGraph normally does its work without holding mMonitor, so it is
   // not safe to just grab mMonitor from some thread and start monkeying with
   // the graph. Instead, communicate with the graph thread using provided
   // mechanisms such as the ControlMessage queue.
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 
   // Data guarded by mMonitor (must always be accessed with mMonitor held,
   // regardless of the value of mLifecycleState).
 
   /**
    * State to copy to main thread
    */
   nsTArray<TrackUpdate> mTrackUpdates;

--- a/dom/media/MemoryBlockCache.h
+++ b/dom/media/MemoryBlockCache.h
@@ -71,17 +71,17 @@ class MemoryBlockCache : public MediaBlo
 
   // Initial content length.
   const size_t mInitialContentLength;
 
   // Maximum number of blocks that this MemoryBlockCache expects.
   const size_t mMaxBlocks;
 
   // Mutex which controls access to all members below.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   nsTArray<uint8_t> mBuffer;
   bool mHasGrown = false;
 };
 
 }  // End namespace mozilla.
 
 #endif /* MEMORY_BLOCK_CACHE_H_ */

--- a/dom/media/VideoFrameContainer.h
+++ b/dom/media/VideoFrameContainer.h
@@ -112,17 +112,17 @@ class VideoFrameContainer {
     // the last call to Invalidate().
     // The next call to Invalidate() will recalculate
     // and update the intrinsic size on the element, request a frame reflow and
     // then reset this flag.
     bool mIntrinsicSizeChanged = false;
   } mMainThreadState;
 
   // mMutex protects all the fields below.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   // The intrinsic size is the ideal size which we should render the
   // ImageContainer's current Image at.
   // This can differ from the Image's actual size when the media resource
   // specifies that the Image should be stretched to have the correct aspect
   // ratio.
   gfx::IntSize mIntrinsicSize;
   // We maintain our own mFrameID which is auto-incremented at every
   // SetCurrentFrame() or NewFrameID() call.

--- a/dom/media/VideoOutput.h
+++ b/dom/media/VideoOutput.h
@@ -208,17 +208,17 @@ class VideoOutput : public DirectMediaTr
         v.AppendFrame(nullptr, gfx::IntSize(640, 480), PRINCIPAL_HANDLE_NONE,
                       true, TimeStamp::Now());
         mFrames.AppendElement(std::make_pair(NewFrameID(), *v.GetLastChunk()));
       }
       SendFramesEnsureLocked();
     }
   }
 
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   TimeStamp mLastFrameTime;
   // Once the frame is forced to black, we initialize mBlackImage for use in any
   // following forced-black frames.
   RefPtr<Image> mBlackImage;
   bool mEnabled = true;
   // This array is accessed from both the direct video thread, and the graph
   // thread. Protected by mMutex.
   nsTArray<std::pair<ImageContainer::FrameID, VideoChunk>> mFrames;

--- a/dom/media/doctor/DDMediaLogs.h
+++ b/dom/media/doctor/DDMediaLogs.h
@@ -170,17 +170,17 @@ struct DDMediaLogs {
           mLinkName(aLinkName),
           mLinkingIndex(aLinkingIndex),
           mUnlinkingIndex(Nothing{}) {}
   };
   // Links between live objects, updated while messages are processed.
   nsTArray<DDObjectLink> mObjectLinks;
 
   // Protects members below.
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
   // Processing thread.
   nsCOMPtr<nsIThread> mThread;
 
   struct PendingPromise {
     MozPromiseHolder<LogMessagesPromise> mPromiseHolder;
     const dom::HTMLMediaElement* mMediaElement;
   };

--- a/dom/media/doctor/MultiWriterQueue.h
+++ b/dom/media/doctor/MultiWriterQueue.h
@@ -23,17 +23,17 @@ namespace mozilla {
 class MultiWriterQueueReaderLocking_Mutex {
  public:
   MultiWriterQueueReaderLocking_Mutex()
       : mMutex("MultiWriterQueueReaderLocking_Mutex") {}
   void Lock() { mMutex.Lock(); };
   void Unlock() { mMutex.Unlock(); };
 
  private:
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 };
 
 // Reader non-locking strategy, trusting that PopAll will never be called
 // concurrently (e.g., by only calling it from a specific thread).
 class MultiWriterQueueReaderLocking_None {
  public:
 #ifndef DEBUG
   void Lock(){};

--- a/dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp
+++ b/dom/media/doctor/test/gtest/TestMultiWriterQueue.cpp
@@ -325,17 +325,17 @@ struct DequeWrapperAW : DequeWrapperST {
     mWriting = false;
     return true;
   }
 };
 
 // Multi-thread writes allowed, make sure you don't pop unless writes can't
 // happen.
 struct DequeWrapperMW : DequeWrapperST {
-  mozilla::Mutex mMutex;
+  mozilla::Mutex mMutex MOZ_UNANNOTATED;
 
   DequeWrapperMW() : mMutex("DequeWrapperMW/MT") {}
 
   bool Push(int i) {
     mozilla::MutexAutoLock lock(mMutex);
     mDQ.PushFront(reinterpret_cast<void*>(static_cast<uintptr_t>(i)));
     return true;
   }

--- a/dom/media/gmp/ChromiumCDMProxy.h
+++ b/dom/media/gmp/ChromiumCDMProxy.h
@@ -126,17 +126,17 @@ class ChromiumCDMProxy : public CDMProxy
   ~ChromiumCDMProxy();
 
   // True if Shutdown() has been called. Should only be read and written on
   // main thread.
   bool mIsShutdown = false;
 
   RefPtr<GMPCrashHelper> mCrashHelper;
 
-  Mutex mCDMMutex;
+  Mutex mCDMMutex MOZ_UNANNOTATED;
   RefPtr<gmp::ChromiumCDMParent> mCDM;
   nsCOMPtr<nsISerialEventTarget> mGMPThread;
   UniquePtr<ChromiumCDMCallbackProxy> mCallback;
 };
 
 }  // namespace mozilla
 
 #endif  // ChromiumCDMProxy_h_

--- a/dom/media/gmp/GMPPlatform.cpp
+++ b/dom/media/gmp/GMPPlatform.cpp
@@ -81,30 +81,30 @@ class GMPSyncRunnable final {
   }
 
  private:
   ~GMPSyncRunnable() = default;
 
   bool mDone;
   GMPTask* mTask;
   MessageLoop* mMessageLoop;
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 };
 
 class GMPThreadImpl : public GMPThread {
  public:
   GMPThreadImpl();
   virtual ~GMPThreadImpl();
 
   // GMPThread
   void Post(GMPTask* aTask) override;
   void Join() override;
 
  private:
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   base::Thread mThread;
 };
 
 GMPErr CreateThread(GMPThread** aThread) {
   if (!aThread) {
     return GMPGenericErr;
   }
 
@@ -143,17 +143,17 @@ class GMPMutexImpl : public GMPMutex {
   virtual ~GMPMutexImpl();
 
   // GMPMutex
   void Acquire() override;
   void Release() override;
   void Destroy() override;
 
  private:
-  ReentrantMonitor mMonitor;
+  ReentrantMonitor mMonitor MOZ_UNANNOTATED;
 };
 
 GMPErr CreateMutex(GMPMutex** aMutex) {
   if (!aMutex) {
     return GMPGenericErr;
   }
 
   *aMutex = new GMPMutexImpl();

--- a/dom/media/gmp/GMPService.h
+++ b/dom/media/gmp/GMPService.h
@@ -101,18 +101,19 @@ class GeckoMediaPluginService : public m
 
   nsresult GMPDispatch(nsIRunnable* event, uint32_t flags = NS_DISPATCH_NORMAL);
   nsresult GMPDispatch(already_AddRefed<nsIRunnable> event,
                        uint32_t flags = NS_DISPATCH_NORMAL);
   void ShutdownGMPThread();
 
   static nsCOMPtr<nsIAsyncShutdownClient> GetShutdownBarrier();
 
-  Mutex mMutex;  // Protects mGMPThread, mPluginCrashHelpers,
-                 // mGMPThreadShutdown and some members in derived classes.
+  Mutex mMutex MOZ_UNANNOTATED;  // Protects mGMPThread, mPluginCrashHelpers,
+                                 // mGMPThreadShutdown and some members in
+                                 // derived classes.
 
   const nsCOMPtr<nsISerialEventTarget> mMainThread;
 
   nsCOMPtr<nsIThread> mGMPThread;
   bool mGMPThreadShutdown;
   bool mShuttingDownOnGMPThread;
   Atomic<bool> mXPCOMWillShutdown;
 

--- a/dom/media/gmp/GMPServiceParent.h
+++ b/dom/media/gmp/GMPServiceParent.h
@@ -206,17 +206,17 @@ class GeckoMediaPluginServiceParent fina
   nsClassHashtable<nsUint32HashKey, nsCString> mTempNodeIds;
 
   // Hashes node id to whether that node id is allowed to store data
   // persistently on disk.
   nsTHashMap<nsCStringHashKey, bool> mPersistentStorageAllowed;
 
   // Synchronization for barrier that ensures we've loaded GMPs from
   // MOZ_GMP_PATH before allowing GetContentParentFrom() to proceed.
-  Monitor mInitPromiseMonitor;
+  Monitor mInitPromiseMonitor MOZ_UNANNOTATED;
   MozMonitoredPromiseHolder<GenericPromise> mInitPromise;
   bool mLoadPluginsFromDiskComplete;
 
   // Hashes nodeId to the hashtable of storage for that nodeId.
   nsRefPtrHashtable<nsCStringHashKey, GMPStorage> mTempGMPStorage;
 
   // Tracks how many IPC connections to GMPServices running in content
   // processes we have. When this is empty we can safely shut down.

--- a/dom/media/gmp/GMPStorageChild.h
+++ b/dom/media/gmp/GMPStorageChild.h
@@ -79,17 +79,17 @@ class GMPStorageChild : public PGMPStora
   mozilla::ipc::IPCResult RecvReadComplete(const nsCString& aRecordName,
                                            const GMPErr& aStatus,
                                            nsTArray<uint8_t>&& aBytes);
   mozilla::ipc::IPCResult RecvWriteComplete(const nsCString& aRecordName,
                                             const GMPErr& aStatus);
   mozilla::ipc::IPCResult RecvShutdown();
 
  private:
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
   nsRefPtrHashtable<nsCStringHashKey, GMPRecordImpl> mRecords;
   GMPChild* mPlugin;
   bool mShutdown;
 };
 
 }  // namespace gmp
 }  // namespace mozilla
 

--- a/dom/media/gtest/MockCubeb.h
+++ b/dom/media/gtest/MockCubeb.h
@@ -177,17 +177,17 @@ class MockCubebStream {
   cubeb* context = nullptr;
 
   const bool mHasInput;
   const bool mHasOutput;
   SmartMockCubebStream* const mSelf;
 
  private:
   // Monitor used to block start until mFrozenStart is false.
-  Monitor mFrozenStartMonitor;
+  Monitor mFrozenStartMonitor MOZ_UNANNOTATED;
   // Whether this stream should wait for an explicit start request before
   // starting. Protected by FrozenStartMonitor.
   bool mFrozenStart;
   // Signal to the audio thread that stream is stopped.
   std::atomic_bool mStreamStop{true};
   // Whether or not the output-side of this stream (what is written from the
   // callback output buffer) is recorded in an internal buffer. The data is then
   // available via `GetRecordedOutput`.

--- a/dom/media/gtest/TestCDMStorage.cpp
+++ b/dom/media/gtest/TestCDMStorage.cpp
@@ -1145,17 +1145,17 @@ class CDMStorageTest {
         : mMessage(aMessage), mContinuation(aContinuation) {}
     nsCString mMessage;
     nsCOMPtr<nsIRunnable> mContinuation;
   };
 
   nsTArray<ExpectedMessage> mExpected;
 
   RefPtr<gmp::ChromiumCDMParent> mCDM;
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
   Atomic<bool> mFinished;
   nsCString mNodeId;
 
   class CallbackProxy : public ChromiumCDMCallback {
    public:
     explicit CallbackProxy(CDMStorageTest* aRunner) : mRunner(aRunner) {}
 
     void SetSessionId(uint32_t aPromiseId,

--- a/dom/media/gtest/TestWebMBuffered.cpp
+++ b/dom/media/gtest/TestWebMBuffered.cpp
@@ -16,17 +16,17 @@ using namespace mozilla;
 // expects in-order timecodes per the WebM spec.  The remaining 6
 // SimpleBlocks have the following attributes:
 static const uint64_t gTimecodes[] = {66000000,  160000000, 166000000,
                                       200000000, 233000000, 320000000};
 static const int64_t gEndOffsets[] = {501, 772, 1244, 1380, 1543, 2015};
 
 TEST(WebMBuffered, BasicTests)
 {
-  ReentrantMonitor dummy("dummy");
+  ReentrantMonitor dummy MOZ_UNANNOTATED("dummy");
   WebMBufferedParser parser(0);
 
   nsTArray<WebMTimeDataOffset> mapping;
   parser.Append(nullptr, 0, mapping, dummy);
   EXPECT_TRUE(mapping.IsEmpty());
   EXPECT_EQ(parser.mStartOffset, 0);
   EXPECT_EQ(parser.mCurrentOffset, 0);
 
@@ -55,17 +55,17 @@ static void ReadFile(const char* aPath, 
   ASSERT_EQ(got, size_t(size));
 
   r = fclose(f);
   ASSERT_EQ(r, 0);
 }
 
 TEST(WebMBuffered, RealData)
 {
-  ReentrantMonitor dummy("dummy");
+  ReentrantMonitor dummy MOZ_UNANNOTATED("dummy");
   WebMBufferedParser parser(0);
 
   nsTArray<uint8_t> webmData;
   ReadFile("test.webm", webmData);
 
   nsTArray<WebMTimeDataOffset> mapping;
   parser.Append(webmData.Elements(), webmData.Length(), mapping, dummy);
   EXPECT_EQ(mapping.Length(), 6u);
@@ -77,17 +77,17 @@ TEST(WebMBuffered, RealData)
     EXPECT_EQ(mapping[i].mEndOffset, gEndOffsets[i]);
     EXPECT_EQ(mapping[i].mSyncOffset, 361);
     EXPECT_EQ(mapping[i].mTimecode, gTimecodes[i]);
   }
 }
 
 TEST(WebMBuffered, RealDataAppend)
 {
-  ReentrantMonitor dummy("dummy");
+  ReentrantMonitor dummy MOZ_UNANNOTATED("dummy");
   WebMBufferedParser parser(0);
   nsTArray<WebMTimeDataOffset> mapping;
 
   nsTArray<uint8_t> webmData;
   ReadFile("test.webm", webmData);
 
   uint32_t arrayEntries = mapping.Length();
   size_t offset = 0;

--- a/dom/media/hls/HLSDecoder.cpp
+++ b/dom/media/hls/HLSDecoder.cpp
@@ -39,17 +39,17 @@ class HLSResourceCallbacksSupport
   explicit HLSResourceCallbacksSupport(HLSDecoder* aResource);
   void Detach();
   void OnLoad(jni::String::Param aUrl);
   void OnDataArrived();
   void OnError(int aErrorCode);
 
  private:
   ~HLSResourceCallbacksSupport() {}
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
   HLSDecoder* mDecoder;
 };
 
 HLSResourceCallbacksSupport::HLSResourceCallbacksSupport(HLSDecoder* aDecoder)
     : mMutex("HLSResourceCallbacksSupport"), mDecoder(aDecoder) {
   MOZ_ASSERT(mDecoder);
 }
 

--- a/dom/media/hls/HLSDemuxer.cpp
+++ b/dom/media/hls/HLSDemuxer.cpp
@@ -114,17 +114,17 @@ class HLSDemuxer::HLSDemuxerCallbacksSup
     Unused << rv;
   }
 
   void Detach() {
     MutexAutoLock lock(mMutex);
     mDemuxer = nullptr;
   }
 
-  Mutex mMutex;
+  Mutex mMutex MOZ_UNANNOTATED;
 
  private:
   ~HLSDemuxerCallbacksSupport() {}
   HLSDemuxer* mDemuxer;
 };
 
 HLSDemuxer::HLSDemuxer(int aPlayerId)
     : mTaskQueue(new TaskQueue(GetMediaThreadPool(MediaThreadType::SUPERVISOR),

--- a/dom/media/hls/HLSDemuxer.h
+++ b/dom/media/hls/HLSDemuxer.h
@@ -122,15 +122,15 @@ class HLSTrackDemuxer : public MediaTrac
   RefPtr<HLSDemuxer> mParent;
   TrackInfo::TrackType mType;
   Maybe<media::TimeUnit> mNextKeyframeTime;
   int32_t mLastFormatIndex = -1;
   // Queued samples extracted by the demuxer, but not yet returned.
   RefPtr<MediaRawData> mQueuedSample;
 
   // Mutex to protect members below across multiple threads.
-  mutable Mutex mMutex;
+  mutable Mutex mMutex MOZ_UNANNOTATED;
   UniquePtr<TrackInfo> mTrackInfo;
 };
 
 }  // namespace mozilla
 
 #endif

--- a/dom/media/mediasource/ContainerParser.cpp
+++ b/dom/media/mediasource/ContainerParser.cpp
@@ -111,17 +111,17 @@ class WebMContainerParser
   MediaResult IsInitSegmentPresent(const MediaSpan& aData) override {
     ContainerParser::IsInitSegmentPresent(aData);
     if (aData.Length() < 4) {
       return NS_ERROR_NOT_AVAILABLE;
     }
 
     WebMBufferedParser parser(0);
     nsTArray<WebMTimeDataOffset> mapping;
-    ReentrantMonitor dummy("dummy");
+    ReentrantMonitor dummy MOZ_ANNOTATED("dummy");
     bool result =
         parser.Append(aData.Elements(), aData.Length(), mapping, dummy);
     if (!result) {
       return MediaResult(NS_ERROR_FAILURE,
                          RESULT_DETAIL("Invalid webm content"));
     }
     return parser.mInitEndOffset > 0 ? NS_OK : NS_ERROR_NOT_AVAILABLE;
   }
@@ -129,17 +129,17 @@ class WebMContainerParser
   MediaResult IsMediaSegmentPresent(const MediaSpan& aData) override {
     ContainerParser::IsMediaSegmentPresent(aData);
     if (aData.Length() < 4) {
       return NS_ERROR_NOT_AVAILABLE;
     }
 
     WebMBufferedParser parser(0);
     nsTArray<WebMTimeDataOffset> mapping;
-    ReentrantMonitor dummy("dummy");
+    ReentrantMonitor dummy MOZ_ANNOTATED("dummy");
     parser.AppendMediaSegmentOnly();
     bool result =
         parser.Append(aData.Elements(), aData.Length(), mapping, dummy);
     if (!result) {
       return MediaResult(NS_ERROR_FAILURE,
                          RESULT_DETAIL("Invalid webm content"));
     }
     return parser.GetClusterOffset() >= 0 ? NS_OK : NS_ERROR_NOT_AVAILABLE;
@@ -177,17 +177,17 @@ class WebMContainerParser
       mGlobalOffset = mTotalParsed;
     }
 
     // XXX if it only adds new mappings, overlapped but not available
     // (e.g. overlap < 0) frames are "lost" from the reported mappings here.
     nsTArray<WebMTimeDataOffset> mapping;
     mapping.AppendElements(mOverlappedMapping);
     mOverlappedMapping.Clear();
-    ReentrantMonitor dummy("dummy");
+    ReentrantMonitor dummy MOZ_ANNOTATED("dummy");
     mParser.Append(aData.Elements(), aData.Length(), mapping, dummy);
     if (mResource) {
       mResource->AppendData(aData);
     }
 
     // XXX This is a bit of a hack.  Assume if there are no timecodes
     // present and it's an init segment that it's _just_ an init segment.
     // We should be more precise.

--- a/dom/media/mediasource/MediaSourceDemuxer.h
+++ b/dom/media/mediasource/MediaSourceDemuxer.h
@@ -78,17 +78,17 @@ class MediaSourceDemuxer : public MediaD
   RefPtr<TaskQueue> mTaskQueue;
   nsTArray<RefPtr<MediaSourceTrackDemuxer>> mDemuxers;
 
   nsTArray<RefPtr<TrackBuffersManager>> mSourceBuffers;
 
   MozPromiseHolder<InitPromise> mInitPromise;
 
   // Monitor to protect members below across multiple threads.
-  mutable Monitor mMonitor;
+  mutable Monitor mMonitor MOZ_UNANNOTATED;
   RefPtr<TrackBuffersManager> mAudioTrack;
   RefPtr<TrackBuffersManager> mVideoTrack;
   MediaInfo mInfo;
 };
 
 class MediaSourceTrackDemuxer
     : public MediaTrackDemuxer,
       public DecoderDoctorLifeLogger<MediaSourceTrackDemuxer> {
@@ -133,17 +133,17 @@ class MediaSourceTrackDemuxer
       const media::TimeUnit& aTimeThreadshold);
   already_AddRefed<MediaRawData> GetSample(MediaResult& aError);
   // Return the timestamp of the next keyframe after mLastSampleIndex.
   media::TimeUnit GetNextRandomAccessPoint();
 
   RefPtr<MediaSourceDemuxer> mParent;
   TrackInfo::TrackType mType;
   // Monitor protecting members below accessed from multiple threads.
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
   media::TimeUnit mNextRandomAccessPoint;
   // Would be accessed in MFR's demuxer proxy task queue and TaskQueue, and
   // only be set on the TaskQueue. It can be accessed while on TaskQueue without
   // the need for the lock.
   RefPtr<TrackBuffersManager> mManager;
 
   // Only accessed on TaskQueue
   Maybe<RefPtr<MediaRawData>> mNextSample;

--- a/dom/media/mediasource/TrackBuffersManager.h
+++ b/dom/media/mediasource/TrackBuffersManager.h
@@ -509,17 +509,17 @@ class TrackBuffersManager final
   enum class EvictionState {
     NO_EVICTION_NEEDED,
     EVICTION_NEEDED,
     EVICTION_COMPLETED,
   };
   Atomic<EvictionState> mEvictionState;
 
   // Monitor to protect following objects accessed across multiple threads.
-  mutable Mutex mMutex;
+  mutable Mutex mMutex MOZ_UNANNOTATED;
   // mTaskQueue is only ever written after construction on the task queue.
   // As such, it can be accessed while on task queue without the need for the
   // mutex.
   RefPtr<TaskQueue> mTaskQueue;
   // Stable audio and video track time ranges.
   media::TimeIntervals mVideoBufferedRanges;
   media::TimeIntervals mAudioBufferedRanges;
   // MediaInfo of the first init segment read.

--- a/dom/media/ogg/OggCodecStore.h
+++ b/dom/media/ogg/OggCodecStore.h
@@ -24,14 +24,14 @@ class OggCodecStore {
   OggCodecState* Get(uint32_t serial);
   bool IsKnownStream(uint32_t aSerial);
 
  private:
   // Maps Ogg serialnos to OggStreams.
   nsClassHashtable<nsUint32HashKey, OggCodecState> mCodecStates;
 
   // Protects the |mCodecStates| and the |mKnownStreams| members.
-  Monitor mMonitor;
+  Monitor mMonitor MOZ_UNANNOTATED;
 };
 
 }  // namespace mozilla
 
 #endif

--- a/dom/media/platforms/AllocationPolicy.h
+++ b/dom/media/platforms/AllocationPolicy.h
@@ -52,17 +52,17 @@ class AllocPolicy {
  */
 class GlobalAllocPolicy {
  public:
   // Get the singleton for the given track type. Thread-safe.
   static NotNull<AllocPolicy*> Instance(TrackInfo::TrackType aTrack);
 
  private:
   // Protect access to Instance().
-  static StaticMutex sMutex;
+  static StaticMutex sMutex MOZ_UNANNOTATED;
 };
 
 /** This the actual base implementation underneath all AllocPolicy objects and
  * control how many decoders can be created concurrently.
  * Alloc() must be called to get a token object as a permission to perform an
  * action. The token should stay alive until Shutdown() is called on the
  * decoder. The destructor of the token will restore the decoder count so it is
  * available for next calls of Alloc().
@@ -81,17 +81,17 @@ class AllocPolicyImpl : public AllocPoli
   class AutoDeallocToken;
   using PromisePrivate = Promise::Private;
   // Called by the destructor of TokenImpl to restore the decoder limit.
   void Dealloc();
   // Decrement the decoder limit and resolve a promise if available.
   void ResolvePromise(ReentrantMonitorAutoEnter& aProofOfLock);
 
   const int mMaxDecoderLimit;
-  ReentrantMonitor mMonitor;
+  ReentrantMonitor mMonitor MOZ_UNANNOTATED;
   // The number of decoders available for creation.
   int mDecoderLimit;
   // Requests to acquire tokens.
   std::queue<RefPtr<PromisePrivate>> mPromises;
 };
 
 /**
  * This class allows to track and serialise a single decoder allocation at a

--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -143,17 +143,17 @@ class PDMInitializer final {
     FFVPXRuntimeLinker::Init();
 #endif
 #ifdef MOZ_FFMPEG
     FFmpegRuntimeLinker::Init();
 #endif
   }
 
   static bool sHasInitializedPDMs;
-  static StaticMutex sMonitor;
+  static StaticMutex sMonitor MOZ_UNANNOTATED;
 };
 
 bool PDMInitializer::sHasInitializedPDMs = false;
 StaticMutex PDMInitializer::sMonitor;
 
 /* static */
 void PDMInitializer::InitPDMs() {
   StaticMutexAutoLock mon(sMonitor);

--- a/dom/media/platforms/SimpleMap.h
+++ b/dom/media/platforms/SimpleMap.h
@@ -41,15 +41,15 @@ class SimpleMap {
   }
   // Remove all elements of the map.
   void Clear() {
     MutexAutoLock lock(mMutex);
     mMap.Clear();
   }
 
  private:
-  Mutex mMutex;  // To protect mMap.
+  Mutex mMutex MOZ_UNANNOTATED;  // To protect mMap.
   AutoTArray<Element, 16> mMap;
 };
 
 }  // namespace mozilla
 
 #endif  // mozilla_SimpleMap_h