[oilpan] Resurrect a loop-back persistent handle in RefCountedHeapAllocated

Source/wtf/RefCounted.h

 /*
  * 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
@@ skipping 15 matching lines @@
 #include <wtf/Noncopyable.h>
 #include <wtf/OwnPtr.h>
 #include <wtf/ThreadRestrictionVerifier.h>
 #include <wtf/UnusedParam.h>
 
 namespace WTF {
 
 #ifdef NDEBUG
 #define CHECK_REF_COUNTED_LIFECYCLE 0
 #else
-#define CHECK_REF_COUNTED_LIFECYCLE 1
+// FIXME(oilpan): Enable this check once we replace all
+// RefCountedHeapAllocated with HeapAllocated.
+// We have to disable the check for RefCountedHeapAllocated
+// since we have to allow the following situation in RefCountedHeapAllocated.
+// (1) A reference count becomes 0, but Handles keep references to the object.
+// (2) The Handle is assigned to a RefPtr. The reference count becomes 1.
+#define CHECK_REF_COUNTED_LIFECYCLE 0
 #endif
 
 // 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()
-    {
-#if CHECK_REF_COUNTED_LIFECYCLE
-        // 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);
-        // 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);
-#endif
-        ++m_refCount;
-    }
-
     bool hasOneRef() const
     {
 #if CHECK_REF_COUNTED_LIFECYCLE
         ASSERT(m_verifier.isSafeToUse());
         ASSERT(!m_deletionHasBegun);
 #endif
         return m_refCount == 1;
     }
 
     int refCount() const
@@ skipping 53 matching lines @@
     }
 
     ~RefCountedBase()
     {
 #if CHECK_REF_COUNTED_LIFECYCLE
         ASSERT(m_deletionHasBegun);
         ASSERT(!m_adoptionIsRequired);
 #endif
     }
 
+    void refBase()
+    {
+#if CHECK_REF_COUNTED_LIFECYCLE
+        // 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);
+        // 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);
+#endif
+        ++m_refCount;
+    }
+
     // Returns whether the pointer should be freed or not.
     bool derefBase()
     {
 #if CHECK_REF_COUNTED_LIFECYCLE
         ASSERT(m_verifier.isSafeToUse());
         ASSERT(!m_deletionHasBegun);
         ASSERT(!m_adoptionIsRequired);
 #endif
 
         ASSERT(m_refCount > 0);
         if (m_refCount == 1) {
 #if CHECK_REF_COUNTED_LIFECYCLE
             m_deletionHasBegun = true;
 #endif
+            --m_refCount;

[haraken, 2013/05/29 14:53:45]

This is critical :)

[Mads Ager (chromium), 2013/05/29 16:46:38]

Yeah, I see, otherwise the ref will actually never reach zero. :-)

             return true;
         }
 
         --m_refCount;
 #if CHECK_REF_COUNTED_LIFECYCLE
         // 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
@@ skipping 27 matching lines @@
     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 ref()
+    {
+        refBase();
+    }
+
     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 ref()
+    {
+        refBase();
+    }
+
     void deref()
     {
         if (derefBase())
             delete static_cast<T*>(this);
     }
 
 protected:
     ~RefCountedCustomAllocated()
     {
     }
@@ skipping 18 matching lines @@
 inline void RefCountedBase::setDispatchQueueForVerifier(dispatch_queue_t) { }
 #endif
 #endif // HAVE(DISPATCH_H)
 
 } // namespace WTF
 
 using WTF::RefCounted;
 using WTF::RefCountedCustomAllocated;
 
 #endif // RefCounted_h