Move fLastMoveToIndex from SkPath to SkPathRef

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 "SkOnce.h"
 #include "SkPath.h"
@@ skipping 136 matching lines @@
 
     // resetToSize clears fSegmentMask and fIsOval
     ref->fSegmentMask = segmentMask;
     ref->fIsOval = isOval;
     return ref;
 }
 
 void SkPathRef::Rewind(SkAutoTUnref<SkPathRef>* pathRef) {
     if ((*pathRef)->unique()) {
         SkDEBUGCODE((*pathRef)->validate();)
+        (*pathRef)->fLastMoveToIndex = kINITIAL_LASTMOVETOINDEX_VALUE;
         (*pathRef)->fBoundsIsDirty = true;  // this also invalidates fIsFinite
         (*pathRef)->fVerbCnt = 0;
         (*pathRef)->fPointCnt = 0;
         (*pathRef)->fFreeSpace = (*pathRef)->currSize();
         (*pathRef)->fGenerationID = 0;
         (*pathRef)->fConicWeights.rewind();
         (*pathRef)->fSegmentMask = 0;
         (*pathRef)->fIsOval = false;
         SkDEBUGCODE((*pathRef)->validate();)
     } else {
@@ skipping 102 matching lines @@
     fBoundsIsDirty = ref.fBoundsIsDirty;
     if (!fBoundsIsDirty) {
         fBounds = ref.fBounds;
         fIsFinite = ref.fIsFinite;
     }
     fSegmentMask = ref.fSegmentMask;
     fIsOval = ref.fIsOval;
     SkDEBUGCODE(this->validate();)
 }
 
+void SkPathRef::injectMoveToIfNeeded() {
+    if (fLastMoveToIndex < 0) {
+        SkScalar x, y;
+        if (this->countVerbs() == 0) {
+            x = y = 0;
+        } else {
+            const SkPoint& pt = this->atPoint(~fLastMoveToIndex);
+            x = pt.fX;
+            y = pt.fY;
+        }
+        this->growForVerb(SkPath::kMove_Verb, 0)->set(x, y);
+    }
+}
+
 SkPoint* SkPathRef::growForRepeatedVerb(int /*SkPath::Verb*/ verb,
                                         int numVbs,
                                         SkScalar** weights) {
     // This value is just made-up for now. When count is 4, calling memset was much
     // slower than just writing the loop. This seems odd, and hopefully in the
     // future this will appear to have been a fluke...
     static const unsigned int kMIN_COUNT_FOR_MEMSET_TO_BE_FAST = 16;
 
+    if (numVbs <= 0) {
+        return NULL;
+    }
+
     SkDEBUGCODE(this->validate();)
     int pCnt;
     bool dirtyAfterEdit = true;
     switch (verb) {
         case SkPath::kMove_Verb:
+            fLastMoveToIndex = fPointCnt + numVbs - 1;
             pCnt = numVbs;
             dirtyAfterEdit = false;
             break;
         case SkPath::kLine_Verb:
             fSegmentMask |= SkPath::kLine_SegmentMask;
             pCnt = numVbs;
             break;
         case SkPath::kQuad_Verb:
             fSegmentMask |= SkPath::kQuad_SegmentMask;
             pCnt = 2 * numVbs;
             break;
         case SkPath::kConic_Verb:
             fSegmentMask |= SkPath::kConic_SegmentMask;
             pCnt = 2 * numVbs;
             break;
         case SkPath::kCubic_Verb:
             fSegmentMask |= SkPath::kCubic_SegmentMask;
             pCnt = 3 * numVbs;
             break;
         case SkPath::kClose_Verb:
             SkDEBUGFAIL("growForRepeatedVerb called for kClose_Verb");
+            // signal that we need a moveTo to follow us (unless we're done)
+            fLastMoveToIndex ^= ~fLastMoveToIndex >> (8 * sizeof(fLastMoveToIndex) - 1);
             pCnt = 0;
             dirtyAfterEdit = false;
             break;
         case SkPath::kDone_Verb:
             SkDEBUGFAIL("growForRepeatedVerb called for kDone");
             // fall through
         default:
             SkDEBUGFAIL("default should not be reached");
             pCnt = 0;
             dirtyAfterEdit = false;
@@ skipping 31 matching lines @@
     SkDEBUGCODE(this->validate();)
     return ret;
 }
 
 SkPoint* SkPathRef::growForVerb(int /* SkPath::Verb*/ verb, SkScalar weight) {
     SkDEBUGCODE(this->validate();)
     int pCnt;
     bool dirtyAfterEdit = true;
     switch (verb) {
         case SkPath::kMove_Verb:
+            // remember our index
+            fLastMoveToIndex = fPointCnt;
             pCnt = 1;
             dirtyAfterEdit = false;
             break;
         case SkPath::kLine_Verb:
             fSegmentMask |= SkPath::kLine_SegmentMask;
             pCnt = 1;
             break;
         case SkPath::kQuad_Verb:
             fSegmentMask |= SkPath::kQuad_SegmentMask;
             pCnt = 2;
             break;
         case SkPath::kConic_Verb:
             fSegmentMask |= SkPath::kConic_SegmentMask;
             pCnt = 2;
             break;
         case SkPath::kCubic_Verb:
             fSegmentMask |= SkPath::kCubic_SegmentMask;
             pCnt = 3;
             break;
         case SkPath::kClose_Verb:
+            // signal that we need a moveTo to follow us (unless we're done)
+            fLastMoveToIndex ^= ~fLastMoveToIndex >> (8 * sizeof(fLastMoveToIndex) - 1);
             pCnt = 0;
             dirtyAfterEdit = false;
             break;
         case SkPath::kDone_Verb:
             SkDEBUGFAIL("growForVerb called for kDone");
             // fall through
         default:
             SkDEBUGFAIL("default is not reached");
             dirtyAfterEdit = false;
             pCnt = 0;
@@ skipping 59 matching lines @@
                      fPoints[i].fY - fBounds.fBottom < SK_ScalarNearlyZero));
             if (!fPoints[i].isFinite()) {
                 isFinite = false;
             }
         }
         SkASSERT(SkToBool(fIsFinite) == isFinite);
     }
 
 #ifdef SK_DEBUG_PATH
     uint32_t mask = 0;
+    int lastMoveToIndex = kINITIAL_LASTMOVETOINDEX_VALUE;
+    int pointCnt = 0;
     for (int i = 0; i < fVerbCnt; ++i) {
         switch (fVerbs[~i]) {
             case SkPath::kMove_Verb:
+                lastMoveToIndex = pointCnt;
+                ++pointCnt;
                 break;
             case SkPath::kLine_Verb:
                 mask |= SkPath::kLine_SegmentMask;
+                ++pointCnt;
                 break;
             case SkPath::kQuad_Verb:
                 mask |= SkPath::kQuad_SegmentMask;
+                pointCnt += 2;
                 break;
             case SkPath::kConic_Verb:
                 mask |= SkPath::kConic_SegmentMask;
+                pointCnt += 2;
                 break;
             case SkPath::kCubic_Verb:
                 mask |= SkPath::kCubic_SegmentMask;
+                pointCnt += 3;
                 break;
             case SkPath::kClose_Verb:
+                if (lastMoveToIndex >= 0) {
+                    lastMoveToIndex = ~lastMoveToIndex;
+                }
                 break;
             case SkPath::kDone_Verb:
                 SkDEBUGFAIL("Done verb shouldn't be recorded.");
                 break;
             default:
                 SkDEBUGFAIL("Unknown Verb");
                 break;
         }
     }
     SkASSERT(mask == fSegmentMask);
+    SkASSERT(lastMoveToIndex == fLastMoveToIndex);
+    SkASSERT(pointCnt == fPointCnt);
 #endif // SK_DEBUG_PATH
 }
 #endif