Use SkPathRef gen id for SkPath::getGenerationID

src/core/SkPath.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkBuffer.h"
@@ skipping 129 matching lines @@
 */
 
 ////////////////////////////////////////////////////////////////////////////
 
 // flag to require a moveTo if we begin with something else, like lineTo etc.
 #define INITIAL_LASTMOVETOINDEX_VALUE   ~0
 
 SkPath::SkPath()
     : fPathRef(SkPathRef::CreateEmpty())
 #ifdef SK_BUILD_FOR_ANDROID
-    , fGenerationID(0)
+    , fSourcePath(NULL)
 #endif
 {
     this->resetFields();
 }
 
 void SkPath::resetFields() {
     //fPathRef is assumed to have been emptied by the caller.
     fLastMoveToIndex = INITIAL_LASTMOVETOINDEX_VALUE;
     fFillType = kWinding_FillType;
     fSegmentMask = 0;
     fConvexity = kUnknown_Convexity;
     fDirection = kUnknown_Direction;
     fIsOval = false;
-#ifdef SK_BUILD_FOR_ANDROID
-    GEN_ID_INC;
-    // We don't touch fSourcePath.  It's used to track texture garbage collection, so we don't
-    // want to muck with it if it's been set to something non-NULL.
-#endif
+
+    // We don't touch Android's fSourcePath.  It's used to track texture garbage collection, so we
+    // don't want to muck with it if it's been set to something non-NULL.
 }
 
 SkPath::SkPath(const SkPath& that)
     : fPathRef(SkRef(that.fPathRef.get())) {
     this->copyFields(that);
 #ifdef SK_BUILD_FOR_ANDROID
-    fGenerationID = that.fGenerationID;
     fSourcePath   = that.fSourcePath;
 #endif
     SkDEBUGCODE(that.validate();)
 }
 
 SkPath::~SkPath() {
     SkDEBUGCODE(this->validate();)
 }
 
 SkPath& SkPath::operator=(const SkPath& that) {
     SkDEBUGCODE(that.validate();)
 
     if (this != &that) {
         fPathRef.reset(SkRef(that.fPathRef.get()));
         this->copyFields(that);
 #ifdef SK_BUILD_FOR_ANDROID
-        GEN_ID_INC;  // Similar to swap, we can't just copy this or it could go back in time.
         fSourcePath = that.fSourcePath;
 #endif
     }
     SkDEBUGCODE(this->validate();)
     return *this;
 }
 
 void SkPath::copyFields(const SkPath& that) {
     //fPathRef is assumed to have been set by the caller.
     fLastMoveToIndex = that.fLastMoveToIndex;
@@ skipping 22 matching lines @@
 
     if (this != &that) {
         fPathRef.swap(&that.fPathRef);
         SkTSwap<int>(fLastMoveToIndex, that.fLastMoveToIndex);
         SkTSwap<uint8_t>(fFillType, that.fFillType);
         SkTSwap<uint8_t>(fSegmentMask, that.fSegmentMask);
         SkTSwap<uint8_t>(fConvexity, that.fConvexity);
         SkTSwap<uint8_t>(fDirection, that.fDirection);
         SkTSwap<SkBool8>(fIsOval, that.fIsOval);
 #ifdef SK_BUILD_FOR_ANDROID
-        // It doesn't really make sense to swap the generation IDs here, because they might go
-        // backwards.  To be safe we increment both to mark them both as changed.
-        GEN_ID_INC;
-        GEN_ID_PTR_INC(&that);
         SkTSwap<const SkPath*>(fSourcePath, that.fSourcePath);
 #endif
     }
 }
 
 static inline bool check_edge_against_rect(const SkPoint& p0,
                                            const SkPoint& p1,
                                            const SkRect& rect,
                                            SkPath::Direction dir) {
     const SkPoint* edgeBegin;
@@ skipping 72 matching lines @@
             if (!check_edge_against_rect(prevPt, pts[nextPt], rect, direction)) {
                 return false;
             }
             prevPt = pts[nextPt];
         }
     }
 
     return check_edge_against_rect(prevPt, firstPt, rect, direction);
 }
 
+uint32_t SkPath::getGenerationID() const {
+    uint32_t genID = fPathRef->genID();
 #ifdef SK_BUILD_FOR_ANDROID
-uint32_t SkPath::getGenerationID() const {
-    return fGenerationID;
+    SkASSERT((unsigned)fFillType < (1 << (32 - kPathRefGenIDBitCnt)));
+    genID |= static_cast<uint32_t>(fFillType) << kPathRefGenIDBitCnt;
+#endif
+    return genID;
 }
 
+#ifdef SK_BUILD_FOR_ANDROID
 const SkPath* SkPath::getSourcePath() const {
     return fSourcePath;
 }
 
 void SkPath::setSourcePath(const SkPath* path) {
     fSourcePath = path;
 }
 #endif
 
 void SkPath::reset() {
@@ skipping 280 matching lines @@
 void SkPath::setLastPt(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     int count = fPathRef->countPoints();
     if (count == 0) {
         this->moveTo(x, y);
     } else {
         fIsOval = false;
         SkPathRef::Editor ed(&fPathRef);
         ed.atPoint(count-1)->set(x, y);
-        GEN_ID_INC;
     }
 }
 
 void SkPath::setConvexity(Convexity c) {
     if (fConvexity != c) {
         fConvexity = c;
-        GEN_ID_INC;
     }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 //  Construction methods
 
 #define DIRTY_AFTER_EDIT                 \
     do {                                 \
         fConvexity = kUnknown_Convexity; \
         fDirection = kUnknown_Direction; \
         fIsOval = false;                 \
     } while (0)
 
 void SkPath::incReserve(U16CPU inc) {
     SkDEBUGCODE(this->validate();)
     SkPathRef::Editor(&fPathRef, inc, inc);
     SkDEBUGCODE(this->validate();)
 }
 
 void SkPath::moveTo(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     SkPathRef::Editor ed(&fPathRef);
 
     // remember our index
     fLastMoveToIndex = ed.pathRef()->countPoints();
 
     ed.growForVerb(kMove_Verb)->set(x, y);
-
-    GEN_ID_INC;
 }
 
 void SkPath::rMoveTo(SkScalar x, SkScalar y) {
     SkPoint pt;
     this->getLastPt(&pt);
     this->moveTo(pt.fX + x, pt.fY + y);
 }
 
 void SkPath::injectMoveToIfNeeded() {
     if (fLastMoveToIndex < 0) {
@@ skipping 11 matching lines @@
 
 void SkPath::lineTo(SkScalar x, SkScalar y) {
     SkDEBUGCODE(this->validate();)
 
     this->injectMoveToIfNeeded();
 
     SkPathRef::Editor ed(&fPathRef);
     ed.growForVerb(kLine_Verb)->set(x, y);
     fSegmentMask |= kLine_SegmentMask;
 
-    GEN_ID_INC;
     DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rLineTo(SkScalar x, SkScalar y) {
     this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
     SkPoint pt;
     this->getLastPt(&pt);
     this->lineTo(pt.fX + x, pt.fY + y);
 }
 
 void SkPath::quadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
     SkDEBUGCODE(this->validate();)
 
     this->injectMoveToIfNeeded();
 
     SkPathRef::Editor ed(&fPathRef);
     SkPoint* pts = ed.growForVerb(kQuad_Verb);
     pts[0].set(x1, y1);
     pts[1].set(x2, y2);
     fSegmentMask |= kQuad_SegmentMask;
 
-    GEN_ID_INC;
     DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rQuadTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2) {
     this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
     SkPoint pt;
     this->getLastPt(&pt);
     this->quadTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2);
 }
 
@@ skipping 11 matching lines @@
         SkDEBUGCODE(this->validate();)
 
         this->injectMoveToIfNeeded();
 
         SkPathRef::Editor ed(&fPathRef);
         SkPoint* pts = ed.growForConic(w);
         pts[0].set(x1, y1);
         pts[1].set(x2, y2);
         fSegmentMask |= kConic_SegmentMask;
 
-        GEN_ID_INC;
         DIRTY_AFTER_EDIT;
     }
 }
 
 void SkPath::rConicTo(SkScalar dx1, SkScalar dy1, SkScalar dx2, SkScalar dy2,
                       SkScalar w) {
     this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
     SkPoint pt;
     this->getLastPt(&pt);
     this->conicTo(pt.fX + dx1, pt.fY + dy1, pt.fX + dx2, pt.fY + dy2, w);
 }
 
 void SkPath::cubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                      SkScalar x3, SkScalar y3) {
     SkDEBUGCODE(this->validate();)
 
     this->injectMoveToIfNeeded();
 
     SkPathRef::Editor ed(&fPathRef);
     SkPoint* pts = ed.growForVerb(kCubic_Verb);
     pts[0].set(x1, y1);
     pts[1].set(x2, y2);
     pts[2].set(x3, y3);
     fSegmentMask |= kCubic_SegmentMask;
 
-    GEN_ID_INC;
     DIRTY_AFTER_EDIT;
 }
 
 void SkPath::rCubicTo(SkScalar x1, SkScalar y1, SkScalar x2, SkScalar y2,
                       SkScalar x3, SkScalar y3) {
     this->injectMoveToIfNeeded();  // This can change the result of this->getLastPt().
     SkPoint pt;
     this->getLastPt(&pt);
     this->cubicTo(pt.fX + x1, pt.fY + y1, pt.fX + x2, pt.fY + y2,
                   pt.fX + x3, pt.fY + y3);
 }
 
 void SkPath::close() {
     SkDEBUGCODE(this->validate();)
 
     int count = fPathRef->countVerbs();
     if (count > 0) {
         switch (fPathRef->atVerb(count - 1)) {
             case kLine_Verb:
             case kQuad_Verb:
             case kConic_Verb:
             case kCubic_Verb:
             case kMove_Verb: {
                 SkPathRef::Editor ed(&fPathRef);
                 ed.growForVerb(kClose_Verb);
-                GEN_ID_INC;
                 break;
             }
             case kClose_Verb:
                 // don't add a close if it's the first verb or a repeat
                 break;
             default:
                 SkDEBUGFAIL("unexpected verb");
                 break;
         }
     }
@@ skipping 65 matching lines @@
             for (int i = 1; i < count; ++i) {
                 vb[~i] = kLine_Verb;
             }
         }
         fSegmentMask |= kLine_SegmentMask;
     }
     if (close) {
         vb[~count] = kClose_Verb;
     }
 
-    GEN_ID_INC;
     DIRTY_AFTER_EDIT;
     SkDEBUGCODE(this->validate();)
 }
 
 #include "SkGeometry.h"
 
 static int build_arc_points(const SkRect& oval, SkScalar startAngle,
                             SkScalar sweepAngle,
                             SkPoint pts[kSkBuildQuadArcStorage]) {
 
@@ skipping 805 matching lines @@
         dst->fDirection = kUnknown_Direction;
     } else {
         SkPathRef::CreateTransformedCopy(&dst->fPathRef, *fPathRef.get(), matrix);
 
         if (this != dst) {
             dst->fFillType = fFillType;
             dst->fSegmentMask = fSegmentMask;
             dst->fConvexity = fConvexity;
         }
 
-#ifdef SK_BUILD_FOR_ANDROID
-        if (!matrix.isIdentity() && !dst->hasComputedBounds()) {
-            GEN_ID_PTR_INC(dst);
-        }
-#endif
-
         if (kUnknown_Direction == fDirection) {
             dst->fDirection = kUnknown_Direction;
         } else {
             SkScalar det2x2 =
                 SkScalarMul(matrix.get(SkMatrix::kMScaleX), matrix.get(SkMatrix::kMScaleY)) -
                 SkScalarMul(matrix.get(SkMatrix::kMSkewX), matrix.get(SkMatrix::kMSkewY));
             if (det2x2 < 0) {
                 dst->fDirection = SkPath::OppositeDirection(static_cast<Direction>(fDirection));
             } else if (det2x2 > 0) {
                 dst->fDirection = fDirection;
@@ skipping 388 matching lines @@
 #endif
 
     fPathRef.reset(SkPathRef::CreateFromBuffer(&buffer
 #ifndef DELETE_THIS_CODE_WHEN_SKPS_ARE_REBUILT_AT_V14_AND_ALL_OTHER_INSTANCES_TOO
         , newFormat, packed)
 #endif
         );
 
     buffer.skipToAlign4();
 
-    GEN_ID_INC;
-
     SkDEBUGCODE(this->validate();)
     return SkToU32(buffer.pos());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #include "SkString.h"
 
 static void append_scalar(SkString* str, SkScalar value) {
     SkString tmp;
@@ skipping 853 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }