ThreadRestrictionVerifier.h [plain text]
#ifndef ThreadRestrictionVerifier_h
#define ThreadRestrictionVerifier_h
#include <wtf/Assertions.h>
#include <wtf/Threading.h>
#include <wtf/ThreadingPrimitives.h>
#if HAVE(DISPATCH_H)
#include <dispatch/dispatch.h>
#endif
#ifndef NDEBUG
namespace WTF {
class ThreadRestrictionVerifier {
public:
ThreadRestrictionVerifier()
: m_mode(SingleThreadVerificationMode)
, m_shared(false)
, m_owningThread(0)
, m_mutex(0)
#if HAVE(DISPATCH_H)
, m_owningQueue(0)
#endif
{
}
#if HAVE(DISPATCH_H)
~ThreadRestrictionVerifier()
{
if (m_owningQueue)
dispatch_release(m_owningQueue);
}
#endif
void setMutexMode(Mutex& mutex)
{
ASSERT(m_mode == SingleThreadVerificationMode || (m_mode == MutexVerificationMode && &mutex == m_mutex));
m_mode = MutexVerificationMode;
m_mutex = &mutex;
}
#if HAVE(DISPATCH_H)
void setDispatchQueueMode(dispatch_queue_t queue)
{
ASSERT(m_mode == SingleThreadVerificationMode);
m_mode = SingleDispatchQueueVerificationMode;
m_owningQueue = queue;
dispatch_retain(m_owningQueue);
}
#endif
void turnOffVerification()
{
ASSERT(m_mode == SingleThreadVerificationMode);
m_mode = NoVerificationMode;
}
void setShared(bool shared)
{
#if !ASSERT_DISABLED
bool previouslyShared = m_shared;
#endif
m_shared = shared;
if (!m_shared)
return;
switch (m_mode) {
case SingleThreadVerificationMode:
ASSERT(shared != previouslyShared);
m_owningThread = currentThread();
return;
#if HAVE(DISPATCH_H)
case SingleDispatchQueueVerificationMode:
#endif
case MutexVerificationMode:
case NoVerificationMode:
return;
}
ASSERT_NOT_REACHED();
}
bool isSafeToUse() const
{
if (!m_shared)
return true;
switch (m_mode) {
case SingleThreadVerificationMode:
return m_owningThread == currentThread();
case MutexVerificationMode:
if (!m_mutex->tryLock())
return true;
m_mutex->unlock();
return false;
#if HAVE(DISPATCH_H)
case SingleDispatchQueueVerificationMode:
return m_owningQueue == dispatch_get_current_queue();
#endif
case NoVerificationMode:
return true;
}
ASSERT_NOT_REACHED();
return true;
}
private:
enum VerificationMode {
SingleThreadVerificationMode,
MutexVerificationMode,
NoVerificationMode,
#if HAVE(DISPATCH_H)
SingleDispatchQueueVerificationMode,
#endif
};
VerificationMode m_mode;
bool m_shared;
ThreadIdentifier m_owningThread;
Mutex* m_mutex;
#if HAVE(DISPATCH_H)
dispatch_queue_t m_owningQueue;
#endif
};
}
#endif
#endif