Remove SK_DEBUG_PATH_REF

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 11 matching lines @@
  *
  * The points and verbs are stored in a single allocation. The points are at the begining of the
  * allocation while the verbs are stored at end of the allocation, in reverse order. Thus the points
  * and verbs both grow into the middle of the allocation until the meet. To access verb i in the
  * verb array use ref.verbs()[~i] (because verbs() returns a pointer just beyond the first
  * logical verb or the last verb in memory).
  */
 
 class SkPathRef;
 
-// This path ref should never be deleted once it is created. It should not be global but was made
-// so for checks when SK_DEBUG_PATH_REF is enabled. It we be re-hidden when the debugging code is
-// reverted.
-SkPathRef* gEmptyPathRef;
-
-// Temporary hackery to try to nail down http://code.google.com/p/chromium/issues/detail?id=148637
-#if SK_DEBUG_PATH_REF
-    #define PR_CONTAINER SkPath::PathRefDebugRef
-    #define SkDEBUGCODE_X(code) code
-    #define SkASSERT_X(cond) SK_DEBUGBREAK(cond)
-    // We put the mutex in a factory function to protect against static-initializion order
-    // fiasco when SkPaths are created before main().
-    static SkMutex* owners_mutex() {
-        static SkMutex* gOwnersMutex;
-        if (!gOwnersMutex) {
-            gOwnersMutex = new SkMutex(); // leak!
-        }
-        return gOwnersMutex;
-    }
-    // We have a static initializer that calls owners_mutex before main() so that
-    // hopefully that we only wind up with one mutex (assuming no threads created
-    // before static initialization is finished.)
-    static const SkMutex* gOwnersMutexForce = owners_mutex();
-#else
-    #define PR_CONTAINER SkAutoTUnref<SkPathRef>
-    #define SkDEBUGCODE_X(code) SkDEBUGCODE(code)
-    #define SkASSERT_X(cond) SkASSERT(cond)
-#endif
-
 class SkPathRef : public ::SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(SkPathRef);
 
     class Editor {
     public:
-        Editor(PR_CONTAINER* pathRef,
+        Editor(SkAutoTUnref<SkPathRef>* pathRef,
                int incReserveVerbs = 0,
                int incReservePoints = 0) {
             if (pathRef->get()->getRefCnt() > 1) {
                 SkPathRef* copy = SkNEW(SkPathRef);
                 copy->copy(*pathRef->get(), incReserveVerbs, incReservePoints);
                 pathRef->reset(copy);
             } else {
                 (*pathRef)->incReserve(incReserveVerbs, incReservePoints);
             }
             fPathRef = pathRef->get();
             fPathRef->fGenerationID = 0;
-            SkDEBUGCODE_X(sk_atomic_inc(&fPathRef->fEditorsAttached);)
+            SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
         }
 
-        ~Editor() { SkDEBUGCODE_X(sk_atomic_dec(&fPathRef->fEditorsAttached);) }
+        ~Editor() { SkDEBUGCODE(sk_atomic_dec(&fPathRef->fEditorsAttached);) }
 
         /**
          * Returns the array of points.
          */
         SkPoint* points() { return fPathRef->fPoints; }
 
         /**
          * Gets the ith point. Shortcut for this->points() + i
          */
         SkPoint* atPoint(int i) {
@@ skipping 45 matching lines @@
         /**
          * Gets the path ref that is wrapped in the Editor.
          */
         SkPathRef* pathRef() { return fPathRef; }
 
     private:
         SkPathRef* fPathRef;
     };
 
 public:
-#if SK_DEBUG_PATH_REF
-    void addOwner(SkPath* owner) {
-        SkAutoMutexAcquire ac(owners_mutex());
-        for (int i = 0; i < fOwners.count(); ++i) {
-            SkASSERT_X(fOwners[i] != owner);
-        }
-        *fOwners.append() = owner;
-        SkASSERT_X((this->getRefCnt() == fOwners.count()) ||
-                   (this == gEmptyPathRef && this->getRefCnt() == fOwners.count() + 1));
-    }
-
-    void removeOwner(SkPath* owner) {
-        SkAutoMutexAcquire ac(owners_mutex());
-        SkASSERT_X((this->getRefCnt() == fOwners.count()) ||
-                   (this == gEmptyPathRef && this->getRefCnt() == fOwners.count() + 1));
-        bool found = false;
-        for (int i = 0; !found && i < fOwners.count(); ++i) {
-            found = (owner == fOwners[i]);
-            if (found) {
-                fOwners.remove(i);
-            }
-        }
-        SkASSERT_X(found);
-    }
-#endif
-
     /**
      * Gets a path ref with no verbs or points.
      */
     static SkPathRef* CreateEmpty() {
+        static SkPathRef* gEmptyPathRef;
         if (!gEmptyPathRef) {
             gEmptyPathRef = SkNEW(SkPathRef); // leak!
         }
         return SkRef(gEmptyPathRef);
     }
 
     /**
      * Transforms a path ref by a matrix, allocating a new one only if necessary.
      */
-    static void CreateTransformedCopy(PR_CONTAINER* dst,
+    static void CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
                                       const SkPathRef& src,
                                       const SkMatrix& matrix) {
         src.validate();
         if (matrix.isIdentity()) {
             if (dst->get() != &src) {
                 src.ref();
                 dst->reset(const_cast<SkPathRef*>(&src));
                 (*dst)->validate();
             }
             return;
@@ skipping 27 matching lines @@
         buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
         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(PR_CONTAINER* pathRef) {
+    static void Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
         if (1 == (*pathRef)->getRefCnt()) {
             (*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();
             pathRef->reset(SkNEW(SkPathRef));
             (*pathRef)->resetToSize(0, 0, 0, oldVCnt, oldPCnt);
         }
     }
 
     virtual ~SkPathRef() {
-        SkASSERT_X(this != gEmptyPathRef);
-#if SK_DEBUG_PATH_REF
-        SkASSERT_X(!fOwners.count());
-#endif
-
         this->validate();
         sk_free(fPoints);
 
-        SkDEBUGCODE_X(fPoints = NULL;)
-        SkDEBUGCODE_X(fVerbs = NULL;)
-        SkDEBUGCODE_X(fVerbCnt = 0x9999999;)
-        SkDEBUGCODE_X(fPointCnt = 0xAAAAAAA;)
-        SkDEBUGCODE_X(fPointCnt = 0xBBBBBBB;)
-        SkDEBUGCODE_X(fGenerationID = 0xEEEEEEEE;)
-        SkDEBUGCODE_X(fEditorsAttached = 0x7777777;)
+        SkDEBUGCODE(fPoints = NULL;)
+        SkDEBUGCODE(fVerbs = NULL;)
+        SkDEBUGCODE(fVerbCnt = 0x9999999;)
+        SkDEBUGCODE(fPointCnt = 0xAAAAAAA;)
+        SkDEBUGCODE(fPointCnt = 0xBBBBBBB;)
+        SkDEBUGCODE(fGenerationID = 0xEEEEEEEE;)
+        SkDEBUGCODE(fEditorsAttached = 0x7777777;)
     }
 
     int countPoints() const { this->validate(); return fPointCnt; }
     int countVerbs() const { this->validate(); return fVerbCnt; }
 
     /**
      * Returns a pointer one beyond the first logical verb (last verb in memory order).
      */
     const uint8_t* verbs() const { this->validate(); return fVerbs; }
 
@@ skipping 65 matching lines @@
             ref.fGenerationID = this->genID();
         }
         return true;
     }
 
     /**
      * Writes the path points and verbs to a buffer.
      */
     void writeToBuffer(SkWBuffer* buffer) {
         this->validate();
-        SkDEBUGCODE_X(size_t beforePos = buffer->pos();)
+        SkDEBUGCODE(size_t beforePos = buffer->pos();)
 
         // TODO: write gen ID here. Problem: We don't know if we're cross process or not from
         // SkWBuffer. Until this is fixed we write 0.
         buffer->write32(0);
         buffer->write32(fVerbCnt);
         buffer->write32(fPointCnt);
         buffer->write32(fConicWeights.count());
         buffer->write(verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
         buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
         buffer->write(fConicWeights.begin(), fConicWeights.bytes());
@@ skipping 12 matching lines @@
     }
 
 private:
     SkPathRef() {
         fPointCnt = 0;
         fVerbCnt = 0;
         fVerbs = NULL;
         fPoints = NULL;
         fFreeSpace = 0;
         fGenerationID = kEmptyGenID;
-        SkDEBUGCODE_X(fEditorsAttached = 0;)
+        SkDEBUGCODE(fEditorsAttached = 0;)
         this->validate();
     }
 
     void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints) {
         this->validate();
         this->resetToSize(ref.fVerbCnt, ref.fPointCnt, ref.fConicWeights.count(),
                           additionalReserveVerbs, additionalReservePoints);
         memcpy(this->verbsMemWritable(), ref.verbsMemBegin(), ref.fVerbCnt * sizeof(uint8_t));
         memcpy(this->fPoints, ref.fPoints, ref.fPointCnt * sizeof(SkPoint));
         fConicWeights = ref.fConicWeights;
@@ skipping 147 matching lines @@
         return reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints);
     }
 
     /**
      * Gets an ID that uniquely identifies the contents of the path ref. If two path refs have the
      * same ID then they have the same verbs and points. However, two path refs may have the same
      * contents but different genIDs. Zero is reserved and means an ID has not yet been determined
      * for the path ref.
      */
     int32_t genID() const {
-        SkASSERT_X(!fEditorsAttached);
+        SkASSERT(!fEditorsAttached);
         if (!fGenerationID) {
             if (0 == fPointCnt && 0 == fVerbCnt) {
                 fGenerationID = kEmptyGenID;
             } else {
                 static int32_t  gPathRefGenerationID;
                 // do a loop in case our global wraps around, as we never want to return a 0 or the
                 // empty ID
                 do {
                     fGenerationID = sk_atomic_inc(&gPathRefGenerationID) + 1;
                 } while (fGenerationID <= kEmptyGenID);
@@ skipping 22 matching lines @@
     uint8_t*            fVerbs; // points just past the end of the allocation (verbs grow backwards)
     int                 fVerbCnt;
     int                 fPointCnt;
     size_t              fFreeSpace; // redundant but saves computation
     SkTDArray<SkScalar> fConicWeights;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
     };
     mutable int32_t     fGenerationID;
-    SkDEBUGCODE_X(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
-
-#if SK_DEBUG_PATH_REF
-    SkTDArray<SkPath*> fOwners;
-#endif
+    SkDEBUGCODE(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
     typedef SkRefCnt INHERITED;
 };
 
 SK_DEFINE_INST_COUNT(SkPathRef);
 
 #endif