diff --git a/gm/runtimeshader.cpp b/gm/runtimeshader.cpp
index 7c0792e..e96f2de 100644
--- a/gm/runtimeshader.cpp
+++ b/gm/runtimeshader.cpp
@@ -20,8 +20,9 @@
 #include "tools/Resources.h"
 
 enum RT_Flags {
-    kAnimate_RTFlag = 0x1,
-    kBench_RTFlag   = 0x2,
+    kAnimate_RTFlag     = 0x1,
+    kBench_RTFlag       = 0x2,
+    kColorFilter_RTFlag = 0x4,
 };
 
 class RuntimeShaderGM : public skiagm::GM {
@@ -30,7 +31,9 @@
             : fName(name), fSize(size), fFlags(flags), fSkSL(sksl) {}
 
     void onOnceBeforeDraw() override {
-        auto [effect, error] = SkRuntimeEffect::MakeForShader(fSkSL);
+        auto [effect, error] = (fFlags & kColorFilter_RTFlag)
+                                       ? SkRuntimeEffect::MakeForColorFilter(fSkSL)
+                                       : SkRuntimeEffect::MakeForShader(fSkSL);
         if (!effect) {
             SkDebugf("RuntimeShader error: %s\n", error.c_str());
         }
@@ -340,6 +343,87 @@
 };
 DEF_GM(return new ColorCubeRT;)
 
+// Same as above, but demonstrating how to implement this as a runtime color filter (that samples
+// a shader child for the LUT).
+class ColorCubeColorFilterRT : public RuntimeShaderGM {
+public:
+    ColorCubeColorFilterRT() : RuntimeShaderGM("color_cube_cf_rt", {512, 512}, R"(
+        uniform shader color_cube;
+
+        uniform float rg_scale;
+        uniform float rg_bias;
+        uniform float b_scale;
+        uniform float inv_size;
+
+        half4 main(half4 inColor) {
+            float4 c = unpremul(inColor);
+
+            // Map to cube coords:
+            float3 cubeCoords = float3(c.rg * rg_scale + rg_bias, c.b * b_scale);
+
+            // Compute slice coordinate
+            float2 coords1 = float2((floor(cubeCoords.b) + cubeCoords.r) * inv_size, cubeCoords.g);
+            float2 coords2 = float2(( ceil(cubeCoords.b) + cubeCoords.r) * inv_size, cubeCoords.g);
+
+            // Two bilinear fetches, plus a manual lerp for the third axis:
+            half4 color = mix(sample(color_cube, coords1), sample(color_cube, coords2),
+                              fract(cubeCoords.b));
+
+            // Premul again
+            color.rgb *= color.a;
+
+            return color;
+        }
+    )", kColorFilter_RTFlag) {}
+
+    sk_sp<SkImage> fMandrill, fMandrillSepia, fIdentityCube, fSepiaCube;
+
+    void onOnceBeforeDraw() override {
+        fMandrill      = GetResourceAsImage("images/mandrill_256.png");
+        fMandrillSepia = GetResourceAsImage("images/mandrill_sepia.png");
+        fIdentityCube  = GetResourceAsImage("images/lut_identity.png");
+        fSepiaCube     = GetResourceAsImage("images/lut_sepia.png");
+
+        this->RuntimeShaderGM::onOnceBeforeDraw();
+    }
+
+    void onDraw(SkCanvas* canvas) override {
+        // First we draw the unmodified image, and a copy that was sepia-toned in Photoshop:
+        canvas->drawImage(fMandrill,      0,   0);
+        canvas->drawImage(fMandrillSepia, 0, 256);
+
+        // LUT dimensions should be (kSize^2, kSize)
+        constexpr float kSize = 16.0f;
+
+        const SkSamplingOptions sampling(SkFilterMode::kLinear);
+
+        float uniforms[] = {
+                (kSize - 1) / kSize,  // rg_scale
+                0.5f / kSize,         // rg_bias
+                kSize - 1,            // b_scale
+                1.0f / kSize,         // inv_size
+        };
+
+        SkPaint paint;
+
+        // TODO: Should we add SkImage::makeNormalizedShader() to handle this automatically?
+        SkMatrix normalize = SkMatrix::Scale(1.0f / (kSize * kSize), 1.0f / kSize);
+
+        // Now draw the image with an identity color cube - it should look like the original
+        SkRuntimeEffect::ChildPtr children[] = {fIdentityCube->makeShader(sampling, normalize)};
+        paint.setColorFilter(fEffect->makeColorFilter(
+                SkData::MakeWithCopy(uniforms, sizeof(uniforms)), SkMakeSpan(children)));
+        canvas->drawImage(fMandrill, 256, 0, sampling, &paint);
+
+        // ... and with a sepia-tone color cube. This should match the sepia-toned image.
+        children[0] = fSepiaCube->makeShader(sampling, normalize);
+        paint.setColorFilter(fEffect->makeColorFilter(
+                SkData::MakeWithCopy(uniforms, sizeof(uniforms)), SkMakeSpan(children)));
+        canvas->drawImage(fMandrill, 256, 256, sampling, &paint);
+    }
+};
+DEF_GM(return new ColorCubeColorFilterRT;)
+
 class DefaultColorRT : public RuntimeShaderGM {
 public:
     DefaultColorRT() : RuntimeShaderGM("default_color_rt", {512, 256}, R"(
diff --git a/include/effects/SkRuntimeEffect.h b/include/effects/SkRuntimeEffect.h
index f3c4f06..ac9fe97 100644
--- a/include/effects/SkRuntimeEffect.h
+++ b/include/effects/SkRuntimeEffect.h
@@ -8,10 +8,12 @@
 #ifndef SkRuntimeEffect_DEFINED
 #define SkRuntimeEffect_DEFINED
 
+#include "include/core/SkColorFilter.h"
 #include "include/core/SkData.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkMatrix.h"
 #include "include/core/SkShader.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/private/SkOnce.h"
 #include "include/private/SkSLSampleUsage.h"
@@ -19,10 +21,8 @@
 #include <vector>
 
 class GrRecordingContext;
-class SkColorFilter;
 class SkFilterColorProgram;
 class SkImage;
-class SkShader;
 
 namespace SkSL {
 class FunctionDefinition;
@@ -42,6 +42,7 @@
  */
 class SK_API SkRuntimeEffect : public SkRefCnt {
 public:
+    // Reflected description of a uniform variable in the effect's SkSL
     struct Uniform {
         enum class Type {
             kFloat,
@@ -72,6 +73,7 @@
         size_t sizeInBytes() const;
     };
 
+    // Reflected description of a uniform child (shader or colorFilter) in the effect's SkSL
     struct Child {
         enum class Type {
             kShader,
@@ -131,11 +133,23 @@
 
     static Result MakeForShader(std::unique_ptr<SkSL::Program> program);
 
+    // Object that allows passing either an SkShader or SkColorFilter as a child
+    struct ChildPtr {
+        ChildPtr(sk_sp<SkShader> s) : shader(std::move(s)) {}
+        ChildPtr(sk_sp<SkColorFilter> cf) : colorFilter(std::move(cf)) {}
+        sk_sp<SkShader> shader;
+        sk_sp<SkColorFilter> colorFilter;
+    };
+
     sk_sp<SkShader> makeShader(sk_sp<SkData> uniforms,
                                sk_sp<SkShader> children[],
                                size_t childCount,
                                const SkMatrix* localMatrix,
                                bool isOpaque) const;
+    sk_sp<SkShader> makeShader(sk_sp<SkData> uniforms,
+                               SkSpan<ChildPtr> children,
+                               const SkMatrix* localMatrix,
+                               bool isOpaque) const;
 
     sk_sp<SkImage> makeImage(GrRecordingContext*,
                              sk_sp<SkData> uniforms,
@@ -149,6 +163,8 @@
     sk_sp<SkColorFilter> makeColorFilter(sk_sp<SkData> uniforms,
                                          sk_sp<SkColorFilter> children[],
                                          size_t childCount) const;
+    sk_sp<SkColorFilter> makeColorFilter(sk_sp<SkData> uniforms,
+                                         SkSpan<ChildPtr> children) const;
 
     const SkString& source() const { return fSkSL; }
 
diff --git a/src/core/SkRuntimeEffect.cpp b/src/core/SkRuntimeEffect.cpp
index 7646883..db02bfe 100644
--- a/src/core/SkRuntimeEffect.cpp
+++ b/src/core/SkRuntimeEffect.cpp
@@ -442,7 +442,18 @@
     // color, an immediate color, or the results of a previous sample call). If the color is none
     // of those, we are unable to use this per-effect program, and callers will need to fall back
     // to another (slower) implementation.
-    //
+
+    // We also require that any children are *also* color filters (not shaders). In theory we could
+    // detect the coords being passed to shader children, and replicate those calls, but that's
+    // very complicated, and has diminishing returns. (eg, for table lookup color filters).
+    if (!std::all_of(effect->fChildren.begin(),
+                     effect->fChildren.end(),
+                     [](const SkRuntimeEffect::Child& c) {
+                         return c.type == SkRuntimeEffect::Child::Type::kColorFilter;
+                     })) {
+        return nullptr;
+    }
+
     // When we run this program later, these uniform values are replaced with either the results of
     // the child (using the SampleCall), or the input color (if the child is nullptr).
     // These Uniform ids are loads from the *first* arg ptr.
@@ -605,15 +616,46 @@
     return uniforms ? uniforms : baseUniforms;
 }
 
+#if SK_SUPPORT_GPU
+static std::unique_ptr<GrFragmentProcessor> make_effect_fp(
+        sk_sp<SkRuntimeEffect> effect,
+        const char* name,
+        sk_sp<SkData> uniforms,
+        SkSpan<const SkRuntimeEffect::ChildPtr> children,
+        const GrFPArgs& childArgs) {
+    auto fp = GrSkSLFP::Make(std::move(effect), name, std::move(uniforms));
+    for (const auto& child : children) {
+        if (child.shader) {
+            auto childFP = as_SB(child.shader)->asFragmentProcessor(childArgs);
+            if (!childFP) {
+                return nullptr;
+            }
+            fp->addChild(std::move(childFP));
+        } else if (child.colorFilter) {
+            auto [success, childFP] = as_CFB(child.colorFilter)
+                                              ->asFragmentProcessor(/*inputFP=*/nullptr,
+                                                                    childArgs.fContext,
+                                                                    *childArgs.fDstColorInfo);
+            if (!success) {
+                return nullptr;
+            }
+            fp->addChild(std::move(childFP));
+        } else {
+            fp->addChild(nullptr);
+        }
+    }
+    return std::move(fp);
+}
+#endif
+
 class SkRuntimeColorFilter : public SkColorFilterBase {
 public:
     SkRuntimeColorFilter(sk_sp<SkRuntimeEffect> effect,
                          sk_sp<SkData> uniforms,
-                         sk_sp<SkColorFilter> children[],
-                         size_t childCount)
+                         SkSpan<SkRuntimeEffect::ChildPtr> children)
             : fEffect(std::move(effect))
             , fUniforms(std::move(uniforms))
-            , fChildren(children, children + childCount) {}
+            , fChildren(children.begin(), children.end()) {}
 
 #if SK_SUPPORT_GPU
     GrFPResult asFragmentProcessor(std::unique_ptr<GrFragmentProcessor> inputFP,
@@ -623,18 +665,14 @@
                 get_xformed_uniforms(fEffect.get(), fUniforms, colorInfo.colorSpace());
         SkASSERT(uniforms);
 
-        auto fp = GrSkSLFP::Make(fEffect, "Runtime_Color_Filter", std::move(uniforms));
-        for (const auto& child : fChildren) {
-            std::unique_ptr<GrFragmentProcessor> childFP;
-            if (child) {
-                bool success;
-                std::tie(success, childFP) = as_CFB(child)->asFragmentProcessor(
-                        /*inputFP=*/nullptr, context, colorInfo);
-                if (!success) {
-                    return GrFPFailure(std::move(inputFP));
-                }
-            }
-            fp->addChild(std::move(childFP));
+        GrFPArgs childArgs(context, SkSimpleMatrixProvider(SkMatrix::I()), &colorInfo);
+        auto fp = make_effect_fp(fEffect,
+                                 "Runtime_Color_Filter",
+                                 std::move(uniforms),
+                                 SkMakeSpan(fChildren),
+                                 childArgs);
+        if (!fp) {
+            return GrFPFailure(std::move(inputFP));
         }
 
         // Runtime effect scripts are written to take an input color, not a fragment processor.
@@ -659,9 +697,13 @@
         // something. (Uninitialized values can trigger asserts in skvm::Builder).
         skvm::Coord zeroCoord = { p->splat(0.0f), p->splat(0.0f) };
 
-        auto sampleChild = [&](int ix, skvm::Coord /*coord*/, skvm::Color color) {
-            if (fChildren[ix]) {
-                return as_CFB(fChildren[ix])->program(p, color, dst, uniforms, alloc);
+        auto sampleChild = [&](int ix, skvm::Coord coord, skvm::Color color) {
+            if (fChildren[ix].shader) {
+                SkSimpleMatrixProvider mats{SkMatrix::I()};
+                return as_SB(fChildren[ix].shader)
+                        ->program(p, coord, coord, color, mats, nullptr, dst, uniforms, alloc);
+            } else if (fChildren[ix].colorFilter) {
+                return as_CFB(fChildren[ix].colorFilter)->program(p, color, dst, uniforms, alloc);
             } else {
                 return color;
             }
@@ -694,8 +736,12 @@
         SkASSERT(inputs);
 
         auto evalChild = [&](int index, SkPMColor4f inColor) {
-            const SkColorFilter* child = fChildren[index].get();
-            return child ? as_CFB(child)->onFilterColor4f(inColor, dstCS) : inColor;
+            const auto& child = fChildren[index];
+
+            // Guaranteed by initFilterColorInfo
+            SkASSERT(!child.shader);
+            return child.colorFilter ? as_CFB(child.colorFilter)->onFilterColor4f(inColor, dstCS)
+                                     : inColor;
         };
 
         return program->eval(color, inputs->data(), evalChild);
@@ -715,7 +761,8 @@
         }
         buffer.write32(fChildren.size());
         for (const auto& child : fChildren) {
-            buffer.writeFlattenable(child.get());
+            buffer.writeFlattenable(child.shader ? (const SkFlattenable*)child.shader.get()
+                                                 : child.colorFilter.get());
         }
     }
 
@@ -724,7 +771,7 @@
 private:
     sk_sp<SkRuntimeEffect> fEffect;
     sk_sp<SkData> fUniforms;
-    std::vector<sk_sp<SkColorFilter>> fChildren;
+    std::vector<SkRuntimeEffect::ChildPtr> fChildren;
 };
 
 sk_sp<SkFlattenable> SkRuntimeColorFilter::CreateProc(SkReadBuffer& buffer) {
@@ -742,25 +789,36 @@
         return nullptr;
     }
 
-    std::vector<sk_sp<SkColorFilter>> children(childCount);
-    for (size_t i = 0; i < children.size(); ++i) {
-        children[i] = buffer.readColorFilter();
+    SkSTArray<4, SkRuntimeEffect::ChildPtr> children(childCount);
+    for (const auto& child : effect->children()) {
+        if (child.type == SkRuntimeEffect::Child::Type::kShader) {
+            children.emplace_back(buffer.readShader());
+        } else {
+            SkASSERT(child.type == SkRuntimeEffect::Child::Type::kColorFilter);
+            children.emplace_back(buffer.readColorFilter());
+        }
+    }
+    if (!buffer.isValid()) {
+        return nullptr;
     }
 
-    return effect->makeColorFilter(std::move(uniforms), children.data(), children.size());
+    return effect->makeColorFilter(std::move(uniforms), SkMakeSpan(children));
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 class SkRTShader : public SkShaderBase {
 public:
-    SkRTShader(sk_sp<SkRuntimeEffect> effect, sk_sp<SkData> uniforms, const SkMatrix* localMatrix,
-               sk_sp<SkShader>* children, size_t childCount, bool isOpaque)
+    SkRTShader(sk_sp<SkRuntimeEffect> effect,
+               sk_sp<SkData> uniforms,
+               const SkMatrix* localMatrix,
+               SkSpan<SkRuntimeEffect::ChildPtr> children,
+               bool isOpaque)
             : SkShaderBase(localMatrix)
             , fEffect(std::move(effect))
             , fIsOpaque(isOpaque)
             , fUniforms(std::move(uniforms))
-            , fChildren(children, children + childCount) {}
+            , fChildren(children.begin(), children.end()) {}
 
     bool isOpaque() const override { return fIsOpaque; }
 
@@ -780,12 +838,12 @@
         GrFPArgs childArgs = args;
         childArgs.fInputColorIsOpaque = false;
 
-        auto fp = GrSkSLFP::Make(fEffect, "runtime_shader", std::move(uniforms));
-        for (const auto& child : fChildren) {
-            auto childFP = child ? as_SB(child)->asFragmentProcessor(childArgs) : nullptr;
-            fp->addChild(std::move(childFP));
+        auto result = make_effect_fp(
+                fEffect, "runtime_shader", std::move(uniforms), SkMakeSpan(fChildren), childArgs);
+        if (!result) {
+            return nullptr;
         }
-        std::unique_ptr<GrFragmentProcessor> result = std::move(fp);
+
         // If the shader was created with isOpaque = true, we *force* that result here.
         // CPU does the same thing (in SkShaderBase::program).
         if (fIsOpaque) {
@@ -826,11 +884,12 @@
         local = SkShaderBase::ApplyMatrix(p,inv,local,uniforms);
 
         auto sampleChild = [&](int ix, skvm::Coord coord, skvm::Color color) {
-            if (fChildren[ix]) {
+            if (fChildren[ix].shader) {
                 SkOverrideDeviceMatrixProvider mats{matrices, SkMatrix::I()};
-                return as_SB(fChildren[ix])->program(p, device, coord, color,
-                                                     mats, nullptr, dst,
-                                                     uniforms, alloc);
+                return as_SB(fChildren[ix].shader)
+                        ->program(p, device, coord, color, mats, nullptr, dst, uniforms, alloc);
+            } else if (fChildren[ix].colorFilter) {
+                return as_CFB(fChildren[ix].colorFilter)->program(p, color, dst, uniforms, alloc);
             } else {
                 return color;
             }
@@ -870,7 +929,8 @@
         }
         buffer.write32(fChildren.size());
         for (const auto& child : fChildren) {
-            buffer.writeFlattenable(child.get());
+            buffer.writeFlattenable(child.shader ? (const SkFlattenable*)child.shader.get()
+                                                 : child.colorFilter.get());
         }
     }
 
@@ -888,7 +948,7 @@
     bool fIsOpaque;
 
     sk_sp<SkData> fUniforms;
-    std::vector<sk_sp<SkShader>> fChildren;
+    std::vector<SkRuntimeEffect::ChildPtr> fChildren;
 };
 
 sk_sp<SkFlattenable> SkRTShader::CreateProc(SkReadBuffer& buffer) {
@@ -914,43 +974,65 @@
         return nullptr;
     }
 
-    std::vector<sk_sp<SkShader>> children(childCount);
-    for (size_t i = 0; i < children.size(); ++i) {
-        children[i] = buffer.readShader();
+    SkSTArray<4, SkRuntimeEffect::ChildPtr> children(childCount);
+    for (const auto& child : effect->children()) {
+        if (child.type == SkRuntimeEffect::Child::Type::kShader) {
+            children.emplace_back(buffer.readShader());
+        } else {
+            SkASSERT(child.type == SkRuntimeEffect::Child::Type::kColorFilter);
+            children.emplace_back(buffer.readColorFilter());
+        }
+    }
+    if (!buffer.isValid()) {
+        return nullptr;
     }
 
-    return effect->makeShader(std::move(uniforms), children.data(), children.size(), localMPtr,
-                              isOpaque);
+    return effect->makeShader(std::move(uniforms), SkMakeSpan(children), localMPtr, isOpaque);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkShader> SkRuntimeEffect::makeShader(sk_sp<SkData> uniforms,
-                                            sk_sp<SkShader> children[],
+                                            sk_sp<SkShader> childShaders[],
                                             size_t childCount,
                                             const SkMatrix* localMatrix,
                                             bool isOpaque) const {
+    SkSTArray<4, ChildPtr> children(childCount);
+    for (size_t i = 0; i < childCount; ++i) {
+        children.emplace_back(childShaders[i]);
+    }
+    return this->makeShader(std::move(uniforms), SkMakeSpan(children), localMatrix, isOpaque);
+}
+
+sk_sp<SkShader> SkRuntimeEffect::makeShader(sk_sp<SkData> uniforms,
+                                            SkSpan<ChildPtr> children,
+                                            const SkMatrix* localMatrix,
+                                            bool isOpaque) const {
     if (!this->allowShader()) {
         return nullptr;
     }
+    if (children.size() != fChildren.size()) {
+        return nullptr;
+    }
+    // Verify that all child objects match the declared type in the SkSL
+    for (size_t i = 0; i < children.size(); ++i) {
+        if (fChildren[i].type == Child::Type::kShader) {
+            if (children[i].colorFilter) {
+                return nullptr;
+            }
+        } else {
+            SkASSERT(fChildren[i].type == Child::Type::kColorFilter);
+            if (children[i].shader) {
+                return nullptr;
+            }
+        }
+    }
     if (!uniforms) {
         uniforms = SkData::MakeEmpty();
     }
-    // Verify that all child objects are shaders (to match the C++ types here).
-    // TODO(skia:11813) When we support shader and colorFilter children (with different samplng
-    // semantics), the 'children' parameter will contain both types, so this will be more complex.
-    if (!std::all_of(fChildren.begin(), fChildren.end(), [](const Child& c) {
-            return c.type == Child::Type::kShader;
-        })) {
-        return nullptr;
-    }
-    return uniforms->size() == this->uniformSize() && childCount == fChildren.size()
-                   ? sk_sp<SkShader>(new SkRTShader(sk_ref_sp(this),
-                                                    std::move(uniforms),
-                                                    localMatrix,
-                                                    children,
-                                                    childCount,
-                                                    isOpaque))
+    return uniforms->size() == this->uniformSize()
+                   ? sk_sp<SkShader>(new SkRTShader(
+                             sk_ref_sp(this), std::move(uniforms), localMatrix, children, isOpaque))
                    : nullptr;
 }
 
@@ -1033,30 +1115,47 @@
 }
 
 sk_sp<SkColorFilter> SkRuntimeEffect::makeColorFilter(sk_sp<SkData> uniforms,
-                                                      sk_sp<SkColorFilter> children[],
+                                                      sk_sp<SkColorFilter> childColorFilters[],
                                                       size_t childCount) const {
+    SkSTArray<4, ChildPtr> children(childCount);
+    for (size_t i = 0; i < childCount; ++i) {
+        children.emplace_back(childColorFilters[i]);
+    }
+    return this->makeColorFilter(std::move(uniforms), SkMakeSpan(children));
+}
+
+sk_sp<SkColorFilter> SkRuntimeEffect::makeColorFilter(sk_sp<SkData> uniforms,
+                                                      SkSpan<ChildPtr> children) const {
     if (!this->allowColorFilter()) {
         return nullptr;
     }
+    if (children.size() != fChildren.size()) {
+        return nullptr;
+    }
+    // Verify that all child objects match the declared type in the SkSL
+    for (size_t i = 0; i < children.size(); ++i) {
+        if (fChildren[i].type == Child::Type::kShader) {
+            if (children[i].colorFilter) {
+                return nullptr;
+            }
+        } else {
+            SkASSERT(fChildren[i].type == Child::Type::kColorFilter);
+            if (children[i].shader) {
+                return nullptr;
+            }
+        }
+    }
     if (!uniforms) {
         uniforms = SkData::MakeEmpty();
     }
-    // Verify that all child objects are color filters (to match the C++ types here).
-    // TODO(skia:11813) When we support shader and colorFilter children (with different samplng
-    // semantics), the 'children' parameter will contain both types, so this will be more complex.
-    if (!std::all_of(fChildren.begin(), fChildren.end(), [](const Child& c) {
-            return c.type == Child::Type::kColorFilter;
-        })) {
-        return nullptr;
-    }
-    return uniforms->size() == this->uniformSize() && childCount == fChildren.size()
+    return uniforms->size() == this->uniformSize()
                    ? sk_sp<SkColorFilter>(new SkRuntimeColorFilter(
-                             sk_ref_sp(this), std::move(uniforms), children, childCount))
+                             sk_ref_sp(this), std::move(uniforms), children))
                    : nullptr;
 }
 
 sk_sp<SkColorFilter> SkRuntimeEffect::makeColorFilter(sk_sp<SkData> uniforms) const {
-    return this->makeColorFilter(std::move(uniforms), nullptr, 0);
+    return this->makeColorFilter(std::move(uniforms), /*children=*/{});
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////