92 lines
2.6 KiB
C++
92 lines
2.6 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// Copyright 2016 Google Inc.
|
|
//
|
|
// This software is licensed under the terms defined in the Widevine Master
|
|
// License Agreement. For a copy of this agreement, please contact
|
|
// widevine-licensing@google.com.
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef BASE_MUTEX_H_
|
|
#define BASE_MUTEX_H_
|
|
|
|
#include <stdlib.h>
|
|
#include <pthread.h>
|
|
|
|
#include "glog/logging.h"
|
|
#include "base/macros.h"
|
|
#include "base/thread_annotations.h"
|
|
|
|
// Basic mutex wrapper around a pthread RW lock.
|
|
class LOCKABLE Mutex {
|
|
public:
|
|
inline Mutex() { CHECK_EQ(pthread_rwlock_init(&lock_, nullptr), 0); }
|
|
inline Mutex(base::LinkerInitialized) { // NOLINT
|
|
CHECK_EQ(pthread_rwlock_init(&lock_, nullptr), 0);
|
|
}
|
|
inline ~Mutex() { CHECK_EQ(pthread_rwlock_destroy(&lock_), 0); }
|
|
inline void Lock() EXCLUSIVE_LOCK_FUNCTION() { WriterLock(); }
|
|
inline void Unlock() UNLOCK_FUNCTION() { WriterUnlock(); }
|
|
inline void ReaderLock() SHARED_LOCK_FUNCTION() {
|
|
CHECK_EQ(pthread_rwlock_rdlock(&lock_), 0);
|
|
}
|
|
inline void ReaderUnlock() UNLOCK_FUNCTION() {
|
|
CHECK_EQ(pthread_rwlock_unlock(&lock_), 0);
|
|
}
|
|
inline void WriterLock() EXCLUSIVE_LOCK_FUNCTION() {
|
|
CHECK_EQ(pthread_rwlock_wrlock(&lock_), 0);
|
|
}
|
|
inline void WriterUnlock() UNLOCK_FUNCTION() {
|
|
CHECK_EQ(pthread_rwlock_unlock(&lock_), 0);
|
|
}
|
|
|
|
private:
|
|
pthread_rwlock_t lock_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(Mutex);
|
|
};
|
|
|
|
// -----------------------------------------------------------------------------
|
|
// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
|
|
class SCOPED_LOCKABLE MutexLock {
|
|
public:
|
|
explicit MutexLock(Mutex* mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
|
|
this->mu_->Lock();
|
|
}
|
|
~MutexLock() UNLOCK_FUNCTION() { this->mu_->Unlock(); }
|
|
|
|
private:
|
|
Mutex* const mu_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(MutexLock);
|
|
};
|
|
|
|
// The ReaderMutexLock and WriterMutexLock classes work like MutexLock
|
|
// to acquire/release read and write locks on reader/writer locks.
|
|
class SCOPED_LOCKABLE ReaderMutexLock {
|
|
public:
|
|
explicit ReaderMutexLock(Mutex* mu) SHARED_LOCK_FUNCTION(mu) : mu_(mu) {
|
|
mu->ReaderLock();
|
|
}
|
|
~ReaderMutexLock() UNLOCK_FUNCTION() { this->mu_->ReaderUnlock(); }
|
|
|
|
private:
|
|
Mutex* const mu_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(ReaderMutexLock);
|
|
};
|
|
|
|
class SCOPED_LOCKABLE WriterMutexLock {
|
|
public:
|
|
explicit WriterMutexLock(Mutex* mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
|
|
mu->WriterLock();
|
|
}
|
|
~WriterMutexLock() UNLOCK_FUNCTION() { this->mu_->WriterUnlock(); }
|
|
|
|
private:
|
|
Mutex* const mu_;
|
|
|
|
DISALLOW_COPY_AND_ASSIGN(WriterMutexLock);
|
|
};
|
|
|
|
#endif // BASE_MUTEX_H_
|