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

package/cpp/rnwgpu/api/descriptors/GPUExternalTextureDescriptor.h

@@ -1,26 +1,36 @@
 #pragma once
 
+#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
-#include <variant>
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Convertors.h"
-
 #include "jsi2/JSIConverter.h"
 
 namespace jsi = facebook::jsi;
 
 namespace rnwgpu {
 
+// Mirror of GPUExternalTextureDescriptor from the WebGPU spec, adapted to
+// Skia's binding. Skia has no VideoFrame; instead `source` is a native buffer
+// pointer (the BigInt returned by Skia.NativeBuffer.MakeFromImage): a
+// CVPixelBufferRef on Apple, an AHardwareBuffer* on Android. The pointer's
+// lifetime is owned by the caller (Skia.NativeBuffer.Release); the imported
+// texture must not outlive it.
+//
+// We don't expose colorSpace yet; the C++ side picks dst-sRGB and identity
+// gamut, the right default for "render this BGRA frame to an sRGB framebuffer".
+//
+// `rotation` / `mirrored` are a non-spec extension baked into Dawn's sampling
+// transform. `rotation` is in degrees and must be one of 0 / 90 / 180 / 270.
 struct GPUExternalTextureDescriptor {
-  // std::variant<std::shared_ptr<HTMLVideoElement>,
-  // std::shared_ptr<VideoFrame>>
-  //     source; // | HTMLVideoElement | VideoFrame
-  // std::optional<wgpu::DefinedColorSpace> colorSpace; // PredefinedColorSpace
-  std::optional<std::string> label; // string
+  // native buffer pointer (CVPixelBufferRef / AHardwareBuffer*)
+  uint64_t source = 0;
+  std::optional<std::string> label;
+  std::optional<double> rotation;
+  std::optional<bool> mirrored;
 };
 
 } // namespace rnwgpu
@@ -31,23 +41,21 @@ template <>
 struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
   static std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>
   fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
-    auto result = std::make_unique<rnwgpu::GPUExternalTextureDescriptor>();
+    auto result = std::make_shared<rnwgpu::GPUExternalTextureDescriptor>();
     if (!outOfBounds && arg.isObject()) {
       auto value = arg.getObject(runtime);
       if (value.hasProperty(runtime, "source")) {
         auto prop = value.getProperty(runtime, "source");
-        // result->source = JSIConverter<
-        //     std::variant<std::shared_ptr<HTMLVideoElement>,
-        //                  std::shared_ptr<VideoFrame>>>::fromJSI(runtime,
-        //                  prop,
-        //                                                         false);
-      }
-      if (value.hasProperty(runtime, "colorSpace")) {
-        auto prop = value.getProperty(runtime, "colorSpace");
-        if (!prop.isUndefined()) {
-          // result->colorSpace =
-          //     JSIConverter<std::optional<wgpu::definedColorSpace>>::fromJSI(
-          //         runtime, prop, false);
+        // The native buffer pointer arrives as a BigInt (uintptr_t value). It
+        // must be a BigInt: a JS number can't represent a 64-bit pointer
+        // without truncation, so we reject it rather than corrupt the address.
+        if (prop.isBigInt()) {
+          result->source = prop.asBigInt(runtime).asUint64(runtime);
+        } else if (!prop.isUndefined() && !prop.isNull()) {
+          throw jsi::JSError(
+              runtime, "GPUExternalTextureDescriptor.source must be a "
+                       "NativeBuffer (BigInt) from "
+                       "Skia.NativeBuffer.MakeFromImage / MakeTestBuffer");
         }
       }
       if (value.hasProperty(runtime, "label")) {
@@ -57,13 +65,24 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor>> {
               runtime, prop, false);
         }
       }
+      if (value.hasProperty(runtime, "rotation")) {
+        auto prop = value.getProperty(runtime, "rotation");
+        if (prop.isNumber()) {
+          result->rotation = prop.asNumber();
+        }
+      }
+      if (value.hasProperty(runtime, "mirrored")) {
+        auto prop = value.getProperty(runtime, "mirrored");
+        if (prop.isBool()) {
+          result->mirrored = prop.getBool();
+        }
+      }
     }
-
     return result;
   }
   static jsi::Value
-  toJSI(jsi::Runtime &runtime,
-        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> arg) {
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUExternalTextureDescriptor> /*arg*/) {
     throw std::runtime_error("Invalid GPUExternalTextureDescriptor::toJSI()");
   }
 };

package/cpp/rnwgpu/api/descriptors/GPUImageCopyExternalImage.h

@@ -7,17 +7,18 @@
 
 #include "webgpu/webgpu_cpp.h"
 
-#include "Convertors.h"
+#include "rnwgpu/api/Convertors.h"
 #include "jsi2/JSIConverter.h"
 
-#include "GPUOrigin2D.h"
+#include "rnwgpu/api/GPUOrigin2D.h"
+#include "rnwgpu/api/ImageBitmap.h"
 
 namespace jsi = facebook::jsi;
 
 namespace rnwgpu {
 
 struct GPUImageCopyExternalImage {
-  // std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
+  std::shared_ptr<ImageBitmap> source; // GPUImageCopyExternalImageSource
   std::optional<std::shared_ptr<GPUOrigin2D>> origin; // GPUOrigin2DStrict
   std::optional<bool> flipY;                          // boolean
 };
@@ -33,12 +34,11 @@ struct JSIConverter<std::shared_ptr<rnwgpu::GPUImageCopyExternalImage>> {
     auto result = std::make_unique<rnwgpu::GPUImageCopyExternalImage>();
     if (!outOfBounds && arg.isObject()) {
       auto obj = arg.getObject(runtime);
-      //      if (obj.hasProperty(runtime, "source")) {
-      //        auto prop = obj.getProperty(runtime, "source");
-      //        result->source =
-      //        JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
-      //            runtime, prop, false);
-      //      }
+      if (obj.hasProperty(runtime, "source")) {
+        auto prop = obj.getProperty(runtime, "source");
+        result->source = JSIConverter<std::shared_ptr<ImageBitmap>>::fromJSI(
+            runtime, prop, false);
+      }
       if (obj.hasProperty(runtime, "origin")) {
         auto prop = obj.getProperty(runtime, "origin");
         result->origin = JSIConverter<std::shared_ptr<GPUOrigin2D>>::fromJSI(

package/cpp/rnwgpu/api/descriptors/GPUImageCopyTexture.h

@@ -6,7 +6,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUOrigin3D.h"
+#include "rnwgpu/api/GPUOrigin3D.h"
 #include "rnwgpu/api/GPUTexture.h"
 
 namespace jsi = facebook::jsi;

package/cpp/rnwgpu/api/descriptors/GPUImageCopyTextureTagged.h

@@ -6,8 +6,8 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "External.h"
-#include "GPUOrigin3D.h"
+#include "rnwgpu/api/External.h"
+#include "rnwgpu/api/GPUOrigin3D.h"
 #include "rnwgpu/api/GPUTexture.h"
 
 namespace jsi = facebook::jsi;

package/cpp/rnwgpu/api/descriptors/GPUSharedFenceDescriptor.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Descriptor for GPUDevice.importSharedFence. `handle` is the native handle
+// (an id<MTLSharedEvent> pointer on Apple, an OS file descriptor on Android),
+// passed from JS as a BigInt.
+struct GPUSharedFenceDescriptor {
+  std::string type;
+  void *handle = nullptr;
+  std::optional<std::string> label;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUSharedFenceDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "type")) {
+        result->type =
+            value.getProperty(runtime, "type").asString(runtime).utf8(runtime);
+      }
+      if (value.hasProperty(runtime, "handle")) {
+        auto prop = value.getProperty(runtime, "handle");
+        result->handle = JSIConverter<void *>::fromJSI(runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+            runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUSharedFenceDescriptor> /*arg*/) {
+    throw std::runtime_error("Invalid GPUSharedFenceDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUSharedFenceState.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+#include "rnwgpu/api/GPUSharedFence.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// A fence and the timeline value to wait for / signal at.
+struct GPUSharedFenceState {
+  std::shared_ptr<GPUSharedFence> fence;
+  uint64_t signaledValue = 0;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <> struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedFenceState>> {
+  static std::shared_ptr<rnwgpu::GPUSharedFenceState>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_unique<rnwgpu::GPUSharedFenceState>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "fence")) {
+        auto prop = value.getProperty(runtime, "fence");
+        result->fence = JSIConverter<std::shared_ptr<GPUSharedFence>>::fromJSI(
+            runtime, prop, false);
+      }
+      if (value.hasProperty(runtime, "signaledValue")) {
+        auto prop = value.getProperty(runtime, "signaledValue");
+        result->signaledValue =
+            JSIConverter<uint64_t>::fromJSI(runtime, prop, false);
+      }
+    }
+    return result;
+  }
+  static jsi::Value toJSI(jsi::Runtime &runtime,
+                          std::shared_ptr<rnwgpu::GPUSharedFenceState> arg) {
+    throw std::runtime_error("Invalid GPUSharedFenceState::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUSharedTextureMemoryDescriptor.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+
+#include "webgpu/webgpu_cpp.h"
+
+#include "jsi2/JSIConverter.h"
+
+namespace jsi = facebook::jsi;
+
+namespace rnwgpu {
+
+// Descriptor for GPUDevice.importSharedTextureMemory.
+//
+// `handle` is a native buffer pointer as a uintptr_t (passed as a BigInt from
+// JS), i.e. the value returned by Skia.NativeBuffer.MakeFromImage:
+//   - Apple platforms: CVPixelBufferRef (its backing IOSurface is imported)
+//   - Android: AHardwareBuffer*
+//
+// Lifetime: the caller is responsible for keeping the underlying object alive
+// (via Skia.NativeBuffer.Release) for as long as this shared memory is in use.
+struct GPUSharedTextureMemoryDescriptor {
+  uint64_t handle = 0;
+  std::optional<std::string> label;
+};
+
+} // namespace rnwgpu
+
+namespace rnwgpu {
+
+template <>
+struct JSIConverter<std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>> {
+  static std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor>
+  fromJSI(jsi::Runtime &runtime, const jsi::Value &arg, bool outOfBounds) {
+    auto result = std::make_shared<rnwgpu::GPUSharedTextureMemoryDescriptor>();
+    if (!outOfBounds && arg.isObject()) {
+      auto value = arg.getObject(runtime);
+      if (value.hasProperty(runtime, "handle")) {
+        auto prop = value.getProperty(runtime, "handle");
+        // The native buffer pointer arrives as a BigInt (uintptr_t value). It
+        // must be a BigInt: a JS number can't represent a 64-bit pointer
+        // without truncation, so we reject it rather than corrupt the address.
+        if (prop.isBigInt()) {
+          result->handle = prop.asBigInt(runtime).asUint64(runtime);
+        } else if (!prop.isUndefined() && !prop.isNull()) {
+          throw jsi::JSError(
+              runtime, "GPUSharedTextureMemoryDescriptor.handle must be a "
+                       "NativeBuffer (BigInt) from "
+                       "Skia.NativeBuffer.MakeFromImage / MakeTestBuffer");
+        }
+      }
+      if (value.hasProperty(runtime, "label")) {
+        auto prop = value.getProperty(runtime, "label");
+        if (!prop.isUndefined()) {
+          result->label = JSIConverter<std::optional<std::string>>::fromJSI(
+              runtime, prop, false);
+        }
+      }
+    }
+    return result;
+  }
+  static jsi::Value
+  toJSI(jsi::Runtime & /*runtime*/,
+        std::shared_ptr<rnwgpu::GPUSharedTextureMemoryDescriptor> /*arg*/) {
+    throw std::runtime_error(
+        "Invalid GPUSharedTextureMemoryDescriptor::toJSI()");
+  }
+};
+
+} // namespace rnwgpu

package/cpp/rnwgpu/api/descriptors/GPUTextureDescriptor.h

@@ -8,7 +8,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUExtent3D.h"
+#include "rnwgpu/api/GPUExtent3D.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/rnwgpu/api/descriptors/GPUUncapturedErrorEventInit.h

@@ -6,7 +6,7 @@
 
 #include "jsi2/JSIConverter.h"
 
-#include "GPUError.h"
+#include "rnwgpu/api/GPUError.h"
 
 namespace jsi = facebook::jsi;
 

package/cpp/skia/include/android/GrAHardwareBufferUtils.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/android/SkAndroidFrameworkUtils.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/android/SkAnimatedImage.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/codec/SkCodec.h

@@ -834,14 +834,6 @@ public:
     };
     IsAnimated isAnimated() { return this->onIsAnimated(); }
 
-    // Register a decoder at runtime by passing two function pointers:
-    //    - peek() to return true if the span of bytes appears to be your encoded format;
-    //    - make() to attempt to create an SkCodec from the given stream.
-    // Not thread safe.
-    static void Register(
-            bool                     (*peek)(const void*, size_t),
-            std::unique_ptr<SkCodec> (*make)(std::unique_ptr<SkStream>, SkCodec::Result*));
-
 protected:
     const SkEncodedInfo& getEncodedInfo() const { return fEncodedInfo; }
 

package/cpp/skia/include/codec/SkEncodedOrigin.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/codec/SkPngRustDecoder.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/core/SkBitmap.h

@@ -27,7 +27,6 @@
 class SkColorSpace;
 class SkImage;
 class SkMatrix;
-class SkMipmap;
 class SkPaint;
 class SkPixelRef;
 class SkShader;
@@ -1241,13 +1240,8 @@ public:
     };
 
 private:
-    sk_sp<SkPixelRef>   fPixelRef;
-    SkPixmap            fPixmap;
-    sk_sp<SkMipmap>     fMips;
-
-    friend class SkImage_Raster;
-    friend class SkReadBuffer;        // unflatten
-    friend class GrProxyProvider;     // fMips
+    sk_sp<SkPixelRef> fPixelRef;
+    SkPixmap fPixmap;
 };
 
 ///////////////////////////////////////////////////////////////////////////////

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

@@ -8,11 +8,13 @@
 #ifndef skcpu_Recorder_DEFINED
 #define skcpu_Recorder_DEFINED
 
+#include <cstdint>
 #include "include/core/SkRecorder.h"
 #include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 
 class SkCanvas;
+class SkContentID;
 class SkSurface;
 class SkSurfaceProps;
 struct SkImageInfo;
@@ -57,7 +59,7 @@ public:
 private:
     // TODO (b/412351769): Implement this so we can capture from a CPU Recorder.
     SkCanvas* makeCaptureCanvas(SkCanvas*) final { return nullptr; }
-    void createCaptureBreakpoint(SkSurface*) final {}
+    SkContentID createCaptureBreakpoint(SkSurface*) final;
 };
 
 inline Recorder* AsRecorder(SkRecorder* recorder) {

package/cpp/skia/include/core/SkCanvasVirtualEnforcer.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/core/SkColorType.h

@@ -103,15 +103,17 @@ enum SkColorType : int {
     // Four channel RGBA data (32-bit float per channel) packed into a LE 128-bit word.
     //   Bits: [A:127..96 B:95..64 G:63..32 R:31..0]
     kRGBA_F32_SkColorType,
-
-    // The following 8 colortypes are just for reading from - not for rendering to
-
     // Two channel RG data (8 bits per channel). Blue is forced to 0, alpha is forced to opaque.
     //   Bits: [G:15..8 R:7..0]
     kR8G8_unorm_SkColorType,
     // Single channel data (16-bit half-float) interpreted as alpha. RGB are 0.
     //   Bits: [A:15..0]
     kA16_float_SkColorType,
+
+    // Single channel data (16 bits half-float) interpreted as red. G and B are forced to 0, alpha
+    // is forced to opaque.
+    //   Bits: [R:15..0]
+    kR16_float_SkColorType,
     // Two channel RG data (16-bit half-float per channel) packed into a LE 32-bit word.
     // Blue is forced to 0, alpha is forced to opaque.
     //   Bits: [G:31..16 R:15..0]

package/cpp/skia/include/core/SkContourMeasure.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/core/SkCoverageMode.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/core/SkCubicMap.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/core/SkExecutor.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/core/SkFont.h

@@ -26,6 +26,7 @@
 
 class SkMatrix;
 class SkPaint;
+class SkStrikeRef;
 enum class SkFontHinting;
 enum class SkTextEncoding;
 struct SkFontMetrics;
@@ -356,6 +357,20 @@ public:
     SkScalar measureText(const void* text, size_t byteLength, SkTextEncoding encoding,
                          SkRect* bounds, const SkPaint* paint) const;
 
+    /** Returns an SkStrikeRef for this font's current settings.
+
+        An SkStrikeRef caches the resolved strike (font metrics engine), avoiding the overhead
+        of descriptor construction, hashing, and global cache lookup on each glyph query.
+        This is useful when making many glyph metric calls (e.g. getWidths) with the same
+        font configuration.
+
+        The returned SkStrikeRef is independent of this SkFont; subsequent changes to this
+        SkFont do not affect it. Create a new SkStrikeRef after changing font properties.
+
+        @return  an SkStrikeRef for the current font settings
+    */
+    SkStrikeRef makeStrikeRef() const;
+
     /** Retrieves the advance and bounds for each glyph in glyphs.
         widths receives min(widths.size(), glyphs.size()) values.
         bounds receives min(bounds.size(), glyphs.size()) values.

package/cpp/skia/include/core/SkFontArguments.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.
@@ -19,6 +19,11 @@
 struct SkFontArguments {
     struct VariationPosition {
         struct Coordinate {
+            static constexpr SkFourByteTag wght = SkSetFourByteTag('w', 'g', 'h', 't');
+            static constexpr SkFourByteTag wdth = SkSetFourByteTag('w', 'd', 't', 'h');
+            static constexpr SkFourByteTag slnt = SkSetFourByteTag('s', 'l', 'n', 't');
+            static constexpr SkFourByteTag ital = SkSetFourByteTag('i', 't', 'a', 'l');
+            static constexpr SkFourByteTag opsz = SkSetFourByteTag('o', 'p', 's', 'z');
             SkFourByteTag axis;
             float value;
         };

package/cpp/skia/include/core/SkFontMetrics.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/core/SkFontMgr.h

@@ -8,7 +8,9 @@
 #ifndef SkFontMgr_DEFINED
 #define SkFontMgr_DEFINED
 
+#include "include/core/SkFontArguments.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 
 #include <memory>
@@ -18,7 +20,6 @@ class SkFontStyle;
 class SkStreamAsset;
 class SkString;
 class SkTypeface;
-struct SkFontArguments;
 
 class SK_API SkFontStyleSet : public SkRefCnt {
 public:
@@ -85,6 +86,38 @@ public:
                                                 const char* bcp47[], int bcp47Count,
                                                 SkUnichar character) const;
 
+    struct Request {
+        struct CMapEntry {
+            SkUnichar character;
+            SkUnichar variation;  // Zero for default variation.
+        };
+        SkSpan<const CMapEntry> cmapEntries;
+
+        /**
+         *  bcp47[0] is the least significant fallback, bcp47[bcp47Count-1] is the most significant.
+         *  If no specified bcp47 codes match any font with the requested character will be matched.
+         */
+        SkSpan<const char*> bcp47;
+
+        const char* familyName;
+
+        SkSpan<const SkFontArguments::VariationPosition::Coordinate> model;
+        SkFontStyle fontStyleFromModel() const;
+        static void SetModel(SkFontStyle s, SkFontArguments::VariationPosition::Coordinate(&m)[4]);
+
+        std::optional<bool> syntheticBold;
+        std::optional<bool> syntheticOblique;
+    };
+
+    /** The familyName must strongly match, everything else is tie breakers. */
+    sk_sp<SkTypeface> match(const Request&) const;
+
+    /**
+     * The first cmapEntry must match. Then matched by bcp47, then familyName,
+     * then model (italic, slant, width, weight), with synthetics allowed or not.
+     */
+    sk_sp<SkTypeface> fallback(const Request&) const;
+
     /**
      *  Create a typeface for the specified data and TTC index (pass 0 for none)
      *  or NULL if the data is not recognized. The caller must call unref() on
@@ -129,6 +162,8 @@ protected:
                                                           const SkFontStyle&,
                                                           const char* bcp47[], int bcp47Count,
                                                           SkUnichar character) const = 0;
+    virtual sk_sp<SkTypeface> onMatch(const Request&) const; // TODO: pure virtual
+    virtual sk_sp<SkTypeface> onFallback(const Request&) const; // TODO: pure virtual
 
     virtual sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData>, int ttcIndex) const = 0;
     virtual sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>,