Apply canonicalizations to path GrShapes.

src/gpu/GrShape.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrShape.h"
 
 GrShape& GrShape::operator=(const GrShape& that) {
@@ skipping 14 matching lines @@
             fRRectDir = that.fRRectDir;
             fRRectStart = that.fRRectStart;
             fRRectIsInverted = that.fRRectIsInverted;
             break;
         case Type::kPath:
             if (wasPath) {
                 *fPath.get() = *that.fPath.get();
             } else {
                 fPath.set(*that.fPath.get());
             }
+            fPathGenID = that.fPathGenID;
             break;
     }
     fInheritedKey.reset(that.fInheritedKey.count());
     sk_careful_memcpy(fInheritedKey.get(), that.fInheritedKey.get(),
                       sizeof(uint32_t) * fInheritedKey.count());
     return *this;
 }
 
 const SkRect& GrShape::bounds() const {
     static constexpr SkRect kEmpty = SkRect::MakeEmpty();
@@ skipping 23 matching lines @@
     }
     switch (fType) {
         case Type::kEmpty:
             return 1;
         case Type::kRRect:
             SkASSERT(!fInheritedKey.count());
             SkASSERT(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
             // + 1 for the direction, start index, and inverseness.
             return SkRRect::kSizeInMemory / sizeof(uint32_t) + 1;
         case Type::kPath:
-            if (fPath.get()->isVolatile()) {
+            if (0 == fPathGenID) {
                 return -1;
             } else {
                 // The key is the path ID and fill type.
                 return 2;
             }
     }
     SkFAIL("Should never get here.");
     return 0;
 }
 
@@ skipping 10 matching lines @@
                 break;
             case Type::kRRect:
                 fRRect.writeToMemory(key);
                 key += SkRRect::kSizeInMemory / sizeof(uint32_t);
                 *key = (fRRectDir == SkPath::kCCW_Direction) ? (1 << 31) : 0;
                 *key |= fRRectIsInverted ? (1 << 30) : 0;
                 *key++ |= fRRectStart;
                 SkASSERT(fRRectStart < 8);
                 break;
             case Type::kPath:
-                SkASSERT(!fPath.get()->isVolatile());
-                *key++ = fPath.get()->getGenerationID();
+                SkASSERT(fPathGenID);
+                *key++ = fPathGenID;
                 // We could canonicalize the fill rule for paths that don't differentiate between
                 // even/odd or winding fill (e.g. convex).
                 *key++ = fPath.get()->getFillType();
                 break;
         }
     }
     SkASSERT(key - origKey == this->unstyledKeySize());
 }
 
 void GrShape::setInheritedKey(const GrShape &parent, GrStyle::Apply apply, SkScalar scale) {
     SkASSERT(!fInheritedKey.count());
     // If the output shape turns out to be simple, then we will just use its geometric key
     if (Type::kPath == fType) {
         // We want ApplyFullStyle(ApplyPathEffect(shape)) to have the same key as
         // ApplyFullStyle(shape).
         // The full key is structured as (geo,path_effect,stroke).
         // If we do ApplyPathEffect we get get,path_effect as the inherited key. If we then
         // do ApplyFullStyle we'll memcpy geo,path_effect into the new inherited key
         // and then append the style key (which should now be stroke only) at the end.
         int parentCnt = parent.fInheritedKey.count();
         bool useParentGeoKey = !parentCnt;
         if (useParentGeoKey) {
             parentCnt = parent.unstyledKeySize();
             if (parentCnt < 0) {
                 // The parent's geometry has no key so we will have no key.
-                fPath.get()->setIsVolatile(true);
+                fPathGenID = 0;
                 return;
             }
         }
         uint32_t styleKeyFlags = 0;
         if (parent.knownToBeClosed()) {
             styleKeyFlags |= GrStyle::kClosed_KeyFlag;
         }
         int styleCnt = GrStyle::KeySize(parent.fStyle, apply, styleKeyFlags);
         if (styleCnt < 0) {
-            // The style doesn't allow a key, set the path to volatile so that we fail when
+            // The style doesn't allow a key, set the path gen ID to 0 so that we fail when
             // we try to get a key for the shape.
-            fPath.get()->setIsVolatile(true);
+            fPathGenID = 0;
             return;
         }
         fInheritedKey.reset(parentCnt + styleCnt);
         if (useParentGeoKey) {
             // This will be the geo key.
             parent.writeUnstyledKey(fInheritedKey.get());
         } else {
             // This should be (geo,path_effect).
             memcpy(fInheritedKey.get(), parent.fInheritedKey.get(),
                    parentCnt * sizeof(uint32_t));
         }
         // Now turn (geo,path_effect) or (geo) into (geo,path_effect,stroke)
         GrStyle::WriteKey(fInheritedKey.get() + parentCnt, parent.fStyle, apply, scale,
                           styleKeyFlags);
     }
 }
 
 GrShape::GrShape(const GrShape& that) : fType(that.fType), fStyle(that.fStyle) {
     switch (fType) {
         case Type::kEmpty:
-            return;
+            break;
         case Type::kRRect:
             fRRect = that.fRRect;
             fRRectDir = that.fRRectDir;
             fRRectStart = that.fRRectStart;
             fRRectIsInverted = that.fRRectIsInverted;
-            return;
+            break;
         case Type::kPath:
             fPath.set(*that.fPath.get());
-            return;
+            fPathGenID = that.fPathGenID;
+            break;
     }
     fInheritedKey.reset(that.fInheritedKey.count());
-    memcpy(fInheritedKey.get(), that.fInheritedKey.get(),
-           sizeof(uint32_t) * fInheritedKey.count());
+    sk_careful_memcpy(fInheritedKey.get(), that.fInheritedKey.get(),
+                      sizeof(uint32_t) * fInheritedKey.count());
 }
 
 GrShape::GrShape(const GrShape& parent, GrStyle::Apply apply, SkScalar scale) {
     // TODO: Add some quantization of scale for better cache performance here or leave that up
     // to caller?
     // TODO: For certain shapes and stroke params we could ignore the scale. (e.g. miter or bevel
     // stroke of a rect).
     if (!parent.style().applies() ||
         (GrStyle::Apply::kPathEffectOnly == apply && !parent.style().pathEffect())) {
         fType = Type::kEmpty;
@@ skipping 115 matching lines @@
                 fType = Type::kRRect;
             }
         }
     }
     if (Type::kPath != fType) {
         fPath.reset();
         fInheritedKey.reset(0);
         if (Type::kRRect == fType) {
             this->attemptToSimplifyRRect();
         }
+    } else {
+        if (fInheritedKey.count() || fPath.get()->isVolatile()) {
+            fPathGenID = 0;
+        } else {
+            fPathGenID = fPath.get()->getGenerationID();
+        }
+        if (this->style().isSimpleFill()) {
+            // Filled paths are treated as though all their contours were closed.
+            // Since SkPath doesn't track individual contours, this will only close the last. :(
+            // There is no point in closing lines, though, since they loose their line-ness.

[bsalomon, 2016/06/20 20:18:58]

In the future we'll extract the line during simplification of a path and store
it like we do rrects and this exception will go away.

+            if (!fPath.get()->isLine(nullptr)) {
+                fPath.get()->close();
+                fPath.get()->setIsVolatile(true);
+            }
+        }
+        if (fPath.get()->isConvex()) {
+            // There is no distinction between even/odd and non-zero winding count for convex
+            // paths.
+            if (fPath.get()->isInverseFillType()) {
+               fPath.get()->setFillType(SkPath::kInverseEvenOdd_FillType);
+            } else {
+                fPath.get()->setFillType(SkPath::kEvenOdd_FillType);
+            }
+        }
+        if (this->style().isDashed()) {
+            // Dashing ignores inverseness (skbug.com/5421)
+            switch (fPath.get()->getFillType()) {
+                case SkPath::kWinding_FillType:
+                case SkPath::kEvenOdd_FillType:
+                    break;
+                case SkPath::kInverseWinding_FillType:
+                    fPath.get()->setFillType(SkPath::kWinding_FillType);
+                    break;
+                case SkPath::kInverseEvenOdd_FillType:
+                    fPath.get()->setFillType(SkPath::kEvenOdd_FillType);
+                    break;
+            }
+        }
     }
 }
 
 void GrShape::attemptToSimplifyRRect() {
     SkASSERT(Type::kRRect == fType);
     SkASSERT(!fInheritedKey.count());
     if (fRRect.isEmpty()) {
         fType = Type::kEmpty;
         return;
     }
     if (!this->style().hasPathEffect()) {
         fRRectDir = kDefaultRRectDir;
         fRRectStart = kDefaultRRectStart;
     } else if (fStyle.isDashed()) {
         // Dashing ignores the inverseness (currently). skbug.com/5421
         fRRectIsInverted = false;
     }
 }