@shopify/react-native-skia 1.5.2 → 1.5.4

package/cpp/rnskia/DawnUtils.h

@@ -0,0 +1,127 @@
+#pragma once
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "dawn/dawn_proc.h"
+#include "dawn/native/DawnNative.h"
+
+#include "include/core/SkColorType.h"
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"
+
+namespace DawnUtils {
+
+#ifdef __APPLE__
+static const SkColorType PreferedColorType = kBGRA_8888_SkColorType;
+static const wgpu::TextureFormat PreferredTextureFormat =
+    wgpu::TextureFormat::BGRA8Unorm;
+#else
+static const SkColorType PreferedColorType = kRGBA_8888_SkColorType;
+static const wgpu::TextureFormat PreferredTextureFormat =
+    wgpu::TextureFormat::RGBA8Unorm;
+#endif
+
+inline skgpu::graphite::DawnBackendContext
+createDawnBackendContext(dawn::native::Instance *instance) {
+
+  auto useTintIR = false;
+  static constexpr const char *kToggles[] = {
+      "allow_unsafe_apis",
+      "use_user_defined_labels_in_backend",
+      "disable_robustness",
+      "use_tint_ir",
+  };
+  wgpu::DawnTogglesDescriptor togglesDesc;
+  togglesDesc.enabledToggleCount = std::size(kToggles) - (useTintIR ? 0 : 1);
+  togglesDesc.enabledToggles = kToggles;
+
+  wgpu::RequestAdapterOptions options;
+#ifdef __APPLE__
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
+#elif __ANDROID__
+  constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
+#endif
+  options.backendType = kDefaultBackendType;
+  options.nextInChain = &togglesDesc;
+
+  std::vector<dawn::native::Adapter> adapters =
+      instance->EnumerateAdapters(&options);
+  if (adapters.empty()) {
+    throw std::runtime_error("No matching adapter found");
+  }
+
+  wgpu::Adapter adapter = adapters[0].Get();
+
+  std::vector<wgpu::FeatureName> features;
+  if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
+    features.push_back(wgpu::FeatureName::MSAARenderToSingleSampled);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::TransientAttachments)) {
+    features.push_back(wgpu::FeatureName::TransientAttachments);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::Unorm16TextureFormats)) {
+    features.push_back(wgpu::FeatureName::Unorm16TextureFormats);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DualSourceBlending)) {
+    features.push_back(wgpu::FeatureName::DualSourceBlending);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::FramebufferFetch)) {
+    features.push_back(wgpu::FeatureName::FramebufferFetch);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::BufferMapExtendedUsages)) {
+    features.push_back(wgpu::FeatureName::BufferMapExtendedUsages);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionETC2)) {
+    features.push_back(wgpu::FeatureName::TextureCompressionETC2);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::TextureCompressionBC)) {
+    features.push_back(wgpu::FeatureName::TextureCompressionBC);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::R8UnormStorage)) {
+    features.push_back(wgpu::FeatureName::R8UnormStorage);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DawnLoadResolveTexture)) {
+    features.push_back(wgpu::FeatureName::DawnLoadResolveTexture);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DawnPartialLoadResolveTexture)) {
+    features.push_back(wgpu::FeatureName::DawnPartialLoadResolveTexture);
+  }
+#ifdef __APPLE__
+  if (adapter.HasFeature(wgpu::FeatureName::SharedTextureMemoryIOSurface)) {
+    features.push_back(wgpu::FeatureName::SharedTextureMemoryIOSurface);
+  }
+#else
+  if (adapter.HasFeature(
+          wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer)) {
+    features.push_back(wgpu::FeatureName::SharedTextureMemoryAHardwareBuffer);
+  }
+#endif
+
+  wgpu::DeviceDescriptor desc;
+  desc.requiredFeatureCount = features.size();
+  desc.requiredFeatures = features.data();
+  desc.nextInChain = &togglesDesc;
+  desc.SetDeviceLostCallback(
+      wgpu::CallbackMode::AllowSpontaneous,
+      [](const wgpu::Device &, wgpu::DeviceLostReason reason,
+         const char *message) {
+        if (reason != wgpu::DeviceLostReason::Destroyed) {
+          SK_ABORT("Device lost: %s\n", message);
+        }
+      });
+  desc.SetUncapturedErrorCallback(
+      [](const wgpu::Device &, wgpu::ErrorType, const char *message) {
+        SkDebugf("Device error: %s\n", message);
+      });
+
+  wgpu::Device device = adapter.CreateDevice(&desc);
+  SkASSERT(device);
+
+  skgpu::graphite::DawnBackendContext backendContext;
+  backendContext.fInstance = wgpu::Instance(instance->Get());
+  backendContext.fDevice = device;
+  backendContext.fQueue = device.GetQueue();
+
+  return backendContext;
+}
+
+} // namespace DawnUtils

package/cpp/rnskia/DawnWindowContext.cpp

@@ -0,0 +1,19 @@
+#include "DawnWindowContext.h"
+
+#include "DawnContext.h"
+
+namespace RNSkia {
+
+void DawnWindowContext::present() {
+  auto recording = _recorder->snap();
+  if (!recording) {
+    throw std::runtime_error("Failed to create graphite recording");
+  }
+  DawnContext::getInstance().submitRecording(recording.get());
+#ifdef __APPLE__
+  dawn::native::metal::WaitForCommandsToBeScheduled(_device.Get());
+#endif
+  _surface.Present();
+}
+
+} // namespace RNSkia

package/cpp/rnskia/DawnWindowContext.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "DawnUtils.h"
+#include "WindowContext.h"
+
+#include "dawn/native/MetalBackend.h"
+#include "webgpu/webgpu_cpp.h"
+
+#include "include/core/SkColorSpace.h"
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/Context.h"
+#include "include/gpu/graphite/ContextOptions.h"
+#include "include/gpu/graphite/GraphiteTypes.h"
+#include "include/gpu/graphite/Recorder.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/gpu/graphite/Surface.h"
+#include "include/gpu/graphite/dawn/DawnBackendContext.h"
+#include "include/gpu/graphite/dawn/DawnTypes.h"
+#include "include/gpu/graphite/dawn/DawnUtils.h"
+
+namespace RNSkia {
+
+class DawnWindowContext : public WindowContext {
+public:
+  DawnWindowContext(skgpu::graphite::Recorder *recorder, wgpu::Device device,
+                    wgpu::Surface surface, int width, int height)
+      : _recorder(recorder), _device(device), _surface(surface), _width(width),
+        _height(height) {
+    wgpu::SurfaceConfiguration config;
+    config.device = _device;
+    config.format = DawnUtils::PreferredTextureFormat;
+    config.width = _width;
+    config.height = _height;
+#ifdef __APPLE__
+    config.alphaMode = wgpu::CompositeAlphaMode::Premultiplied;
+#endif
+    _surface.Configure(&config);
+  }
+
+  sk_sp<SkSurface> getSurface() override {
+    wgpu::SurfaceTexture surfaceTexture;
+    _surface.GetCurrentTexture(&surfaceTexture);
+    auto texture = surfaceTexture.texture;
+    skgpu::graphite::DawnTextureInfo info(
+        /*sampleCount=*/1, skgpu::Mipmapped::kNo,
+        DawnUtils::PreferredTextureFormat, texture.GetUsage(),
+        wgpu::TextureAspect::All);
+    auto backendTex = skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
+    sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeSRGB();
+    SkSurfaceProps surfaceProps;
+    auto surface = SkSurfaces::WrapBackendTexture(_recorder, backendTex,
+                                                  DawnUtils::PreferedColorType,
+                                                  colorSpace, &surfaceProps);
+    return surface;
+  }
+
+  void present() override;
+
+  void resize(int width, int height) override {
+    throw std::runtime_error("resize not implemented yet");
+  }
+
+  int getWidth() override { return _width; }
+
+  int getHeight() override { return _height; }
+
+private:
+  skgpu::graphite::Recorder *_recorder;
+  // TODO: keep device in DawnContext? Do we need it for resizing?
+  wgpu::Device _device;
+  wgpu::Surface _surface;
+  int _width;
+  int _height;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/ImageProvider.h

@@ -0,0 +1,100 @@
+#pragma once
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
+
+#include "include/core/SkTiledImageUtils.h"
+#include "include/gpu/graphite/Image.h"
+#include "include/gpu/graphite/ImageProvider.h"
+#include "include/gpu/graphite/Recorder.h"
+#include "src/core/SkLRUCache.h"
+
+namespace RNSkia {
+
+// Currently, we give each new Recorder its own ImageProvider. This means we
+// don't have to deal w/ any threading issues.
+// TODO: We should probably have this class generate and report some cache stats
+// TODO: Hook up to listener system?
+// TODO: add testing of a single ImageProvider passed to multiple recorders
+class ImageProvider : public skgpu::graphite::ImageProvider {
+public:
+  ImageProvider() : fCache(kDefaultNumCachedImages) {}
+  ~ImageProvider() override {}
+
+  static sk_sp<ImageProvider> Make() { return sk_ref_sp(new ImageProvider); }
+
+  sk_sp<SkImage>
+  findOrCreate(skgpu::graphite::Recorder *recorder, const SkImage *image,
+               SkImage::RequiredProperties requiredProps) override {
+    if (!requiredProps.fMipmapped) {
+      // If no mipmaps are required, check to see if we have a mipmapped version
+      // anyway - since it can be used in that case.
+      // TODO: we could get fancy and, if ever a mipmapped key eclipsed a
+      // non-mipmapped key, we could remove the hidden non-mipmapped key/image
+      // from the cache.
+      ImageKey mipMappedKey(image, /* mipmapped= */ true);
+      auto result = fCache.find(mipMappedKey);
+      if (result) {
+        return *result;
+      }
+    }
+
+    ImageKey key(image, requiredProps.fMipmapped);
+
+    auto result = fCache.find(key);
+    if (result) {
+      return *result;
+    }
+
+    sk_sp<SkImage> newImage =
+        SkImages::TextureFromImage(recorder, image, requiredProps);
+    if (!newImage) {
+      return nullptr;
+    }
+
+    result = fCache.insert(key, std::move(newImage));
+    SkASSERT(result);
+
+    return *result;
+  }
+
+private:
+  static constexpr int kDefaultNumCachedImages = 256;
+
+  class ImageKey {
+  public:
+    ImageKey(const SkImage *image, bool mipmapped) {
+      uint32_t flags = mipmapped ? 0x1 : 0x0;
+      SkTiledImageUtils::GetImageKeyValues(image, &fValues[1]);
+      fValues[kNumValues - 1] = flags;
+      fValues[0] =
+          SkChecksum::Hash32(&fValues[1], (kNumValues - 1) * sizeof(uint32_t));
+    }
+
+    uint32_t hash() const { return fValues[0]; }
+
+    bool operator==(const ImageKey &other) const {
+      for (int i = 0; i < kNumValues; ++i) {
+        if (fValues[i] != other.fValues[i]) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+    bool operator!=(const ImageKey &other) const { return !(*this == other); }
+
+  private:
+    static const int kNumValues = SkTiledImageUtils::kNumImageKeyValues + 2;
+
+    uint32_t fValues[kNumValues];
+  };
+
+  struct ImageHash {
+    size_t operator()(const ImageKey &key) const { return key.hash(); }
+  };
+
+  SkLRUCache<ImageKey, sk_sp<SkImage>, ImageHash> fCache;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkView.h

@@ -108,7 +108,13 @@ public:
     } else {
       image = _surface->makeImageSnapshot();
     }
+#if defined(SK_GRAPHITE)
+    DawnContext::getInstance().submitRecording(
+        _surface->recorder()->snap().get());
+    return DawnContext::getInstance().MakeRasterImage(image);
+#else
     return image->makeNonTextureImage();
+#endif
   }
 
   /**

package/cpp/skia/include/android/SkAnimatedImage.h

@@ -110,6 +110,19 @@ public:
      */
     int getFrameCount() const { return fFrameCount; }
 
+    /**
+     *  Change the filter mode.
+     *
+     *  By default, the image will apply bilinear filtering when drawing in the
+     *  OnDraw method.
+     */
+    void setFilterMode(SkFilterMode filterMode);
+
+    /**
+     *  Return the filter mode used for sampling when drawing.
+     */
+    SkFilterMode getFilterMode() const { return fFilterMode; }
+
 protected:
     SkRect onGetBounds() override;
     void onDraw(SkCanvas*) override;
@@ -152,6 +165,7 @@ private:
     Frame                           fRestoreFrame;
     int                             fRepetitionCount;
     int                             fRepetitionsCompleted;
+    SkFilterMode                    fFilterMode = SkFilterMode::kLinear;
 
     SkAnimatedImage(std::unique_ptr<SkAndroidCodec>, const SkImageInfo& requestedInfo,
             SkIRect cropRect, sk_sp<SkPicture> postProcess);

package/cpp/skia/include/codec/SkAvifDecoder.h

@@ -18,13 +18,15 @@ class SkStream;
 
 namespace SkAvifDecoder {
 
-/** Returns true if this data claims to be a AVIF image. */
+namespace LibAvif {
+
+/** Returns true if this data claims to be an AVIF image. */
 SK_API bool IsAvif(const void*, size_t);
 
 /**
- *  Attempts to decode the given bytes as a AVIF.
+ *  Attempts to decode the given bytes as an AVIF.
  *
- *  If the bytes are not a AVIF, returns nullptr.
+ *  If the bytes are not an AVIF, returns nullptr.
  *
  *  DecodeContext is ignored
  */
@@ -39,6 +41,40 @@ inline constexpr SkCodecs::Decoder Decoder() {
     return { "avif", IsAvif, Decode };
 }
 
+}  // namespace LibAvif
+
+// This function is in the root SkAvifDecoder namespace. It simply routes
+// everything through the LibAvif namespace and exists for backwards
+// compatibility.
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "avif", LibAvif::IsAvif, LibAvif::Decode };
+}
+
+namespace CrabbyAvif {
+
+/** Returns true if this data claims to be an AVIF image. */
+SK_API bool IsAvif(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as an AVIF.
+ *
+ *  If the bytes are not an AVIF, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline constexpr SkCodecs::Decoder Decoder() {
+    return { "avif", IsAvif, Decode };
+}
+
+}  // namespace CrabbyAvif
+
 }  // namespace SkAvifDecoder
 
 #endif  // SkAvifDecoder_DEFINED

package/cpp/skia/include/codec/SkCodec.h

@@ -239,6 +239,16 @@ public:
         return this->getEncodedInfo().profile();
     }
 
+    /**
+     * Whether the encoded input uses 16 or more bits per component.
+     */
+    bool hasHighBitDepthEncodedData() const {
+        // API design note: We don't return `bitsPerComponent` because it may be
+        // misleading in some cases - see https://crbug.com/359350061#comment4
+        // for more details.
+        return this->getEncodedInfo().bitsPerComponent() >= 16;
+    }
+
     /**
      *  Returns the image orientation stored in the EXIF data.
      *  If there is no EXIF data, or if we cannot read the EXIF data, returns kTopLeft.
@@ -637,6 +647,12 @@ public:
      *  Return the number of frames in the image.
      *
      *  May require reading through the stream.
+     *
+     *  Note that some codecs may be unable to gather `FrameInfo` for all frames
+     *  in case of `kIncompleteInput`.  For such codecs `getFrameCount` may
+     *  initially report a low frame count.  After the underlying `SkStream`
+     *  provides additional data, then calling `getFrameCount` again may return
+     *  an updated, increased frame count.
      */
     int getFrameCount() {
         return this->onGetFrameCount();

package/cpp/skia/include/config/SkUserConfig.h

@@ -90,9 +90,10 @@
    integrate with their histogram collection backend.
 */
 //#define SK_HISTOGRAM_BOOLEAN(name, sample)
-//#define SK_HISTOGRAM_ENUMERATION(name, sample, enum_size)
-//#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, value_max)
+//#define SK_HISTOGRAM_ENUMERATION(name, sampleEnum, enumSize)
+//#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
+//#define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
 
 // To use smaller but slower mipmap builder
 //#define SK_USE_DRAWING_MIPMAP_DOWNSAMPLER

package/cpp/skia/include/core/SkCanvas.h

@@ -28,6 +28,7 @@
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkSurfaceProps.h"
+#include "include/core/SkTileMode.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkCPUTypes.h"
 #include "include/private/base/SkDeque.h"
@@ -700,7 +701,8 @@ public:
             @return                SaveLayerRec with empty fBackdrop
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
-            : SaveLayerRec(bounds, paint, nullptr, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, nullptr, nullptr, 1.f, SkTileMode::kClamp,
+                           saveLayerFlags, /*filters=*/{}) {}
 
         /** Sets fBounds, fPaint, fBackdrop, and fSaveLayerFlags.
 
@@ -716,9 +718,10 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, backdrop, nullptr, 1.f, SkTileMode::kClamp,
+                           saveLayerFlags, /*filters=*/{}) {}
 
-        /** Sets fBounds, fColorSpace, and fSaveLayerFlags.
+        /** Sets fBounds, fBackdrop, fColorSpace, and fSaveLayerFlags.
 
             @param bounds          layer dimensions; may be nullptr
             @param paint           applied to layer when overlaying prior layer;
@@ -738,15 +741,44 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      const SkColorSpace* colorSpace, SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, saveLayerFlags, /*filters=*/{}) {}
+            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, SkTileMode::kClamp,
+                           saveLayerFlags, /*filters=*/{}) {}
+
+
+        /** Sets fBounds, fBackdrop, fBackdropTileMode, fColorSpace, and fSaveLayerFlags.
+
+            @param bounds           layer dimensions; may be nullptr
+            @param paint            applied to layer when overlaying prior layer;
+                                    may be nullptr
+            @param backdrop         If not null, this causes the current layer to be filtered by
+                                    backdrop, and then drawn into the new layer
+                                    (respecting the current clip).
+                                    If null, the new layer is initialized with transparent-black.
+            @param backdropTileMode If the 'backdrop' is not null, or 'saveLayerFlags' has
+                                    kInitWithPrevious set, this tile mode is used when the new layer
+                                    would read outside the backdrop image's available content.
+            @param colorSpace       If not null, when the layer is restored, a color space
+                                    conversion will be applied from this color space to the parent's
+                                    color space. The restore paint and backdrop filters will be
+                                    applied in this color space.
+                                    If null, the new layer will inherit the color space from its
+                                    parent.
+            @param saveLayerFlags   SaveLayerRec options to modify layer
+            @return                 SaveLayerRec fully specified
+        */
+        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
+                     SkTileMode backdropTileMode, const SkColorSpace* colorSpace,
+                     SaveLayerFlags saveLayerFlags)
+            : SaveLayerRec(bounds, paint, backdrop, colorSpace, 1.f, backdropTileMode,
+                           saveLayerFlags, /*filters=*/{}) {}
 
         /** hints at layer size limit */
-        const SkRect*        fBounds         = nullptr;
+        const SkRect* fBounds = nullptr;
 
         /** modifies overlay */
-        const SkPaint*       fPaint          = nullptr;
+        const SkPaint* fPaint = nullptr;
 
-        FilterSpan           fFilters        = {};
+        FilterSpan fFilters = {};
 
         /**
          *  If not null, this triggers the same initialization behavior as setting
@@ -754,17 +786,24 @@ public:
          *  the new layer, rather than initializing the new layer with transparent-black.
          *  This is then filtered by fBackdrop (respecting the current clip).
          */
-        const SkImageFilter* fBackdrop       = nullptr;
+        const SkImageFilter* fBackdrop = nullptr;
+
+        /**
+         * If the layer is initialized with prior content (and/or with a backdrop filter) and this
+         * would require sampling outside of the available backdrop, this is the tilemode applied
+         * to the boundary of the prior layer's image.
+         */
+        SkTileMode fBackdropTileMode = SkTileMode::kClamp;
 
         /**
          * If not null, this triggers a color space conversion when the layer is restored. It
          * will be as if the layer's contents are drawn in this color space. Filters from
          * fBackdrop and fPaint will be applied in this color space.
          */
-        const SkColorSpace* fColorSpace      = nullptr;
+        const SkColorSpace* fColorSpace = nullptr;
 
         /** preserves LCD text, creates with prior layer contents */
-        SaveLayerFlags       fSaveLayerFlags = 0;
+        SaveLayerFlags fSaveLayerFlags = 0;
 
     private:
         friend class SkCanvas;
@@ -775,12 +814,14 @@ public:
                      const SkImageFilter* backdrop,
                      const SkColorSpace* colorSpace,
                      SkScalar backdropScale,
+                     SkTileMode backdropTileMode,
                      SaveLayerFlags saveLayerFlags,
                      FilterSpan filters)
                 : fBounds(bounds)
                 , fPaint(paint)
                 , fFilters(filters)
                 , fBackdrop(backdrop)
+                , fBackdropTileMode(backdropTileMode)
                 , fColorSpace(colorSpace)
                 , fSaveLayerFlags(saveLayerFlags)
                 , fExperimentalBackdropScale(backdropScale) {
@@ -2591,12 +2632,16 @@ private:
      * before any filtering, or as part of the copy, and is then drawn with 1/scaleFactor to 'dst'.
      * Must be 1.0 if 'compat' is kYes (i.e. any scale factor has already been baked into the
      * relative transforms between the devices).
+     *
+     * 'srcTileMode' is the tile mode to apply to the boundary of the 'src' image when insufficient
+     * content is available. It defaults to kDecal for the regular saveLayer() case.
      */
     void internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst,
                                       FilterSpan filters, const SkPaint& paint,
                                       DeviceCompatibleWithFilter compat,
                                       const SkColorInfo& filterColorInfo,
                                       SkScalar scaleFactor = 1.f,
+                                      SkTileMode srcTileMode = SkTileMode::kDecal,
                                       bool srcIsCoverageLayer = false);
 
     /*