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

include/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 46 matching lines @@
         SkPoint* atPoint(int i) {
             SkASSERT((unsigned) i < (unsigned) fPathRef->fPointCnt);
             return this->points() + i;
         };
 
         /**
          * Adds the verb and allocates space for the number of points indicated by the verb. The
          * return value is a pointer to where the points for the verb should be written.
          */
         SkPoint* growForVerb(int /*SkPath::Verb*/ verb) {
-            fPathRef->validate();
+            SkDEBUGCODE(fPathRef->validate();)
             return fPathRef->growForVerb(verb);
         }
 
         SkPoint* growForConic(SkScalar w);
 
         /**
          * Allocates space for additional verbs and points and returns pointers to the new verbs and
          * points. verbs will point one beyond the first new verb (index it using [~<i>]). pts points
          * at the first new point (indexed normally [<i>]).
          */
         void grow(int newVerbs, int newPts, uint8_t** verbs, SkPoint** pts) {
             SkASSERT(NULL != verbs);
             SkASSERT(NULL != pts);
-            fPathRef->validate();
+            SkDEBUGCODE(fPathRef->validate();)
             int oldVerbCnt = fPathRef->fVerbCnt;
             int oldPointCnt = fPathRef->fPointCnt;
             SkASSERT(verbs && pts);
             fPathRef->grow(newVerbs, newPts);
             *verbs = fPathRef->fVerbs - oldVerbCnt;
             *pts = fPathRef->fPoints + oldPointCnt;
-            fPathRef->validate();
+            SkDEBUGCODE(fPathRef->validate();)
         }
 
         /**
          * Resets the path ref to a new verb and point count. The new verbs and points are
          * uninitialized.
          */
         void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
             fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
         }
         /**
@@ skipping 65 matching lines @@
         );
 
     /**
      * 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);
 
     virtual ~SkPathRef() {
-        this->validate();
+        SkDEBUGCODE(this->validate();)
         sk_free(fPoints);
 
         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; }
+    int countPoints() const { SkDEBUGCODE(this->validate();) return fPointCnt; }
+    int countVerbs() const { SkDEBUGCODE(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; }
+    const uint8_t* verbs() const { SkDEBUGCODE(this->validate();) return fVerbs; }
 
     /**
      * Returns a const pointer to the first verb in memory (which is the last logical verb).
      */
     const uint8_t* verbsMemBegin() const { return this->verbs() - fVerbCnt; }
 
     /**
      * Returns a const pointer to the first point.
      */
-    const SkPoint* points() const { this->validate(); return fPoints; }
+    const SkPoint* points() const { SkDEBUGCODE(this->validate();) return fPoints; }
 
     /**
      * Shortcut for this->points() + this->countPoints()
      */
     const SkPoint* pointsEnd() const { return this->points() + this->countPoints(); }
 
-    const SkScalar* conicWeights() const { this->validate(); return fConicWeights.begin(); }
-    const SkScalar* conicWeightsEnd() const { this->validate(); return fConicWeights.end(); }
+    const SkScalar* conicWeights() const { SkDEBUGCODE(this->validate();) return fConicWeights.begin(); }
+    const SkScalar* conicWeightsEnd() const { SkDEBUGCODE(this->validate();) return fConicWeights.end(); }
 
     /**
      * Convenience methods for getting to a verb or point by index.
      */
     uint8_t atVerb(int index) {
         SkASSERT((unsigned) index < (unsigned) fVerbCnt);
         return this->verbs()[~index];
     }
     const SkPoint& atPoint(int index) const {
         SkASSERT((unsigned) index < (unsigned) fPointCnt);
@@ skipping 19 matching lines @@
 
     SkPathRef() {
         fBoundsIsDirty = true;    // this also invalidates fIsFinite
         fPointCnt = 0;
         fVerbCnt = 0;
         fVerbs = NULL;
         fPoints = NULL;
         fFreeSpace = 0;
         fGenerationID = kEmptyGenID;
         SkDEBUGCODE(fEditorsAttached = 0;)
-        this->validate();
+        SkDEBUGCODE(this->validate();)
     }
 
     void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints);
 
     // Return true if the computed bounds are finite.
     static bool ComputePtBounds(SkRect* bounds, const SkPathRef& ref) {
         int count = ref.countPoints();
         if (count <= 1) {  // we ignore just 1 point (moveto)
             bounds->setEmpty();
             return count ? ref.points()->isFinite() : true;
         } else {
             return bounds->setBoundsCheck(ref.points(), count);
         }
     }
 
     // called, if dirty, by getBounds()
     void computeBounds() const {
         SkDEBUGCODE(this->validate();)
         SkASSERT(fBoundsIsDirty);
 
         fIsFinite = ComputePtBounds(&fBounds, *this);
         fBoundsIsDirty = false;
     }
 
     /** Makes additional room but does not change the counts or change the genID */
     void incReserve(int additionalVerbs, int additionalPoints) {
-        this->validate();
+        SkDEBUGCODE(this->validate();)
         size_t space = additionalVerbs * sizeof(uint8_t) + additionalPoints * sizeof (SkPoint);
         this->makeSpace(space);
-        this->validate();
+        SkDEBUGCODE(this->validate();)
     }
 
     /** Resets the path ref with verbCount verbs and pointCount points, all uninitialized. Also
      *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
     void resetToSize(int verbCount, int pointCount, int conicCount,
                      int reserveVerbs = 0, int reservePoints = 0);
 
     /**
      * Increases the verb count by newVerbs and the point count be newPoints. New verbs and points
      * are uninitialized.
      */
     void grow(int newVerbs, int newPoints) {
-        this->validate();
+        SkDEBUGCODE(this->validate();)
         size_t space = newVerbs * sizeof(uint8_t) + newPoints * sizeof (SkPoint);
         this->makeSpace(space);
         fVerbCnt += newVerbs;
         fPointCnt += newPoints;
         fFreeSpace -= space;
         fBoundsIsDirty = true;  // this also invalidates fIsFinite
-        this->validate();
+        SkDEBUGCODE(this->validate();)
     }
 
     /**
      * Increases the verb count 1, records the new verb, and creates room for the requisite number
      * of additional points. A pointer to the first point is returned. Any new points are
      * uninitialized.
      */
     SkPoint* growForVerb(int /*SkPath::Verb*/ verb);
 
     /**
      * Ensures that the free space available in the path ref is >= size. The verb and point counts
      * are not changed.
      */
     void makeSpace(size_t size);
 
     /**
      * Private, non-const-ptr version of the public function verbsMemBegin().
      */
     uint8_t* verbsMemWritable() {
-        this->validate();
+        SkDEBUGCODE(this->validate();)
         return fVerbs - fVerbCnt;
     }
 
     /**
      * Gets the total amount of space allocated for verbs, points, and reserve.
      */
     size_t currSize() const {
         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;
 
-    void validate() const;
+    SkDEBUGCODE(void validate() const;)
 
     enum {
         kMinSize = 256,
     };
 
     mutable SkRect      fBounds;
     mutable uint8_t     fBoundsIsDirty;
     mutable SkBool8     fIsFinite;    // only meaningful if bounds are valid
 
     SkPoint*            fPoints; // points to begining of the allocation
     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(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif