@shopify/react-native-skia 0.1.158 → 0.1.159

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

@@ -0,0 +1,143 @@
+// Copyright 2019 Google LLC.
+#ifndef ParagraphStyle_DEFINED
+#define ParagraphStyle_DEFINED
+
+#include "include/core/SkFontStyle.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkString.h"
+#include "modules/skparagraph/include/DartTypes.h"
+#include "modules/skparagraph/include/TextStyle.h"
+
+#include <stddef.h>
+#include <algorithm>
+#include <limits>
+#include <string>
+#include <utility>
+#include <vector>
+
+namespace skia {
+namespace textlayout {
+
+struct StrutStyle {
+    StrutStyle();
+
+    const std::vector<SkString>& getFontFamilies() const { return fFontFamilies; }
+    void setFontFamilies(std::vector<SkString> families) { fFontFamilies = std::move(families); }
+
+    SkFontStyle getFontStyle() const { return fFontStyle; }
+    void setFontStyle(SkFontStyle fontStyle) { fFontStyle = fontStyle; }
+
+    SkScalar getFontSize() const { return fFontSize; }
+    void setFontSize(SkScalar size) { fFontSize = size; }
+
+    void setHeight(SkScalar height) { fHeight = height; }
+    SkScalar getHeight() const { return fHeight; }
+
+    void setLeading(SkScalar Leading) { fLeading = Leading; }
+    SkScalar getLeading() const { return fLeading; }
+
+    bool getStrutEnabled() const { return fEnabled; }
+    void setStrutEnabled(bool v) { fEnabled = v; }
+
+    bool getForceStrutHeight() const { return fForceHeight; }
+    void setForceStrutHeight(bool v) { fForceHeight = v; }
+
+    bool getHeightOverride() const { return fHeightOverride; }
+    void setHeightOverride(bool v) { fHeightOverride = v; }
+
+    void setHalfLeading(bool halfLeading) { fHalfLeading = halfLeading; }
+    bool getHalfLeading() const { return fHalfLeading; }
+
+    bool operator==(const StrutStyle& rhs) const {
+        return this->fEnabled == rhs.fEnabled &&
+               this->fHeightOverride == rhs.fHeightOverride &&
+               this->fForceHeight == rhs.fForceHeight &&
+               this->fHalfLeading == rhs.fHalfLeading &&
+               nearlyEqual(this->fLeading, rhs.fLeading) &&
+               nearlyEqual(this->fHeight, rhs.fHeight) &&
+               nearlyEqual(this->fFontSize, rhs.fFontSize) &&
+               this->fFontStyle == rhs.fFontStyle &&
+               this->fFontFamilies == rhs.fFontFamilies;
+    }
+
+private:
+
+    std::vector<SkString> fFontFamilies;
+    SkFontStyle fFontStyle;
+    SkScalar fFontSize;
+    SkScalar fHeight;
+    SkScalar fLeading;
+    bool fForceHeight;
+    bool fEnabled;
+    bool fHeightOverride;
+    // true: half leading.
+    // false: scale ascent/descent with fHeight.
+    bool fHalfLeading;
+};
+
+struct ParagraphStyle {
+    ParagraphStyle();
+
+    bool operator==(const ParagraphStyle& rhs) const {
+        return this->fHeight == rhs.fHeight &&
+               this->fEllipsis == rhs.fEllipsis &&
+               this->fEllipsisUtf16 == rhs.fEllipsisUtf16 &&
+               this->fTextDirection == rhs.fTextDirection && this->fTextAlign == rhs.fTextAlign &&
+               this->fDefaultTextStyle == rhs.fDefaultTextStyle &&
+               this->fReplaceTabCharacters == rhs.fReplaceTabCharacters;
+    }
+
+    const StrutStyle& getStrutStyle() const { return fStrutStyle; }
+    void setStrutStyle(StrutStyle strutStyle) { fStrutStyle = std::move(strutStyle); }
+
+    const TextStyle& getTextStyle() const { return fDefaultTextStyle; }
+    void setTextStyle(const TextStyle& textStyle) { fDefaultTextStyle = textStyle; }
+
+    TextDirection getTextDirection() const { return fTextDirection; }
+    void setTextDirection(TextDirection direction) { fTextDirection = direction; }
+
+    TextAlign getTextAlign() const { return fTextAlign; }
+    void setTextAlign(TextAlign align) { fTextAlign = align; }
+
+    size_t getMaxLines() const { return fLinesLimit; }
+    void setMaxLines(size_t maxLines) { fLinesLimit = maxLines; }
+
+    SkString getEllipsis() const { return fEllipsis; }
+    std::u16string getEllipsisUtf16() const { return fEllipsisUtf16; }
+    void setEllipsis(const std::u16string& ellipsis) {  fEllipsisUtf16 = ellipsis; }
+    void setEllipsis(const SkString& ellipsis) { fEllipsis = ellipsis; }
+
+    SkScalar getHeight() const { return fHeight; }
+    void setHeight(SkScalar height) { fHeight = height; }
+
+    TextHeightBehavior getTextHeightBehavior() const { return fTextHeightBehavior; }
+    void setTextHeightBehavior(TextHeightBehavior v) { fTextHeightBehavior = v; }
+
+    bool unlimited_lines() const {
+        return fLinesLimit == std::numeric_limits<size_t>::max();
+    }
+    bool ellipsized() const { return !fEllipsis.isEmpty() || !fEllipsisUtf16.empty(); }
+    TextAlign effective_align() const;
+    bool hintingIsOn() const { return fHintingIsOn; }
+    void turnHintingOff() { fHintingIsOn = false; }
+
+    bool getReplaceTabCharacters() const { return fReplaceTabCharacters; }
+    void setReplaceTabCharacters(bool value) { fReplaceTabCharacters = value; }
+
+private:
+    StrutStyle fStrutStyle;
+    TextStyle fDefaultTextStyle;
+    TextAlign fTextAlign;
+    TextDirection fTextDirection;
+    size_t fLinesLimit;
+    std::u16string fEllipsisUtf16;
+    SkString fEllipsis;
+    SkScalar fHeight;
+    TextHeightBehavior fTextHeightBehavior;
+    bool fHintingIsOn;
+    bool fReplaceTabCharacters;
+};
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // ParagraphStyle_DEFINED

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

@@ -0,0 +1,30 @@
+// Copyright 2019 Google LLC.
+#ifndef TextShadow_DEFINED
+#define TextShadow_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkPoint.h"
+
+namespace skia {
+namespace textlayout {
+
+class TextShadow {
+public:
+    SkColor fColor = SK_ColorBLACK;
+    SkPoint fOffset;
+    double fBlurSigma = 0.0;
+
+    TextShadow();
+
+    TextShadow(SkColor color, SkPoint offset, double blurSigma);
+
+    bool operator==(const TextShadow& other) const;
+
+    bool operator!=(const TextShadow& other) const;
+
+    bool hasShadow() const;
+};
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // TextShadow_DEFINED

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

@@ -0,0 +1,352 @@
+// Copyright 2019 Google LLC.
+#ifndef TextStyle_DEFINED
+#define TextStyle_DEFINED
+
+#include <optional>
+#include <vector>
+#include "include/core/SkColor.h"
+#include "include/core/SkFont.h"
+#include "include/core/SkFontMetrics.h"
+#include "include/core/SkFontStyle.h"
+#include "include/core/SkPaint.h"
+#include "include/core/SkScalar.h"
+#include "modules/skparagraph/include/DartTypes.h"
+#include "modules/skparagraph/include/FontArguments.h"
+#include "modules/skparagraph/include/TextShadow.h"
+
+// TODO: Make it external so the other platforms (Android) could use it
+#define DEFAULT_FONT_FAMILY "sans-serif"
+
+namespace skia {
+namespace textlayout {
+
+static inline bool nearlyZero(SkScalar x, SkScalar tolerance = SK_ScalarNearlyZero) {
+    if (SkScalarIsFinite(x)) {
+        return SkScalarNearlyZero(x, tolerance);
+    }
+    return false;
+}
+
+static inline bool nearlyEqual(SkScalar x, SkScalar y, SkScalar tolerance = SK_ScalarNearlyZero) {
+    if (SkScalarIsFinite(x) && SkScalarIsFinite(x)) {
+        return SkScalarNearlyEqual(x, y, tolerance);
+    }
+    // Inf == Inf, anything else is false
+    return x == y;
+}
+
+// Multiple decorations can be applied at once. Ex: Underline and overline is
+// (0x1 | 0x2)
+enum TextDecoration {
+    kNoDecoration = 0x0,
+    kUnderline = 0x1,
+    kOverline = 0x2,
+    kLineThrough = 0x4,
+};
+constexpr TextDecoration AllTextDecorations[] = {
+        kNoDecoration,
+        kUnderline,
+        kOverline,
+        kLineThrough,
+};
+
+enum TextDecorationStyle { kSolid, kDouble, kDotted, kDashed, kWavy };
+
+enum TextDecorationMode { kGaps, kThrough };
+
+enum StyleType {
+    kNone,
+    kAllAttributes,
+    kFont,
+    kForeground,
+    kBackground,
+    kShadow,
+    kDecorations,
+    kLetterSpacing,
+    kWordSpacing
+};
+
+struct Decoration {
+    TextDecoration fType;
+    TextDecorationMode fMode;
+    SkColor fColor;
+    TextDecorationStyle fStyle;
+    SkScalar fThicknessMultiplier;
+
+    bool operator==(const Decoration& other) const {
+        return this->fType == other.fType &&
+               this->fMode == other.fMode &&
+               this->fColor == other.fColor &&
+               this->fStyle == other.fStyle &&
+               this->fThicknessMultiplier == other.fThicknessMultiplier;
+    }
+};
+
+/// Where to vertically align the placeholder relative to the surrounding text.
+enum class PlaceholderAlignment {
+  /// Match the baseline of the placeholder with the baseline.
+  kBaseline,
+
+  /// Align the bottom edge of the placeholder with the baseline such that the
+  /// placeholder sits on top of the baseline.
+  kAboveBaseline,
+
+  /// Align the top edge of the placeholder with the baseline specified in
+  /// such that the placeholder hangs below the baseline.
+  kBelowBaseline,
+
+  /// Align the top edge of the placeholder with the top edge of the font.
+  /// When the placeholder is very tall, the extra space will hang from
+  /// the top and extend through the bottom of the line.
+  kTop,
+
+  /// Align the bottom edge of the placeholder with the top edge of the font.
+  /// When the placeholder is very tall, the extra space will rise from
+  /// the bottom and extend through the top of the line.
+  kBottom,
+
+  /// Align the middle of the placeholder with the middle of the text. When the
+  /// placeholder is very tall, the extra space will grow equally from
+  /// the top and bottom of the line.
+  kMiddle,
+};
+
+struct FontFeature {
+    FontFeature(const SkString name, int value) : fName(name), fValue(value) {}
+    bool operator==(const FontFeature& that) const {
+        return fName == that.fName && fValue == that.fValue;
+    }
+    SkString fName;
+    int fValue;
+};
+
+struct PlaceholderStyle {
+    PlaceholderStyle() = default;
+    PlaceholderStyle(SkScalar width, SkScalar height, PlaceholderAlignment alignment,
+                     TextBaseline baseline, SkScalar offset)
+            : fWidth(width)
+            , fHeight(height)
+            , fAlignment(alignment)
+            , fBaseline(baseline)
+            , fBaselineOffset(offset) {}
+
+    bool equals(const PlaceholderStyle&) const;
+
+    SkScalar fWidth = 0;
+    SkScalar fHeight = 0;
+    PlaceholderAlignment fAlignment = PlaceholderAlignment::kBaseline;
+    TextBaseline fBaseline = TextBaseline::kAlphabetic;
+    // Distance from the top edge of the rect to the baseline position. This
+    // baseline will be aligned against the alphabetic baseline of the surrounding
+    // text.
+    //
+    // Positive values drop the baseline lower (positions the rect higher) and
+    // small or negative values will cause the rect to be positioned underneath
+    // the line. When baseline == height, the bottom edge of the rect will rest on
+    // the alphabetic baseline.
+    SkScalar fBaselineOffset = 0;
+};
+
+class TextStyle {
+public:
+    TextStyle() = default;
+    TextStyle(const TextStyle& other) = default;
+    TextStyle& operator=(const TextStyle& other) = default;
+
+    TextStyle cloneForPlaceholder();
+
+    bool equals(const TextStyle& other) const;
+    bool equalsByFonts(const TextStyle& that) const;
+    bool matchOneAttribute(StyleType styleType, const TextStyle& other) const;
+    bool operator==(const TextStyle& rhs) const { return this->equals(rhs); }
+
+    // Colors
+    SkColor getColor() const { return fColor; }
+    void setColor(SkColor color) { fColor = color; }
+
+    bool hasForeground() const { return fHasForeground; }
+    SkPaint getForeground() const { return fForeground; }
+    void setForegroundColor(SkPaint paint) {
+        fHasForeground = true;
+        fForeground = std::move(paint);
+    }
+    void clearForegroundColor() { fHasForeground = false; }
+
+    bool hasBackground() const { return fHasBackground; }
+    SkPaint getBackground() const { return fBackground; }
+    void setBackgroundColor(SkPaint paint) {
+        fHasBackground = true;
+        fBackground = std::move(paint);
+    }
+    void clearBackgroundColor() { fHasBackground = false; }
+
+    // Decorations
+    Decoration getDecoration() const { return fDecoration; }
+    TextDecoration getDecorationType() const { return fDecoration.fType; }
+    TextDecorationMode getDecorationMode() const { return fDecoration.fMode; }
+    SkColor getDecorationColor() const { return fDecoration.fColor; }
+    TextDecorationStyle getDecorationStyle() const { return fDecoration.fStyle; }
+    SkScalar getDecorationThicknessMultiplier() const {
+        return fDecoration.fThicknessMultiplier;
+    }
+    void setDecoration(TextDecoration decoration) { fDecoration.fType = decoration; }
+    void setDecorationMode(TextDecorationMode mode) { fDecoration.fMode = mode; }
+    void setDecorationStyle(TextDecorationStyle style) { fDecoration.fStyle = style; }
+    void setDecorationColor(SkColor color) { fDecoration.fColor = color; }
+    void setDecorationThicknessMultiplier(SkScalar m) { fDecoration.fThicknessMultiplier = m; }
+
+    // Weight/Width/Slant
+    SkFontStyle getFontStyle() const { return fFontStyle; }
+    void setFontStyle(SkFontStyle fontStyle) { fFontStyle = fontStyle; }
+
+    // Shadows
+    size_t getShadowNumber() const { return fTextShadows.size(); }
+    std::vector<TextShadow> getShadows() const { return fTextShadows; }
+    void addShadow(TextShadow shadow) { fTextShadows.emplace_back(shadow); }
+    void resetShadows() { fTextShadows.clear(); }
+
+    // Font features
+    size_t getFontFeatureNumber() const { return fFontFeatures.size(); }
+    std::vector<FontFeature> getFontFeatures() const { return fFontFeatures; }
+    void addFontFeature(const SkString& fontFeature, int value)
+        { fFontFeatures.emplace_back(fontFeature, value); }
+    void resetFontFeatures() { fFontFeatures.clear(); }
+
+    // Font arguments
+    const std::optional<FontArguments>& getFontArguments() const { return fFontArguments; }
+    // The contents of the SkFontArguments will be copied into the TextStyle,
+    // and the SkFontArguments can be safely deleted after setFontArguments returns.
+    void setFontArguments(const std::optional<SkFontArguments>& args);
+
+    SkScalar getFontSize() const { return fFontSize; }
+    void setFontSize(SkScalar size) { fFontSize = size; }
+
+    const std::vector<SkString>& getFontFamilies() const { return fFontFamilies; }
+    void setFontFamilies(std::vector<SkString> families) {
+        fFontFamilies = std::move(families);
+    }
+
+    SkScalar getBaselineShift() const { return fBaselineShift; }
+    void setBaselineShift(SkScalar baselineShift) { fBaselineShift = baselineShift; }
+
+    void setHeight(SkScalar height) { fHeight = height; }
+    SkScalar getHeight() const { return fHeightOverride ? fHeight : 0; }
+
+    void setHeightOverride(bool heightOverride) { fHeightOverride = heightOverride; }
+    bool getHeightOverride() const { return fHeightOverride; }
+
+    void setHalfLeading(bool halfLeading) { fHalfLeading = halfLeading; }
+    bool getHalfLeading() const { return fHalfLeading; }
+
+    void setLetterSpacing(SkScalar letterSpacing) { fLetterSpacing = letterSpacing; }
+    SkScalar getLetterSpacing() const { return fLetterSpacing; }
+
+    void setWordSpacing(SkScalar wordSpacing) { fWordSpacing = wordSpacing; }
+    SkScalar getWordSpacing() const { return fWordSpacing; }
+
+    SkTypeface* getTypeface() const { return fTypeface.get(); }
+    sk_sp<SkTypeface> refTypeface() const { return fTypeface; }
+    void setTypeface(sk_sp<SkTypeface> typeface) { fTypeface = std::move(typeface); }
+
+    SkString getLocale() const { return fLocale; }
+    void setLocale(const SkString& locale) { fLocale = locale; }
+
+    TextBaseline getTextBaseline() const { return fTextBaseline; }
+    void setTextBaseline(TextBaseline baseline) { fTextBaseline = baseline; }
+
+    void getFontMetrics(SkFontMetrics* metrics) const;
+
+    bool isPlaceholder() const { return fIsPlaceholder; }
+    void setPlaceholder() { fIsPlaceholder = true; }
+
+private:
+    static const std::vector<SkString>* kDefaultFontFamilies;
+
+    Decoration fDecoration = {
+            TextDecoration::kNoDecoration,
+            // TODO: switch back to kGaps when (if) switching flutter to skparagraph
+            TextDecorationMode::kThrough,
+            // It does not make sense to draw a transparent object, so we use this as a default
+            // value to indicate no decoration color was set.
+            SK_ColorTRANSPARENT, TextDecorationStyle::kSolid,
+            // Thickness is applied as a multiplier to the default thickness of the font.
+            1.0f};
+
+    SkFontStyle fFontStyle;
+
+    std::vector<SkString> fFontFamilies = *kDefaultFontFamilies;
+
+    SkScalar fFontSize = 14.0;
+    SkScalar fHeight = 1.0;
+    bool fHeightOverride = false;
+    SkScalar fBaselineShift = 0.0f;
+    // true: half leading.
+    // false: scale ascent/descent with fHeight.
+    bool fHalfLeading = false;
+    SkString fLocale = {};
+    SkScalar fLetterSpacing = 0.0;
+    SkScalar fWordSpacing = 0.0;
+
+    TextBaseline fTextBaseline = TextBaseline::kAlphabetic;
+
+    SkColor fColor = SK_ColorWHITE;
+    bool fHasBackground = false;
+    SkPaint fBackground;
+    bool fHasForeground = false;
+    SkPaint fForeground;
+
+    std::vector<TextShadow> fTextShadows;
+
+    sk_sp<SkTypeface> fTypeface;
+    bool fIsPlaceholder = false;
+
+    std::vector<FontFeature> fFontFeatures;
+
+    std::optional<FontArguments> fFontArguments;
+};
+
+typedef size_t TextIndex;
+typedef SkRange<size_t> TextRange;
+const SkRange<size_t> EMPTY_TEXT = EMPTY_RANGE;
+
+struct Block {
+    Block() = default;
+    Block(size_t start, size_t end, const TextStyle& style) : fRange(start, end), fStyle(style) {}
+    Block(TextRange textRange, const TextStyle& style) : fRange(textRange), fStyle(style) {}
+
+    void add(TextRange tail) {
+        SkASSERT(fRange.end == tail.start);
+        fRange = TextRange(fRange.start, fRange.start + fRange.width() + tail.width());
+    }
+
+    TextRange fRange = EMPTY_RANGE;
+    TextStyle fStyle;
+};
+
+
+typedef size_t BlockIndex;
+typedef SkRange<size_t> BlockRange;
+const size_t EMPTY_BLOCK = EMPTY_INDEX;
+const SkRange<size_t> EMPTY_BLOCKS = EMPTY_RANGE;
+
+struct Placeholder {
+    Placeholder() = default;
+    Placeholder(size_t start, size_t end, const PlaceholderStyle& style, const TextStyle& textStyle,
+                BlockRange blocksBefore, TextRange textBefore)
+            : fRange(start, end)
+            , fStyle(style)
+            , fTextStyle(textStyle)
+            , fBlocksBefore(blocksBefore)
+            , fTextBefore(textBefore) {}
+
+    TextRange fRange = EMPTY_RANGE;
+    PlaceholderStyle fStyle;
+    TextStyle fTextStyle;
+    BlockRange fBlocksBefore;
+    TextRange fTextBefore;
+};
+
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // TextStyle_DEFINED

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

@@ -0,0 +1,81 @@
+// Copyright 2019 Google LLC.
+#ifndef TypefaceFontProvider_DEFINED
+#define TypefaceFontProvider_DEFINED
+
+#include "include/private/SkTArray.h"
+#include "include/private/SkTHash.h"
+#include <string>
+#include <unordered_map>
+#include <vector>
+#include "include/core/SkFontMgr.h"
+#include "include/core/SkStream.h"
+#include "include/core/SkString.h"
+
+namespace skia {
+namespace textlayout {
+
+class TypefaceFontStyleSet : public SkFontStyleSet {
+public:
+    explicit TypefaceFontStyleSet(const SkString& familyName);
+
+    int count() override;
+    void getStyle(int index, SkFontStyle*, SkString* name) override;
+    SkTypeface* createTypeface(int index) override;
+    SkTypeface* matchStyle(const SkFontStyle& pattern) override;
+
+    SkString getFamilyName() const { return fFamilyName; }
+    SkString getAlias() const { return fAlias; }
+    void appendTypeface(sk_sp<SkTypeface> typeface);
+
+private:
+    SkTArray<sk_sp<SkTypeface>> fStyles;
+    SkString fFamilyName;
+    SkString fAlias;
+};
+
+class TypefaceFontProvider : public SkFontMgr {
+public:
+    size_t registerTypeface(sk_sp<SkTypeface> typeface);
+    size_t registerTypeface(sk_sp<SkTypeface> typeface, const SkString& alias);
+
+    int onCountFamilies() const override;
+
+    void onGetFamilyName(int index, SkString* familyName) const override;
+
+    SkFontStyleSet* onMatchFamily(const char familyName[]) const override;
+
+    SkFontStyleSet* onCreateStyleSet(int) const override { return nullptr; }
+    SkTypeface* onMatchFamilyStyle(const char[], const SkFontStyle&) const override {
+        return nullptr;
+    }
+    SkTypeface* onMatchFamilyStyleCharacter(const char[], const SkFontStyle&,
+                                            const char*[], int,
+                                            SkUnichar) const override {
+        return nullptr;
+    }
+
+    sk_sp<SkTypeface> onMakeFromData(sk_sp<SkData>, int) const override { return nullptr; }
+    sk_sp<SkTypeface> onMakeFromStreamIndex(std::unique_ptr<SkStreamAsset>, int) const override {
+        return nullptr;
+    }
+    sk_sp<SkTypeface> onMakeFromStreamArgs(std::unique_ptr<SkStreamAsset>,
+                                           const SkFontArguments&) const override {
+        return nullptr;
+    }
+    sk_sp<SkTypeface> onMakeFromFile(const char[], int) const override {
+        return nullptr;
+    }
+
+    sk_sp<SkTypeface> onLegacyMakeTypeface(const char[], SkFontStyle) const override {
+        return nullptr;
+    }
+
+private:
+    SkTHashMap<SkString, sk_sp<TypefaceFontStyleSet>> fRegisteredFamilies;
+    SkTArray<SkString> fFamilyNames;
+};
+
+}  // namespace textlayout
+}  // namespace skia
+
+#endif  // TypefaceFontProvider_DEFINED

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

@@ -141,7 +141,7 @@ private:
 
     template <typename T, typename TArray>
     bool parseEnumMap(const TArray& arr, T* result) {
-        for (size_t i = 0; i < SK_ARRAY_COUNT(arr); ++i) {
+        for (size_t i = 0; i < std::size(arr); ++i) {
             if (this->parseExpectedStringToken(std::get<0>(arr[i]))) {
                 *result = std::get<1>(arr[i]);
                 return true;

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

@@ -204,10 +204,10 @@ public:
     Type type() const { return fType; }
     const SkSVGColorType& color() const { SkASSERT(fType == Type::kColor); return fColor; }
     SkSpan<const SkString> vars() const {
-        return fVars ? SkMakeSpan<const Vars>(fVars->fData) : SkSpan<const SkString>{nullptr, 0};
+        return fVars ? SkSpan<const SkString>(fVars->fData) : SkSpan<const SkString>();
     }
-    SkSpan<      SkString> vars()       {
-        return fVars ? SkMakeSpan<      Vars>(fVars->fData) : SkSpan<      SkString>{nullptr, 0};
+    SkSpan<SkString> vars()       {
+        return fVars ? SkSpan<SkString>(fVars->fData) : SkSpan<SkString>();
     }
 
 private: