Expand GrStyle's interface.

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 88 matching lines @@
     GrShape& operator=(const GrShape& that);
 
     ~GrShape() {
         if (Type::kPath == fType) {
             fPath.reset();
         }
     }
 
     const GrStyle& style() const { return fStyle; }
 
-    /**
-     * Returns a GrShape where the shape's geometry fully reflects the original shape's GrStyle.
-     * The GrStyle of the returned shape will either be fill or hairline.
-     */
-    GrShape applyFullStyle() { return GrShape(*this, false); }
-
-    /**
-     * Similar to above but applies only the path effect. Path effects take the original geometry
-     * and fill/stroking information and compute a new geometry and residual fill/stroking
-     * information to be applied. The path effect's output geometry and stroking will be captured
-     * in the returned GrShape.
-     */
-    GrShape applyPathEffect() { return GrShape(*this, true); }
+    GrShape applyStyle(GrStyle::Apply apply) { return GrShape(*this, apply); }
 
     bool asRRect(SkRRect* rrect) const {
         if (Type::kRRect != fType) {
             return false;
         }
         if (rrect) {
             *rrect = fRRect;
         }
         return true;
     }
@@ skipping 26 matching lines @@
      */
     void writeUnstyledKey(uint32_t* key) const;
 
 private:
     enum class Type {
         kEmpty,
         kRRect,
         kPath,
     };
 
-    /**
-     * Computes the key length for a GrStyle. The return will be negative if it cannot be turned
-     * into a key.
-     */
-    static int StyleKeySize(const GrStyle& , bool stopAfterPE);
-
-    /**
-     * Writes a unique key for the style into the provided buffer. This function assumes the buffer
-     * has room for at least StyleKeySize() values. It assumes that StyleKeySize() returns a
-     * positive value for the style and stopAfterPE param. This is written so that the key for just
-     * dash application followed by the key for the remaining SkStrokeRec is the same as the
-     * key for applying dashing and SkStrokeRec all at once.
-     */
-    static void StyleKey(uint32_t*, const GrStyle&, bool stopAfterPE);
 
     /** Constructor used by Apply* functions */
-    GrShape(const GrShape& parentShape, bool stopAfterPE);
+    GrShape(const GrShape& parentShape, GrStyle::Apply);
 
     /**
      * 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, bool stopAfterPE);
+    void setInheritedKey(const GrShape& parentShape, GrStyle::Apply);
 
     void attemptToReduceFromPath() {
         SkASSERT(Type::kPath == fType);
         fType = AttemptToReduceFromPathImpl(*fPath.get(), &fRRect, fStyle.pathEffect(),
                                             fStyle.strokeRec());
         if (Type::kPath != fType) {
             fPath.reset();
             fInheritedKey.reset(0);
         }
     }
@@ skipping 30 matching lines @@
         return Type::kPath;
     }
 
     Type                        fType;
     SkRRect                     fRRect;
     SkTLazy<SkPath>             fPath;
     GrStyle                     fStyle;
     SkAutoSTArray<8, uint32_t>  fInheritedKey;
 };
 #endif