@shopify/react-native-skia 2.6.5 → 2.6.6

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.

package/cpp/skia/include/ports/SkFontScanner_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/SkFontScanner_FreeType.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/SkTypeface_fontations.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/private/SkExif.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/private/SkGainmapInfo.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/private/SkGainmapShader.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/private/SkHdrMetadata.h

@@ -12,6 +12,8 @@
 #include "include/core/SkData.h"
 #include "include/private/base/SkAPI.h"
 
+#include <algorithm>
+#include <cmath>
 #include <memory>
 #include <optional>
 #include <vector>
@@ -54,6 +56,20 @@ struct SK_API ContentLightLevelInformation {
      */
     sk_sp<SkData> serialize() const;
 
+    /**
+     * Helper functions for accessing members as uint16_t, which is often needed when interacting
+     * with libraries using the CTA semantics.
+     */
+    static ContentLightLevelInformation MakeUint16(uint16_t maxCLL, uint16_t maxFALL) {
+        return { .fMaxCLL = static_cast<float>(maxCLL), .fMaxFALL = static_cast<float>(maxFALL) };
+    }
+    uint16_t getUint16MaxCLL() const {
+        return static_cast<uint16_t>(std::clamp(std::round(fMaxCLL), 0.f, 65535.f));
+    }
+    uint16_t getUint16MaxFALL() const {
+        return static_cast<uint16_t>(std::clamp(std::round(fMaxFALL), 0.f, 65535.f));
+    }
+
     /**
      * Decode from the binary encoding listed at:
      *   Portable Network Graphics (PNG) Specification (Third Edition)
@@ -242,6 +258,11 @@ struct SK_API AdaptiveGlobalToneMap {
      */
     SkString toString() const;
 
+    /**
+     * Return true if this metadata satisfies all normative constraints.
+     */
+    bool isValid() const;
+
     bool operator==(const AdaptiveGlobalToneMap& other) const {
         return fHdrReferenceWhite == other.fHdrReferenceWhite &&
                fHeadroomAdaptiveToneMap == other.fHeadroomAdaptiveToneMap;

package/cpp/skia/include/private/SkJpegGainmapEncoder.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/private/SkPixelStorage.h

@@ -0,0 +1,37 @@
+/*
+ * 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 SkPixelStorage_DEFINED
+#define SkPixelStorage_DEFINED
+
+#include <cstdint>
+
+/**
+ * SkPixelStorage is the class representing the storage block for pixel data. It serves as the
+ * abstract source of pixel memory—the 2D array of data—that is read from and written to by
+ * higher-level Skia objects like SkImage and SkSurface.
+ */
+class SkPixelStorage {
+public:
+    SkPixelStorage();
+    virtual ~SkPixelStorage() = default;
+
+    enum Type {
+        kTextureProxy,
+        kPixelRef,
+    };
+
+    uint32_t getPixelStorageId() const { return fID; }
+    virtual Type type() const = 0;
+
+private:
+    uint32_t fID;
+
+    static uint32_t NextId();
+};
+
+#endif

package/cpp/skia/include/private/SkXmp.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/private/base/SkAssert.h

@@ -11,6 +11,7 @@
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkAttributes.h"
 #include "include/private/base/SkDebug.h" // IWYU pragma: keep
+#include "include/private/base/SkLog.h"
 
 #include <cstddef>
 #include <limits>
@@ -69,7 +70,7 @@
 #  endif
 #  define SK_ABORT(message, ...) \
     do { \
-        SkDebugf(SK_DUMP_LINE_FORMAT ": fatal error: \"" message "\"\n", \
+        SKIA_LOG_E(SK_DUMP_LINE_FORMAT ": fatal error: \"" message "\"", \
                  __FILE__, __LINE__, ##__VA_ARGS__); \
         SK_DUMP_GOOGLE3_STACK(); \
         sk_abort_no_print(); \
@@ -137,7 +138,7 @@
 #endif
 
 [[noreturn]] SK_API inline void sk_print_index_out_of_bounds(size_t i, size_t size) {
-    SK_ABORT("Index (%zu) out of bounds for size %zu.\n", i, size);
+    SK_ABORT("Index (%zu) out of bounds for size %zu.", i, size);
 }
 
 template <typename T> SK_API inline T sk_collection_check_bounds(T i, T size) {
@@ -155,7 +156,7 @@ template <typename T> SK_API inline T sk_collection_check_bounds(T i, T size) {
 }
 
 [[noreturn]] SK_API inline void sk_print_length_too_big(size_t i, size_t size) {
-    SK_ABORT("Length (%zu) is too big for size %zu.\n", i, size);
+    SK_ABORT("Length (%zu) is too big for size %zu.", i, size);
 }
 
 template <typename T> SK_API inline T sk_collection_check_length(T i, T size) {
@@ -175,7 +176,7 @@ template <typename T> SK_API inline T sk_collection_check_length(T i, T size) {
 SK_API inline void sk_collection_not_empty(bool empty) {
     if (empty) SK_UNLIKELY {
         #if defined(SK_DEBUG)
-            SK_ABORT("Collection is empty.\n");
+            SK_ABORT("Collection is empty.");
         #else
             SkUNREACHABLE;
         #endif
@@ -183,7 +184,7 @@ SK_API inline void sk_collection_not_empty(bool empty) {
 }
 
 [[noreturn]] SK_API inline void sk_print_size_too_big(size_t size, size_t maxSize) {
-    SK_ABORT("Size (%zu) can't be represented in bytes. Max size is %zu.\n", size, maxSize);
+    SK_ABORT("Size (%zu) can't be represented in bytes. Max size is %zu.", size, maxSize);
 }
 
 template <typename T>

package/cpp/skia/include/private/base/SkContainers.h

@@ -1,4 +1,4 @@
-// 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.
 
 #ifndef SkContainers_DEFINED

package/cpp/skia/include/private/base/SkFeatures.h

@@ -78,20 +78,20 @@
 #endif
 
 /**
- *  SK_CPU_SSE_LEVEL
+ *  SK_CPU_X64_LEVEL
  *
- *  If defined, SK_CPU_SSE_LEVEL should be set to the highest supported level.
- *  On non-intel CPU this should be undefined.
+ *  If defined, SK_CPU_X64_LEVEL should be set to the highest supported level.
+ *  On non-Intel, non-AMD CPUs this should be undefined.
  */
-#define SK_CPU_SSE_LEVEL_SSE1     10
-#define SK_CPU_SSE_LEVEL_SSE2     20
-#define SK_CPU_SSE_LEVEL_SSE3     30
-#define SK_CPU_SSE_LEVEL_SSSE3    31
-#define SK_CPU_SSE_LEVEL_SSE41    41
-#define SK_CPU_SSE_LEVEL_SSE42    42
-#define SK_CPU_SSE_LEVEL_AVX      51
-#define SK_CPU_SSE_LEVEL_AVX2     52
-#define SK_CPU_SSE_LEVEL_SKX      60
+#define SK_CPU_X64_LEVEL_SSE1     10
+#define SK_CPU_X64_LEVEL_SSE2     20
+#define SK_CPU_X64_LEVEL_SSE3     30
+#define SK_CPU_X64_LEVEL_SSSE3    31
+#define SK_CPU_X64_LEVEL_SSE41    41
+#define SK_CPU_X64_LEVEL_SSE42    42
+#define SK_CPU_X64_LEVEL_AVX      51
+#define SK_CPU_X64_LEVEL_AVX2     52
+#define SK_CPU_X64_LEVEL_ML4      60
 
 /**
  *  SK_CPU_LSX_LEVEL
@@ -99,32 +99,32 @@
  *  If defined, SK_CPU_LSX_LEVEL should be set to the highest supported level.
  *  On non-loongarch CPU this should be undefined.
  */
-#define SK_CPU_LSX_LEVEL_LSX      70
-#define SK_CPU_LSX_LEVEL_LASX     80
+#define SK_CPU_LSX_LEVEL_LSX      10
+#define SK_CPU_LSX_LEVEL_LASX     20
 
 // TODO(kjlubick) clean up these checks
 
 // Are we in GCC/Clang?
-#ifndef SK_CPU_SSE_LEVEL
+#ifndef SK_CPU_X64_LEVEL
     // These checks must be done in descending order to ensure we set the highest
     // available SSE level.
     #if defined(__AVX512F__) && defined(__AVX512DQ__) && defined(__AVX512CD__) && \
         defined(__AVX512BW__) && defined(__AVX512VL__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SKX
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_ML4
     #elif defined(__AVX2__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_AVX2
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_AVX2
     #elif defined(__AVX__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_AVX
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_AVX
     #elif defined(__SSE4_2__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE42
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE42
     #elif defined(__SSE4_1__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE41
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE41
     #elif defined(__SSSE3__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSSE3
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSSE3
     #elif defined(__SSE3__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE3
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE3
     #elif defined(__SSE2__)
-        #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE2
+        #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE2
     #endif
 #endif
 
@@ -137,23 +137,23 @@
 #endif
 
 // Are we in VisualStudio?
-#ifndef SK_CPU_SSE_LEVEL
+#ifndef SK_CPU_X64_LEVEL
     // These checks must be done in descending order to ensure we set the highest
     // available SSE level. 64-bit intel guarantees at least SSE2 support.
     #if defined(__AVX512F__) && defined(__AVX512DQ__) && defined(__AVX512CD__) && \
         defined(__AVX512BW__) && defined(__AVX512VL__)
-        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_SKX
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_ML4
     #elif defined(__AVX2__)
-        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_AVX2
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_AVX2
     #elif defined(__AVX__)
-        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_AVX
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_AVX
     #elif defined(_M_X64) || defined(_M_AMD64)
-        #define SK_CPU_SSE_LEVEL        SK_CPU_SSE_LEVEL_SSE2
+        #define SK_CPU_X64_LEVEL        SK_CPU_X64_LEVEL_SSE2
     #elif defined(_M_IX86_FP)
         #if _M_IX86_FP >= 2
-            #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE2
+            #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE2
         #elif _M_IX86_FP == 1
-            #define SK_CPU_SSE_LEVEL    SK_CPU_SSE_LEVEL_SSE1
+            #define SK_CPU_X64_LEVEL    SK_CPU_X64_LEVEL_SSE1
         #endif
     #endif
 #endif

package/cpp/skia/include/private/base/SkLog.h

@@ -50,16 +50,10 @@ void SK_SPI SkLog(SkLogPriority priority, const char format[], ...) SK_PRINTF_LI
 #define SKIA_LOG(priority, fmt, ...)                                           \
     do {                                                                       \
         if constexpr (priority <= SKIA_LOWEST_ACTIVE_LOG_PRIORITY) {           \
-            if constexpr (priority == SkLogPriority::kFatal) {                 \
-                SK_ABORT("[skia] " fmt, ##__VA_ARGS__);                        \
-            }                                                                  \
-            else {                                                             \
-                SkLog(priority, "[skia] " fmt "\n", ##__VA_ARGS__);            \
-            }                                                                  \
+            SkLog(priority, "[skia] " fmt "\n", ##__VA_ARGS__);                \
         }                                                                      \
     } while (0)
 
-#define SKIA_LOG_F(fmt, ...) SKIA_LOG(SkLogPriority::kFatal, "** ERROR ** " fmt, ##__VA_ARGS__)
 #define SKIA_LOG_E(fmt, ...) SKIA_LOG(SkLogPriority::kError, "** ERROR ** " fmt, ##__VA_ARGS__)
 #define SKIA_LOG_W(fmt, ...) SKIA_LOG(SkLogPriority::kWarning, "WARNING - " fmt, ##__VA_ARGS__)
 #define SKIA_LOG_I(fmt, ...) SKIA_LOG(SkLogPriority::kInfo, fmt, ##__VA_ARGS__)

package/cpp/skia/include/private/base/SkLogPriority.h

@@ -25,11 +25,10 @@
  * However, debug logs would be omitted.
  */
 enum class SkLogPriority : int {
-    kFatal = 0,
-    kError = 1,
-    kWarning = 2,
-    kInfo = 3,
-    kDebug = 4,
+    kError = 0,
+    kWarning = 1,
+    kInfo = 2,
+    kDebug = 3,
 };
 
 #endif // SkLogPriority_DEFINED