Some simplifications of GrShape reductions/canonicalizations

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 21 matching lines @@
  * applying style to the geometry. The idea is to expand this to cover most or all of the geometries
  * that have SkCanvas::draw APIs.
  */
 class GrShape {
 public:
     GrShape() : fType(Type::kEmpty) {}
 
     explicit GrShape(const SkPath& path)
         : fType(Type::kPath)
         , fPath(&path) {
-        this->attemptToReduceFromPath();
+        this->attemptToSimplifyPath();
     }
 
     explicit GrShape(const SkRRect& rrect)
         : fType(Type::kRRect)
         , fRRect(rrect)
         , fRRectIsInverted(false) {
         fRRectStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectDir);
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     explicit GrShape(const SkRect& rect)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
         , fRRectIsInverted(false) {
         fRRectStart = DefaultRectDirAndStartIndex(rect, false, &fRRectDir);
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkPath& path, const GrStyle& style)
         : fType(Type::kPath)
         , fPath(&path)
         , fStyle(style) {
-        this->attemptToReduceFromPath();
+        this->attemptToSimplifyPath();
     }
 
     GrShape(const SkRRect& rrect, const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(rrect)
         , fRRectIsInverted(false)
         , fStyle(style) {
         fRRectStart = DefaultRRectDirAndStartIndex(rrect, style.hasPathEffect(), &fRRectDir);
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkRRect& rrect, SkPath::Direction dir, unsigned start, bool inverted,
             const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(rrect)
         , fRRectIsInverted(inverted)
         , fStyle(style) {
         if (style.pathEffect()) {
             fRRectDir = dir;
             fRRectStart = start;
             if (fRRect.getType() == SkRRect::kRect_Type) {
                 fRRectStart = (fRRectStart + 1) & 0b110;
             } else if (fRRect.getType() == SkRRect::kOval_Type) {
                 fRRectStart &= 0b110;
             }
         } else {
             fRRectStart = DefaultRRectDirAndStartIndex(rrect, false, &fRRectDir);
         }
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkRect& rect, const GrStyle& style)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
         , fRRectIsInverted(false)
         , fStyle(style) {
         fRRectStart = DefaultRectDirAndStartIndex(rect, style.hasPathEffect(), &fRRectDir);
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkPath& path, const SkPaint& paint)
         : fType(Type::kPath)
         , fPath(&path)
         , fStyle(paint) {
-        this->attemptToReduceFromPath();
+        this->attemptToSimplifyPath();
     }
 
     GrShape(const SkRRect& rrect, const SkPaint& paint)
         : fType(Type::kRRect)
         , fRRect(rrect)
         , fRRectIsInverted(false)
         , fStyle(paint) {
         fRRectStart = DefaultRRectDirAndStartIndex(rrect, fStyle.hasPathEffect(), &fRRectDir);
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     GrShape(const SkRect& rect, const SkPaint& paint)
         : fType(Type::kRRect)
         , fRRect(SkRRect::MakeRect(rect))
         , fRRectIsInverted(false)
         , fStyle(paint) {
         fRRectStart = DefaultRectDirAndStartIndex(rect, fStyle.hasPathEffect(), &fRRectDir);
-        this->attemptToReduceFromRRect();
+        this->attemptToSimplifyRRect();
     }
 
     GrShape(const GrShape&);
     GrShape& operator=(const GrShape& that);
 
     ~GrShape() {
         if (Type::kPath == fType) {
             fPath.reset();
         }
     }
@@ skipping 132 matching lines @@
 
     /** Constructor used by the applyStyle() function */
     GrShape(const GrShape& parentShape, GrStyle::Apply, SkScalar scale);
 
     /**
      * Determines the key we should inherit from the input shape's geometry and style when
      * we are applying the style to create a new shape.
      */
     void setInheritedKey(const GrShape& parentShape, GrStyle::Apply, SkScalar scale);
 
-    void attemptToReduceFromPath() {
-        SkASSERT(Type::kPath == fType);
-        fType = AttemptToReduceFromPathImpl(*fPath.get(), &fRRect, &fRRectDir, &fRRectStart,
-                                            &fRRectIsInverted, fStyle.pathEffect(),
-                                            fStyle.strokeRec());
-        if (Type::kPath != fType) {
-            fPath.reset();
-            fInheritedKey.reset(0);
-        }
-    }
+    void attemptToSimplifyPath();
 
-    void attemptToReduceFromRRect() {
-        SkASSERT(Type::kRRect == fType);
-        SkASSERT(!fInheritedKey.count());
-        if (fRRectIsInverted) {
-            if (fStyle.isDashed()) {
-                // Dashing ignores the inverseness (currently). skbug.com/5421
-                fRRectIsInverted = false;
-            }
-        } else if (fRRect.isEmpty()) {
-            fType = Type::kEmpty;
-        }
-    }
-
-    static Type AttemptToReduceFromPathImpl(const SkPath& path, SkRRect* rrect,
-                                            SkPath::Direction* rrectDir, unsigned* rrectStart,
-                                            bool* rrectIsInverted, const SkPathEffect* pe,
-                                            const SkStrokeRec& strokeRec);
+    void attemptToSimplifyRRect();
 
     static constexpr SkPath::Direction kDefaultRRectDir = SkPath::kCW_Direction;
     static constexpr unsigned kDefaultRRectStart = 0;
 
     static unsigned DefaultRectDirAndStartIndex(const SkRect& rect, bool hasPathEffect,
                                                 SkPath::Direction* dir) {
         *dir = kDefaultRRectDir;
         // This comes from SkPath's interface. The default for adding a SkRect is counter clockwise
         // beginning at index 0 (which happens to correspond to rrect index 0 or 7).
         if (!hasPathEffect) {
@@ skipping 36 matching lines @@
     Type                        fType;
     SkRRect                     fRRect;
     SkPath::Direction           fRRectDir;
     unsigned                    fRRectStart;
     bool                        fRRectIsInverted;
     SkTLazy<SkPath>             fPath;
     GrStyle                     fStyle;
     SkAutoSTArray<8, uint32_t>  fInheritedKey;
 };
 #endif