public:

#if !DCHECK_IS_ON() // Optimized wrapper implementation

Lock() : lock_() {}

Lock(const Lock&) = delete;

Lock& operator=(const Lock&) = delete;

~Lock() {}

void Acquire() { lock_.Lock(); }

void Release() { lock_.Unlock(); }

///

/// If the lock is not held, take it and return true. If the lock is already

/// held by another thread, immediately return false. This must not be called

/// by a thread already holding the lock (what happens is undefined and an

/// assertion may fail).

///

bool Try() { return lock_.Try(); }

// Null implementation if not debug.

void AssertAcquired() const {}

#else

Lock();

~Lock();

// NOTE: Although windows critical sections support recursive locks, we do not

// allow this, and we will commonly fire a DCHECK() if a thread attempts to

// acquire the lock a second time (while already holding it).

void Acquire() {

lock_.Lock();

CheckUnheldAndMark();

}

void Release() {

CheckHeldAndUnmark();

lock_.Unlock();

}

bool Try() {

bool rv = lock_.Try();

if (rv) {

CheckUnheldAndMark();

}

return rv;

}

void AssertAcquired() const;

#endif // !DCHECK_IS_ON()

private:

#if DCHECK_IS_ON()

// Members and routines taking care of locks assertions.

// Note that this checks for recursive locks and allows them

// if the variable is set. This is allowed by the underlying implementation

// on windows but not on Posix, so we're doing unneeded checks on Posix.

// It's worth it to share the code.

void CheckHeldAndUnmark();

void CheckUnheldAndMark();

// All private data is implicitly protected by lock_.

// Be VERY careful to only access members under that lock.

base::PlatformThreadRef owning_thread_ref_;

#endif // DCHECK_IS_ON()

// Platform specific underlying lock implementation.

LockImpl lock_;

public:

struct AlreadyAcquired {};

explicit AutoLock(Lock& lock) : lock_(lock) { lock_.Acquire(); }

AutoLock(Lock& lock, const AlreadyAcquired&) : lock_(lock) {

lock_.AssertAcquired();

}

AutoLock(const AutoLock&) = delete;

AutoLock& operator=(const AutoLock&) = delete;

~AutoLock() {

lock_.AssertAcquired();

lock_.Release();

}

private:

Lock& lock_;

public:

explicit AutoUnlock(Lock& lock) : lock_(lock) {

// We require our caller to have the lock.

lock_.AssertAcquired();

lock_.Release();

}

AutoUnlock(const AutoUnlock&) = delete;

AutoUnlock& operator=(const AutoUnlock&) = delete;

~AutoUnlock() { lock_.Acquire(); }

private:

Lock& lock_;