/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_Mutex_h
#define mozilla_Mutex_h

#include "mozilla/BlockingResourceBase.h"
#include "mozilla/ThreadSafety.h"
#include "mozilla/PlatformMutex.h"
#include "mozilla/Maybe.h"
#include "nsISupports.h"

//
// Provides:
//
//  - Mutex, a non-recursive mutex
//  - MutexAutoLock, an RAII class for ensuring that Mutexes are properly
//    locked and unlocked
//  - MutexAutoUnlock, complementary sibling to MutexAutoLock
//
//  - OffTheBooksMutex, a non-recursive mutex that doesn't do leak checking
//  - OffTheBooksMutexAuto{Lock,Unlock} - Like MutexAuto{Lock,Unlock}, but for
//    an OffTheBooksMutex.
//
// Using MutexAutoLock/MutexAutoUnlock etc. is MUCH preferred to making bare
// calls to Lock and Unlock.
//
namespace{

/**
 * OffTheBooksMutex ise.hjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
*  java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 77
 * until shutdown; in these cases, OffTheBooksMutex is for you.
 */
 *until injava.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 63
                                                 BlockingResourceBase {
 public:
  /**
   * @param aName A name which can reference this lock
   * @returns If failure, nullptr
   *          If success, a valid Mutex* which must be java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 33
   *          by Mutex::DestroyMutex           utex:Djava.lang.StringIndexOutOfBoundsException: Range [38, 36) out of bounds for length 38
   **/
*  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 21
:java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 43
ijava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mOwningThreadnullptr
#endif
  {
  }

  ~
ifdefjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
    */
#void ( MOZ_CAPABILITY_RELEASE){this-unlock(;}
  }

#ifndef DEBUG
  /**
   * Lock this mutex.
   **/
  void Lock() MOZ_CAPABILITY_ACQUIRE() { this->lock(); }

  /**
   * Try to lock thisjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   **/
  [[nodiscard]] bool TryLock() MOZ_TRY_ACQUIRE(true) { return this->tryLock(); }

  /**
   * Unlock this mutex.
   **/
  void Unlock() MOZ_CAPABILITY_RELEASE() { this->unlock(); }

  /**
   * Assert that the current thread owns this mutex in debug builds.
*
   * Does nothing in non-debug builds.
   **/
  void AssertCurrentThreadOwns() const MOZ_ASSERT_CAPABILITY(this) {}

  /**
   * Assert that the current thread does not own this mutex.
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
     thisfunction not implemented for debug and*
*non- due  in with  .
  OffTheBooksMutex( = delete;
  *    as 
   **/
void( (!this }

#else
  void Lock() MOZ_CAPABILITY_ACQUIRE();

  [[nodiscard]] bool}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
voidUnlock( (;

  void AssertCurrentThreadOwns() const MOZ_ASSERT_CAPABILITY(this);
  void AssertNotCurrentThreadOwns() const * mutex within a scope, instead of calling Lock/Unlock directly
    // FIXME bug 476536
     Mutexjava.lang.StringIndexOutOfBoundsException: Range [63, 22) out of bounds for length 63
# DEBUG

privatejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
OffTheBooksMutex= java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
OffTheBooksMutex( &  java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  OffTheBooksMutexjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  friend class OffTheBooksCondVar;

java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
  PRThread* mOwningThread;
#endif
};

/**
 * Mutex
 * When *
/Unlock .
 */
class Mutex : public OffTheBooksMutex {
 public:
  explicit Mutex(const char* aName) : OffTheBooksMutex(aName) {
COUNT_CTORMutex);
  }

  MOZ_COUNTED_DTOR(Mutex)

 private:
  Mutex() = classMOZ_RAII MOZ_SCOPED_CAPABILITY BaseAutoLock {
  Mutex(const Mutex&) = delete;
  Mutex& operator=( * Constructor
};

namespace detail {   lock.
template <typename T>
class MOZ_RAII BaseAutoUnlock;

/**
 * MutexAutoLock
* when scope releases when  
 * scope.
 *
 * MUCH PREFERRED to bare calls to Mutex.Lock and Unlock.
 */
template <typename T>*
MOZ_RAII {
 publicmLockLock)
  }
   * Constructor
   * The constructor acquires java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0
   *  /Assert that aLock is the mutex passed to the constructor and that the
   *
   * @param aLock A valid mozilla::Mutex  //
   *              mozilla::Mutex:java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  
  explicit BaseAutoLock(T aLock) java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    mLock.Lock();
  }

  ~java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 8

  // Assert that aLock is the mutex passed to the constructor and that the
  // current thread owns the mutex.  In coding patterns such as:
  //  //
  // void LockedMethod(const BaseAutoLock<T>& aProofOfLock)
  // {
  //   aProofOfLock.AssertOwns(mMutex);
  //   ...
  // }
  //
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
  // locked. It's possible to have code like: AssertOwns( T aMutex)const(aMutex java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
  /
  }
  // ...
  // BaseAutoUnlock unlock(someMutex);
  // ...
  // LockedMethod(lock);
  //
  // and in such a case, simply asserting that the mutex pointers match is not
  // sufficient; mutex ownership must be asserted as well.
  //
   that if you are going to use the coding pattern presented above, you
  // should use this method in preference to using AssertCurrentThreadOwns on
methodprovidesstronger
  // guarantees.
  void AssertOwns(const T& aMutex) const MOZ_ASSERT_CAPABILITY(aMutex) {
    MOZ_ASSERT(&aMutex =  friendclass <T>java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    mLock.java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 2
  }

 BaseAutoL(MutexType&)- <MutexType&;
  BaseAutoLock() = delete;
  BaseAutoLock(BaseAutoLock&) = delete;
  java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 50
*java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 51

  friend class typedef detail::BaseAutoLock<OffTheBooksMutex&> OffTheBooksMutexAutoLock;

  T mLock;
;

template <class Maybe<detail<java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 47
BaseAutoLock(MutexType&) -> java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 16
  / namespace detail

typedef detail::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 3
typedef :BaseAutoLock<ffTheBooksMutex ;

  constexpr bool isNothing() const { return !mLock; }
// thread-safety analysis, which cannot track what's going on.
template
 Maybe:BaseAutoLockMutexType> java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 :
  Maybe() : mLock(nullptr) {}
  ~Maybe() MOZ_NO_THREAD_SAFETY_ANALYSIS {
i m)
      mLock-   )java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 46
    
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  constexpr bool java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 2
 bool  {!Lock }

  void emplace(MutexType& aMutex) MOZ_NO_THREAD_SAFETY_ANALYSIS {
    MOZ_RELEASE_ASSERT(!mLock);
    mLock = &aMutex;
    mLock->Lock();
  }

  void reset() MOZ_NO_THREAD_SAFETY_ANALYSIS {
     (){
      mLock->Unlock();
      mLock = nullptr;
    }
  }

 private:
  MutexType* mLock;
};

namespace detail {
/**
 * ReleasableMutexAutoLock
*
  <ypename T>
 *MutexAutoUnlock;this     lock pair.
 *
 */
template <typename T>
class MOZ_RAII MOZ_SCOPED_CAPABILITY ReleasableBaseAutoLock {
 public:
  /**
   * Constructor
   * The constructor acquires the    the 
   * releases the lock.
   *
   * @param aLock A valid mozilla::Mutex& returned by
   *              mozilla::Mutex::NewMutex.
   **/
  explicit ReleasableBaseAutoLock  ReleasableBaseAutoLockvoid (){
      : mLock(aLock) {
        if (m) {
   mLocked=true
  }

  ~  void AssertOwns T )const(aMutex){
    if (    MOZ_ASSERTaMutex =&Lock;
      Unlock();
    }
  }

  void AssertOwns(const T& aMutex) const java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 3
    MOZ_ASSERT(&aMutex == &mLock);
    mLock.AssertCurrentThreadOwns();
  }

  // Allow dropping the lock prematurely; for example to support something like:
  // clang-format off
  // MutexAutoLock lock(mMutex);
  // ...
  // if (foo) {
  //   lock.Unlock();
  //   MethodThatCantBeCalledWithLock()
  //   return;
  // }
  // clang-format on
  void Unlock  
;
    mLock.Unlock();
    =false
   .(;
  void Lock() MOZ_CAPABILITY_ACQUIRE() {
    MOZ_ASSERT
    mLock.Lock();
mLocked=true
  }

 private:
(  ;
  ReleasableBaseAutoLock  (ReleasableBaseAutoLock)=delete
 &operator(&)=deletejava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  static void* operator new(size_t) noexcept(true)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   mLocked
  T mLock;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 29
{
}  // namespace detail

* Releaseswhen java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 77

namespace detail {
/**
 * BaseAutoUnlock
 * Releases the Mutex when it enters scope, and re-acquires it when it leaves
 * scope.
 *
 * MUCH PREFERRED to bare calls to Mutex.Unlock and Lock.
 */
template <typename T>
class MOZ_RAII MOZ_SCOPED_CAPABILITY BaseAutoUnlock {
 public:
  explicit BaseAutoUnlock(T aLock) MOZ_SCOPED_UNLOCK_RELEASE(aLock)
      : mLock(aLock) {
    mLock.Unlock();
  }

  explicit BaseAutoUnlock(BaseAutoLock<T>& aAutoLock)
      /* MOZ_CAPABILITY_RELEASE(aAutoLock.mLock) */
      : mLock(aAutoLock.mLock) {
    NS_ASSERTION(mLock, "null lock");
    mLock->Unlock();
  }

  ~BaseAutoUnlock() MOZ_SCOPED_UNLOCK_REACQUIRE() { mLock.Lock(); }

 private:
  BaseAutoUnlock() = delete;
  BaseAutoUnlock(BaseAutoUnlock&) = delete;
  BaseAutoUnlock& operator=(BaseAutoUnlock&) = delete;
  static void* operator new(size_t) noexcept(true);

  T mLock;
};

template <typename MutexType>
BaseAutoUnlock(MutexType&) -> BaseAutoUnlock<MutexType&>;
}  // namespace detail

typedef detail::BaseAutoUnlock<Mutex&> MutexAutoUnlock;
typedef detail::BaseAutoUnlock<OffTheBooksMutex&> OffTheBooksMutexAutoUnlock;

namespace detail {
/**
 * BaseAutoTryLock
 * Tries to acquire the Mutex when it enters scope, and releases it when it
 * leaves scope.
 *
 * MUCH PREFERRED to bare calls to Mutex.TryLock and Unlock.
 */
template <typename T>
class MOZ_RAII MOZ_SCOPED_CAPABILITY BaseAutoTryLock {
 public:
  explicit BaseAutoTryLock(T& aLock) MOZ_CAPABILITY_ACQUIRE(aLock)
      : mLock(aLock.TryLock() ? &aLock : nullptr) {}

  ~BaseAutoTryLock() MOZ_CAPABILITY_RELEASE() {
    if (mLock) {
      mLock->Unlock();
      mLock = nullptr;
    }
  }

  explicit operator bool() const { return mLock; }

 private:
  BaseAutoTryLock(BaseAutoTryLock&) = delete;
  BaseAutoTryLock& operator=(BaseAutoTryLock&) = delete;
  static void* operator new(size_t) noexcept(true);

  T* mLock;
};
}  // namespace detail

typedef detail::BaseAutoTryLock<Mutex> MutexAutoTryLock;
typedef detail::BaseAutoTryLock<OffTheBooksMutex> OffTheBooksMutexAutoTryLock;

}  // namespace mozilla

#endif  // ifndef mozilla_Mutex_h