@shopify/react-native-skia 2.6.2 → 2.6.3-next.2

package/cpp/skia/include/gpu/ganesh/GrBackendSurface.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Google Inc.
+ * Copyright 2017 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
@@ -12,13 +12,11 @@
 #include "include/core/SkSize.h"
 #include "include/gpu/GpuTypes.h"
 #include "include/gpu/ganesh/GrTypes.h"
-#include "include/gpu/ganesh/mock/GrMockTypes.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAnySubclass.h"
 #include "include/private/base/SkDebug.h"
 #include "include/private/gpu/ganesh/GrTypesPriv.h"
 
-enum class SkTextureCompressionType;
 class GrBackendFormatData;
 class GrBackendTextureData;
 class GrBackendRenderTargetData;
@@ -44,10 +42,6 @@ public:
     GrBackendFormat& operator=(const GrBackendFormat&);
     ~GrBackendFormat();
 
-    static GrBackendFormat MakeMock(GrColorType colorType,
-                                    SkTextureCompressionType compression,
-                                    bool isStencilFormat = false);
-
     bool operator==(const GrBackendFormat& that) const;
     bool operator!=(const GrBackendFormat& that) const { return !(*this == that); }
 
@@ -62,15 +56,6 @@ public:
 
     GrColorFormatDesc desc() const;
 
-    /**
-     * If the backend API is not Mock these three calls will return kUnknown, kNone or false,
-     * respectively. Otherwise, only one of the following can be true. The GrColorType is not
-     * kUnknown, the compression type is not kNone, or this is a mock stencil format.
-     */
-    GrColorType asMockColorType() const;
-    SkTextureCompressionType asMockCompressionType() const;
-    bool isMockStencilFormat() const;
-
     // If possible, copies the GrBackendFormat and forces the texture type to be Texture2D. If the
     // GrBackendFormat was for Vulkan and it originally had a skgpu::VulkanYcbcrConversionInfo,
     // we will remove the conversion and set the format to be VK_FORMAT_R8G8B8A8_UNORM.
@@ -96,43 +81,22 @@ private:
     // GrBackendFormats::MakeGL instead.
     template <typename FormatData>
     GrBackendFormat(GrTextureType textureType, GrBackendApi api, const FormatData& formatData)
-            : fBackend(api), fValid(true), fTextureType(textureType) {
+            : fBackend(api), fTextureType(textureType), fValid(true) {
         fFormatData.emplace<FormatData>(formatData);
     }
 
-    GrBackendFormat(GrColorType, SkTextureCompressionType, bool isStencilFormat);
-
-#ifdef SK_DEBUG
-    bool validateMock() const;
-#endif
-
-    GrBackendApi fBackend = GrBackendApi::kMock;
-    bool fValid = false;
     AnyFormatData fFormatData;
-
-    struct {
-        GrColorType fColorType;
-        SkTextureCompressionType fCompressionType;
-        bool fIsStencilFormat;
-    } fMock;
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
     GrTextureType fTextureType = GrTextureType::kNone;
+    bool fValid = false;
 };
 
 class SK_API GrBackendTexture {
 public:
     // Creates an invalid backend texture.
     GrBackendTexture();
-
-    GrBackendTexture(int width,
-                     int height,
-                     skgpu::Mipmapped,
-                     const GrMockTextureInfo& mockInfo,
-                     std::string_view label = {});
-
     GrBackendTexture(const GrBackendTexture& that);
-
     ~GrBackendTexture();
-
     GrBackendTexture& operator=(const GrBackendTexture& that);
 
     SkISize dimensions() const { return {fWidth, fHeight}; }
@@ -147,10 +111,6 @@ public:
     // Get the GrBackendFormat for this texture (or an invalid format if this is not valid).
     GrBackendFormat getBackendFormat() const;
 
-    // If the backend API is Mock, copies a snapshot of the GrMockTextureInfo struct into the passed
-    // in pointer and returns true. Otherwise returns false if the backend API is not Mock.
-    bool getMockTextureInfo(GrMockTextureInfo*) const;
-
     // If the client changes any of the mutable backend of the GrBackendTexture they should call
     // this function to inform Skia that those values have changed. The backend API specific state
     // that can be set from this function are:
@@ -208,26 +168,16 @@ private:
     int fHeight;        //<! height in pixels
     const std::string fLabel;
     skgpu::Mipmapped fMipmapped;
-    GrBackendApi fBackend;
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
     GrTextureType fTextureType;
     AnyTextureData fTextureData;
-
-    GrMockTextureInfo fMockInfo;
 };
 
 class SK_API GrBackendRenderTarget {
 public:
     // Creates an invalid backend texture.
     GrBackendRenderTarget();
-
-    GrBackendRenderTarget(int width,
-                          int height,
-                          int sampleCnt,
-                          int stencilBits,
-                          const GrMockRenderTargetInfo& mockInfo);
-
     ~GrBackendRenderTarget();
-
     GrBackendRenderTarget(const GrBackendRenderTarget& that);
     GrBackendRenderTarget& operator=(const GrBackendRenderTarget&);
 
@@ -242,10 +192,6 @@ public:
     // Get the GrBackendFormat for this render target (or an invalid format if this is not valid).
     GrBackendFormat getBackendFormat() const;
 
-    // If the backend API is Mock, copies a snapshot of the GrMockTextureInfo struct into the passed
-    // in pointer and returns true. Otherwise returns false if the backend API is not Mock.
-    bool getMockRenderTargetInfo(GrMockRenderTargetInfo*) const;
-
     // If the client changes any of the mutable backend of the GrBackendTexture they should call
     // this function to inform Skia that those values have changed. The backend API specific state
     // that can be set from this function are:
@@ -304,10 +250,8 @@ private:
     int fSampleCnt;
     int fStencilBits;
 
-    GrBackendApi fBackend;
+    GrBackendApi fBackend = GrBackendApi::kUnsupported;
     AnyRenderTargetData fRTData;
-
-    GrMockRenderTargetInfo fMockInfo;
 };
 
 #endif

package/cpp/skia/include/gpu/ganesh/GrContextThreadSafeProxy.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Google Inc.
+ * Copyright 2019 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/ganesh/GrDirectContext.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc.
+ * Copyright 2020 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/ganesh/GrDriverBugWorkarounds.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 Google Inc.
+ * Copyright 2018 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/ganesh/GrRecordingContext.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Google Inc.
+ * Copyright 2019 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
@@ -67,6 +67,7 @@ public:
             colorType == kA16_unorm_SkColorType          ||
             colorType == kA16_float_SkColorType          ||
             colorType == kR16_unorm_SkColorType          ||
+            colorType == kR16_float_SkColorType          ||
             colorType == kR16G16_float_SkColorType       ||
             colorType == kR16G16B16A16_unorm_SkColorType ||
             colorType == kGray_8_SkColorType) {

package/cpp/skia/include/gpu/ganesh/mock/GrMockBackendSurface.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef GrMockBackendSurface_DEFINED
+#define GrMockBackendSurface_DEFINED
+
+#include "include/gpu/ganesh/GrTypes.h"
+#include "include/gpu/ganesh/mock/GrMockTypes.h"
+#include "include/private/base/SkAPI.h"
+
+#include <string_view>
+
+class GrBackendFormat;
+class GrBackendTexture;
+class GrBackendRenderTarget;
+enum class SkTextureCompressionType;
+enum class GrColorType;
+
+namespace GrBackendFormats {
+
+SK_API GrBackendFormat MakeMockColorType(GrColorType colorType);
+SK_API GrBackendFormat MakeMockCompressionType(SkTextureCompressionType compression);
+SK_API GrBackendFormat MakeMockStencilFormat();
+
+// Only one of these getters will return a non-unknown, non-false value
+SK_API GrColorType AsMockColorType(const GrBackendFormat&);
+SK_API SkTextureCompressionType AsMockCompressionType(const GrBackendFormat&);
+SK_API bool IsMockStencilFormat(const GrBackendFormat&);
+
+}  // namespace GrBackendFormats
+
+namespace GrBackendTextures {
+
+SK_API GrBackendTexture MakeMock(int width,
+                                 int height,
+                                 skgpu::Mipmapped,
+                                 const GrMockTextureInfo& mockInfo,
+                                 std::string_view label = {});
+
+SK_API GrMockTextureInfo GetMockTextureInfo(const GrBackendTexture&);
+
+}  // namespace GrBackendTextures
+
+namespace GrBackendRenderTargets {
+
+SK_API GrBackendRenderTarget MakeMock(int width,
+                                      int height,
+                                      int sampleCnt,
+                                      int stencilBits,
+                                      const GrMockRenderTargetInfo& mockInfo);
+
+SK_API GrMockRenderTargetInfo GetMockRenderTargetInfo(const GrBackendRenderTarget&);
+
+}  // namespace GrBackendRenderTargets
+
+#endif

package/cpp/skia/include/gpu/ganesh/mock/GrMockTypes.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Google Inc.
+ * Copyright 2017 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/ganesh/mtl/GrMtlBackendContext.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 Google Inc.
+ * Copyright 2020 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/ganesh/mtl/GrMtlTypes.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Google Inc.
+ * Copyright 2017 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/ganesh/vk/GrBackendDrawableInfo.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 Google Inc.
+ * Copyright 2018 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/graphite/Context.h

@@ -61,6 +61,7 @@ class QueueManager;
 class ResourceProvider;
 class SharedContext;
 class TextureProxy;
+class TextureProxyView;
 
 class SK_API Context final {
 public:
@@ -87,6 +88,9 @@ public:
     /** Returns true if there is work that was submitted to the GPU that has not finished. */
     bool hasUnfinishedGpuWork() const;
 
+    /** Returns true if there is pending GPU work that needs to be submitted. */
+    bool hasPendingGPUWork() const;
+
     /** Makes image pixel data available to caller, possibly asynchronously. It can also rescale
         the image pixels.
 
@@ -226,9 +230,12 @@ public:
     /**
      * Purge GPU resources on the Context that haven't been used in the past 'msNotUsed'
      * milliseconds or are otherwise marked for deletion, regardless of whether the context is under
-     * budget.
+     * budget. Optionally provide a `microsMaxPurgingDur` after which Skia should stop purging
+     * resources.
      */
-    void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
+    void performDeferredCleanup(
+            std::chrono::milliseconds msNotUsed,
+            std::optional<std::chrono::microseconds> microsMaxPurgingDur = std::nullopt);
 
     /**
      * Returns the number of bytes of the Context's gpu memory cache budget that are currently in
@@ -382,14 +389,14 @@ private:
     // Like asyncReadPixels() except it performs no fallbacks, and requires that the texture be
     // readable. However, the texture does not need to be sampleable.
     void asyncReadTexture(std::unique_ptr<Recorder>,
-                          const AsyncParams<TextureProxy>&,
+                          const AsyncParams<TextureProxyView>&,
                           const SkColorInfo& srcColorInfo);
 
     // Inserts a texture to buffer transfer task, used by asyncReadPixels methods. If the
     // Recorder is non-null, tasks will be added to the Recorder's list; otherwise the transfer
     // tasks will be added to the queue manager directly.
     PixelTransferResult transferPixels(Recorder*,
-                                       const TextureProxy* srcProxy,
+                                       const TextureProxyView& srcView,
                                        const SkColorInfo& srcColorInfo,
                                        const SkColorInfo& dstColorInfo,
                                        const SkIRect& srcRect);
@@ -403,8 +410,8 @@ private:
 
     sk_sp<SharedContext> fSharedContext;
     std::unique_ptr<ResourceProvider> fResourceProvider;
-    std::unique_ptr<QueueManager> fQueueManager;
     std::unique_ptr<ClientMappedBufferManager> fMappedBufferManager;
+    std::unique_ptr<QueueManager> fQueueManager;
     std::unique_ptr<const skcpu::ContextImpl> fCPUContext;
 
     PersistentPipelineStorage* fPersistentPipelineStorage;

package/cpp/skia/include/gpu/graphite/GraphiteTypes.h

@@ -190,6 +190,12 @@ struct SubmitInfo {
     MarkFrameBoundary fMarkBoundary = MarkFrameBoundary::kNo;
     uint64_t fFrameID = 0;
 
+    // Optional finish proc that is invoked when all GPU work submitted by this call has
+    // completed. If there is no pending work to submit, the proc is attached to the most
+    // recently outstanding GPU submission, or invoked immediately if the GPU is idle.
+    GpuFinishedProc fFinishedProc = nullptr;
+    GpuFinishedContext fFinishedContext = nullptr;
+
     constexpr SubmitInfo() = default;
 
     constexpr SubmitInfo(SyncToCpu sync)

package/cpp/skia/include/gpu/graphite/Image.h

@@ -52,18 +52,56 @@ using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureRelease
 /** Creates an SkImage from a GPU texture associated with the recorder. The client is still
     responsible for managing the backend texture's lifetime.
 
-    SkImage is returned if the format of backendTexture is recognized and supported.
-    Recognized formats vary by GPU back-end.
+    SkImage is returned if the format of backendTexture is recognized and supported. Recognized
+    formats vary by GPU back-end.
+
+    The provided `alphaType` determines how the wrapped texture is sampled:
+     - kUnknown_SkAlphaType:  Sampled as RGB1, ignoring any alpha data. G and B are automatically
+                              treated as 0 if the format does not provide them. Single channel
+                              texture formats are interpretd as the "red" SkColorTypes instead of
+                              the "alpha-only" SkColorTypes.
+     - kOpaque_SkAlphaType:   Sampled as RGBA but higher-level logic *assumes* that all A values are
+                              equal to 1. Single channel texture formats are interpeted as "red"
+                              instead of "alpha-only" for disambiguating SkColorTypes.
+     - kPremul_SkAlphaType:   Sampled as RGBA and higher-level logic assumes the RGB values have
+                              been premultiplied with the A value. Single channel texture formats
+                              are interpreted as "alpha-only" color types (e.g. 000A or 000R
+                              swizzles depending on the texture format).
+     - kUnpremul_SkAlphaType: Sampled as RGBA and higher-level logic assumes the RGB values have not
+                              been multiplied with A yet. Single channel texture formats are
+                              interpreted as "alpha-only" color types the same as
+                              kPremul_SkAlphaType.
+
+    The SkColorType of the returned SkImage is selected to best match the bit depth and
+    representation of the texture format of the backend texture. This is not necessarily an exact
+    match since texture formats may have more options than SkColorType. Any mismatch between the
+    format and the SkColorType is handled automatically for read/write operations on the image (the
+    SkColorType represents how the image data will be made available on the CPU).
+
+    If possible, the color type will also take into account the behavior of `alphaType`, such as
+    using kRGB_888x_SkColorType for an RGBA8 texture with kUnknown_SkAlphaType. For single-channel
+    textures with kUnknown|kOpaque_SkAlphaType, the best "red-only" color type is chosen, e.g.
+    kR8_unorm_SkColorType. For single-channel textures with kPremul|kUnpremul_SkAlphaType, the best
+    "alpha-only" color type is chosen, e.g. kAlpha_8_SkColorType. This preserves the semantic
+    behaviors in Skia's high-level shading logic that treats red formats as color data, and
+    automatically colorizes alpha formats based on the paint's color or shader.
+
+    When using such a single-channel texture in a runtime effect, this semantic distinction defines
+    which channel of the float4 shader value has the interesting data (R001 vs 000A). When combining
+    multiple single-channel textures into a multiplaner YUV[A] SkImage, either colortype behaves the
+    same. The most significant distinction occurs when the SkImage is used in
+    SkCanvas::drawImageRect() or combined into a non-runtime SkShader.
 
     @param recorder                The recorder
     @param backendTexture          texture residing on GPU
-    @param colorSpace              This describes the color space of this image's contents, as
-                                   seen after sampling. In general, if the format of the backend
-                                   texture is SRGB, some linear colorSpace should be supplied
-                                   (e.g., SkColorSpace::MakeSRGBLinear()). If the format of the
-                                   backend texture is linear, then the colorSpace should include
-                                   a description of the transfer function as
-                                   well (e.g., SkColorSpace::MakeSRGB()).
+    @param alphaType               The nature of alpha channel data provided in the texture.
+    @param colorSpace              This describes the color space of this image's contents, as seen
+                                   after sampling. In general, if the format of the backend texture
+                                   is SRGB, some linear colorSpace should be supplied (e.g.,
+                                   SkColorSpace::MakeSRGBLinear()). If the format of the backend
+                                   texture is linear, then the colorSpace should include a
+                                   description of the transfer function as well (e.g.,
+                                   SkColorSpace::MakeSRGB()).
     @param origin                  Whether the Texture logically treats the origin as TopLeft or
                                    BottomLeft
     @param generateMipmapsFromBase If kYes then the pixel contents of the textures upper mipmap
@@ -74,6 +112,41 @@ using GraphitePromiseTextureReleaseProc = void (*)(GraphitePromiseTextureRelease
                                    valid.
     @return                        created SkImage, or nullptr
 */
+SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
+                                  const skgpu::graphite::BackendTexture&,
+                                  SkAlphaType alphaType,
+                                  sk_sp<SkColorSpace> colorSpace,
+                                  skgpu::Origin origin,
+                                  GenerateMipmapsFromBase genMipmaps,
+                                  TextureReleaseProc = nullptr,
+                                  ReleaseContext = nullptr,
+                                  std::string_view label = {});
+
+SK_API inline sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder* recorder,
+                                         const skgpu::graphite::BackendTexture& backendTex,
+                                         SkAlphaType alphaType,
+                                         sk_sp<SkColorSpace> colorSpace,
+                                         skgpu::Origin origin,
+                                         TextureReleaseProc releaseP = nullptr,
+                                         ReleaseContext releaseC = nullptr,
+                                         std::string_view label = {}) {
+    return WrapTexture(recorder, backendTex, alphaType, std::move(colorSpace), origin,
+                       GenerateMipmapsFromBase::kNo, releaseP, releaseC, label);
+}
+
+SK_API inline sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder* recorder,
+                                         const skgpu::graphite::BackendTexture& backendTex,
+                                         SkAlphaType alphaType,
+                                         sk_sp<SkColorSpace> colorSpace,
+                                         TextureReleaseProc releaseP = nullptr,
+                                         ReleaseContext releaseC = nullptr,
+                                         std::string_view label = {}) {
+    return WrapTexture(recorder, backendTex, alphaType, std::move(colorSpace),
+                       skgpu::Origin::kTopLeft, releaseP, releaseC, label);
+}
+
+// DEPRECATED: The WrapTexture calls that take an SkColorType are deprecated. Use the new versions
+// that automatically pick a compatible color type from the texture's format.
 SK_API sk_sp<SkImage> WrapTexture(skgpu::graphite::Recorder*,
                                   const skgpu::graphite::BackendTexture&,
                                   SkColorType colorType,

package/cpp/skia/include/gpu/graphite/PrecompileContext.h

@@ -63,12 +63,17 @@ public:
     bool precompile(sk_sp<SkData> serializedPipelineKey);
 
     /**
-     * Get a human-readable version of a serialized pipeline key.
+     * Get a human-readable version of a serialized pipeline key and, optionally, the unique
+     * hash of the Pipeline.
      *
      * @param serializedPipelineKey   serialized Pipeline key.
+     * @param uniqueHash              If non-null, this will be filled in with the unique hash.
+     *                                Note that the uniqueHash is only valid for the lifetime
+     *                                of the Context used to create this PrecompileContext.
      * @return                        A human-readable version of the provided key; "" on failure.
      */
-    std::string getPipelineLabel(sk_sp<SkData> serializedPipelineKey);
+    std::string getPipelineLabel(sk_sp<SkData> serializedPipelineKey,
+                                 uint32_t* uniqueHash = nullptr);
 
     // Provides access to functions that aren't part of the public API.
     PrecompileContextPriv priv();

package/cpp/skia/include/gpu/graphite/Recorder.h

@@ -17,7 +17,6 @@
 #include "include/private/base/SingleOwner.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkTArray.h"
-#include "include/private/base/SkTDArray.h"
 
 #include <chrono>
 #include <cstddef>
@@ -210,9 +209,12 @@ public:
     /**
      * Purge GPU resources on the Recorder that haven't been used in the past 'msNotUsed'
      * milliseconds or are otherwise marked for deletion, regardless of whether the context is under
-     * budget.
+     * budget. Optionally provide a `microsMaxPurgingDur` after which Skia should stop purging
+     * resources.
      */
-    void performDeferredCleanup(std::chrono::milliseconds msNotUsed);
+    void performDeferredCleanup(
+            std::chrono::milliseconds msNotUsed,
+            std::optional<std::chrono::microseconds> microsMaxPurgingDur = std::nullopt);
 
     /**
      * Returns the number of bytes of the Recorder's gpu memory cache budget that are currently in
@@ -281,7 +283,7 @@ private:
     void deregisterDevice(const Device*);
 
     SkCanvas* makeCaptureCanvas(SkCanvas*) override;
-    void createCaptureBreakpoint(SkSurface*) override;
+    SkContentID createCaptureBreakpoint(SkSurface*) override;
 
     sk_sp<SharedContext> fSharedContext;
     ResourceProvider* fResourceProvider; // May point to the Context's resource provider

package/cpp/skia/include/gpu/graphite/precompile/PrecompileColorFilter.h

@@ -14,6 +14,8 @@ enum class SkBlendMode;
 
 namespace skgpu::graphite {
 
+class PrecompileColorFilterPriv;
+
 /** \class PrecompileColorFilter
     This class corresponds to the SkColorFilter class in the main API.
 */
@@ -36,9 +38,17 @@ public:
      */
     sk_sp<PrecompileColorFilter> makeComposed(sk_sp<PrecompileColorFilter> inner) const;
 
+    // Provides access to functions that aren't part of the public API.
+    PrecompileColorFilterPriv priv();
+    const PrecompileColorFilterPriv priv() const;  // NOLINT(readability-const-return-type)
+
 protected:
+    friend class PrecompileColorFilterPriv;
+
     PrecompileColorFilter() : PrecompileBase(Type::kColorFilter) {}
     ~PrecompileColorFilter() override;
+
+    virtual bool isAlphaUnchanged(int /*desiredCombination*/) const = 0;
 };
 
 //--------------------------------------------------------------------------------------------------
@@ -54,7 +64,7 @@ namespace PrecompileColorFilters {
     SK_API sk_sp<PrecompileColorFilter> Blend(); // Prefer the explicit blend mode variant
 
     // This encompasses both variants of SkColorFilters::Matrix
-    SK_API sk_sp<PrecompileColorFilter> Matrix();
+    SK_API sk_sp<PrecompileColorFilter> Matrix(bool clamp=true);
 
     // This encompasses both variants of SkColorFilters::HSLAMatrix
     SK_API sk_sp<PrecompileColorFilter> HSLAMatrix();

package/cpp/skia/include/gpu/graphite/precompile/PrecompileShader.h

@@ -86,6 +86,7 @@ protected:
     ~PrecompileShader() override;
 
     virtual bool isConstant(int /* desiredCombination */) const { return false; }
+    virtual bool isOpaque(int /* desiredCombination */) const = 0;
 
     virtual bool isALocalMatrixShader() const { return false; }
 };

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteTypes.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC.
+ * Copyright 2022 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/mtl/MtlMemoryAllocator.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google Inc.
+ * Copyright 2022 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/vk/VulkanExtensions.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC.
+ * Copyright 2022 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/vk/VulkanMemoryAllocator.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC.
+ * Copyright 2022 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/gpu/vk/VulkanTypes.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 Google LLC.
+ * Copyright 2022 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/ports/SkCFObject.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 Google Inc.
+ * Copyright 2019 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/ports/SkFontMgr_Fontations.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Google Inc.
+ * Copyright 2024 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/ports/SkFontMgr_android_ndk.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2024 Google LLC.
+ * Copyright 2024 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/ports/SkFontMgr_data.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2023 Google Inc.
+ * Copyright 2023 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/ports/SkFontMgr_fuchsia.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 Google Inc.
+ * Copyright 2018 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.

package/cpp/skia/include/ports/SkFontMgr_mac_ct.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 Google Inc.
+ * Copyright 2017 Google LLC
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.