@shopify/react-native-skia 1.3.13 → 1.4.1

package/cpp/skia/modules/skparagraph/include/ParagraphBuilder.h

@@ -6,6 +6,7 @@
 #include <stack>
 #include <string>
 #include <tuple>
+#include <vector>
 #include "modules/skparagraph/include/FontCollection.h"
 #include "modules/skparagraph/include/Paragraph.h"
 #include "modules/skparagraph/include/ParagraphStyle.h"
@@ -60,6 +61,7 @@ public:
     virtual SkSpan<char> getText() = 0;
     virtual const ParagraphStyle& getParagraphStyle() const = 0;
 
+#if !defined(SK_DISABLE_LEGACY_CLIENT_UNICODE) && defined(SK_UNICODE_CLIENT_IMPLEMENTATION)
     // Mainly, support for "Client" unicode
     virtual void setWordsUtf8(std::vector<SkUnicode::Position> wordsUtf8) = 0;
     virtual void setWordsUtf16(std::vector<SkUnicode::Position> wordsUtf16) = 0;
@@ -70,15 +72,27 @@ public:
     virtual void setLineBreaksUtf8(std::vector<SkUnicode::LineBreakBefore> lineBreaksUtf8) = 0;
     virtual void setLineBreaksUtf16(std::vector<SkUnicode::LineBreakBefore> lineBreaksUtf16) = 0;
 
-    virtual void SetUnicode(std::unique_ptr<SkUnicode> unicode) = 0;
+    virtual std::tuple<std::vector<SkUnicode::Position>,
+               std::vector<SkUnicode::Position>,
+               std::vector<SkUnicode::LineBreakBefore>>
+        getClientICUData() const = 0;
+
+    virtual void SetUnicode(sk_sp<SkUnicode> unicode) = 0;
+#endif
 
     // Resets this builder to its initial state, discarding any text, styles, placeholders that have
     // been added, but keeping the initial ParagraphStyle.
     virtual void Reset() = 0;
 
     // Just until we fix all the google3 code
+    static std::unique_ptr<ParagraphBuilder> make(const ParagraphStyle& style,
+                                                  sk_sp<FontCollection> fontCollection,
+                                                  sk_sp<SkUnicode> unicode);
+
+#if !defined(SK_DISABLE_LEGACY_PARAGRAPH_UNICODE)
     static std::unique_ptr<ParagraphBuilder> make(const ParagraphStyle& style,
                                                   sk_sp<FontCollection> fontCollection);
+#endif
 };
 }  // namespace textlayout
 }  // namespace skia

package/cpp/skia/modules/skparagraph/include/TextStyle.h

@@ -22,14 +22,14 @@ namespace skia {
 namespace textlayout {
 
 static inline bool nearlyZero(SkScalar x, SkScalar tolerance = SK_ScalarNearlyZero) {
-    if (SkScalarIsFinite(x)) {
+    if (SkIsFinite(x)) {
         return SkScalarNearlyZero(x, tolerance);
     }
     return false;
 }
 
 static inline bool nearlyEqual(SkScalar x, SkScalar y, SkScalar tolerance = SK_ScalarNearlyZero) {
-    if (SkScalarIsFinite(x) && SkScalarIsFinite(x)) {
+    if (SkIsFinite(x, y)) {
         return SkScalarNearlyEqual(x, y, tolerance);
     }
     // Inf == Inf, anything else is false

package/cpp/skia/modules/skparagraph/include/TypefaceFontProvider.h

@@ -46,7 +46,7 @@ public:
 
     sk_sp<SkFontStyleSet> onMatchFamily(const char familyName[]) const override;
 
-    sk_sp<SkFontStyleSet> onCreateStyleSet(int) const override { return nullptr; }
+    sk_sp<SkFontStyleSet> onCreateStyleSet(int) const override;
     sk_sp<SkTypeface> onMatchFamilyStyle(const char familyName[], const SkFontStyle& pattern) const override;
     sk_sp<SkTypeface> onMatchFamilyStyleCharacter(const char[], const SkFontStyle&,
                                                   const char*[], int,
@@ -66,9 +66,7 @@ public:
         return nullptr;
     }
 
-    sk_sp<SkTypeface> onLegacyMakeTypeface(const char[], SkFontStyle) const override {
-        return nullptr;
-    }
+    sk_sp<SkTypeface> onLegacyMakeTypeface(const char[], SkFontStyle) const override;
 
 private:
     skia_private::THashMap<SkString, sk_sp<TypefaceFontStyleSet>> fRegisteredFamilies;

package/cpp/skia/modules/skresources/include/SkResources.h

@@ -260,7 +260,7 @@ private:
     using INHERITED = ResourceProviderProxyBase;
 };
 
-class DataURIResourceProviderProxy final : public ResourceProviderProxyBase {
+class SK_API DataURIResourceProviderProxy final : public ResourceProviderProxyBase {
 public:
     // If font data is supplied via base64 encoding, this needs a provided SkFontMgr to process
     // that font data into an SkTypeface. To decode images, clients must call SkCodecs::Register()

package/cpp/skia/modules/skshaper/include/SkShaper.h

@@ -0,0 +1,316 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkShaper_DEFINED
+#define SkShaper_DEFINED
+
+#include "include/core/SkFont.h"
+#include "include/core/SkFourByteTag.h"
+#include "include/core/SkPoint.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTextBlob.h"
+#include "include/core/SkTypes.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <type_traits>
+
+class SkFontStyle;
+
+#if defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+class SkFontMgr;
+#else
+#include "include/core/SkFontMgr.h"
+#endif
+
+#if !defined(SKSHAPER_IMPLEMENTATION)
+    #define SKSHAPER_IMPLEMENTATION 0
+#endif
+
+#if !defined(SKSHAPER_API)
+    #if defined(SKSHAPER_DLL)
+        #if defined(_MSC_VER)
+            #if SKSHAPER_IMPLEMENTATION
+                #define SKSHAPER_API __declspec(dllexport)
+            #else
+                #define SKSHAPER_API __declspec(dllimport)
+            #endif
+        #else
+            #define SKSHAPER_API __attribute__((visibility("default")))
+        #endif
+    #else
+        #define SKSHAPER_API
+    #endif
+#endif
+
+class SKSHAPER_API SkShaper {
+public:
+#if !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+    static std::unique_ptr<SkShaper> MakePrimitive();
+
+#if defined(SK_SHAPER_HARFBUZZ_AVAILABLE)
+    static std::unique_ptr<SkShaper> MakeShaperDrivenWrapper(sk_sp<SkFontMgr> fallback);
+    static std::unique_ptr<SkShaper> MakeShapeThenWrap(sk_sp<SkFontMgr> fallback);
+    static void PurgeHarfBuzzCache();
+#endif
+
+#if defined(SK_SHAPER_CORETEXT_AVAILABLE)
+    static std::unique_ptr<SkShaper> MakeCoreText();
+#endif
+
+    static std::unique_ptr<SkShaper> Make(sk_sp<SkFontMgr> fallback = nullptr);
+    static void PurgeCaches();
+#endif  // !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+
+    SkShaper();
+    virtual ~SkShaper();
+
+    class RunIterator {
+    public:
+        virtual ~RunIterator() = default;
+        /** Set state to that of current run and move iterator to end of that run. */
+        virtual void consume() = 0;
+        /** Offset to one past the last (utf8) element in the current run. */
+        virtual size_t endOfCurrentRun() const = 0;
+        /** Return true if consume should no longer be called. */
+        virtual bool atEnd() const = 0;
+    };
+    class FontRunIterator : public RunIterator {
+    public:
+        virtual const SkFont& currentFont() const = 0;
+    };
+    class BiDiRunIterator : public RunIterator {
+    public:
+        /** The unicode bidi embedding level (even ltr, odd rtl) */
+        virtual uint8_t currentLevel() const = 0;
+    };
+    class ScriptRunIterator : public RunIterator {
+    public:
+        /** Should be iso15924 codes. */
+        virtual SkFourByteTag currentScript() const = 0;
+    };
+    class LanguageRunIterator : public RunIterator {
+    public:
+        /** Should be BCP-47, c locale names may also work. */
+        virtual const char* currentLanguage() const = 0;
+    };
+    struct Feature {
+        SkFourByteTag tag;
+        uint32_t value;
+        size_t start; // Offset to the start (utf8) element of the run.
+        size_t end;   // Offset to one past the last (utf8) element of the run.
+    };
+
+private:
+    template <typename RunIteratorSubclass>
+    class TrivialRunIterator : public RunIteratorSubclass {
+    public:
+        static_assert(std::is_base_of<RunIterator, RunIteratorSubclass>::value, "");
+        TrivialRunIterator(size_t utf8Bytes) : fEnd(utf8Bytes), fAtEnd(fEnd == 0) {}
+        void consume() override { SkASSERT(!fAtEnd); fAtEnd = true; }
+        size_t endOfCurrentRun() const override { return fAtEnd ? fEnd : 0; }
+        bool atEnd() const override { return fAtEnd; }
+    private:
+        size_t fEnd;
+        bool fAtEnd;
+    };
+
+public:
+    static std::unique_ptr<FontRunIterator>
+    MakeFontMgrRunIterator(const char* utf8, size_t utf8Bytes,
+                           const SkFont& font, sk_sp<SkFontMgr> fallback);
+    static std::unique_ptr<SkShaper::FontRunIterator>
+    MakeFontMgrRunIterator(const char* utf8, size_t utf8Bytes,
+                           const SkFont& font, sk_sp<SkFontMgr> fallback,
+                           const char* requestName, SkFontStyle requestStyle,
+                           const SkShaper::LanguageRunIterator*);
+    class TrivialFontRunIterator : public TrivialRunIterator<FontRunIterator> {
+    public:
+        TrivialFontRunIterator(const SkFont& font, size_t utf8Bytes)
+            : TrivialRunIterator(utf8Bytes), fFont(font) {}
+        const SkFont& currentFont() const override { return fFont; }
+    private:
+        SkFont fFont;
+    };
+
+#if !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+    static std::unique_ptr<BiDiRunIterator>
+    MakeBiDiRunIterator(const char* utf8, size_t utf8Bytes, uint8_t bidiLevel);
+#if defined(SK_SHAPER_UNICODE_AVAILABLE)
+    static std::unique_ptr<BiDiRunIterator>
+    MakeIcuBiDiRunIterator(const char* utf8, size_t utf8Bytes, uint8_t bidiLevel);
+#endif  // defined(SK_SHAPER_UNICODE_AVAILABLE)
+#endif  // !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+
+    class TrivialBiDiRunIterator : public TrivialRunIterator<BiDiRunIterator> {
+    public:
+        TrivialBiDiRunIterator(uint8_t bidiLevel, size_t utf8Bytes)
+            : TrivialRunIterator(utf8Bytes), fBidiLevel(bidiLevel) {}
+        uint8_t currentLevel() const override { return fBidiLevel; }
+    private:
+        uint8_t fBidiLevel;
+    };
+
+#if !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+    static std::unique_ptr<ScriptRunIterator>
+    MakeScriptRunIterator(const char* utf8, size_t utf8Bytes, SkFourByteTag script);
+#if defined(SK_SHAPER_HARFBUZZ_AVAILABLE)
+    static std::unique_ptr<ScriptRunIterator>
+    MakeSkUnicodeHbScriptRunIterator(const char* utf8, size_t utf8Bytes);
+    static std::unique_ptr<ScriptRunIterator>
+    MakeSkUnicodeHbScriptRunIterator(const char* utf8, size_t utf8Bytes, SkFourByteTag script);
+    // Still used in some cases
+    static std::unique_ptr<ScriptRunIterator>
+    MakeHbIcuScriptRunIterator(const char* utf8, size_t utf8Bytes);
+#endif  // defined(SK_SHAPER_HARFBUZZ_AVAILABLE)
+#endif  // !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+
+    class TrivialScriptRunIterator : public TrivialRunIterator<ScriptRunIterator> {
+    public:
+        TrivialScriptRunIterator(SkFourByteTag script, size_t utf8Bytes)
+            : TrivialRunIterator(utf8Bytes), fScript(script) {}
+        SkFourByteTag currentScript() const override { return fScript; }
+    private:
+        SkFourByteTag fScript;
+    };
+
+    static std::unique_ptr<LanguageRunIterator>
+    MakeStdLanguageRunIterator(const char* utf8, size_t utf8Bytes);
+    class TrivialLanguageRunIterator : public TrivialRunIterator<LanguageRunIterator> {
+    public:
+        TrivialLanguageRunIterator(const char* language, size_t utf8Bytes)
+            : TrivialRunIterator(utf8Bytes), fLanguage(language) {}
+        const char* currentLanguage() const override { return fLanguage.c_str(); }
+    private:
+        SkString fLanguage;
+    };
+
+    class RunHandler {
+    public:
+        virtual ~RunHandler() = default;
+
+        struct Range {
+            constexpr Range() : fBegin(0), fSize(0) {}
+            constexpr Range(size_t begin, size_t size) : fBegin(begin), fSize(size) {}
+            size_t fBegin;
+            size_t fSize;
+            constexpr size_t begin() const { return fBegin; }
+            constexpr size_t end() const { return begin() + size(); }
+            constexpr size_t size() const { return fSize; }
+        };
+
+        struct RunInfo {
+            const SkFont& fFont;
+            uint8_t fBidiLevel;
+            SkVector fAdvance;
+            size_t glyphCount;
+            Range utf8Range;
+        };
+
+        struct Buffer {
+            SkGlyphID* glyphs;  // required
+            SkPoint* positions; // required, if (!offsets) put glyphs[i] at positions[i]
+                                //           if ( offsets) positions[i+1]-positions[i] are advances
+            SkPoint* offsets;   // optional, if ( offsets) put glyphs[i] at positions[i]+offsets[i]
+            uint32_t* clusters; // optional, utf8+clusters[i] starts run which produced glyphs[i]
+            SkPoint point;      // offset to add to all positions
+        };
+
+        /** Called when beginning a line. */
+        virtual void beginLine() = 0;
+
+        /** Called once for each run in a line. Can compute baselines and offsets. */
+        virtual void runInfo(const RunInfo&) = 0;
+
+        /** Called after all runInfo calls for a line. */
+        virtual void commitRunInfo() = 0;
+
+        /** Called for each run in a line after commitRunInfo. The buffer will be filled out. */
+        virtual Buffer runBuffer(const RunInfo&) = 0;
+
+        /** Called after each runBuffer is filled out. */
+        virtual void commitRunBuffer(const RunInfo&) = 0;
+
+        /** Called when ending a line. */
+        virtual void commitLine() = 0;
+    };
+
+#if !defined(SK_DISABLE_LEGACY_SKSHAPER_FUNCTIONS)
+    virtual void shape(const char* utf8, size_t utf8Bytes,
+                       const SkFont& srcFont,
+                       bool leftToRight,
+                       SkScalar width,
+                       RunHandler*) const = 0;
+
+    virtual void shape(const char* utf8, size_t utf8Bytes,
+                       FontRunIterator&,
+                       BiDiRunIterator&,
+                       ScriptRunIterator&,
+                       LanguageRunIterator&,
+                       SkScalar width,
+                       RunHandler*) const = 0;
+#endif
+    virtual void shape(const char* utf8,
+                       size_t utf8Bytes,
+                       FontRunIterator&,
+                       BiDiRunIterator&,
+                       ScriptRunIterator&,
+                       LanguageRunIterator&,
+                       const Feature* features,
+                       size_t featuresSize,
+                       SkScalar width,
+                       RunHandler*) const = 0;
+
+private:
+    SkShaper(const SkShaper&) = delete;
+    SkShaper& operator=(const SkShaper&) = delete;
+};
+
+/**
+ * Helper for shaping text directly into a SkTextBlob.
+ */
+class SKSHAPER_API SkTextBlobBuilderRunHandler final : public SkShaper::RunHandler {
+public:
+    SkTextBlobBuilderRunHandler(const char* utf8Text, SkPoint offset)
+        : fUtf8Text(utf8Text)
+        , fOffset(offset) {}
+    sk_sp<SkTextBlob> makeBlob();
+    SkPoint endPoint() { return fOffset; }
+
+    void beginLine() override;
+    void runInfo(const RunInfo&) override;
+    void commitRunInfo() override;
+    Buffer runBuffer(const RunInfo&) override;
+    void commitRunBuffer(const RunInfo&) override;
+    void commitLine() override;
+
+private:
+    SkTextBlobBuilder fBuilder;
+    char const * const fUtf8Text;
+    uint32_t* fClusters;
+    int fClusterOffset;
+    int fGlyphCount;
+    SkScalar fMaxRunAscent;
+    SkScalar fMaxRunDescent;
+    SkScalar fMaxRunLeading;
+    SkPoint fCurrentPosition;
+    SkPoint fOffset;
+};
+
+namespace SkShapers::Primitive {
+SKSHAPER_API std::unique_ptr<SkShaper> PrimitiveText();
+
+SKSHAPER_API std::unique_ptr<SkShaper::BiDiRunIterator> TrivialBiDiRunIterator
+                                              (size_t utf8Bytes,  uint8_t bidiLevel);
+SKSHAPER_API std::unique_ptr<SkShaper::ScriptRunIterator> TrivialScriptRunIterator
+                                              (size_t utf8Bytes, SkFourByteTag scriptTag);
+}  // namespace SkShapers
+
+#endif  // SkShaper_DEFINED

package/cpp/skia/modules/skshaper/include/SkShaper_coretext.h

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkShaper_coretext_DEFINED
+#define SkShaper_coretext_DEFINED
+
+#include "modules/skshaper/include/SkShaper.h"
+
+#include <memory>
+
+namespace SkShapers::CT {
+SKSHAPER_API std::unique_ptr<SkShaper> CoreText();
+}
+
+#endif

package/cpp/skia/modules/skshaper/include/SkShaper_factory.h

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkShaperFactory_DEFINED
+#define SkShaperFactory_DEFINED
+
+#include "include/core/SkFourByteTag.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "modules/skshaper/include/SkShaper.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+class SkFontMgr;
+class SkUnicode;
+
+namespace SkShapers {
+
+class SKSHAPER_API Factory : public SkRefCnt {
+public:
+    virtual std::unique_ptr<SkShaper> makeShaper(sk_sp<SkFontMgr> fallback) = 0;
+    virtual std::unique_ptr<SkShaper::BiDiRunIterator> makeBidiRunIterator(
+            const char* utf8, size_t utf8Bytes, uint8_t bidiLevel) = 0;
+    virtual std::unique_ptr<SkShaper::ScriptRunIterator> makeScriptRunIterator(
+            const char* utf8, size_t utf8Bytes, SkFourByteTag script) = 0;
+
+    virtual SkUnicode* getUnicode() = 0;
+};
+
+namespace Primitive {
+SKSHAPER_API sk_sp<Factory> Factory();
+}
+
+}  // namespace SkShapers
+
+#endif  // SkShaperFactory_DEFINED

package/cpp/skia/modules/skshaper/include/SkShaper_harfbuzz.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkShaper_harfbuzz_DEFINED
+#define SkShaper_harfbuzz_DEFINED
+
+#include "include/core/SkFourByteTag.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "modules/skshaper/include/SkShaper.h"
+
+#include <cstddef>
+#include <memory>
+
+class SkFontMgr;
+class SkUnicode;
+
+namespace SkShapers::HB {
+SKSHAPER_API std::unique_ptr<SkShaper> ShaperDrivenWrapper(sk_sp<SkUnicode> unicode,
+                                                           sk_sp<SkFontMgr> fallback);
+SKSHAPER_API std::unique_ptr<SkShaper> ShapeThenWrap(sk_sp<SkUnicode> unicode,
+                                                     sk_sp<SkFontMgr> fallback);
+SKSHAPER_API std::unique_ptr<SkShaper> ShapeDontWrapOrReorder(sk_sp<SkUnicode> unicode,
+                                                              sk_sp<SkFontMgr> fallback);
+
+SKSHAPER_API std::unique_ptr<SkShaper::ScriptRunIterator> ScriptRunIterator(const char* utf8,
+                                                                            size_t utf8Bytes);
+SKSHAPER_API std::unique_ptr<SkShaper::ScriptRunIterator> ScriptRunIterator(const char* utf8,
+                                                                            size_t utf8Bytes,
+                                                                            SkFourByteTag script);
+
+SKSHAPER_API void PurgeCaches();
+}  // namespace SkShapers::HB
+
+#endif

package/cpp/skia/modules/skshaper/include/SkShaper_skunicode.h

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkShaper_skunicode_DEFINED
+#define SkShaper_skunicode_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "modules/skshaper/include/SkShaper.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+class SkUnicode;
+
+namespace SkShapers::unicode {
+SKSHAPER_API std::unique_ptr<SkShaper::BiDiRunIterator> BidiRunIterator(sk_sp<SkUnicode> unicode,
+                                                                        const char* utf8,
+                                                                        size_t utf8Bytes,
+                                                                        uint8_t bidiLevel);
+
+}  // namespace SkShapers::unicode
+
+#endif

package/cpp/skia/modules/skunicode/include/SkUnicode.h

@@ -6,18 +6,19 @@
  */
 #ifndef SkUnicode_DEFINED
 #define SkUnicode_DEFINED
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkTArray.h"
 #include "include/private/base/SkTo.h"
 #include "src/base/SkUTF.h"
-
 #include <cstddef>
 #include <cstdint>
 #include <memory>
 #include <string>
 #include <vector>
+namespace sknonstd { template <typename T> struct is_bitmask_enum; }
 
 #if !defined(SKUNICODE_IMPLEMENTATION)
     #define SKUNICODE_IMPLEMENTATION 0
@@ -39,10 +40,6 @@
     #endif
 #endif
 
-namespace sknonstd {
-template <typename T> struct is_bitmask_enum;
-}
-
 class SKUNICODE_API SkBidiIterator {
 public:
     typedef int32_t Position;
@@ -77,7 +74,7 @@ public:
     virtual bool setText(const char16_t utftext16[], int utf16Units) = 0;
 };
 
-class SKUNICODE_API SkUnicode {
+class SKUNICODE_API SkUnicode : public SkRefCnt {
     public:
         enum CodeUnitFlags {
             kNoCodeUnitFlag = 0x00,
@@ -120,9 +117,11 @@ class SKUNICODE_API SkUnicode {
             LineBreakType breakType;
         };
 
-        virtual ~SkUnicode() = default;
+        ~SkUnicode() override = default;
 
+        // deprecated
         virtual SkString toUpper(const SkString&) = 0;
+        virtual SkString toUpper(const SkString&, const char* locale) = 0;
 
         virtual bool isControl(SkUnichar utf8) = 0;
         virtual bool isWhitespace(SkUnichar utf8) = 0;
@@ -299,22 +298,6 @@ class SKUNICODE_API SkUnicode {
         }
 
         virtual void reorderVisual(const BidiLevel runLevels[], int levelsCount, int32_t logicalFromVisual[]) = 0;
-
-        virtual std::unique_ptr<SkUnicode> copy() = 0;
-
-        static std::unique_ptr<SkUnicode> Make();
-
-        static std::unique_ptr<SkUnicode> MakeIcuBasedUnicode();
-
-        static std::unique_ptr<SkUnicode> MakeClientBasedUnicode(
-                SkSpan<char> text,
-                std::vector<SkUnicode::Position> words,
-                std::vector<SkUnicode::Position> graphemeBreaks,
-                std::vector<SkUnicode::LineBreakBefore> lineBreaks);
-
-        static std::unique_ptr<SkUnicode> MakeLibgraphemeBasedUnicode();
-
-        static std::unique_ptr<SkUnicode> MakeIcu4xBasedUnicode();
 };
 
 namespace sknonstd {

package/cpp/skia/modules/svg/include/SkSVGAttribute.h

@@ -9,9 +9,6 @@
 #define SkSVGAttribute_DEFINED
 
 #include "modules/svg/include/SkSVGTypes.h"
-#include "src/base/SkTLazy.h"
-
-class SkSVGRenderContext;
 
 enum class SkSVGAttribute {
     kClipRule,

package/cpp/skia/modules/svg/include/SkSVGAttributeParser.h

@@ -8,12 +8,22 @@
 #ifndef SkSVGAttributeParser_DEFINED
 #define SkSVGAttributeParser_DEFINED
 
-#include <vector>
-
+#include "include/core/SkColor.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/private/base/SkNoncopyable.h"
 #include "modules/svg/include/SkSVGTypes.h"
+
 #include "src/base/SkTLazy.h"
 
+#include <cstdint>
+#include <cstring>
+#include <tuple>
+#include <vector>
+
+class SkMatrix;
+class SkString;
+
 class SkSVGAttributeParser : public SkNoncopyable {
 public:
     SkSVGAttributeParser(const char[]);

package/cpp/skia/modules/svg/include/SkSVGCircle.h

@@ -8,9 +8,22 @@
 #ifndef SkSVGCircle_DEFINED
 #define SkSVGCircle_DEFINED
 
+#include "include/core/SkPath.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkScalar.h"
+#include "include/private/base/SkAPI.h"
+#include "modules/svg/include/SkSVGNode.h"
 #include "modules/svg/include/SkSVGShape.h"
 #include "modules/svg/include/SkSVGTypes.h"
 
+#include <tuple>
+
+class SkCanvas;
+class SkPaint;
+class SkSVGLengthContext;
+class SkSVGRenderContext;
+enum class SkPathFillType;
 struct SkPoint;
 
 class SK_API SkSVGCircle final : public SkSVGShape {