Make it explicit that some validate methods are debug only ...

src/core/SkPathRef.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBuffer.h"
 #include "SkPath.h"
 #include "SkPathRef.h"
@@ skipping 11 matching lines @@
         SkPathRef* copy = SkNEW(SkPathRef);
         copy->copy(**pathRef, incReserveVerbs, incReservePoints);
         pathRef->reset(copy);
     }
     fPathRef = *pathRef;
     fPathRef->fGenerationID = 0;
     SkDEBUGCODE(sk_atomic_inc(&fPathRef->fEditorsAttached);)
 }
 
 SkPoint* SkPathRef::Editor::growForConic(SkScalar w) {
-    fPathRef->validate();
+    SkDEBUGCODE(fPathRef->validate();)
     SkPoint* pts = fPathRef->growForVerb(SkPath::kConic_Verb);
     *fPathRef->fConicWeights.append() = w;
     return pts;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void SkPathRef::CreateTransformedCopy(SkAutoTUnref<SkPathRef>* dst,
                                       const SkPathRef& src,
                                       const SkMatrix& matrix) {
-    src.validate();
+    SkDEBUGCODE(src.validate();)
     if (matrix.isIdentity()) {
         if (*dst != &src) {
             src.ref();
             dst->reset(const_cast<SkPathRef*>(&src));
-            (*dst)->validate();
+            SkDEBUGCODE((*dst)->validate();)
         }
         return;
     }
 
     bool dstUnique = (*dst)->unique();
     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));
         (*dst)->fConicWeights = src.fConicWeights;
@@ skipping 22 matching lines @@
                 (*dst)->fBounds.setEmpty();
             }
         } else {
             (*dst)->fIsFinite = false;
             (*dst)->fBounds.setEmpty();
         }
     } else {
         (*dst)->fBoundsIsDirty = true;
     }
 
-    (*dst)->validate();
+    SkDEBUGCODE((*dst)->validate();)
 }
 
 SkPathRef* SkPathRef::CreateFromBuffer(SkRBuffer* buffer
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
                                    , bool newFormat, int32_t oldPacked
 #endif
     ) {
     SkPathRef* ref = SkNEW(SkPathRef);
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
     if (newFormat) {
@@ skipping 19 matching lines @@
     buffer->read(ref->verbsMemWritable(), verbCount * sizeof(uint8_t));
     buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
     buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar));
     buffer->read(&ref->fBounds, sizeof(SkRect));
     ref->fBoundsIsDirty = false;
     return ref;
 }
 
 void SkPathRef::Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
     if ((*pathRef)->unique()) {
-        (*pathRef)->validate();
+        SkDEBUGCODE((*pathRef)->validate();)
         (*pathRef)->fBoundsIsDirty = true;  // this also invalidates fIsFinite
         (*pathRef)->fVerbCnt = 0;
         (*pathRef)->fPointCnt = 0;
         (*pathRef)->fFreeSpace = (*pathRef)->currSize();
         (*pathRef)->fGenerationID = 0;
         (*pathRef)->fConicWeights.rewind();
-        (*pathRef)->validate();
+        SkDEBUGCODE((*pathRef)->validate();)
     } else {
         int oldVCnt = (*pathRef)->countVerbs();
         int oldPCnt = (*pathRef)->countPoints();
         pathRef->reset(SkNEW(SkPathRef));
         (*pathRef)->resetToSize(0, 0, 0, oldVCnt, oldPCnt);
     }
 }
 
 bool SkPathRef::operator== (const SkPathRef& ref) const {
-    this->validate();
-    ref.validate();
+    SkDEBUGCODE(this->validate();)
+    SkDEBUGCODE(ref.validate();)
     bool genIDMatch = fGenerationID && fGenerationID == ref.fGenerationID;
 #ifdef SK_RELEASE
     if (genIDMatch) {
         return true;
     }
 #endif
     if (fPointCnt != ref.fPointCnt ||
         fVerbCnt != ref.fVerbCnt) {
         SkASSERT(!genIDMatch);
         return false;
@@ skipping 18 matching lines @@
     // the other's. If both are 0 then genID() will compute the next ID.
     if (0 == fGenerationID) {
         fGenerationID = ref.genID();
     } else if (0 == ref.fGenerationID) {
         ref.fGenerationID = this->genID();
     }
     return true;
 }
 
 void SkPathRef::writeToBuffer(SkWBuffer* buffer) {
-    this->validate();
+    SkDEBUGCODE(this->validate();)
     SkDEBUGCODE(size_t beforePos = buffer->pos();)
 
     // Call getBounds() to ensure (as a side-effect) that fBounds
     // and fIsFinite are computed.
     const SkRect& bounds = this->getBounds();
 
     int32_t packed = ((fIsFinite & 1) << kIsFinite_SerializationShift);
     buffer->write32(packed);
 
     // TODO: write gen ID here. Problem: We don't know if we're cross process or not from
@@ skipping 14 matching lines @@
     return uint32_t(5 * sizeof(uint32_t) +
                     fVerbCnt * sizeof(uint8_t) +
                     fPointCnt * sizeof(SkPoint) +
                     fConicWeights.bytes() +
                     sizeof(SkRect));
 }
 
 void SkPathRef::copy(const SkPathRef& ref,
                      int additionalReserveVerbs,
                      int additionalReservePoints) {
-    this->validate();
+    SkDEBUGCODE(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;
     // We could call genID() here to force a real ID (instead of 0). However, if we're making
     // a copy then presumably we intend to make a modification immediately afterwards.
     fGenerationID = ref.fGenerationID;
     fBoundsIsDirty = ref.fBoundsIsDirty;
     if (!fBoundsIsDirty) {
         fBounds = ref.fBounds;
         fIsFinite = ref.fIsFinite;
     }
-    this->validate();
+    SkDEBUGCODE(this->validate();)
 }
 
 void SkPathRef::resetToSize(int verbCount, int pointCount, int conicCount,
                             int reserveVerbs, int reservePoints) {
-    this->validate();
+    SkDEBUGCODE(this->validate();)
     fBoundsIsDirty = true;      // this also invalidates fIsFinite
     fGenerationID = 0;
 
     size_t newSize = sizeof(uint8_t) * verbCount + sizeof(SkPoint) * pointCount;
     size_t newReserve = sizeof(uint8_t) * reserveVerbs + sizeof(SkPoint) * reservePoints;
     size_t minSize = newSize + newReserve;
 
     ptrdiff_t sizeDelta = this->currSize() - minSize;
 
     if (sizeDelta < 0 || static_cast<size_t>(sizeDelta) >= 3 * minSize) {
         sk_free(fPoints);
         fPoints = NULL;
         fVerbs = NULL;
         fFreeSpace = 0;
         fVerbCnt = 0;
         fPointCnt = 0;
         this->makeSpace(minSize);
         fVerbCnt = verbCount;
         fPointCnt = pointCount;
         fFreeSpace -= newSize;
     } else {
         fPointCnt = pointCount;
         fVerbCnt = verbCount;
         fFreeSpace = this->currSize() - minSize;
     }
     fConicWeights.setCount(conicCount);
-    this->validate();
+    SkDEBUGCODE(this->validate();)
 }
 
 SkPoint* SkPathRef::growForVerb(int /* SkPath::Verb*/ verb) {
-    this->validate();
+    SkDEBUGCODE(this->validate();)
     int pCnt;
     switch (verb) {
         case SkPath::kMove_Verb:
             pCnt = 1;
             break;
         case SkPath::kLine_Verb:
             pCnt = 1;
             break;
         case SkPath::kQuad_Verb:
             // fall through
@@ skipping 14 matching lines @@
             pCnt = 0;
     }
     size_t space = sizeof(uint8_t) + pCnt * sizeof (SkPoint);
     this->makeSpace(space);
     this->fVerbs[~fVerbCnt] = verb;
     SkPoint* ret = fPoints + fPointCnt;
     fVerbCnt += 1;
     fPointCnt += pCnt;
     fFreeSpace -= space;
     fBoundsIsDirty = true;  // this also invalidates fIsFinite
-    this->validate();
+    SkDEBUGCODE(this->validate();)
     return ret;
 }
 
 void SkPathRef::makeSpace(size_t size) {
-    this->validate();
+    SkDEBUGCODE(this->validate();)
     ptrdiff_t growSize = size - fFreeSpace;
     if (growSize <= 0) {
         return;
     }
     size_t oldSize = this->currSize();
     // round to next multiple of 8 bytes
     growSize = (growSize + 7) & ~static_cast<size_t>(7);
     // we always at least double the allocation
     if (static_cast<size_t>(growSize) < oldSize) {
         growSize = oldSize;
     }
     if (growSize < kMinSize) {
         growSize = kMinSize;
     }
     size_t newSize = oldSize + growSize;
     // Note that realloc could memcpy more than we need. It seems to be a win anyway. TODO:
     // encapsulate this.
     fPoints = reinterpret_cast<SkPoint*>(sk_realloc_throw(fPoints, newSize));
     size_t oldVerbSize = fVerbCnt * sizeof(uint8_t);
     void* newVerbsDst = reinterpret_cast<void*>(
                             reinterpret_cast<intptr_t>(fPoints) + newSize - oldVerbSize);
     void* oldVerbsSrc = reinterpret_cast<void*>(
                             reinterpret_cast<intptr_t>(fPoints) + oldSize - oldVerbSize);
     memmove(newVerbsDst, oldVerbsSrc, oldVerbSize);
     fVerbs = reinterpret_cast<uint8_t*>(reinterpret_cast<intptr_t>(fPoints) + newSize);
     fFreeSpace += growSize;
-    this->validate();
+    SkDEBUGCODE(this->validate();)
 }
 
 int32_t SkPathRef::genID() const {
     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);
         }
     }
     return fGenerationID;
 }
 
+#ifdef SK_DEBUG
 void SkPathRef::validate() const {
+    this->INHERITED::validate();
     SkASSERT(static_cast<ptrdiff_t>(fFreeSpace) >= 0);
     SkASSERT(reinterpret_cast<intptr_t>(fVerbs) - reinterpret_cast<intptr_t>(fPoints) >= 0);
     SkASSERT((NULL == fPoints) == (NULL == fVerbs));
     SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
     SkASSERT(!(NULL == fPoints && 0 != fFreeSpace));
     SkASSERT(!(NULL == fPoints && fPointCnt));
     SkASSERT(!(NULL == fVerbs && fVerbCnt));
     SkASSERT(this->currSize() ==
                 fFreeSpace + sizeof(SkPoint) * fPointCnt + sizeof(uint8_t) * fVerbCnt);
 
 #ifdef SK_DEBUG
     if (!fBoundsIsDirty && !fBounds.isEmpty()) {
         bool isFinite = true;
         for (int i = 0; i < fPointCnt; ++i) {
             SkASSERT(fPoints[i].fX >= fBounds.fLeft && fPoints[i].fX <= fBounds.fRight &&
                         fPoints[i].fY >= fBounds.fTop && fPoints[i].fY <= fBounds.fBottom);
             if (!fPoints[i].isFinite()) {
                 isFinite = false;
             }
         }
         SkASSERT(SkToBool(fIsFinite) == isFinite);
     }
 #endif
 }
+#endif