add asserts to point<-->verb helpers

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
 
 #include "SkRefCnt.h"
 #include <stddef.h> // ptrdiff_t
 
-// When we're ready to break the picture format. Changes:
-// * Write genID.
-// * SkPathRef read/write counts (which will change the field order)
-// * SkPathRef reads/writes verbs backwards.
-#define NEW_PICTURE_FORMAT 0
-
 /**
  * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
  * modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
  * SkPathRef::Editor object. Installing the editor resets the generation ID. It also performs
  * copy-on-write if the SkPathRef is shared by multipls SkPaths. The caller passes the Editor's
  * constructor a SkAutoTUnref, which may be updated to point to a new SkPathRef after the editor's
  * constructor returns.
  *
  * 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
@@ skipping 71 matching lines @@
 
         /**
          * 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(SkPath::Verb verb) {
             fPathRef->validate();
             return fPathRef->growForVerb(verb);
         }
 
+        SkPoint* growForConic(SkScalar w) {
+            fPathRef->validate();
+            SkPoint* pts = fPathRef->growForVerb(SkPath::kConic_Verb);
+            *fPathRef->fConicWeights.append() = w;
+            return pts;
+        }
+
         /**
          * 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();
             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();
         }
 
         /**
          * Resets the path ref to a new verb and point count. The new verbs and points are
          * uninitialized.
          */
-        void resetToSize(int newVerbCnt, int newPointCnt) {
-            fPathRef->resetToSize(newVerbCnt, newPointCnt);
+        void resetToSize(int newVerbCnt, int newPointCnt, int newConicCount) {
+            fPathRef->resetToSize(newVerbCnt, newPointCnt, newConicCount);
         }
         /**
          * Gets the path ref that is wrapped in the Editor.
          */
         SkPathRef* pathRef() { return fPathRef; }
 
     private:
         SkPathRef* fPathRef;
     };
 
@@ skipping 49 matching lines @@
             }
             return;
         }
         int32_t rcnt = dst->get()->getRefCnt();
         if (&src == dst->get() && 1 == rcnt) {
             matrix.mapPoints((*dst)->fPoints, (*dst)->fPointCnt);
             return;
         } else if (rcnt > 1) {
             dst->reset(SkNEW(SkPathRef));
         }
-        (*dst)->resetToSize(src.fVerbCnt, src.fPointCnt);
+        (*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();
     }
 
-#if NEW_PICTURE_FORMAT
     static SkPathRef* CreateFromBuffer(SkRBuffer* buffer) {
         SkPathRef* ref = SkNEW(SkPathRef);
         ref->fGenerationID = buffer->readU32();
         int32_t verbCount = buffer->readS32();
         int32_t pointCount = buffer->readS32();
-        ref->resetToSize(verbCount, pointCount);
+        int32_t conicCount = buffer->readS32();
+        ref->resetToSize(verbCount, pointCount, conicCount);
 
         SkASSERT(verbCount == ref->countVerbs());
         SkASSERT(pointCount == ref->countPoints());
+        SkASSERT(conicCount == ref->fConicWeights.count());
         buffer->read(ref->verbsMemWritable(), verbCount * sizeof(uint8_t));
         buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
+        buffer->read(ref->fConicWeights.begin(), conicCount * sizeof(SkScalar));
         return ref;
     }
-#else
-    static SkPathRef* CreateFromBuffer(int verbCount, int pointCount, SkRBuffer* buffer) {
-        SkPathRef* ref = SkNEW(SkPathRef);
-
-        ref->resetToSize(verbCount, pointCount);
-        SkASSERT(verbCount == ref->countVerbs());
-        SkASSERT(pointCount == ref->countPoints());
-        buffer->read(ref->fPoints, pointCount * sizeof(SkPoint));
-        for (int i = 0; i < verbCount; ++i) {
-            ref->fVerbs[~i] = buffer->readU8();
-        }
-        return ref;
-    }
-#endif
 
     /**
      * 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) {
         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, oldVCnt, oldPCnt);
+            (*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();
@@ skipping 24 matching lines @@
     /**
      * Returns a const pointer to the first point.
      */
     const SkPoint* points() const { 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(); }
+
     /**
      * 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);
         return this->points()[index];
@@ skipping 18 matching lines @@
                         ref.fVerbCnt * sizeof(uint8_t))) {
             SkASSERT(!genIDMatch);
             return false;
         }
         if (0 != memcmp(this->points(),
                         ref.points(),
                         ref.fPointCnt * sizeof(SkPoint))) {
             SkASSERT(!genIDMatch);
             return false;
         }
+        if (fConicWeights != ref.fConicWeights) {
+            SkASSERT(!genIDMatch);
+            return false;
+        }
         // We've done the work to determine that these are equal. If either has a zero genID, copy
         // 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;
     }
 
     /**
      * Writes the path points and verbs to a buffer.
      */
-#if NEW_PICTURE_FORMAT
     void writeToBuffer(SkWBuffer* buffer) {
         this->validate();
         SkDEBUGCODE_X(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(this->fVerbCnt);
-        buffer->write32(this->fPointCnt);
-        buffer->write(this->verbsMemBegin(), fVerbCnt * sizeof(uint8_t));
+        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());
 
         SkASSERT(buffer->pos() - beforePos == (size_t) this->writeSize());
     }
 
     /**
      * Gets the number of bytes that would be written in writeBuffer()
      */
     uint32_t writeSize() {
-        return 3 * sizeof(uint32_t) + fVerbCnt * sizeof(uint8_t) + fPointCnt * sizeof(SkPoint);
+        return 4 * sizeof(uint32_t) +
+               fVerbCnt * sizeof(uint8_t) +
+               fPointCnt * sizeof(SkPoint) +
+               fConicWeights.bytes();
     }
-#else
-    void writeToBuffer(SkWBuffer* buffer) {
-        this->validate();
-        buffer->write(fPoints, fPointCnt * sizeof(SkPoint));
-        for (int i = 0; i < fVerbCnt; ++i) {
-            buffer->write8(fVerbs[~i]);
-        }
-    }
-#endif
 
 private:
     SkPathRef() {
         fPointCnt = 0;
         fVerbCnt = 0;
         fVerbs = NULL;
         fPoints = NULL;
         fFreeSpace = 0;
         fGenerationID = kEmptyGenID;
         SkDEBUGCODE_X(fEditorsAttached = 0;)
         this->validate();
     }
 
     void copy(const SkPathRef& ref, int additionalReserveVerbs, int additionalReservePoints) {
         this->validate();
-        this->resetToSize(ref.fVerbCnt, ref.fPointCnt,
+        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;
         this->validate();
     }
 
     /** Makes additional room but does not change the counts or change the genID */
     void incReserve(int additionalVerbs, int additionalPoints) {
         this->validate();
         size_t space = additionalVerbs * sizeof(uint8_t) + additionalPoints * sizeof (SkPoint);
         this->makeSpace(space);
         this->validate();
     }
 
     /** Resets the path ref with verbCount verbs and pointCount points, all unitialized. Also
      *  allocates space for reserveVerb additional verbs and reservePoints additional points.*/
-    void resetToSize(int verbCount, int pointCount, int reserveVerbs = 0, int reservePoints = 0) {
+    void resetToSize(int verbCount, int pointCount, int conicCount,
+                     int reserveVerbs = 0, int reservePoints = 0) {
         this->validate();
         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();
     }
 
     /**
      * 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();
         size_t space = newVerbs * sizeof(uint8_t) + newPoints * sizeof (SkPoint);
@@ skipping 12 matching lines @@
     SkPoint* growForVerb(SkPath::Verb verb) {
         this->validate();
         int pCnt;
         switch (verb) {
             case SkPath::kMove_Verb:
                 pCnt = 1;
                 break;
             case SkPath::kLine_Verb:
                 pCnt = 1;
                 break;
+            case SkPath::kConic_Verb:
             case SkPath::kQuad_Verb:
                 pCnt = 2;
                 break;
             case SkPath::kCubic_Verb:
                 pCnt = 3;
                 break;
-            default:
+            case SkPath::kDone_Verb:
+                SkASSERT(!"growForVerb called for kDone");
+                // fall through
+            case SkPath::kClose_Verb:
                 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;
         this->validate();
@@ skipping 87 matching lines @@
 
     enum {
         kMinSize = 256,
     };
 
     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_X(int32_t fEditorsAttached;) // assert that only one editor in use at any time.
 
 #if SK_DEBUG_PATH_REF
     SkTDArray<SkPath*> fOwners;
 #endif
 
     typedef SkRefCnt INHERITED;
 };
 
 SK_DEFINE_INST_COUNT(SkPathRef);
 
 #endif