Add a 'unique' method to SkRefCnt, document the usage, and add support.

src/core/SkPathRef.h

 
 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkPathRef_DEFINED
 #define SkPathRef_DEFINED
@@ skipping 19 matching lines @@
 class SkPathRef;
 
 class SkPathRef : public ::SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkPathRef);
 
     class Editor {
     public:
         Editor(SkAutoTUnref<SkPathRef>* pathRef,
                int incReserveVerbs = 0,
-               int incReservePoints = 0) {
-            if (pathRef->get()->getRefCnt() > 1) {
+               int incReservePoints = 0)
+        {
+            if ((*pathRef)->unique()) {
+                (*pathRef)->incReserve(incReserveVerbs, incReservePoints);
+            } else {
                 SkPathRef* copy = SkNEW(SkPathRef);
-                copy->copy(*pathRef->get(), incReserveVerbs, incReservePoints);
+                copy->copy(**pathRef, incReserveVerbs, incReservePoints);
                 pathRef->reset(copy);
-            } else {
-                (*pathRef)->incReserve(incReserveVerbs, incReservePoints);
             }
-            fPathRef = pathRef->get();
+            fPathRef = *pathRef;
             fPathRef->fGenerationID = 0;
             SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
         }
 
         ~Editor() { SkDEBUGCODE(sk_atomic_dec(&fPathRef->fEditorsAttached);) }
 
         /**
          * Returns the array of points.
          */
         SkPoint* points() { return fPathRef->fPoints; }
@@ skipping 69 matching lines @@
     }
 
     /**
      * Transforms a path ref by a matrix, allocating a new one only if necessary.
      */
     static void CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
                                       const SkPathRef& src,
                                       const SkMatrix& matrix) {
         src.validate();
         if (matrix.isIdentity()) {
-            if (dst->get() != &src) {
+            if (*dst != &src) {
                 src.ref();
                 dst->reset(const_cast<SkPathRef*>(&src));
                 (*dst)->validate();
             }
             return;
         }
-        int32_t rcnt = dst->get()->getRefCnt();
-        if (&src == dst->get() && 1 == rcnt) {
+        bool dstUnique = (*dst)->unique();
+        if (&src == *dst && dstUnique) {
             matrix.mapPoints((*dst)->fPoints, (*dst)->fPointCnt);
             return;
-        } else if (rcnt > 1) {
+        } else if (!dstUnique) {
             dst->reset(SkNEW(SkPathRef));
         }
         (*dst)->resetToSize(src.fVerbCnt, src.fPointCnt, src.fConicWeights.count());
         memcpy((*dst)->verbsMemWritable(), src.verbsMemBegin(), src.fVerbCnt * sizeof(uint8_t));
         matrix.mapPoints((*dst)->fPoints, src.points(), src.fPointCnt);
         (*dst)->fConicWeights = src.fConicWeights;
         (*dst)->validate();
     }
 
     static SkPathRef* CreateFromBuffer(SkRBuffer* buffer) {
@@ skipping 12 matching lines @@
         buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar));
         return ref;
     }
 
     /**
      * Rollsback a path ref to zero verbs and points with the assumption that the path ref will be
      * repopulated with approximately the same number of verbs and points. A new path ref is created
      * only if necessary.
      */
     static void Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
-        if (1 == (*pathRef)->getRefCnt()) {
+        if ((*pathRef)->unique()) {
             (*pathRef)->validate();
             (*pathRef)->fVerbCnt = 0;
             (*pathRef)->fPointCnt = 0;
             (*pathRef)->fFreeSpace = (*pathRef)->currSize();
             (*pathRef)->fGenerationID = 0;
             (*pathRef)->fConicWeights.rewind();
             (*pathRef)->validate();
         } else {
             int oldVCnt = (*pathRef)->countVerbs();
             int oldPCnt = (*pathRef)->countPoints();
@@ skipping 348 matching lines @@
     };
     mutable int32_t     fGenerationID;
     SkDEBUGCODE(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
     typedef SkRefCnt INHERITED;
 };
 
 SK_DEFINE_INST_COUNT(SkPathRef);
 
 #endif