Bug 1761040 - Prefix thread safety macros with MOZ_ r=geckoview-reviewers,media-playback-reviewers,alwu,jesup,m_kato

Differential Revision: https://phabricator.services.mozilla.com/D152575

Author: fabricedesre

docshell/base/timeline/ObservedDocShell.h

@@ -37,7 +37,7 @@ class ObservedDocShell : public MarkersStorage {
   // Off the main thread only.
   Mutex mLock;
   nsTArray<UniquePtr<AbstractTimelineMarker>> mOffTheMainThreadTimelineMarkers
-      GUARDED_BY(mLock);
+      MOZ_GUARDED_BY(mLock);
 
  public:
   explicit ObservedDocShell(nsIDocShell* aDocShell);

docshell/base/timeline/TimelineConsumers.h

@@ -101,11 +101,11 @@ class TimelineConsumers {
  private:
   static StaticMutex sMutex;
 
-  static LinkedList<MarkersStorage>& MarkersStores() REQUIRES(sMutex);
+  static LinkedList<MarkersStorage>& MarkersStores() MOZ_REQUIRES(sMutex);
 
-  static uint32_t sActiveConsumers GUARDED_BY(sMutex);
+  static uint32_t sActiveConsumers MOZ_GUARDED_BY(sMutex);
   static StaticAutoPtr<LinkedList<MarkersStorage>> sMarkersStores
-      GUARDED_BY(sMutex);
+      MOZ_GUARDED_BY(sMutex);
 };
 
 }  // namespace mozilla

dom/base/BodyStream.cpp

@@ -428,7 +428,7 @@ void BodyStream::EnqueueChunkWithSizeIntoStream(JSContext* aCx,
 // thread-safety doesn't handle emplace well
 NS_IMETHODIMP
 BodyStream::OnInputStreamReady(nsIAsyncInputStream* aStream)
-    NO_THREAD_SAFETY_ANALYSIS {
+    MOZ_NO_THREAD_SAFETY_ANALYSIS {
   AssertIsOnOwningThread();
   MOZ_DIAGNOSTIC_ASSERT(aStream);
   mAsyncWaitWorkerRef = nullptr;

dom/base/BodyStream.h

@@ -141,17 +141,18 @@ class BodyStream final : public nsIInputStreamCallback,
 
   void ErrorPropagation(JSContext* aCx,
                         const MutexSingleWriterAutoLock& aProofOfLock,
-                        ReadableStream* aStream, nsresult aRv) REQUIRES(mMutex);
+                        ReadableStream* aStream, nsresult aRv)
+      MOZ_REQUIRES(mMutex);
 
   // TODO: convert this to MOZ_CAN_RUN_SCRIPT (bug 1750605)
   MOZ_CAN_RUN_SCRIPT_BOUNDARY void CloseAndReleaseObjects(
       JSContext* aCx, const MutexSingleWriterAutoLock& aProofOfLock,
-      ReadableStream* aStream) REQUIRES(mMutex);
+      ReadableStream* aStream) MOZ_REQUIRES(mMutex);
 
   class WorkerShutdown;
 
   void ReleaseObjects(const MutexSingleWriterAutoLock& aProofOfLock)
-      REQUIRES(mMutex);
+      MOZ_REQUIRES(mMutex);
 
   void ReleaseObjects();
 
@@ -186,12 +187,12 @@ class BodyStream final : public nsIInputStreamCallback,
   MutexSingleWriter mMutex;
 
   // Protected by mutex.
-  State mState GUARDED_BY(mMutex);  // all writes are from the owning thread
+  State mState MOZ_GUARDED_BY(mMutex);  // all writes are from the owning thread
 
   // mGlobal is set on creation, and isn't modified off the owning thread.
   // It isn't set to nullptr until ReleaseObjects() runs.
   nsCOMPtr<nsIGlobalObject> mGlobal;
-  RefPtr<BodyStreamHolder> mStreamHolder GUARDED_BY(mMutex);
+  RefPtr<BodyStreamHolder> mStreamHolder MOZ_GUARDED_BY(mMutex);
   nsCOMPtr<nsIEventTarget> mOwningEventTarget;
 
   // This is the original inputStream received during the CTOR. It will be

dom/canvas/WebGLContext.h

@@ -272,7 +272,7 @@ class WebGLContext : public VRefCounted, public SupportsWeakPtr {
     ~LruPosition() { Reset(); }
   };
 
-  mutable LruPosition mLruPosition GUARDED_BY(sLruMutex);
+  mutable LruPosition mLruPosition MOZ_GUARDED_BY(sLruMutex);
 
   void BumpLruLocked(const StaticMutexAutoLock& aProofOfLock);
 
@@ -740,7 +740,7 @@ class WebGLContext : public VRefCounted, public SupportsWeakPtr {
 
  private:
   static StaticMutex sLruMutex;
-  static std::list<WebGLContext*> sLru GUARDED_BY(sLruMutex);
+  static std::list<WebGLContext*> sLru MOZ_GUARDED_BY(sLruMutex);
 
   // State tracking slots
   bool mDitherEnabled = true;

dom/console/ConsoleReportCollector.h

@@ -81,7 +81,7 @@ class ConsoleReportCollector final : public nsIConsoleReportCollector {
   Mutex mMutex;
 
   // protected by mMutex
-  nsTArray<PendingReport> mPendingReports GUARDED_BY(mMutex);
+  nsTArray<PendingReport> mPendingReports MOZ_GUARDED_BY(mMutex);
 
  public:
   NS_DECL_THREADSAFE_ISUPPORTS

dom/file/ipc/RemoteLazyInputStream.h

@@ -66,12 +66,12 @@ class RemoteLazyInputStream final : public nsIAsyncInputStream,
 
   ~RemoteLazyInputStream();
 
-  void StreamNeeded() REQUIRES(mMutex);
+  void StreamNeeded() MOZ_REQUIRES(mMutex);
 
   // Upon receiving the stream from our actor, we will not wrap it into an async
   // stream until needed. This allows callers to get access to the underlying
   // potentially-sync stream using `TakeInternalStream` before reading.
-  nsresult EnsureAsyncRemoteStream() REQUIRES(mMutex);
+  nsresult EnsureAsyncRemoteStream() MOZ_REQUIRES(mMutex);
 
   // Note that data has been read from our input stream, and disconnect from our
   // remote actor.
@@ -82,7 +82,7 @@ class RemoteLazyInputStream final : public nsIAsyncInputStream,
       IPC::MessageReader* aReader);
 
   // Helper method to generate a description of a stream for use in loggging.
-  nsCString Describe() REQUIRES(mMutex);
+  nsCString Describe() MOZ_REQUIRES(mMutex);
 
   // Start and length of the slice to apply on this RemoteLazyInputStream when
   // fetching the underlying stream with `SendStreamNeeded`.
@@ -112,7 +112,7 @@ class RemoteLazyInputStream final : public nsIAsyncInputStream,
     // mInnerStream is released and any method will return
     // NS_BASE_STREAM_CLOSED.
     eClosed,
-  } mState GUARDED_BY(mMutex) = eClosed;
+  } mState MOZ_GUARDED_BY(mMutex) = eClosed;
 
   // The actor which will be used to provide the underlying stream or length
   // information when needed, as well as to efficiently allow transferring the
@@ -121,22 +121,25 @@ class RemoteLazyInputStream final : public nsIAsyncInputStream,
   // The connection to our actor will be cleared once the stream has been closed
   // or has started reading, at which point this stream will be serialized and
   // cloned as-if it was the underlying stream.
-  RefPtr<RemoteLazyInputStreamChild> mActor GUARDED_BY(mMutex);
+  RefPtr<RemoteLazyInputStreamChild> mActor MOZ_GUARDED_BY(mMutex);
 
-  nsCOMPtr<nsIInputStream> mInnerStream GUARDED_BY(mMutex);
-  nsCOMPtr<nsIAsyncInputStream> mAsyncInnerStream GUARDED_BY(mMutex);
+  nsCOMPtr<nsIInputStream> mInnerStream MOZ_GUARDED_BY(mMutex);
+  nsCOMPtr<nsIAsyncInputStream> mAsyncInnerStream MOZ_GUARDED_BY(mMutex);
 
   // These 2 values are set only if mState is ePending or eRunning.
   // RefPtr is used instead of nsCOMPtr to avoid invoking QueryInterface when
   // assigning in debug builds, as `mInputStreamCallback` may not be threadsafe.
-  RefPtr<nsIInputStreamCallback> mInputStreamCallback GUARDED_BY(mMutex);
-  nsCOMPtr<nsIEventTarget> mInputStreamCallbackEventTarget GUARDED_BY(mMutex);
-  uint32_t mInputStreamCallbackFlags GUARDED_BY(mMutex) = 0;
-  uint32_t mInputStreamCallbackRequestedCount GUARDED_BY(mMutex) = 0;
+  RefPtr<nsIInputStreamCallback> mInputStreamCallback MOZ_GUARDED_BY(mMutex);
+  nsCOMPtr<nsIEventTarget> mInputStreamCallbackEventTarget
+      MOZ_GUARDED_BY(mMutex);
+  uint32_t mInputStreamCallbackFlags MOZ_GUARDED_BY(mMutex) = 0;
+  uint32_t mInputStreamCallbackRequestedCount MOZ_GUARDED_BY(mMutex) = 0;
 
   // These 2 values are set only if mState is ePending.
-  nsCOMPtr<nsIFileMetadataCallback> mFileMetadataCallback GUARDED_BY(mMutex);
-  nsCOMPtr<nsIEventTarget> mFileMetadataCallbackEventTarget GUARDED_BY(mMutex);
+  nsCOMPtr<nsIFileMetadataCallback> mFileMetadataCallback
+      MOZ_GUARDED_BY(mMutex);
+  nsCOMPtr<nsIEventTarget> mFileMetadataCallbackEventTarget
+      MOZ_GUARDED_BY(mMutex);
 };
 
 }  // namespace mozilla

dom/ipc/ProcessHangMonitor.cpp

@@ -156,21 +156,22 @@ class HangMonitorChild : public PProcessHangMonitorChild,
   bool mSentReport;
 
   // These fields must be accessed with mMonitor held.
-  bool mTerminateScript GUARDED_BY(mMonitor);
-  bool mStartDebugger GUARDED_BY(mMonitor);
-  bool mFinishedStartingDebugger GUARDED_BY(mMonitor);
-  bool mPaintWhileInterruptingJS GUARDED_BY(mMonitor);
-  TabId mPaintWhileInterruptingJSTab GUARDED_BY(mMonitor);
+  bool mTerminateScript MOZ_GUARDED_BY(mMonitor);
+  bool mStartDebugger MOZ_GUARDED_BY(mMonitor);
+  bool mFinishedStartingDebugger MOZ_GUARDED_BY(mMonitor);
+  bool mPaintWhileInterruptingJS MOZ_GUARDED_BY(mMonitor);
+  TabId mPaintWhileInterruptingJSTab MOZ_GUARDED_BY(mMonitor);
   MOZ_INIT_OUTSIDE_CTOR LayersObserverEpoch mPaintWhileInterruptingJSEpoch
-      GUARDED_BY(mMonitor);
-  bool mCancelContentJS GUARDED_BY(mMonitor);
-  TabId mCancelContentJSTab GUARDED_BY(mMonitor);
+      MOZ_GUARDED_BY(mMonitor);
+  bool mCancelContentJS MOZ_GUARDED_BY(mMonitor);
+  TabId mCancelContentJSTab MOZ_GUARDED_BY(mMonitor);
   nsIRemoteTab::NavigationType mCancelContentJSNavigationType
-      GUARDED_BY(mMonitor);
-  int32_t mCancelContentJSNavigationIndex GUARDED_BY(mMonitor);
-  mozilla::Maybe<nsCString> mCancelContentJSNavigationURI GUARDED_BY(mMonitor);
-  int32_t mCancelContentJSEpoch GUARDED_BY(mMonitor);
-  bool mShutdownDone GUARDED_BY(mMonitor);
+      MOZ_GUARDED_BY(mMonitor);
+  int32_t mCancelContentJSNavigationIndex MOZ_GUARDED_BY(mMonitor);
+  mozilla::Maybe<nsCString> mCancelContentJSNavigationURI
+      MOZ_GUARDED_BY(mMonitor);
+  int32_t mCancelContentJSEpoch MOZ_GUARDED_BY(mMonitor);
+  bool mShutdownDone MOZ_GUARDED_BY(mMonitor);
 
   JSContext* mContext;  // const after constructor
 
@@ -293,14 +294,14 @@ class HangMonitorParent : public PProcessHangMonitorParent,
   RefPtr<HangMonitoredProcess> mProcess;
 
   // Must be accessed with mMonitor held.
-  bool mShutdownDone GUARDED_BY(mMonitor);
+  bool mShutdownDone MOZ_GUARDED_BY(mMonitor);
   // Map from plugin ID to crash dump ID. Protected by
   // mBrowserCrashDumpHashLock.
   nsTHashMap<nsUint32HashKey, nsString> mBrowserCrashDumpIds
-      GUARDED_BY(mMonitor);
-  Mutex mBrowserCrashDumpHashLock GUARDED_BY(mMonitor);
+      MOZ_GUARDED_BY(mMonitor);
+  Mutex mBrowserCrashDumpHashLock MOZ_GUARDED_BY(mMonitor);
   mozilla::ipc::TaskFactory<HangMonitorParent> mMainThreadTaskFactory
-      GUARDED_BY(mMonitor);
+      MOZ_GUARDED_BY(mMonitor);
 };
 
 }  // namespace

dom/media/AudioStream.cpp

@@ -228,7 +228,7 @@ int AudioStream::InvokeCubeb(Function aFunction, Args&&... aArgs) {
 }
 
 nsresult AudioStream::Init(AudioDeviceInfo* aSinkInfo)
-    NO_THREAD_SAFETY_ANALYSIS {
+    MOZ_NO_THREAD_SAFETY_ANALYSIS {
   auto startTime = TimeStamp::Now();
   TRACE("AudioStream::Init");
 

dom/media/AudioStream.h

@@ -112,7 +112,7 @@ class AudioClock {
   // protected by the AudioStream monitor on other platforms.
   const UniquePtr<FrameHistory> mFrameHistory
 #  ifndef XP_MACOSX
-      GUARDED_BY(mMutex)
+      MOZ_GUARDED_BY(mMutex)
 #  endif
           ;
 #  ifdef XP_MACOSX
@@ -335,10 +335,10 @@ class AudioStream final {
 
   // Return true if audio frames are valid (correct sampling rate and valid
   // channel count) otherwise false.
-  bool IsValidAudioFormat(Chunk* aChunk) REQUIRES(mMonitor);
+  bool IsValidAudioFormat(Chunk* aChunk) MOZ_REQUIRES(mMonitor);
 
   template <typename Function, typename... Args>
-  int InvokeCubeb(Function aFunction, Args&&... aArgs) REQUIRES(mMonitor);
+  int InvokeCubeb(Function aFunction, Args&&... aArgs) MOZ_REQUIRES(mMonitor);
   bool CheckThreadIdChanged();
   void AssertIsOnAudioThread() const;
 
@@ -382,7 +382,8 @@ class AudioStream final {
   std::atomic<ProfilerThreadId> mAudioThreadId;
   const bool mSandboxed = false;
 
-  MozPromiseHolder<MediaSink::EndedPromise> mEndedPromise GUARDED_BY(mMonitor);
+  MozPromiseHolder<MediaSink::EndedPromise> mEndedPromise
+      MOZ_GUARDED_BY(mMonitor);
   std::atomic<bool> mPlaybackComplete;
   // Both written on the MDSM thread, read on the audio thread.
   std::atomic<float> mPlaybackRate;