Add some more getters to GrShape.

src/gpu/GrShape.h

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrShape_DEFINED
 #define GrShape_DEFINED
 
@@ skipping 126 matching lines @@
         }
     }
 
     const GrStyle& style() const { return fStyle; }
 
     /**
      * Returns a shape that has either applied the path effect or path effect and stroking
      * information from this shape's style to its geometry. Scale is used when approximating the
      * output geometry and typically is computed from the view matrix
      */
-    GrShape applyStyle(GrStyle::Apply apply, SkScalar scale) {
+    GrShape applyStyle(GrStyle::Apply apply, SkScalar scale) const {
         return GrShape(*this, apply, scale);
     }
 
     /** Returns the unstyled geometry as a rrect if possible. */
     bool asRRect(SkRRect* rrect, SkPath::Direction* dir, unsigned* start, bool* inverted) const {
         if (Type::kRRect != fType) {
             return false;
         }
         if (rrect) {
             *rrect = fRRect;
@@ skipping 55 matching lines @@
      */
     const SkRect& bounds() const;
 
     /**
      * Gets the bounds of the geometry reflecting the shape's styling (ignoring inverse fill
      * status).
      */
     void styledBounds(SkRect* bounds) const;
 
     /**
+     * Is this shape known to be convex, before styling is applied. An unclosed but otherwise
+     * convex path is considered to be closed if they styling reflects a fill and not otherwise.
+     * This is because filling closes all contours in the path.
+     */
+    bool knownToBeConvex() const {
+        switch (fType) {
+            case Type::kEmpty:
+                return true;
+            case Type::kRRect:
+                return true;
+            case Type::kPath:
+                // SkPath.isConvex() really means "is this path convex were it to be closed" and
+                // thus doesn't give the correct answer for stroked paths, hence we also check
+                // whether the path is either filled or closed. Convex paths may only have one
+                // contour hence isLastContourClosed() is a sufficient for a convex path.
+                return (this->style().isSimpleFill() || fPath.get()->isLastContourClosed()) &&
+                       fPath.get()->isConvex();
+        }
+        return false;
+    }
+
+    /** Is the pre-styled geometry inverse filled? */
+    bool inverseFilled() const {
+        bool ret = false;
+        switch (fType) {
+            case Type::kEmpty:
+                ret = false;
+                break;
+            case Type::kRRect:
+                ret = fRRectIsInverted;
+                break;
+            case Type::kPath:
+                ret = this->fPath.get()->isInverseFillType();
+                break;
+        }
+        // Dashing ignores inverseness. We should have caught this earlier. skbug.com/5421
+        SkASSERT(!(ret && this->style().isDashed()));
+        return ret;
+    }
+
+    /**
+     * Might applying the styling to the geometry produce an inverse fill. The "may" part comes in
+     * because an arbitrary path effect could produce an inverse filled path. In other cases this
+     * can be thought of as "inverseFilledAfterStyling()".
+     */
+    bool mayBeInverseFilledAfterStyling() const {
+         // An arbitrary path effect can produce an arbitrary output path, which may be inverse
+         // filled.
+        if (this->style().hasNonDashPathEffect()) {
+            return true;
+        }
+        return this->inverseFilled();
+    }
+
+    /**
      * Is it known that the unstyled geometry has no unclosed contours. This means that it will
      * not have any caps if stroked (modulo the effect of any path effect).
      */
     bool knownToBeClosed() const {
         switch (fType) {
             case Type::kEmpty:
                 return true;
             case Type::kRRect:
                 return true;
             case Type::kPath:
-                return false;
+                // SkPath doesn't keep track of the closed status of each contour.
+                return SkPathPriv::IsClosedSingleContour(*fPath.get());
         }
         return false;
     }
 
     uint32_t segmentMask() const {
         switch (fType) {
             case Type::kEmpty:
                 return 0;
             case Type::kRRect:
                 if (fRRect.getType() == SkRRect::kOval_Type) {
                     return SkPath::kConic_SegmentMask;
                 } else if (fRRect.getType() == SkRRect::kRect_Type) {
                     return SkPath::kLine_SegmentMask;
                 }
                 return SkPath::kLine_SegmentMask | SkPath::kConic_SegmentMask;
             case Type::kPath:
                 return fPath.get()->getSegmentMasks();
         }
         return 0;
     }
 
     /**
      * Gets the size of the key for the shape represented by this GrShape (ignoring its styling).
      * A negative value is returned if the shape has no key (shouldn't be cached).
      */
     int unstyledKeySize() const;
 
+    bool hasUnstyledKey() const { return this->unstyledKeySize() >= 0; }
+
     /**
      * Writes unstyledKeySize() bytes into the provided pointer. Assumes that there is enough
      * space allocated for the key and that unstyledKeySize() does not return a negative value
      * for this shape.
      */
     void writeUnstyledKey(uint32_t* key) const;
 
 private:
     enum class Type {
         kEmpty,
@@ skipping 68 matching lines @@
     SkPath::Direction           fRRectDir;
     unsigned                    fRRectStart;
     bool                        fRRectIsInverted;
     SkTLazy<SkPath>             fPath;
     // Gen ID of the original path (fPath may be modified)
     int32_t                     fPathGenID = 0;
     GrStyle                     fStyle;
     SkAutoSTArray<8, uint32_t>  fInheritedKey;
 };
 #endif