Restore SkPath(const SkPath&) to copy the generation ID on Android.

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 167 matching lines @@
     fDirection = kUnknown_Direction;
     fIsFinite = false;
     fIsOval = false;
 #ifdef SK_BUILD_FOR_ANDROID
     GEN_ID_INC;
     fSourcePath = NULL;
 #endif
 }
 
 SkPath::SkPath(const SkPath& that)
-    : fPathRef(SkRef(that.fPathRef.get()))
+    : fPathRef(SkRef(that.fPathRef.get())) {
+    this->copyFields(that);
 #ifdef SK_BUILD_FOR_ANDROID
-    , fGenerationID(0)
+    fGenerationID = that.fGenerationID;
+    fSourcePath   = NULL;  // TODO(mtklein): follow up with Android: do we want to copy this too?
 #endif
-{
-    this->copyFields(that);
     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 = NULL;  // TODO(mtklein): follow up with Android: do we want to copy this too?
+#endif
     }
     SkDEBUGCODE(this->validate();)
     return *this;
 }
 
 void SkPath::copyFields(const SkPath& that) {
     //fPathRef is assumed to have been set by the caller.
     fBounds          = that.fBounds;
     fLastMoveToIndex = that.fLastMoveToIndex;
     fFillType        = that.fFillType;
     fSegmentMask     = that.fSegmentMask;
     fBoundsIsDirty   = that.fBoundsIsDirty;
     fConvexity       = that.fConvexity;
     fDirection       = that.fDirection;
     fIsFinite        = that.fIsFinite;
     fIsOval          = that.fIsOval;
-#ifdef SK_BUILD_FOR_ANDROID
-    GEN_ID_INC;
-    fSourcePath      = NULL;
-#endif
 }
 
 SK_API bool operator==(const SkPath& a, const SkPath& b) {
     // note: don't need to look at isConvex or bounds, since just comparing the
     // raw data is sufficient.
 
     // We explicitly check fSegmentMask as a quick-reject. We could skip it,
     // since it is only a cache of info in the fVerbs, but its a fast way to
     // notice a difference
 
     return &a == &b ||
         (a.fFillType == b.fFillType && a.fSegmentMask == b.fSegmentMask &&
          *a.fPathRef.get() == *b.fPathRef.get());
 }
 
 void SkPath::swap(SkPath& that) {
     SkASSERT(&that != NULL);
 
     if (this != &that) {
         fPathRef.swap(&that.fPathRef);
         SkTSwap<SkRect>(fBounds, that.fBounds);
         SkTSwap<int>(fLastMoveToIndex, that.fLastMoveToIndex);
         SkTSwap<uint8_t>(fFillType, that.fFillType);
         SkTSwap<uint8_t>(fSegmentMask, that.fSegmentMask);
         SkTSwap<uint8_t>(fBoundsIsDirty, that.fBoundsIsDirty);
         SkTSwap<uint8_t>(fConvexity, that.fConvexity);
         SkTSwap<uint8_t>(fDirection, that.fDirection);
         SkTSwap<SkBool8>(fIsFinite, that.fIsFinite);
         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<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;
     SkVector v;
     if (SkPath::kCW_Direction == dir) {
@@ skipping 2727 matching lines @@
     switch (this->getFillType()) {
         case SkPath::kEvenOdd_FillType:
         case SkPath::kInverseEvenOdd_FillType:
             w &= 1;
             break;
         default:
             break;
     }
     return SkToBool(w);
 }