Make GrShape track the winding direction and starting point for rrect types.

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) {
     bool wasPath = Type::kPath == fType;
     fStyle = that.fStyle;
     fType = that.fType;
     switch (fType) {
         case Type::kEmpty:
             if (wasPath) {
                 fPath.reset();
             }
             break;
         case Type::kRRect:
             if (wasPath) {
                 fPath.reset();
             }
             fRRect = that.fRRect;
+            fRRectDir = that.fRRectDir;
+            fRRectStart = that.fRRectStart;
             break;
         case Type::kPath:
             if (wasPath) {
                 *fPath.get() = *that.fPath.get();
             } else {
                 fPath.set(*that.fPath.get());
             }
             break;
     }
     fInheritedKey.reset(that.fInheritedKey.count());
@@ skipping 27 matching lines @@
 int GrShape::unstyledKeySize() const {
     if (fInheritedKey.count()) {
         return fInheritedKey.count();
     }
     switch (fType) {
         case Type::kEmpty:
             return 1;
         case Type::kRRect:
             SkASSERT(!fInheritedKey.count());
             SkASSERT(0 == SkRRect::kSizeInMemory % sizeof(uint32_t));
-            return SkRRect::kSizeInMemory / sizeof(uint32_t);
+            // + 1 for the direction + start index.
+            return SkRRect::kSizeInMemory / sizeof(uint32_t) + 1;
         case Type::kPath:
             if (fPath.get()->isVolatile()) {
                 return -1;
             } else {
                 return 1;
             }
     }
     SkFAIL("Should never get here.");
     return 0;
 }
 
 void GrShape::writeUnstyledKey(uint32_t* key) const {
     SkASSERT(this->unstyledKeySize());
     SkDEBUGCODE(uint32_t* origKey = key;)
     if (fInheritedKey.count()) {
         memcpy(key, fInheritedKey.get(), sizeof(uint32_t) * fInheritedKey.count());
         SkDEBUGCODE(key += fInheritedKey.count();)
     } else {
         switch (fType) {
             case Type::kEmpty:
                 *key++ = 1;
                 break;
             case Type::kRRect:
                 fRRect.writeToMemory(key);
                 key += SkRRect::kSizeInMemory / sizeof(uint32_t);
+                *key = (fRRectDir == SkPath::kCCW_Direction) ? (1 << 31) : 0;
+                *key++ |= fRRectStart;
                 break;
             case Type::kPath:
                 SkASSERT(!fPath.get()->isVolatile());
                 *key++ = fPath.get()->getGenerationID();
                 break;
         }
     }
     SkASSERT(key - origKey == this->unstyledKeySize());
 }
 
@@ skipping 102 matching lines @@
         if (GrStyle::Apply::kPathEffectAndStrokeRec == apply) {
             if (strokeRec.needToApply()) {
                 // The intermediate shape may not be a general path. If we we're just applying
                 // the path effect then attemptToReduceFromPath would catch it. This means that
                 // when we subsequently applied the remaining strokeRec we would have a non-path
                 // parent shape that would be used to determine the the stroked path's key.
                 // We detect that case here and change parentForKey to a temporary that represents
                 // the simpler shape so that applying both path effect and the strokerec all at
                 // once produces the same key.
                 SkRRect rrect;
-                Type parentType = AttemptToReduceFromPathImpl(*fPath.get(), &rrect, nullptr,
-                                                              strokeRec);
+                SkPath::Direction dir;
+                unsigned start;
+                Type parentType = AttemptToReduceFromPathImpl(*fPath.get(), &rrect, &dir, &start,
+                                                              nullptr, strokeRec);
                 switch (parentType) {
                     case Type::kEmpty:
                         tmpParent.init();
                         parentForKey = tmpParent.get();
                         break;
                     case Type::kRRect:
-                        tmpParent.init(rrect, GrStyle(strokeRec, nullptr));
+                        tmpParent.init(rrect, dir, start, GrStyle(strokeRec, nullptr));
                         parentForKey = tmpParent.get();
                     case Type::kPath:
                         break;
                 }
                 SkAssertResult(strokeRec.applyToPath(fPath.get(), *fPath.get()));
             } else {
                 fStyle = GrStyle(strokeRec, nullptr);
             }
         } else {
             fStyle = GrStyle(strokeRec, nullptr);
         }
     } else {
         const SkPath* srcForParentStyle;
         if (parent.fType == Type::kPath) {
             srcForParentStyle = parent.fPath.get();
         } else {
             srcForParentStyle = tmpPath.init();
             parent.asPath(tmpPath.get());
         }
         SkStrokeRec::InitStyle fillOrHairline;
         SkASSERT(parent.fStyle.applies());
         SkASSERT(!parent.fStyle.pathEffect());
         SkAssertResult(parent.fStyle.applyToPath(fPath.get(), &fillOrHairline, *srcForParentStyle,
                                                  scale));
         fStyle.resetToInitStyle(fillOrHairline);
     }
     this->attemptToReduceFromPath();
     this->setInheritedKey(*parentForKey, apply, scale);
 }
+
+GrShape::Type GrShape::AttemptToReduceFromPathImpl(const SkPath& path, SkRRect* rrect,
+                                                   SkPath::Direction* rrectDir,
+                                                   unsigned* rrectStart,
+                                                   const SkPathEffect* pe,
+                                                   const SkStrokeRec& strokeRec) {
+    if (path.isEmpty()) {
+        return Type::kEmpty;
+    }
+    if (path.isRRect(rrect, rrectDir, rrectStart)) {
+        SkASSERT(!rrect->isEmpty());
+        if (!pe) {
+            *rrectDir = SkPath::kCW_Direction;
+            *rrectStart = DefaultRRectStartIndex(*rrect, false);
+        } else {
+            // For oval and rect subtypes of rrects pairs of start indices collapse to the same
+            // point. Here we canonicalize which of the start points we use.
+            if (rrect->getType() == SkRRect::kOval_Type) {
+                *rrectStart |= ~0b1;
+            } else if (rrect->getType() == SkRRect::kRect_Type) {
+                *rrectStart = ((*rrectStart + 1) & 0b110);
+            }
+        }
+        return Type::kRRect;
+    }
+    SkRect rect;
+    if (path.isOval(&rect, rrectDir, rrectStart)) {
+        rrect->setOval(rect);
+        if (!pe) {
+            *rrectDir = SkPath::kCW_Direction;
+            *rrectStart = 2;
+        } else {
+            // convert from oval indexing to rrect indexiing.
+            *rrectStart *= 2;
+        }
+        return Type::kRRect;
+    }
+    // When there is a path effect we restrict rect detection to the narrower API that
+    // gives us the starting position. Otherwise, we will retry with the more aggressive isRect().
+    if (SkPathPriv::IsSimpleClosedRect(path, &rect, rrectDir, rrectStart)) {
+        if (!pe) {
+            *rrectDir = SkPath::kCW_Direction;
+            *rrectStart = 0;
+        } else {
+            // convert from rect indexing to rrect indexiing.
+            *rrectStart *= 2;
+        }
+        rrect->setRect(rect);
+        return Type::kRRect;
+    }
+    if (!pe) {
+        bool closed;
+        if (path.isRect(&rect, &closed, nullptr)) {
+            if (closed || strokeRec.isFillStyle()) {
+                rrect->setRect(rect);
+                // Since there is no path effect the dir and start index is immaterial.
+                *rrectDir = SkPath::kCW_Direction;
+                *rrectStart = 0;
+                return Type::kRRect;
+            }
+        }
+    }
+    return Type::kPath;
+}