Add run-time reference adoption checks to SkRefCnt

include/core/SkRefCnt.h

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #ifndef SkRefCnt_DEFINED
 #define SkRefCnt_DEFINED
 
 #include "SkThread.h"
 #include "SkInstCnt.h"
 #include "SkTemplates.h"
 
+#ifdef SK_REF_CNT_BASE_INCLUDE
+#include SK_REF_CNT_BASE_INCLUDE
+#else
+/** \class SkRefCntBase
+
+    Default implementation of SkRefCntBase. The base class' contract is to
+    provide an implementation of aboutToRef. Embedders of skia can specify
+    an alternate implementation by setting SK_REF_CNT_BASE_INCLUDE. This is
+    useful for adding debug run-time checks to enforce certain usage patterns.
+*/
+class SK_API SkRefCntBase {
+public:
+    void aboutToRef() const {}
+};
+#endif
+
 /** \class SkRefCnt
 
     SkRefCnt is the base class for objects that may be shared by multiple
     objects. When an existing owner wants to share a reference, it calls ref().
     When an owner wants to release its reference, it calls unref(). When the
     shared object's reference count goes to zero as the result of an unref()
     call, its (virtual) destructor is called. It is an error for the
     destructor to be called explicitly (or via the object going out of scope on
     the stack or calling delete) if getRefCnt() > 1.
 */
-class SK_API SkRefCnt : SkNoncopyable {
+class SK_API SkRefCnt : public SkRefCntBase {
 public:
     SK_DECLARE_INST_COUNT_ROOT(SkRefCnt)
 
     /** Default construct, initializing the reference count to 1.
     */
     SkRefCnt() : fRefCnt(1) {}
 
     /** Destruct, asserting that the reference count is 1.
     */
     virtual ~SkRefCnt() {
@@ skipping 16 matching lines @@
             // Prevents user's 'unique' code from happening before decrements.
             //TODO: issue the barrier.
         }
         return unique;
     }
 
     /** Increment the reference count. Must be balanced by a call to unref().
     */
     void ref() const {
         SkASSERT(fRefCnt > 0);
+        this->INHERITED::aboutToRef();
         sk_atomic_inc(&fRefCnt);  // No barrier required.
     }
 
     /** Decrement the reference count. If the reference count is 1 before the
         decrement, then delete the object. Note that if this is the case, then
         the object needs to have been allocated via new, and not on the stack.
     */
     void unref() const {
         SkASSERT(fRefCnt > 0);
         // Release barrier (SL/S), if not provided below.
@@ skipping 25 matching lines @@
      */
     void internal_dispose_restore_refcnt_to_1() const {
 #ifdef SK_DEBUG
         SkASSERT(0 == fRefCnt);
         fRefCnt = 1;
 #endif
     }
 
 private:
     /**
+     *  Make SkRefCnt non-copyable.
+     */
+    SkRefCnt(const SkRefCnt&);
+    SkRefCnt& operator=(const SkRefCnt&);
+
+    /**
      *  Called when the ref count goes to 0.
      */
     virtual void internal_dispose() const {
         this->internal_dispose_restore_refcnt_to_1();
         SkDELETE(this);
     }
 
     // The following friends are those which override internal_dispose()
     // and conditionally call SkRefCnt::internal_dispose().
     friend class GrTexture;
     friend class SkWeakRefCnt;
 
     mutable int32_t fRefCnt;
 
-    typedef SkNoncopyable INHERITED;
+    typedef SkRefCntBase INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Helper macro to safely assign one SkRefCnt[TS]* to another, checking for
     null in on each side of the assignment, and ensuring that ref() is called
     before unref(), in case the two pointers point to the same object.
  */
 #define SkRefCnt_SafeAssign(dst, src)   \
     do {                                \
@@ skipping 140 matching lines @@
     typedef T* SkRefPtr::*unspecified_bool_type;
     operator unspecified_bool_type() const {
         return fObj ? &SkRefPtr::fObj : NULL;
     }
 
 private:
     T* fObj;
 };
 
 #endif