Add support for building GrShape from SkPath and more tests

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 138 matching lines @@
                  ? style.strokeRec().getMiter()
                  : -1.f;
         memcpy(&key[i++], &scalar, sizeof(scalar));
 
         scalar = style.strokeRec().getWidth();
         memcpy(&key[i++], &scalar, sizeof(scalar));
     }
     SkASSERT(StyleKeySize(style, stopAfterPE) == i);
 }
 
-void GrShape::setInheritedKey(const GrShape &parent, bool stopAfterPE){
+void GrShape::setInheritedKey(const GrShape &parent, bool stopAfterPE) {
     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);
+                return;
+            }
         }
         int styleCnt = StyleKeySize(parent.fStyle, stopAfterPE);
         if (styleCnt < 0) {
             // The style doesn't allow a key, set the path to volatile so that we fail when
             // we try to get a key for the shape.
             fPath.get()->setIsVolatile(true);
+            return;
+        }
+        fInheritedKey.reset(parentCnt + styleCnt);
+        if (useParentGeoKey) {
+            // This will be the geo key.
+            parent.writeUnstyledKey(fInheritedKey.get());
         } else {
-            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)
-            StyleKey(fInheritedKey.get() + parentCnt, parent.fStyle, stopAfterPE);
+            // 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)
+        StyleKey(fInheritedKey.get() + parentCnt, parent.fStyle, stopAfterPE);
     }
 }
 
 GrShape::GrShape(const GrShape& that) : fType(that.fType), fStyle(that.fStyle) {
     switch (fType) {
         case Type::kEmpty:
             return;
         case Type::kRRect:
             fRRect = that.fRRect;
             return;
         case Type::kPath:
             fPath.set(*that.fPath.get());
             return;
     }
     fInheritedKey.reset(that.fInheritedKey.count());
     memcpy(fInheritedKey.get(), that.fInheritedKey.get(),
            sizeof(uint32_t) * fInheritedKey.count());
 }
 
 GrShape::GrShape(const GrShape& parent, bool stopAfterPE) {
     fType = Type::kEmpty;
     SkPathEffect* pe = parent.fStyle.pathEffect();
     const SkPath* inPath;
     SkStrokeRec strokeRec = parent.fStyle.strokeRec();
+    bool appliedPE = false;
     if (pe) {
         fType = Type::kPath;
         fPath.init();
         if (parent.fType == Type::kPath) {
             inPath = parent.fPath.get();
         } else {
             inPath = fPath.get();
             parent.asPath(fPath.get());
         }
         // Should we consider bounds? Would have to include in key, but it'd be nice to know
         // if the bounds actually modified anything before including in key.
         if (!pe->filterPath(fPath.get(), *inPath, &strokeRec, nullptr)) {
             // Make an empty unstyled shape if filtering fails.
             fType = Type::kEmpty;
             fStyle = GrStyle();
             fPath.reset();
             return;
         }
+        appliedPE = true;
         inPath = fPath.get();
     } else if (stopAfterPE || !strokeRec.needToApply()) {
         *this = parent;
         return;
     } else {
         fType = Type::kPath;
         fPath.init();
         if (parent.fType == Type::kPath) {
             inPath = parent.fPath.get();
         } else {
             inPath = fPath.get();
             parent.asPath(fPath.get());
         }
     }
+    const GrShape* effectiveParent = &parent;
+    SkTLazy<GrShape> tmpParent;
     if (!stopAfterPE) {
+        if (appliedPE) {
+            // If the intermediate shape from just the PE is not a path then we capture that here
+            // so that we can pass the non-path parent to setInheritedKey.
+            SkRRect rrect;
+            Type parentType = AttemptToReduceFromPathImpl(*fPath.get(), &rrect, nullptr, strokeRec);
+            switch (parentType) {
+                case Type::kEmpty:
+                    tmpParent.init();
+                    effectiveParent = tmpParent.get();
+                    break;
+                case Type::kRRect:
+                    tmpParent.init(rrect, GrStyle(strokeRec, nullptr));
+                    effectiveParent = tmpParent.get();
+                case Type::kPath:
+                    break;
+            }
+        }
         strokeRec.applyToPath(fPath.get(), *inPath);
     } else {
         fStyle = GrStyle(strokeRec, nullptr);
     }
-    this->setInheritedKey(parent, stopAfterPE);
+    this->attemptToReduceFromPath();
+    this->setInheritedKey(*effectiveParent, stopAfterPE);
 }