@shopify/react-native-skia 0.1.158 → 0.1.160

package/cpp/skia/include/effects/SkCornerPathEffect.h

@@ -8,7 +8,11 @@
 #ifndef SkCornerPathEffect_DEFINED
 #define SkCornerPathEffect_DEFINED
 
-#include "include/core/SkPathEffect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPathEffect;
 
 /** \class SkCornerPathEffect
 

package/cpp/skia/include/effects/SkDashPathEffect.h

@@ -8,7 +8,11 @@
 #ifndef SkDashPathEffect_DEFINED
 #define SkDashPathEffect_DEFINED
 
-#include "include/core/SkPathEffect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPathEffect;
 
 class SK_API SkDashPathEffect {
 public:

package/cpp/skia/include/effects/SkGradientShader.h

@@ -8,12 +8,11 @@
 #ifndef SkGradientShader_DEFINED
 #define SkGradientShader_DEFINED
 
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkShader.h"
 #include "include/core/SkTileMode.h"
 
-class SkColorSpace;
-
 /** \class SkGradientShader
 
     SkGradientShader hosts factories for creating subclasses of SkShader that
@@ -60,6 +59,16 @@ public:
         kInterpolateColorsInPremul_Flag = 1 << 0,
     };
 
+    struct Interpolation {
+        enum class InPremul : bool { kNo = false, kYes = true };
+
+        InPremul fInPremul = InPremul::kNo;
+
+        static Interpolation FromFlags(uint32_t flags) {
+            return {flags & kInterpolateColorsInPremul_Flag ? InPremul::kYes : InPremul::kNo};
+        }
+    };
+
     /** Returns a shader that generates a linear gradient between the two specified points.
         <p />
         @param  pts     The start and end points for the gradient.
@@ -77,12 +86,7 @@ public:
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor colors[], const SkScalar pos[], int count,
                                       SkTileMode mode,
-                                      uint32_t flags, const SkMatrix* localMatrix);
-    static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
-                                      const SkColor colors[], const SkScalar pos[], int count,
-                                      SkTileMode mode) {
-        return MakeLinear(pts, colors, pos, count, mode, 0, nullptr);
-    }
+                                      uint32_t flags = 0, const SkMatrix* localMatrix = nullptr);
 
     /** Returns a shader that generates a linear gradient between the two specified points.
         <p />
@@ -101,10 +105,15 @@ public:
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                       const SkScalar pos[], int count, SkTileMode mode,
-                                      uint32_t flags, const SkMatrix* localMatrix);
+                                      const Interpolation& interpolation,
+                                      const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeLinear(const SkPoint pts[2],
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
-                                      const SkScalar pos[], int count, SkTileMode mode);
+                                      const SkScalar pos[], int count, SkTileMode mode,
+                                      uint32_t flags = 0, const SkMatrix* localMatrix = nullptr) {
+        return MakeLinear(pts, colors, std::move(colorSpace), pos, count, mode,
+                          Interpolation::FromFlags(flags), localMatrix);
+    }
 
     /** Returns a shader that generates a radial gradient given the center and radius.
         <p />
@@ -122,12 +131,7 @@ public:
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor colors[], const SkScalar pos[], int count,
                                       SkTileMode mode,
-                                      uint32_t flags, const SkMatrix* localMatrix);
-    static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
-                                      const SkColor colors[], const SkScalar pos[], int count,
-                                      SkTileMode mode) {
-        return MakeRadial(center, radius, colors, pos, count, mode, 0, nullptr);
-    }
+                                      uint32_t flags = 0, const SkMatrix* localMatrix = nullptr);
 
     /** Returns a shader that generates a radial gradient given the center and radius.
         <p />
@@ -145,10 +149,15 @@ public:
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                       const SkScalar pos[], int count, SkTileMode mode,
-                                      uint32_t flags, const SkMatrix* localMatrix);
+                                      const Interpolation& interpolation,
+                                      const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeRadial(const SkPoint& center, SkScalar radius,
                                       const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
-                                      const SkScalar pos[], int count, SkTileMode mode);
+                                      const SkScalar pos[], int count, SkTileMode mode,
+                                      uint32_t flags = 0, const SkMatrix* localMatrix = nullptr) {
+        return MakeRadial(center, radius, colors, std::move(colorSpace), pos, count, mode,
+                          Interpolation::FromFlags(flags), localMatrix);
+    }
 
     /**
      *  Returns a shader that generates a conical gradient given two circles, or
@@ -160,14 +169,8 @@ public:
                                                const SkPoint& end, SkScalar endRadius,
                                                const SkColor colors[], const SkScalar pos[],
                                                int count, SkTileMode mode,
-                                               uint32_t flags, const SkMatrix* localMatrix);
-    static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
-                                               const SkPoint& end, SkScalar endRadius,
-                                               const SkColor colors[], const SkScalar pos[],
-                                               int count, SkTileMode mode) {
-        return MakeTwoPointConical(start, startRadius, end, endRadius, colors, pos, count, mode,
-                                   0, nullptr);
-    }
+                                               uint32_t flags = 0,
+                                               const SkMatrix* localMatrix = nullptr);
 
     /**
      *  Returns a shader that generates a conical gradient given two circles, or
@@ -180,14 +183,29 @@ public:
                                                const SkColor4f colors[],
                                                sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
                                                int count, SkTileMode mode,
-                                               uint32_t flags, const SkMatrix* localMatrix);
+                                               const Interpolation& interpolation,
+                                               const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeTwoPointConical(const SkPoint& start, SkScalar startRadius,
                                                const SkPoint& end, SkScalar endRadius,
                                                const SkColor4f colors[],
                                                sk_sp<SkColorSpace> colorSpace, const SkScalar pos[],
-                                               int count, SkTileMode mode);
+                                               int count, SkTileMode mode,
+                                               uint32_t flags = 0,
+                                               const SkMatrix* localMatrix = nullptr) {
+        return MakeTwoPointConical(start, startRadius, end, endRadius, colors,
+                                   std::move(colorSpace), pos, count, mode,
+                                   Interpolation::FromFlags(flags), localMatrix);
+    }
 
     /** Returns a shader that generates a sweep gradient given a center.
+
+        The shader accepts negative angles and angles larger than 360, draws
+        between 0 and 360 degrees, similar to the CSS conic-gradient
+        semantics. 0 degrees means horizontal positive x axis. The start angle
+        must be less than the end angle, otherwise a null pointer is
+        returned. If color stops do not contain 0 and 1 but are within this
+        range, the respective outer color stop is repeated for 0 and 1. Color
+        stops less than 0 are clamped to 0, and greater than 1 are clamped to 1.
         <p />
         @param  cx         The X coordinate of the center of the sweep
         @param  cx         The Y coordinate of the center of the sweep
@@ -210,16 +228,20 @@ public:
                                      uint32_t flags, const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor colors[], const SkScalar pos[], int count,
-                                     uint32_t flags, const SkMatrix* localMatrix) {
+                                     uint32_t flags = 0, const SkMatrix* localMatrix = nullptr) {
         return MakeSweep(cx, cy, colors, pos, count, SkTileMode::kClamp, 0, 360, flags,
                          localMatrix);
     }
-    static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
-                                     const SkColor colors[], const SkScalar pos[], int count) {
-        return MakeSweep(cx, cy, colors, pos, count, 0, nullptr);
-    }
 
     /** Returns a shader that generates a sweep gradient given a center.
+
+        The shader accepts negative angles and angles larger than 360, draws
+        between 0 and 360 degrees, similar to the CSS conic-gradient
+        semantics. 0 degrees means horizontal positive x axis. The start angle
+        must be less than the end angle, otherwise a null pointer is
+        returned. If color stops do not contain 0 and 1 but are within this
+        range, the respective outer color stop is repeated for 0 and 1. Color
+        stops less than 0 are clamped to 0, and greater than 1 are clamped to 1.
         <p />
         @param  cx         The X coordinate of the center of the sweep
         @param  cx         The Y coordinate of the center of the sweep
@@ -240,16 +262,24 @@ public:
                                      const SkScalar pos[], int count,
                                      SkTileMode mode,
                                      SkScalar startAngle, SkScalar endAngle,
-                                     uint32_t flags, const SkMatrix* localMatrix);
+                                     const Interpolation& interpolation,
+                                     const SkMatrix* localMatrix);
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
                                      const SkScalar pos[], int count,
-                                     uint32_t flags, const SkMatrix* localMatrix);
+                                     SkTileMode mode,
+                                     SkScalar startAngle, SkScalar endAngle,
+                                     uint32_t flags, const SkMatrix* localMatrix) {
+        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, mode, startAngle,
+                         endAngle, Interpolation::FromFlags(flags), localMatrix);
+    }
     static sk_sp<SkShader> MakeSweep(SkScalar cx, SkScalar cy,
                                      const SkColor4f colors[], sk_sp<SkColorSpace> colorSpace,
-                                     const SkScalar pos[], int count);
-
-    static void RegisterFlattenables();
+                                     const SkScalar pos[], int count,
+                                     uint32_t flags = 0, const SkMatrix* localMatrix = nullptr) {
+        return MakeSweep(cx, cy, colors, std::move(colorSpace), pos, count, SkTileMode::kClamp,
+                         0, 360, flags, localMatrix);
+    }
 };
 
 #endif

package/cpp/skia/include/effects/SkHighContrastFilter.h

@@ -8,7 +8,11 @@
 #ifndef SkHighContrastFilter_DEFINED
 #define SkHighContrastFilter_DEFINED
 
-#include "include/core/SkColorFilter.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkColorFilter;
 
 /**
  *  Configuration struct for SkHighContrastFilter.

package/cpp/skia/include/effects/SkImageFilters.h

@@ -154,7 +154,8 @@ public:
      *  @param yChannelSelector RGBA channel that encodes the y displacement per pixel.
      *  @param scale            Scale applied to displacement extracted from image.
      *  @param displacement     The filter defining the displacement image, or null to use source.
-     *  @param color            The filter providing the color pixels to be displaced.
+     *  @param color            The filter providing the color pixels to be displaced. If null,
+     *                          it will use the source.
      *  @param cropRect         Optional rectangle that crops the color input and output.
      */
     static sk_sp<SkImageFilter> DisplacementMap(SkColorChannel xChannelSelector,
@@ -344,13 +345,13 @@ public:
      *                         fill the result image
      *  @param childShaderName The name of the child shader defined in the builder that will be
      *                         bound to the input param (or the source image if the input param
-     *                         is null).  If null the builder can have exactly one child shader,
+     *                         is null).  If empty, the builder can have exactly one child shader,
      *                         which automatically binds the input param.
      *  @param input           The image filter that will be provided as input to the runtime
      *                         shader. If null the implicit source image is used instead
      */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
-                                              const char* childShaderName,
+                                              std::string_view childShaderName,
                                               sk_sp<SkImageFilter> input);
 
     /**
@@ -369,7 +370,7 @@ public:
      *  @param inputCount       How many entries are present in 'childShaderNames' and 'inputs'.
      */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeShaderBuilder& builder,
-                                              const char* childShaderNames[],
+                                              std::string_view childShaderNames[],
                                               const sk_sp<SkImageFilter> inputs[],
                                               int inputCount);
 #endif  // SK_ENABLE_SKSL

package/cpp/skia/include/effects/SkLumaColorFilter.h

@@ -8,7 +8,10 @@
 #ifndef SkLumaColorFilter_DEFINED
 #define SkLumaColorFilter_DEFINED
 
-#include "include/core/SkColorFilter.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+class SkColorFilter;
 
 /**
  *  SkLumaColorFilter multiplies the luma of its input into the alpha channel,

package/cpp/skia/include/effects/SkOpPathEffect.h

@@ -8,11 +8,15 @@
 #ifndef SkOpPathEffect_DEFINED
 #define SkOpPathEffect_DEFINED
 
-#include "include/core/SkMatrix.h"
 #include "include/core/SkPaint.h"
-#include "include/core/SkPathEffect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/pathops/SkPathOps.h"
 
+class SkMatrix;
+class SkPathEffect;
+
 class SK_API SkMergePathEffect {
 public:
     /*  Defers to two other patheffects, and then combines their outputs using the specified op.

package/cpp/skia/include/effects/SkOverdrawColorFilter.h

@@ -5,8 +5,11 @@
  * found in the LICENSE file.
  */
 
-#include "include/core/SkColorFilter.h"
-#include "include/core/SkFlattenable.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+class SkColorFilter;
 
 #ifndef SkOverdrawColorFilter_DEFINED
 #define SkOverdrawColorFilter_DEFINED

package/cpp/skia/include/effects/SkRuntimeEffect.h

@@ -25,6 +25,8 @@
 
 #ifdef SK_ENABLE_SKSL
 
+#include "include/sksl/SkSLVersion.h"
+
 class GrRecordingContext;
 class SkFilterColorProgram;
 class SkImage;
@@ -68,20 +70,32 @@ public:
         };
 
         enum Flags {
-            // Uniform is an declared as an array. 'count' contains array length.
+            // Uniform is declared as an array. 'count' contains array length.
             kArray_Flag = 0x1,
 
             // Uniform is declared with layout(color). Colors should be supplied as unpremultiplied,
             // extended-range (unclamped) sRGB (ie SkColor4f). The uniform will be automatically
             // transformed to unpremultiplied extended-range working-space colors.
             kColor_Flag = 0x2,
+
+            // When used with SkMeshSpecification, indicates that the uniform is present in the
+            // vertex shader. Not used with SkRuntimeEffect.
+            kVertex_Flag = 0x4,
+
+            // When used with SkMeshSpecification, indicates that the uniform is present in the
+            // fragment shader. Not used with SkRuntimeEffect.
+            kFragment_Flag = 0x8,
+
+            // This flag indicates that the SkSL uniform uses a medium-precision type
+            // (i.e., `half` instead of `float`).
+            kHalfPrecision_Flag = 0x10,
         };
 
-        SkString  name;
-        size_t    offset;
-        Type      type;
-        int       count;
-        uint32_t  flags;
+        std::string_view name;
+        size_t           offset;
+        Type             type;
+        int              count;
+        uint32_t         flags;
 
         bool isArray() const { return SkToBool(this->flags & kArray_Flag); }
         bool isColor() const { return SkToBool(this->flags & kColor_Flag); }
@@ -96,9 +110,9 @@ public:
     };
 
     struct Child {
-        SkString  name;
-        ChildType type;
-        int       index;
+        std::string_view name;
+        ChildType        type;
+        int              index;
     };
 
     class Options {
@@ -112,16 +126,16 @@ public:
         friend class SkRuntimeEffect;
         friend class SkRuntimeEffectPriv;
 
+        // Public SkSL does not allow access to sk_FragCoord. The semantics of that variable are
+        // confusing, and expose clients to implementation details of saveLayer and image filters.
+        bool usePrivateRTShaderModule = false;
+
+        // TODO(skia:11209) - Replace this with a promised SkCapabilities?
         // This flag lifts the ES2 restrictions on Runtime Effects that are gated by the
         // `strictES2Mode` check. Be aware that the software renderer and pipeline-stage effect are
         // still largely ES3-unaware and can still fail or crash if post-ES2 features are used.
         // This is only intended for use by tests and certain internally created effects.
-        bool enforceES2Restrictions = true;
-
-        // Similarly: Public SkSL does not allow access to sk_FragCoord. The semantics of that
-        // variable are confusing, and expose clients to implementation details of saveLayer and
-        // image filters.
-        bool usePrivateRTShaderModule = false;
+        SkSL::Version maxVersionAllowed = SkSL::Version::k100;
     };
 
     // If the effect is compiled successfully, `effect` will be non-null.
@@ -148,10 +162,6 @@ public:
 
     // Shader SkSL requires an entry point that looks like:
     //     vec4 main(vec2 inCoords) { ... }
-    //   -or-
-    //     vec4 main(vec2 inCoords, vec4 inColor) { ... }
-    //
-    // Most shaders don't use the input color, so that parameter is optional.
     static Result MakeForShader(SkString sksl, const Options&);
     static Result MakeForShader(SkString sksl) {
         return MakeForShader(std::move(sksl), Options{});
@@ -164,19 +174,6 @@ public:
         return MakeForBlender(std::move(sksl), Options{});
     }
 
-    // DSL entry points
-    static Result MakeForColorFilter(std::unique_ptr<SkSL::Program> program, const Options&);
-    static Result MakeForColorFilter(std::unique_ptr<SkSL::Program> program);
-
-    static Result MakeForShader(std::unique_ptr<SkSL::Program> program, const Options&);
-    static Result MakeForShader(std::unique_ptr<SkSL::Program> program);
-    static sk_sp<SkRuntimeEffect> MakeForShader(std::unique_ptr<SkSL::Program> program,
-                                                const Options&, SkSL::ErrorReporter* errors);
-
-
-    static Result MakeForBlender(std::unique_ptr<SkSL::Program> program, const Options&);
-    static Result MakeForBlender(std::unique_ptr<SkSL::Program> program);
-
     // Object that allows passing a SkShader, SkColorFilter or SkBlender as a child
     class ChildPtr {
     public:
@@ -195,33 +192,38 @@ public:
         SkBlender* blender() const;
         SkFlattenable* flattenable() const { return fChild.get(); }
 
+        using sk_is_trivially_relocatable = std::true_type;
+
     private:
         sk_sp<SkFlattenable> fChild;
+
+        static_assert(::sk_is_trivially_relocatable<decltype(fChild)>::value);
     };
 
-    sk_sp<SkShader> makeShader(sk_sp<SkData> uniforms,
+    sk_sp<SkShader> makeShader(sk_sp<const SkData> uniforms,
                                sk_sp<SkShader> children[],
                                size_t childCount,
                                const SkMatrix* localMatrix = nullptr) const;
-    sk_sp<SkShader> makeShader(sk_sp<SkData> uniforms,
+    sk_sp<SkShader> makeShader(sk_sp<const SkData> uniforms,
                                SkSpan<ChildPtr> children,
                                const SkMatrix* localMatrix = nullptr) const;
 
     sk_sp<SkImage> makeImage(GrRecordingContext*,
-                             sk_sp<SkData> uniforms,
+                             sk_sp<const SkData> uniforms,
                              SkSpan<ChildPtr> children,
                              const SkMatrix* localMatrix,
                              SkImageInfo resultInfo,
                              bool mipmapped) const;
 
-    sk_sp<SkColorFilter> makeColorFilter(sk_sp<SkData> uniforms) const;
-    sk_sp<SkColorFilter> makeColorFilter(sk_sp<SkData> uniforms,
+    sk_sp<SkColorFilter> makeColorFilter(sk_sp<const SkData> uniforms) const;
+    sk_sp<SkColorFilter> makeColorFilter(sk_sp<const SkData> uniforms,
                                          sk_sp<SkColorFilter> children[],
                                          size_t childCount) const;
-    sk_sp<SkColorFilter> makeColorFilter(sk_sp<SkData> uniforms,
+    sk_sp<SkColorFilter> makeColorFilter(sk_sp<const SkData> uniforms,
                                          SkSpan<ChildPtr> children) const;
 
-    sk_sp<SkBlender> makeBlender(sk_sp<SkData> uniforms, SkSpan<ChildPtr> children = {}) const;
+    sk_sp<SkBlender> makeBlender(sk_sp<const SkData> uniforms,
+                                 SkSpan<ChildPtr> children = {}) const;
 
     /**
      * Creates a new Runtime Effect patterned after an already-existing one. The new shader behaves
@@ -248,14 +250,19 @@ public:
     // provide an SkData of this size, containing values for all of those variables.
     size_t uniformSize() const;
 
-    SkSpan<const Uniform> uniforms() const { return SkMakeSpan(fUniforms); }
-    SkSpan<const Child> children() const { return SkMakeSpan(fChildren); }
+    SkSpan<const Uniform> uniforms() const { return SkSpan(fUniforms); }
+    SkSpan<const Child> children() const { return SkSpan(fChildren); }
 
     // Returns pointer to the named uniform variable's description, or nullptr if not found
-    const Uniform* findUniform(const char* name) const;
+    const Uniform* findUniform(std::string_view name) const;
 
     // Returns pointer to the named child's description, or nullptr if not found
-    const Child* findChild(const char* name) const;
+    const Child* findChild(std::string_view name) const;
+
+    // Allows the runtime effect type to be identified.
+    bool allowShader()        const { return (fFlags & kAllowShader_Flag);        }
+    bool allowColorFilter()   const { return (fFlags & kAllowColorFilter_Flag);   }
+    bool allowBlender()       const { return (fFlags & kAllowBlender_Flag);       }
 
     static void RegisterFlattenables();
     ~SkRuntimeEffect() override;
@@ -283,15 +290,6 @@ private:
 
     static Result MakeFromSource(SkString sksl, const Options& options, SkSL::ProgramKind kind);
 
-    static Result MakeFromDSL(std::unique_ptr<SkSL::Program> program,
-                              const Options& options,
-                              SkSL::ProgramKind kind);
-
-    static sk_sp<SkRuntimeEffect> MakeFromDSL(std::unique_ptr<SkSL::Program> program,
-                                              const Options& options,
-                                              SkSL::ProgramKind kind,
-                                              SkSL::ErrorReporter* errors);
-
     static Result MakeInternal(std::unique_ptr<SkSL::Program> program,
                                const Options& options,
                                SkSL::ProgramKind kind);
@@ -300,14 +298,11 @@ private:
 
     uint32_t hash() const { return fHash; }
     bool usesSampleCoords()   const { return (fFlags & kUsesSampleCoords_Flag);   }
-    bool allowShader()        const { return (fFlags & kAllowShader_Flag);        }
-    bool allowColorFilter()   const { return (fFlags & kAllowColorFilter_Flag);   }
-    bool allowBlender()       const { return (fFlags & kAllowBlender_Flag);       }
     bool samplesOutsideMain() const { return (fFlags & kSamplesOutsideMain_Flag); }
     bool usesColorTransform() const { return (fFlags & kUsesColorTransform_Flag); }
     bool alwaysOpaque()       const { return (fFlags & kAlwaysOpaque_Flag);       }
 
-    const SkFilterColorProgram* getFilterColorProgram();
+    const SkFilterColorProgram* getFilterColorProgram() const;
 
 #if SK_SUPPORT_GPU
     friend class GrSkSLFP;             // fBaseProgram, fSampleUsages
@@ -417,11 +412,8 @@ public:
 
     const SkRuntimeEffect* effect() const { return fEffect.get(); }
 
-    BuilderUniform uniform(const char* name) { return { this, fEffect->findUniform(name) }; }
-    BuilderChild child(const char* name) {
-        const SkRuntimeEffect::Child* child = fEffect->findChild(name);
-        return { this, child };
-    }
+    BuilderUniform uniform(std::string_view name) { return { this, fEffect->findUniform(name) }; }
+    BuilderChild child(std::string_view name) { return { this, fEffect->findChild(name) }; }
 
 protected:
     SkRuntimeEffectBuilder() = delete;
@@ -440,7 +432,7 @@ protected:
     SkRuntimeEffectBuilder& operator=(SkRuntimeEffectBuilder&&) = delete;
     SkRuntimeEffectBuilder& operator=(const SkRuntimeEffectBuilder&) = delete;
 
-    sk_sp<SkData> uniforms() { return fUniforms; }
+    sk_sp<const SkData> uniforms() { return fUniforms; }
     SkRuntimeEffect::ChildPtr* children() { return fChildren.data(); }
     size_t numChildren() { return fChildren.size(); }
 

package/cpp/skia/include/effects/SkShaderMaskFilter.h

@@ -8,8 +8,10 @@
 #ifndef SkShaderMaskFilter_DEFINED
 #define SkShaderMaskFilter_DEFINED
 
-#include "include/core/SkMaskFilter.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
 
+class SkMaskFilter;
 class SkShader;
 
 class SK_API SkShaderMaskFilter {

package/cpp/skia/include/effects/SkTableColorFilter.h

@@ -10,33 +10,20 @@
 
 #include "include/core/SkColorFilter.h"
 
+// (DEPRECATED) These factory functions are deprecated. Please use the ones in
+// SkColorFilters (i.e., Table and TableARGB).
 class SK_API SkTableColorFilter {
 public:
-    /**
-     *  Create a table colorfilter, copying the table into the filter, and
-     *  applying it to all 4 components.
-     *      a' = table[a];
-     *      r' = table[r];
-     *      g' = table[g];
-     *      b' = table[b];
-     *  Compoents are operated on in unpremultiplied space. If the incomming
-     *  colors are premultiplied, they are temporarily unpremultiplied, then
-     *  the table is applied, and then the result is remultiplied.
-     */
-    static sk_sp<SkColorFilter> Make(const uint8_t table[256]);
+    static sk_sp<SkColorFilter> Make(const uint8_t table[256]) {
+        return SkColorFilters::Table(table);
+    }
 
-    /**
-     *  Create a table colorfilter, with a different table for each
-     *  component [A, R, G, B]. If a given table is NULL, then it is
-     *  treated as identity, with the component left unchanged. If a table
-     *  is not null, then its contents are copied into the filter.
-     */
     static sk_sp<SkColorFilter> MakeARGB(const uint8_t tableA[256],
                                          const uint8_t tableR[256],
                                          const uint8_t tableG[256],
-                                         const uint8_t tableB[256]);
-
-    static void RegisterFlattenables();
+                                         const uint8_t tableB[256]) {
+        return SkColorFilters::TableARGB(tableA, tableR, tableG, tableB);
+    }
 };
 
 #endif

package/cpp/skia/include/effects/SkTableMaskFilter.h

@@ -8,8 +8,12 @@
 #ifndef SkTableMaskFilter_DEFINED
 #define SkTableMaskFilter_DEFINED
 
-#include "include/core/SkMaskFilter.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+#include <cstdint>
+
+class SkMaskFilter;
 
 /** \class SkTableMaskFilter
 

package/cpp/skia/include/effects/SkTrimPathEffect.h

@@ -8,7 +8,11 @@
 #ifndef SkTrimPathEffect_DEFINED
 #define SkTrimPathEffect_DEFINED
 
-#include "include/core/SkPathEffect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
+
+class SkPathEffect;
 
 class SK_API SkTrimPathEffect {
 public: