diff options
Diffstat (limited to 'Source/JavaScriptCore/wtf/RefCounted.h')
| -rw-r--r-- | Source/JavaScriptCore/wtf/RefCounted.h | 234 |
1 files changed, 234 insertions, 0 deletions
diff --git a/Source/JavaScriptCore/wtf/RefCounted.h b/Source/JavaScriptCore/wtf/RefCounted.h new file mode 100644 index 000000000..51c5dc26e --- /dev/null +++ b/Source/JavaScriptCore/wtf/RefCounted.h @@ -0,0 +1,234 @@ +/* + * Copyright (C) 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved. + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + * + */ + +#ifndef RefCounted_h +#define RefCounted_h + +#include "Assertions.h" +#include "FastAllocBase.h" +#include "ThreadRestrictionVerifier.h" +#include "Noncopyable.h" +#include "OwnPtr.h" +#include "UnusedParam.h" + +namespace WTF { + +// This base class holds the non-template methods and attributes. +// The RefCounted class inherits from it reducing the template bloat +// generated by the compiler (technique called template hoisting). +class RefCountedBase { +public: + void ref() + { +#ifndef NDEBUG + // Start thread verification as soon as the ref count gets to 2. This + // heuristic reflects the fact that items are often created on one thread + // and then given to another thread to be used. + // FIXME: Make this restriction tigher. Especially as we move to more + // common methods for sharing items across threads like CrossThreadCopier.h + // We should be able to add a "detachFromThread" method to make this explicit. + if (m_refCount == 1) + m_verifier.setShared(true); +#endif + // If this assert fires, it either indicates a thread safety issue or + // that the verification needs to change. See ThreadRestrictionVerifier for + // the different modes. + ASSERT(m_verifier.isSafeToUse()); + ASSERT(!m_deletionHasBegun); + ASSERT(!m_adoptionIsRequired); + ++m_refCount; + } + + bool hasOneRef() const + { + ASSERT(m_verifier.isSafeToUse()); + ASSERT(!m_deletionHasBegun); + return m_refCount == 1; + } + + int refCount() const + { + ASSERT(m_verifier.isSafeToUse()); + return m_refCount; + } + + void setMutexForVerifier(Mutex&); + +#if HAVE(DISPATCH_H) + void setDispatchQueueForVerifier(dispatch_queue_t); +#endif + + // Turns off verification. Use of this method is discouraged (instead extend + // ThreadRestrictionVerifier to verify your case). + // FIXME: remove this method. + void deprecatedTurnOffVerifier() + { +#ifndef NDEBUG + m_verifier.turnOffVerification(); +#endif + } + + void relaxAdoptionRequirement() + { +#ifndef NDEBUG + ASSERT(!m_deletionHasBegun); + ASSERT(m_adoptionIsRequired); + m_adoptionIsRequired = false; +#endif + } + + // Helper for generating JIT code. Please do not use for non-JIT purposes. + const int* addressOfCount() const + { + return &m_refCount; + } + +protected: + RefCountedBase() + : m_refCount(1) +#ifndef NDEBUG + , m_deletionHasBegun(false) + , m_adoptionIsRequired(true) +#endif + { + } + + ~RefCountedBase() + { + ASSERT(m_deletionHasBegun); + ASSERT(!m_adoptionIsRequired); + } + + // Returns whether the pointer should be freed or not. + bool derefBase() + { + ASSERT(m_verifier.isSafeToUse()); + ASSERT(!m_deletionHasBegun); + ASSERT(!m_adoptionIsRequired); + + ASSERT(m_refCount > 0); + if (m_refCount == 1) { +#ifndef NDEBUG + m_deletionHasBegun = true; +#endif + return true; + } + + --m_refCount; +#ifndef NDEBUG + // Stop thread verification when the ref goes to 1 because it + // is safe to be passed to another thread at this point. + if (m_refCount == 1) + m_verifier.setShared(false); +#endif + return false; + } + +#ifndef NDEBUG + bool deletionHasBegun() const + { + return m_deletionHasBegun; + } +#endif + +private: + +#ifndef NDEBUG + friend void adopted(RefCountedBase*); +#endif + + int m_refCount; +#ifndef NDEBUG + bool m_deletionHasBegun; + bool m_adoptionIsRequired; + ThreadRestrictionVerifier m_verifier; +#endif +}; + +#ifndef NDEBUG + +inline void adopted(RefCountedBase* object) +{ + if (!object) + return; + ASSERT(!object->m_deletionHasBegun); + object->m_adoptionIsRequired = false; +} + +#endif + +template<typename T> class RefCounted : public RefCountedBase { + WTF_MAKE_NONCOPYABLE(RefCounted); WTF_MAKE_FAST_ALLOCATED; +public: + void deref() + { + if (derefBase()) + delete static_cast<T*>(this); + } + +protected: + RefCounted() { } + ~RefCounted() + { + } +}; + +template<typename T> class RefCountedCustomAllocated : public RefCountedBase { + WTF_MAKE_NONCOPYABLE(RefCountedCustomAllocated); + +public: + void deref() + { + if (derefBase()) + delete static_cast<T*>(this); + } + +protected: + ~RefCountedCustomAllocated() + { + } +}; + +#ifdef NDEBUG +inline void RefCountedBase::setMutexForVerifier(Mutex&) { } +#else +inline void RefCountedBase::setMutexForVerifier(Mutex& mutex) +{ + m_verifier.setMutexMode(mutex); +} +#endif + +#if HAVE(DISPATCH_H) +#ifdef NDEBUG +inline void RefCountedBase::setDispatchQueueForVerifier(dispatch_queue_t) { } +#else +inline void RefCountedBase::setDispatchQueueForVerifier(dispatch_queue_t queue) +{ + m_verifier.setDispatchQueueMode(queue); +} +#endif // NDEBUG +#endif // HAVE(DISPATCH_H) + +} // namespace WTF + +using WTF::RefCounted; +using WTF::RefCountedCustomAllocated; + +#endif // RefCounted_h |