@shopify/react-native-skia 0.1.234 → 0.1.236

package/cpp/api/JsiSkTypefaceFactory.h

@@ -17,7 +17,8 @@ class JsiSkTypefaceFactory : public JsiSkHostObject {
 public:
   JSI_HOST_FUNCTION(MakeFreeTypeFaceFromData) {
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
-    auto typeface = SkFontMgr::RefDefault()->makeFromData(std::move(data));
+    auto fontMgr = JsiSkFontMgrFactory::getFontMgr(getContext());
+    auto typeface = fontMgr->makeFromData(std::move(data));
     if (typeface == nullptr) {
       return jsi::Value::null();
     }

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef AHardwareBufferUtils_DEFINED
+#define AHardwareBufferUtils_DEFINED
+
+#include "include/core/SkColorType.h"
+#include "include/core/SkTypes.h"
+
+#if __ANDROID_API__ >= 26
+
+namespace AHardwareBufferUtils {
+
+SkColorType GetSkColorTypeFromBufferFormat(uint32_t bufferFormat);
+
+}  // namespace AHardwareBufferUtils
+
+#endif
+
+#endif // AHardwareBufferUtils_DEFINED

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

@@ -22,6 +22,8 @@ extern "C" {
 
 namespace GrAHardwareBufferUtils {
 
+// TODO: remove this function once Android has been updated to call the AHardwareBufferUtils
+// version
 SkColorType GetSkColorTypeFromBufferFormat(uint32_t bufferFormat);
 
 #if !defined(SK_DISABLE_LEGACY_ANDROID_HW_UTILS)

package/cpp/skia/include/android/graphite/SurfaceAndroid.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SurfaceAndroid_DEFINED
+#define SurfaceAndroid_DEFINED
+
+#include "include/core/SkRefCnt.h"
+
+struct AHardwareBuffer;
+class SkColorSpace;
+class SkSurface;
+class SkSurfaceProps;
+
+namespace skgpu::graphite {
+    class Recorder;
+}
+
+namespace SkSurfaces {
+
+using ReleaseContext = void*;
+using BufferReleaseProc = void (*)(ReleaseContext);
+
+/** Private; only to be used by Android Framework.
+    Creates an SkSurface from an Android hardware buffer.
+
+    Upon success bufferReleaseProc is called when it is safe to delete the buffer in the
+    backend API (accounting only for use of the buffer by this surface). If SkSurface creation
+    fails bufferReleaseProc is called before this function returns.
+
+    Currently this is only supported for buffers that can be textured as well as rendered to.
+    In other words the buffer must have both AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT and
+    AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE usage bits.
+
+    @param recorder          the applicable Graphite recorder
+    @param hardwareBuffer    an Android hardware buffer
+    @param colorSpace        range of colors; may be nullptr
+    @param surfaceProps      LCD striping orientation and setting for device independent
+                             fonts; may be nullptr
+    @param bufferReleaseProc function called when the buffer can be released
+    @param ReleaseContext    state passed to bufferReleaseProc
+    @param fromWindow        Whether or not the AHardwareBuffer is part of an Android Window.
+                             Currently only used with Vulkan backend.
+    @return                  created SkSurface, or nullptr
+*/
+SK_API sk_sp<SkSurface> WrapAndroidHardwareBuffer(skgpu::graphite::Recorder* recorder,
+                                                  AHardwareBuffer* hardwareBuffer,
+                                                  sk_sp<SkColorSpace> colorSpace,
+                                                  const SkSurfaceProps* surfaceProps,
+                                                  BufferReleaseProc = nullptr,
+                                                  ReleaseContext = nullptr,
+                                                  bool fromWindow = false);
+
+}  // namespace SkSurfaces
+
+#endif // SurfaceAndroid_DEFINED

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "avif", IsAvif, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "bmp", IsBmp, Decode };
 }
 

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

@@ -14,6 +14,7 @@
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
 #include "include/core/SkYUVAPixmaps.h"
 #include "include/private/SkEncodedInfo.h"
@@ -23,7 +24,7 @@
 #include <cstddef>
 #include <functional>
 #include <memory>
-#include <string>
+#include <string_view>
 #include <tuple>
 #include <vector>
 
@@ -46,6 +47,10 @@ namespace DM {
 class CodecSrc;
 } // namespace DM
 
+namespace SkCodecs {
+struct Decoder;
+}
+
 /**
  *  Abstraction layer directly on top of an image codec.
  */
@@ -175,7 +180,15 @@ public:
      *  SkCodec takes ownership of it, and will delete it when done with it.
      */
     static std::unique_ptr<SkCodec> MakeFromStream(
-            std::unique_ptr<SkStream>, Result* = nullptr,
+            std::unique_ptr<SkStream>,
+            SkSpan<const SkCodecs::Decoder> decoders,
+            Result* = nullptr,
+            SkPngChunkReader* = nullptr,
+            SelectionPolicy selectionPolicy = SelectionPolicy::kPreferStillImage);
+    // deprecated
+    static std::unique_ptr<SkCodec> MakeFromStream(
+            std::unique_ptr<SkStream>,
+            Result* = nullptr,
             SkPngChunkReader* = nullptr,
             SelectionPolicy selectionPolicy = SelectionPolicy::kPreferStillImage);
 
@@ -195,6 +208,10 @@ public:
      *      If the PNG does not contain unknown chunks, the SkPngChunkReader
      *      will not be used or modified.
      */
+    static std::unique_ptr<SkCodec> MakeFromData(sk_sp<SkData>,
+                                                 SkSpan<const SkCodecs::Decoder> decoders,
+                                                 SkPngChunkReader* = nullptr);
+    // deprecated
     static std::unique_ptr<SkCodec> MakeFromData(sk_sp<SkData>, SkPngChunkReader* = nullptr);
 
     virtual ~SkCodec();
@@ -1012,6 +1029,7 @@ private:
     friend class SkSampledCodec;
     friend class SkIcoCodec;
     friend class SkAndroidCodec; // for fEncodedInfo
+    friend class SkPDFBitmap; // for fEncodedInfo
 };
 
 namespace SkCodecs {
@@ -1025,7 +1043,7 @@ using MakeFromStreamCallback = std::unique_ptr<SkCodec> (*)(std::unique_ptr<SkSt
 struct SK_API Decoder {
     // By convention, we use all lowercase letters and go with the primary filename extension.
     // For example "png", "jpg", "ico", "webp", etc
-    std::string id;
+    std::string_view id;
     IsFormatCallback isFormat;
     MakeFromStreamCallback makeFromStream;
 };

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "gif", IsGif, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "ico", IsIco, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "jpeg", IsJpeg, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "jpegxl", IsJpegxl, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "png", IsPng, Decode };
 }
 

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

@@ -41,7 +41,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodecs::DecodeContext = nullptr);
 
 // This decoder will always be checked last, no matter when it is registered.
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "raw", IsRaw, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "wbmp", IsWbmp, Decode };
 }
 

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

@@ -35,7 +35,7 @@ SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
                                        SkCodec::Result*,
                                        SkCodecs::DecodeContext = nullptr);
 
-inline SkCodecs::Decoder Decoder() {
+inline constexpr SkCodecs::Decoder Decoder() {
     return { "webp", IsWebp, Decode };
 }
 

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

@@ -94,6 +94,9 @@
 //#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, value_max)
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
 
+// To use smaller but slower mipmap builder
+//#define SK_USE_DRAWING_MIPMAP_DOWNSAMPLER
+
 /* Skia tries to make use of some non-standard C++ language extensions.
    By default, Skia provides msvc and clang/gcc versions of these macros.
    Skia consumers can provide their own definitions of these macros to
@@ -115,5 +118,4 @@
  */
 //#define SK_API __declspec(dllexport)
 
-
 #endif

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

@@ -24,11 +24,13 @@
 #include "include/core/SkSamplingOptions.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkSize.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkCPUTypes.h"
 #include "include/private/base/SkDeque.h"
+#include "include/private/base/SkTArray.h"
 
 #include <cstdint>
 #include <cstring>
@@ -70,6 +72,9 @@ class SkVertices;
 struct SkDrawShadowRec;
 struct SkRSXform;
 
+template<typename E>
+class SkEnumBitMask;
+
 namespace skgpu::graphite { class Recorder; }
 namespace sktext::gpu { class Slug; }
 namespace SkRecords { class Draw; }
@@ -667,7 +672,9 @@ public:
         kF16ColorType                   = 1 << 4,
     };
 
-    typedef uint32_t SaveLayerFlags;
+    using SaveLayerFlags = uint32_t;
+    using FilterSpan = SkSpan<sk_sp<SkImageFilter>>;
+    static constexpr int kMaxFiltersPerLayer = 16;
 
     /** \struct SkCanvas::SaveLayerRec
         SaveLayerRec contains the state used to create the layer.
@@ -687,7 +694,7 @@ public:
             @return                SaveLayerRec with empty fBackdrop
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
-            : SaveLayerRec(bounds, paint, nullptr, 1.f, saveLayerFlags) {}
+            : SaveLayerRec(bounds, paint, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
 
         /** Sets fBounds, fPaint, fBackdrop, and fSaveLayerFlags.
 
@@ -703,7 +710,7 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, 1.f, saveLayerFlags) {}
+            : SaveLayerRec(bounds, paint, backdrop, 1.f, saveLayerFlags, /*filters=*/{}) {}
 
         /** hints at layer size limit */
         const SkRect*        fBounds         = nullptr;
@@ -711,6 +718,8 @@ public:
         /** modifies overlay */
         const SkPaint*       fPaint          = nullptr;
 
+        FilterSpan           fFilters        = {};
+
         /**
          *  If not null, this triggers the same initialization behavior as setting
          *  kInitWithPrevious_SaveLayerFlag on fSaveLayerFlags: the current layer is copied into
@@ -726,13 +735,23 @@ public:
         friend class SkCanvas;
         friend class SkCanvasPriv;
 
-        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
-                     SkScalar backdropScale, SaveLayerFlags saveLayerFlags)
-            : fBounds(bounds)
-            , fPaint(paint)
-            , fBackdrop(backdrop)
-            , fSaveLayerFlags(saveLayerFlags)
-            , fExperimentalBackdropScale(backdropScale) {}
+        SaveLayerRec(const SkRect* bounds,
+                     const SkPaint* paint,
+                     const SkImageFilter* backdrop,
+                     SkScalar backdropScale,
+                     SaveLayerFlags saveLayerFlags,
+                     FilterSpan filters)
+                : fBounds(bounds)
+                , fPaint(paint)
+                , fFilters(filters)
+                , fBackdrop(backdrop)
+                , fSaveLayerFlags(saveLayerFlags)
+                , fExperimentalBackdropScale(backdropScale) {
+            // We only allow the paint's image filter or the side-car list of filters -- not both.
+            SkASSERT(fFilters.empty() || !paint || !paint->getImageFilter());
+            // To keep things reasonable (during deserialization), we limit filter list size.
+            SkASSERT(fFilters.size() <= kMaxFiltersPerLayer);
+        }
 
         // Relative scale factor that the image content used to initialize the layer when the
         // kInitFromPrevious flag or a backdrop filter is used.
@@ -2283,30 +2302,33 @@ protected:
     virtual void onDrawSlug(const sktext::gpu::Slug* slug);
 
 private:
-
-    enum ShaderOverrideOpacity {
-        kNone_ShaderOverrideOpacity,        //!< there is no overriding shader (bitmap or image)
-        kOpaque_ShaderOverrideOpacity,      //!< the overriding shader is opaque
-        kNotOpaque_ShaderOverrideOpacity,   //!< the overriding shader may not be opaque
+    enum class PredrawFlags : unsigned {
+        kNone                    = 0,
+        kOpaqueShaderOverride    = 1, // The paint's shader is overridden with an opaque image
+        kNonOpaqueShaderOverride = 2, // The paint's shader is overridden but is not opaque
+        kCheckForOverwrite       = 4, // Check if the draw would overwrite the entire surface
+        kSkipMaskFilterAutoLayer = 8, // Do not apply mask filters in the AutoLayer
     };
+    // Inlined SK_DECL_BITMASK_OPS_FRIENDS to avoid including SkEnumBitMask.h
+    friend constexpr SkEnumBitMask<PredrawFlags> operator|(PredrawFlags, PredrawFlags);
+    friend constexpr SkEnumBitMask<PredrawFlags> operator&(PredrawFlags, PredrawFlags);
+    friend constexpr SkEnumBitMask<PredrawFlags> operator^(PredrawFlags, PredrawFlags);
+    friend constexpr SkEnumBitMask<PredrawFlags> operator~(PredrawFlags);
 
     // notify our surface (if we have one) that we are about to draw, so it
     // can perform copy-on-write or invalidate any cached images
     // returns false if the copy failed
     [[nodiscard]] bool predrawNotify(bool willOverwritesEntireSurface = false);
-    [[nodiscard]] bool predrawNotify(const SkRect*, const SkPaint*, ShaderOverrideOpacity);
+    [[nodiscard]] bool predrawNotify(const SkRect*, const SkPaint*, SkEnumBitMask<PredrawFlags>);
 
-    enum class CheckForOverwrite : bool {
-        kNo = false,
-        kYes = true
-    };
     // call the appropriate predrawNotify and create a layer if needed.
     std::optional<AutoLayerForImageFilter> aboutToDraw(
-        SkCanvas* canvas,
-        const SkPaint& paint,
-        const SkRect* rawBounds = nullptr,
-        CheckForOverwrite = CheckForOverwrite::kNo,
-        ShaderOverrideOpacity = kNone_ShaderOverrideOpacity);
+            const SkPaint& paint,
+            const SkRect* rawBounds,
+            SkEnumBitMask<PredrawFlags> flags);
+    std::optional<AutoLayerForImageFilter> aboutToDraw(
+            const SkPaint& paint,
+            const SkRect* rawBounds = nullptr);
 
     // The bottom-most device in the stack, only changed by init(). Image properties and the final
     // canvas pixels are determined by this device.
@@ -2323,12 +2345,16 @@ private:
     // clip, and matrix commands. There is a layer per call to saveLayer() using the
     // kFullLayer_SaveLayerStrategy.
     struct Layer {
-        sk_sp<SkDevice>      fDevice;
-        sk_sp<SkImageFilter> fImageFilter; // applied to layer *before* being drawn by paint
-        SkPaint              fPaint;
-        bool                 fDiscard;
-
-        Layer(sk_sp<SkDevice> device, sk_sp<SkImageFilter> imageFilter, const SkPaint& paint);
+        sk_sp<SkDevice>                                fDevice;
+        skia_private::STArray<1, sk_sp<SkImageFilter>> fImageFilters;
+        SkPaint                                        fPaint;
+        bool                                           fIsCoverage;
+        bool                                           fDiscard;
+
+        Layer(sk_sp<SkDevice> device,
+              FilterSpan imageFilters,
+              const SkPaint& paint,
+              bool isCoverage);
     };
 
     // Encapsulate state needed to restore from saveBehind()
@@ -2364,8 +2390,9 @@ private:
         ~MCRec();
 
         void newLayer(sk_sp<SkDevice> layerDevice,
-                      sk_sp<SkImageFilter> filter,
-                      const SkPaint& restorePaint);
+                      FilterSpan filters,
+                      const SkPaint& restorePaint,
+                      bool layerIsCoverage);
 
         void reset(SkDevice* device);
     };
@@ -2470,7 +2497,7 @@ private:
                              const SkMatrix* matrix = nullptr);
 
     void internalDrawPaint(const SkPaint& paint);
-    void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy);
+    void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy, bool coverageOnly=false);
     void internalSaveBehind(const SkRect*);
 
     void internalConcat44(const SkM44&);
@@ -2499,16 +2526,18 @@ private:
      * relative transforms between the devices).
      */
     void internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst,
-                                      const SkImageFilter* filter, const SkPaint& paint,
+                                      FilterSpan filters, const SkPaint& paint,
                                       DeviceCompatibleWithFilter compat,
-                                      SkScalar scaleFactor = 1.f);
+                                      SkScalar scaleFactor = 1.f,
+                                      bool srcIsCoverageLayer = false);
 
     /*
      *  Returns true if drawing the specified rect (or all if it is null) with the specified
      *  paint (or default if null) would overwrite the entire root device of the canvas
      *  (i.e. the canvas' surface if it had one).
      */
-    bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*, ShaderOverrideOpacity) const;
+    bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*,
+                                     SkEnumBitMask<PredrawFlags>) const;
 
     /**
      *  Returns true if the paint's imagefilter can be invoked directly, without needed a layer.

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

@@ -15,6 +15,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <utility>
 
 class SkColorMatrix;
 class SkColorSpace;
@@ -82,8 +83,10 @@ private:
 
 class SK_API SkColorFilters {
 public:
-    static sk_sp<SkColorFilter> Compose(sk_sp<SkColorFilter> outer, sk_sp<SkColorFilter> inner) {
-        return outer ? outer->makeComposed(inner) : inner;
+    static sk_sp<SkColorFilter> Compose(const sk_sp<SkColorFilter>& outer,
+                                        sk_sp<SkColorFilter> inner) {
+        return outer ? outer->makeComposed(std::move(inner))
+                     : std::move(inner);
     }
 
     // Blends between the constant color (src) and input color (dst) based on the SkBlendMode.

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

@@ -90,6 +90,7 @@ private:
     const Segment* distanceToSegment(SkScalar distance, SkScalar* t) const;
 
     friend class SkContourMeasureIter;
+    friend class SkPathMeasurePriv;
 };
 
 class SK_API SkContourMeasureIter {

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

@@ -36,6 +36,7 @@ public:
      *  Begin a new page for the document, returning the canvas that will draw
      *  into the page. The document owns this canvas, and it will go out of
      *  scope when endPage() or close() is called, or the document is deleted.
+     *  This will call endPage() if there is a currently active page.
      */
     SkCanvas* beginPage(SkScalar width, SkScalar height, const SkRect* content = nullptr);
 

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

@@ -201,20 +201,14 @@ public:
      */
     SkFont makeWithSize(SkScalar size) const;
 
-    /** Returns SkTypeface if set, or nullptr.
-        Does not alter SkTypeface SkRefCnt.
+    /** Does not alter SkTypeface SkRefCnt.
 
-        @return  SkTypeface if previously set, nullptr otherwise
+        @return  non-null SkTypeface
     */
-    SkTypeface* getTypeface() const {return fTypeface.get(); }
-
-    /** Returns SkTypeface if set, or the default typeface.
-        Does not alter SkTypeface SkRefCnt.
-
-        @return  SkTypeface if previously set or, a pointer to the default typeface if not
-        previously set.
-    */
-    SkTypeface* getTypefaceOrDefault() const;
+    SkTypeface* getTypeface() const {
+        SkASSERT(fTypeface);
+        return fTypeface.get();
+    }
 
     /** Returns text size in points.
 
@@ -238,24 +232,20 @@ public:
 
     /** Increases SkTypeface SkRefCnt by one.
 
-        @return  SkTypeface if previously set, nullptr otherwise
+        @return  A non-null SkTypeface.
     */
-    sk_sp<SkTypeface> refTypeface() const { return fTypeface; }
-
-    /** Increases SkTypeface SkRefCnt by one.
-
-        @return  SkTypeface if previously set or, a pointer to the default typeface if not
-        previously set.
-    */
-    sk_sp<SkTypeface> refTypefaceOrDefault() const;
+    sk_sp<SkTypeface> refTypeface() const {
+        SkASSERT(fTypeface);
+        return fTypeface;
+    }
 
     /** Sets SkTypeface to typeface, decreasing SkRefCnt of the previous SkTypeface.
-        Pass nullptr to clear SkTypeface and use the default typeface. Increments
-        tf SkRefCnt by one.
+        Pass nullptr to clear SkTypeface and use an empty typeface (which draws nothing).
+        Increments tf SkRefCnt by one.
 
         @param tf  font and style used to draw text
     */
-    void setTypeface(sk_sp<SkTypeface> tf) { fTypeface = tf; }
+    void setTypeface(sk_sp<SkTypeface> tf);
 
     /** Sets text size in points.
         Has no effect if textSize is not greater than or equal to zero.

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

@@ -32,7 +32,7 @@ struct SkFontArguments {
      */
     struct Palette {
         struct Override {
-            int index;
+            uint16_t index;
             SkColor color;
         };
         int index;

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

@@ -16,7 +16,7 @@
     The metric values are consistent with the Skia y-down coordinate system.
  */
 struct SK_API SkFontMetrics {
-    bool operator==(const SkFontMetrics& that) {
+    bool operator==(const SkFontMetrics& that) const {
         return
         this->fFlags == that.fFlags &&
         this->fTop == that.fTop &&

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

@@ -112,9 +112,6 @@ public:
 
     sk_sp<SkTypeface> legacyMakeTypeface(const char familyName[], SkFontStyle style) const;
 
-    /** Return the default fontmgr. */
-    static sk_sp<SkFontMgr> RefDefault();
-
     /* Returns an empty font manager without any typeface dependencies */
     static sk_sp<SkFontMgr> RefEmpty();
 
@@ -141,10 +138,6 @@ protected:
     virtual sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const = 0;
 
     virtual sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle) const = 0;
-
-private:
-    /** Implemented by porting layer to return the default factory. */
-    static sk_sp<SkFontMgr> Factory();
 };
 
 #endif