Allow users to build on top of, instead of beneath, 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
+    SkRefCntBase 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 : public SkRefCntBase {
+class SK_API SkRefCntBase : public SkNoncopyable {
 public:
-    SK_DECLARE_INST_COUNT_ROOT(SkRefCnt)
+    SK_DECLARE_INST_COUNT_ROOT(SkRefCntBase)
 
     /** Default construct, initializing the reference count to 1.
     */
-    SkRefCnt() : fRefCnt(1) {}
+    SkRefCntBase() : fRefCnt(1) {}
 
     /** Destruct, asserting that the reference count is 1.
     */
-    virtual ~SkRefCnt() {
+    virtual ~SkRefCntBase() {
 #ifdef SK_DEBUG
         SkASSERT(fRefCnt == 1);
         fRefCnt = 0;    // illegal value, to catch us if we reuse after delete
 #endif
     }
 
     /** Return the reference count. Use only for debugging. */
     int32_t getRefCnt() const { return fRefCnt; }
 
     /** Returns true if the caller is the only owner.
      *  Ensures that all previous owner's actions are complete.
      */
     bool unique() const {
         bool const unique = (1 == fRefCnt);
         if (unique) {
             // Aquire barrier (L/SL), if not provided by load of fRefCnt.
             // 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.
         if (sk_atomic_dec(&fRefCnt) == 1) {
             // Aquire barrier (L/SL), if not provided above.
             // Prevents code in dispose from happening before the decrement.
             sk_membar_aquire__after_atomic_dec();
             internal_dispose();
         }
     }
 
 #ifdef SK_DEBUG
     void validate() const {
         SkASSERT(fRefCnt > 0);
     }
 #endif
 
-    /**
-     * Alias for unref(), for compatibility with WTF::RefPtr.
-     */
-    void deref() { this->unref(); }
-
 protected:
     /**
      *  Allow subclasses to call this if they've overridden internal_dispose
      *  so they can reset fRefCnt before the destructor is called. Should only
      *  be called right before calling through to inherited internal_dispose()
      *  or before calling the destructor.
      */
     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 SkRefCntBase INHERITED;
+    typedef SkNoncopyable INHERITED;
 };
 
+#ifdef SK_REF_CNT_MIXIN_INCLUDE
+// It is the responsibility of the following include to define the type SkRefCnt.
+// This SkRefCnt should normally derive from SkRefCntBase.
+#include SK_REF_CNT_MIXIN_INCLUDE
+#else
+class SK_API SkRefCnt : public SkRefCntBase { };
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /** 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 {                                \
         if (src) src->ref();            \
         if (dst) dst->unref();          \
@@ skipping 138 matching lines @@
     typedef T* SkRefPtr::*unspecified_bool_type;
     operator unspecified_bool_type() const {
         return fObj ? &SkRefPtr::fObj : NULL;
     }
 
 private:
     T* fObj;
 };
 
 #endif