@shopify/react-native-skia 1.12.0 → 1.12.2

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

@@ -39,6 +39,85 @@ struct SK_API SkColorSpacePrimaries {
     bool toXYZD50(skcms_Matrix3x3* toXYZD50) const;
 };
 
+namespace SkNamedPrimaries {
+
+////////////////////////////////////////////////////////////////////////////////
+// Color primaries defined by ITU-T H.273, table 2. Names are given by the first
+// specification referenced in the value's row.
+
+// Rec. ITU-R BT.709-6, value 1.
+static constexpr SkColorSpacePrimaries kRec709 = {
+        0.64f, 0.33f, 0.3f, 0.6f, 0.15f, 0.06f, 0.3127f, 0.329f};
+
+// Rec. ITU-R BT.470-6 System M (historical), value 4.
+static constexpr SkColorSpacePrimaries kRec470SystemM = {
+        0.67f, 0.33f, 0.21f, 0.71f, 0.14f, 0.08f, 0.31f, 0.316f};
+
+// Rec. ITU-R BT.470-6 System B, G (historical), value 5.
+static constexpr SkColorSpacePrimaries kRec470SystemBG = {
+        0.64f, 0.33f, 0.29f, 0.60f, 0.15f, 0.06f, 0.3127f, 0.3290f};
+
+// Rec. ITU-R BT.601-7 525, value 6.
+static constexpr SkColorSpacePrimaries kRec601 = {
+        0.630f, 0.340f, 0.310f, 0.595f, 0.155f, 0.070f, 0.3127f, 0.3290f};
+
+// SMPTE ST 240, value 7 (functionally the same as value 6).
+static constexpr SkColorSpacePrimaries kSMPTE_ST_240 = kRec601;
+
+// Generic film (colour filters using Illuminant C), value 8.
+static constexpr SkColorSpacePrimaries kGenericFilm = {
+        0.681f, 0.319f, 0.243f, 0.692f, 0.145f, 0.049f, 0.310f, 0.316f};
+
+// Rec. ITU-R BT.2020-2, value 9.
+static constexpr SkColorSpacePrimaries kRec2020{
+        0.708f, 0.292f, 0.170f, 0.797f, 0.131f, 0.046f, 0.3127f, 0.3290f};
+
+// SMPTE ST 428-1, value 10.
+static constexpr SkColorSpacePrimaries kSMPTE_ST_428_1 = {
+        1.f, 0.f, 0.f, 1.f, 0.f, 0.f, 1.f / 3.f, 1.f / 3.f};
+
+// SMPTE RP 431-2, value 11.
+static constexpr SkColorSpacePrimaries kSMPTE_RP_431_2 = {
+        0.680f, 0.320f, 0.265f, 0.690f, 0.150f, 0.060f, 0.314f, 0.351f};
+
+// SMPTE EG 432-1, value 12.
+static constexpr SkColorSpacePrimaries kSMPTE_EG_432_1 = {
+        0.680f, 0.320f, 0.265f, 0.690f, 0.150f, 0.060f, 0.3127f, 0.3290f};
+
+// No corresponding industry specification identified, value 22.
+// This is sometimes referred to as EBU 3213-E, but that document doesn't
+// specify these values.
+static constexpr SkColorSpacePrimaries kITU_T_H273_Value22 = {
+        0.630f, 0.340f, 0.295f, 0.605f, 0.155f, 0.077f, 0.3127f, 0.3290f};
+
+// Mapping between names of color primaries and the number of the corresponding
+// row in ITU-T H.273, table 2.  As above, the constants are named based on the
+// first specification referenced in the value's row.
+enum class CicpId : uint8_t {
+    // Value 0 is reserved.
+    kRec709 = 1,
+    // Value 2 is unspecified.
+    // Value 3 is reserved.
+    kRec470SystemM = 4,
+    kRec470SystemBG = 5,
+    kRec601 = 6,
+    kSMPTE_ST_240 = 7,
+    kGenericFilm = 8,
+    kRec2020 = 9,
+    kSMPTE_ST_428_1 = 10,
+    kSMPTE_RP_431_2 = 11,
+    kSMPTE_EG_432_1 = 12,
+    // Values 13-21 are reserved.
+    kITU_T_H273_Value22 = 22,
+    // Values 23-255 are reserved.
+};
+
+// https://www.w3.org/TR/css-color-4/#predefined-prophoto-rgb
+static constexpr SkColorSpacePrimaries kProPhotoRGB = {
+        0.7347f, 0.2653f, 0.1596f, 0.8404f, 0.0366f, 0.0001f, 0.34567f, 0.35850f};
+
+}  // namespace SkNamedPrimaries
+
 namespace SkNamedTransferFn {
 
 // Like SkNamedGamut::kSRGB, keeping this bitwise exactly the same as skcms makes things fastest.
@@ -48,18 +127,98 @@ static constexpr skcms_TransferFunction kSRGB =
 static constexpr skcms_TransferFunction k2Dot2 =
     { 2.2f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 
+static constexpr skcms_TransferFunction kRec2020 = {
+        2.22222f, 0.909672f, 0.0903276f, 0.222222f, 0.0812429f, 0, 0};
+
+////////////////////////////////////////////////////////////////////////////////
+// Color primaries defined by ITU-T H.273, table 3. Names are given by the first
+// specification referenced in the value's row.
+
+// Rec. ITU-R BT.709-6, value 1.
+static constexpr skcms_TransferFunction kRec709 = {2.222222222222f,
+                                                   0.909672415686f,
+                                                   0.090327584314f,
+                                                   0.222222222222f,
+                                                   0.081242858299f,
+                                                   0.f,
+                                                   0.f};
+
+// Rec. ITU-R BT.470-6 System M (historical) assumed display gamma 2.2, value 4.
+static constexpr skcms_TransferFunction kRec470SystemM = {2.2f, 1.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+
+// Rec. ITU-R BT.470-6 System B, G (historical) assumed display gamma 2.8,
+// value 5.
+static constexpr skcms_TransferFunction kRec470SystemBG = {2.8f, 1.f, 0.f, 0.f, 0.f, 0.f, 0.f};
+
+// Rec. ITU-R BT.601-7, same as kRec709, value 6.
+static constexpr skcms_TransferFunction kRec601 = kRec709;
+
+// SMPTE ST 240, value 7.
+static constexpr skcms_TransferFunction kSMPTE_ST_240 = {
+        2.222222222222f, 0.899626676224f, 0.100373323776f, 0.25f, 0.091286342118f, 0.f, 0.f};
+
+// Linear, value 8
 static constexpr skcms_TransferFunction kLinear =
     { 1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
 
-static constexpr skcms_TransferFunction kRec2020 =
-    {2.22222f, 0.909672f, 0.0903276f, 0.222222f, 0.0812429f, 0, 0};
+// IEC 61966-2-4, value 11, same as kRec709 (but is explicitly extended).
+static constexpr skcms_TransferFunction kIEC61966_2_4 = kRec709;
+
+// IEC 61966-2-1 sRGB, value 13.
+static constexpr skcms_TransferFunction kIEC61966_2_1 = kSRGB;
+
+// Rec. ITU-R BT.2020-2 (10-bit system), value 14.
+static constexpr skcms_TransferFunction kRec2020_10bit = kRec709;
 
+// Rec. ITU-R BT.2020-2 (12-bit system), value 15.
+static constexpr skcms_TransferFunction kRec2020_12bit = kRec709;
+
+// Rec. ITU-R BT.2100-2 perceptual quantization (PQ) system, value 16.
 static constexpr skcms_TransferFunction kPQ =
     {-2.0f, -107/128.0f, 1.0f, 32/2523.0f, 2413/128.0f, -2392/128.0f, 8192/1305.0f };
 
+// SMPTE ST 428-1, value 17.
+static constexpr skcms_TransferFunction kSMPTE_ST_428_1 = {
+        2.6f, 1.034080527699f, 0.f, 0.f, 0.f, 0.f, 0.f};
+
+// Rec. ITU-R BT.2100-2 hybrid log-gamma (HLG) system, value 18.
 static constexpr skcms_TransferFunction kHLG =
     {-3.0f, 2.0f, 2.0f, 1/0.17883277f, 0.28466892f, 0.55991073f, 0.0f };
 
+// Mapping between transfer function names and the number of the corresponding
+// row in ITU-T H.273, table 3.  As above, the constants are named based on the
+// first specification referenced in the value's row.
+enum class CicpId : uint8_t {
+    // Value 0 is reserved.
+    kRec709 = 1,
+    // Value 2 is unspecified.
+    // Value 3 is reserved.
+    kRec470SystemM = 4,
+    kRec470SystemBG = 5,
+    kRec601 = 6,
+    kSMPTE_ST_240 = 7,
+    kLinear = 8,
+    // Value 9 is not supported by `SkColorSpace::MakeCICP`.
+    // Value 10 is not supported by `SkColorSpace::MakeCICP`.
+    kIEC61966_2_4 = 11,
+    // Value 12 is not supported by `SkColorSpace::MakeCICP`.
+    kIEC61966_2_1 = 13,
+    kSRGB = kIEC61966_2_1,
+    kRec2020_10bit = 14,
+    kRec2020_12bit = 15,
+    kPQ = 16,
+    kSMPTE_ST_428_1 = 17,
+    kHLG = 18,
+    // Values 19-255 are reserved.
+};
+
+// https://w3.org/TR/css-color-4/#valdef-color-prophoto-rgb
+// "The transfer curve is a gamma function with a value of 1/1.8"
+static constexpr skcms_TransferFunction kProPhotoRGB = {1.8f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f};
+
+// https://www.w3.org/TR/css-color-4/#predefined-a98-rgb
+static constexpr skcms_TransferFunction kA98RGB = k2Dot2;
+
 }  // namespace SkNamedTransferFn
 
 namespace SkNamedGamut {
@@ -122,6 +281,29 @@ public:
     static sk_sp<SkColorSpace> MakeRGB(const skcms_TransferFunction& transferFn,
                                        const skcms_Matrix3x3& toXYZ);
 
+    /**
+     *  Create an SkColorSpace from code points specified in Rec. ITU-T H.273.
+     *  Null will be returned for invalid or unsupported combination of code
+     *  points.
+     *
+     *  Parameters:
+     *
+     * - `color_primaries` identifies an entry in Rec. ITU-T H.273, Table 2.
+     * - `transfer_characteristics` identifies an entry in Rec. ITU-T H.273, Table 3.
+     *
+     * `SkColorSpace` (and the underlying `skcms_ICCProfile`) only supports RGB
+     * color spaces and therefore this function does not take a
+     * `matrix_coefficients` parameter - the caller is expected to verify that
+     * `matrix_coefficients` is `0`.
+     *
+     * Narrow range images are extremely rare - see
+     * https://github.com/w3c/png/issues/312#issuecomment-2327349614.  Therefore
+     * this function doesn't take a `video_full_range_flag` - the caller is
+     * expected to verify that it is `1` (indicating a full range image).
+     */
+    static sk_sp<SkColorSpace> MakeCICP(SkNamedPrimaries::CicpId color_primaries,
+                                        SkNamedTransferFn::CicpId transfer_characteristics);
+
     /**
      *  Create an SkColorSpace from a parsed (skcms) ICC profile.
      */

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

@@ -15,43 +15,125 @@
 
     kN32_SkColorType selects the native 32-bit ARGB format for the current configuration. This can
     lead to inconsistent results across platforms, so use with caution.
-*/
-enum SkColorType : int {
-    kUnknown_SkColorType,      //!< uninitialized
-    kAlpha_8_SkColorType,      //!< pixel with alpha in 8-bit byte
-    kRGB_565_SkColorType,      //!< pixel with 5 bits red, 6 bits green, 5 bits blue, in 16-bit word
-    kARGB_4444_SkColorType,    //!< pixel with 4 bits for alpha, red, green, blue; in 16-bit word
-    kRGBA_8888_SkColorType,    //!< pixel with 8 bits for red, green, blue, alpha; in 32-bit word
-    kRGB_888x_SkColorType,     //!< pixel with 8 bits each for red, green, blue; in 32-bit word
-    kBGRA_8888_SkColorType,    //!< pixel with 8 bits for blue, green, red, alpha; in 32-bit word
-    kRGBA_1010102_SkColorType, //!< 10 bits for red, green, blue; 2 bits for alpha; in 32-bit word
-    kBGRA_1010102_SkColorType, //!< 10 bits for blue, green, red; 2 bits for alpha; in 32-bit word
-    kRGB_101010x_SkColorType,  //!< pixel with 10 bits each for red, green, blue; in 32-bit word
-    kBGR_101010x_SkColorType,  //!< pixel with 10 bits each for blue, green, red; in 32-bit word
-    kBGR_101010x_XR_SkColorType, //!< pixel with 10 bits each for blue, green, red; in 32-bit word, extended range
-    kBGRA_10101010_XR_SkColorType, //!< pixel with 10 bits each for blue, green, red, alpha; in 64-bit word, extended range
-    kRGBA_10x6_SkColorType,    //!< pixel with 10 used bits (most significant) followed by 6 unused
-                               //   bits for red, green, blue, alpha; in 64-bit word
-    kGray_8_SkColorType,       //!< pixel with grayscale level in 8-bit byte
-    kRGBA_F16Norm_SkColorType, //!< pixel with half floats in [0,1] for red, green, blue, alpha;
-                               //   in 64-bit word
-    kRGBA_F16_SkColorType,     //!< pixel with half floats for red, green, blue, alpha;
-                               //   in 64-bit word
-    kRGB_F16F16F16x_SkColorType,     //!< pixel with half floats for red, green, blue; in 64-bit word
-    kRGBA_F32_SkColorType,     //!< pixel using C float for red, green, blue, alpha; in 128-bit word
 
-    // The following 6 colortypes are just for reading from - not for rendering to
-    kR8G8_unorm_SkColorType,         //!< pixel with a uint8_t for red and green
+    By default, Skia operates with the assumption of a little-Endian system. The names of each
+    SkColorType implicitly define the channel ordering and size in memory. Due to historical reasons
+    the names do not follow 100% identical convention, but are typically labeled from least
+    significant to most significant. To help clarify when the actual data layout differs from the
+    default convention, every SkColorType's comment includes a bit-labeled description of a pixel
+    in that color type on a LE system.
 
-    kA16_float_SkColorType,          //!< pixel with a half float for alpha
-    kR16G16_float_SkColorType,       //!< pixel with a half float for red and green
+    Unless specified otherwise, a channel's value is treated as an unsigned integer with a range of
+    of [0, 2^N-1] and this is mapped uniformly to a floating point value of [0.0, 1.0]. Some color
+    types instead store data directly in 32-bit floating point (assumed to be IEEE), or in 16-bit
+    "half" floating point values. A half float, or F16/float16, is interpreted as FP 1-5-10 or
+       Bits: [sign:15 exp:14..10 man:9..0]
+*/
+enum SkColorType : int {
+    // Unknown or unrepresentable as an SkColorType.
+    kUnknown_SkColorType,
+    // Single channel data (8-bit) interpreted as an alpha value. RGB are 0.
+    //   Bits: [A:7..0]
+    kAlpha_8_SkColorType,
+    // Three channel BGR data (5 bits red, 6 bits green, 5 bits blue) packed into a LE 16-bit word.
+    // NOTE: The name of this enum value does not match the standard convention for SkColorType.
+    //   Bits: [R:15..11 G:10..5 B:4..0]
+    kRGB_565_SkColorType,
+    // Four channel ABGR data (4 bits per channel) packed into a LE 16-bit word.
+    // NOTE: The name of this enum value does not match the standard convention for SkColorType.
+    //   Bits: [R:15..12 G:11..8 B:7..4 A:3..0]
+    kARGB_4444_SkColorType,
+    // Four channel RGBA data (8 bits per channel) packed into a LE 32-bit word.
+    //   Bits: [A:31..24 B:23..16 G:15..8 R:7..0]
+    kRGBA_8888_SkColorType,
+    // Three channel RGB data (8 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque.
+    //   Bits: [x:31..24 B:23..16 G:15..8 R:7..0]
+    kRGB_888x_SkColorType,
+    // Four channel BGRA data (8 bits per channel) packed into a LE 32-bit word. R and B are swapped
+    // relative to kRGBA_8888.
+    //   Bits: [A:31..24 R:23..16 G:15..8 B:7..0]
+    kBGRA_8888_SkColorType,
+    // Four channel RGBA data (10 bits per color, 2 bits for alpha) packed into a LE 32-bit word.
+    //   Bits: [A:31..30 B:29..20 G:19..10 R:9..0]
+    kRGBA_1010102_SkColorType,
+    // Four channel BGRA data (10 bits per color, 2 bits for alpha) packed into a LE 32-bit word.
+    // R and B are swapped relative to kRGBA_1010102.
+    //   Bits: [A:31..30 R:29..20 G:19..10 B:9..0]
+    kBGRA_1010102_SkColorType,
+    // Three channel RGB data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque.
+    //   Bits: [x:31..30 B:29..20 G:19..10 R:9..0]
+    kRGB_101010x_SkColorType,
+    // Three channel BGR data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque. R and B are swapped relative to kRGB_101010x.
+    //   Bits: [x:31..30 R:29..20 G:19..10 B:9..0]
+    kBGR_101010x_SkColorType,
+    // Three channel BGR data (10 bits per channel) packed into a LE 32-bit word. The remaining bits
+    // are ignored and alpha is forced to opaque. Instead of normalizing [0, 1023] to [0.0, 1.0] the
+    // color channels map to an extended range of [-0.752941, 1.25098], compatible with
+    // MTLPixelFormatBGR10_XR.
+    //   Bits: [x:31..30 R:29..20 G:19..10 B:9..0]
+    kBGR_101010x_XR_SkColorType,
+    // Four channel BGRA data (10 bits per channel) packed into a LE 64-bit word. Each channel is
+    // preceded by 6 bits of padding.  Instead of normalizing [0, 1023] to [0.0, 1.0] the color and
+    // alpha channels map to an extended range of [-0.752941, 1.25098], compatible with
+    // MTLPixelFormatBGRA10_XR.
+    //   Bits: [A:63..54 x:53..48 R:47..38 x:37..32 G:31..22 x:21..16 B:15..6 x:5..0]
+    kBGRA_10101010_XR_SkColorType,
+    // Four channel RGBA data (10 bits per channel) packed into a LE 64-bit word. Each channel is
+    // preceded by 6 bits of padding.
+    //   Bits: [A:63..54 x:53..48 B:47..38 x:37..32 G:31..22 x:21..16 R:15..6 x:5..0]
+    kRGBA_10x6_SkColorType,
+    // Single channel data (8-bit) interpreted as a grayscale value (e.g. replicated to RGB).
+    //   Bits: [G:7..0]
+    kGray_8_SkColorType,
+    // Four channel RGBA data (16-bit half-float per channel) packed into a LE 64-bit word. Values
+    // are assumed to be in [0.0,1.0] range, unlike kRGBA_F16.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kRGBA_F16Norm_SkColorType,
+    // Four channel RGBA data (16-bit half-float per channel) packed into a LE 64-bit word.
+    // This has extended range compared to kRGBA_F16Norm.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kRGBA_F16_SkColorType,
+    // Three channel RGB data (16-bit half-float per channel) packed into a LE 64-bit word. The last
+    // 16 bits are ignored and alpha is forced to opaque.
+    //   Bits: [x:63..48 B:47..32 G:31..16 R:15..0]
+    kRGB_F16F16F16x_SkColorType,
+    // 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,
 
-    kA16_unorm_SkColorType,          //!< pixel with a little endian uint16_t for alpha
-    kR16G16_unorm_SkColorType,       //!< pixel with a little endian uint16_t for red and green
-    kR16G16B16A16_unorm_SkColorType, //!< pixel with a little endian uint16_t for red, green, blue
-                                     //   and alpha
+    // 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,
+    // 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]
+    kR16G16_float_SkColorType,
+    // Single channel data (16 bits) interpreted as alpha. RGB are 0.
+    //   Bits: [A:15..0]
+    kA16_unorm_SkColorType,
+    // Two channel RG data (16 bits per channel) packed into a LE 32-bit word. B is forced to 0,
+    // alpha is forced to opaque.
+    //   Bits: [G:31..16 R:15..0]
+    kR16G16_unorm_SkColorType,
+    // Four channel RGBA data (16 bits per channel) packed into a LE 64-bit word.
+    //   Bits: [A:63..48 B:47..32 G:31..16 R:15..0]
+    kR16G16B16A16_unorm_SkColorType,
+    // Four channel RGBA data (8 bits per channel) packed into a LE 32-bit word. The RGB values are
+    // assumed to be encoded with the sRGB transfer function, which can be decoded automatically
+    // by GPU hardware with certain texture formats.
+    //   Bits: [A:31..24 B:23..16 G:15..8 R:7..0]
     kSRGBA_8888_SkColorType,
+    // Single channel data (8 bits) interpreted as red. G and B are forced to 0, alpha is forced to
+    // opaque.
+    //    Bits: [R:7..0]
     kR8_unorm_SkColorType,
 
     kLastEnum_SkColorType     = kR8_unorm_SkColorType, //!< last valid value

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

@@ -9,6 +9,7 @@
 #define SKFONTSCANNER_H_
 
 #include "include/core/SkFontArguments.h"
+#include "include/core/SkFontParameters.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkFixed.h"
@@ -22,13 +23,8 @@ class SkTypeface;
 class SkFontScanner : public SkNoncopyable {
 public:
     virtual ~SkFontScanner() = default;
-    struct AxisDefinition {
-        SkFourByteTag fTag;
-        SkScalar fMinimum;
-        SkScalar fDefault;
-        SkScalar fMaximum;
-    };
-    typedef skia_private::STArray<4, AxisDefinition, true> AxisDefinitions;
+    using AxisDefinitions = skia_private::STArray<4, SkFontParameters::Variation::Axis, true>;
+    using VariationPosition = skia_private::STArray<4, SkFontArguments::VariationPosition::Coordinate, true>;
 
     virtual bool scanFile(SkStreamAsset* stream, int* numFaces) const = 0;
     virtual bool scanFace(SkStreamAsset* stream, int faceIndex, int* numInstances) const = 0;
@@ -39,7 +35,8 @@ public:
                               SkString* name,
                               SkFontStyle* style,
                               bool* isFixedPitch,
-                              AxisDefinitions* axes) const = 0;
+                              AxisDefinitions* axes,
+                              VariationPosition* position) const = 0;
     virtual sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream,
                                              const SkFontArguments& args) const = 0;
     virtual SkFourByteTag getFactoryId() const = 0;

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

@@ -41,7 +41,7 @@ public:
         kUltraExpanded_Width    = 9,
     };
 
-    enum Slant {
+    enum Slant : uint8_t {
         kUpright_Slant,
         kItalic_Slant,
         kOblique_Slant,

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

@@ -17,7 +17,6 @@
 
 enum SkBlurStyle : int;
 struct SkDeserialProcs;
-struct SkRect;
 
 /** \class SkMaskFilter
 
@@ -35,13 +34,6 @@ public:
     static sk_sp<SkMaskFilter> MakeBlur(SkBlurStyle style, SkScalar sigma,
                                         bool respectCTM = true);
 
-    /**
-     *  Returns the approximate bounds that would result from filtering the src rect.
-     *  The actual result may be different, but it should be contained within the
-     *  returned bounds.
-     */
-    SkRect approximateFilteredBounds(const SkRect& src) const;
-
     static sk_sp<SkMaskFilter> Deserialize(const void* data, size_t size,
                                            const SkDeserialProcs* procs = nullptr);
 

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

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 132
+#define SK_MILESTONE 134
 #endif

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

@@ -1909,7 +1909,7 @@ private:
     void shrinkToFit();
 
     // Creates a new Path after the supplied arguments have been validated by
-    // sk_path_analyze_verbs().
+    // SkPathPriv::AnalyzeVerbs().
     static SkPath MakeInternal(const SkPathVerbAnalysis& analsis,
                                const SkPoint points[],
                                const uint8_t verbs[],

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

@@ -13,6 +13,7 @@
 #include "include/core/SkScalar.h"
 #include "include/core/SkSpan.h"
 #include "include/core/SkTypes.h"
+#include "include/private/base/SkMacros.h"
 
 #include <cstdint>
 #include <cstring>
@@ -33,6 +34,7 @@ class SkString;
     If either axis radii is zero or less: radii are stored as zero; corner is square.
     If corner curves overlap, radii are proportionally reduced to fit within bounds.
 */
+SK_BEGIN_REQUIRE_DENSE
 class SK_API SkRRect {
 public:
 
@@ -511,11 +513,11 @@ private:
     SkVector fRadii[4] = {{0, 0}, {0, 0}, {0,0}, {0,0}};
     // use an explicitly sized type so we're sure the class is dense (no uninitialized bytes)
     int32_t fType = kEmpty_Type;
-    // TODO: add padding so we can use memcpy for flattening and not copy uninitialized data
 
     // to access fRadii directly
     friend class SkPath;
     friend class SkRRectPriv;
 };
+SK_END_REQUIRE_DENSE
 
 #endif

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

@@ -25,9 +25,9 @@ struct SkSamplingOptions;
 
 /** \class SkShader
  *
- *  Shaders specify the source color(s) for what is being drawn. If a paint
- *  has no shader, then the paint's color is used. If the paint has a
- *  shader, then the shader's color(s) are use instead, but they are
+ *  Shaders specify the premultiplied source color(s) for what is being drawn.
+ *  If a paint has no shader, then the paint's color is used. If the paint has a
+ *  shader, then the shader's color(s) are used instead, but they are
  *  modulated by the paint's alpha. This makes it easy to create a shader
  *  once (e.g. bitmap tiling or gradient) and then change its transparency
  *  w/o having to modify the original shader... only the paint's alpha needs

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

@@ -28,13 +28,13 @@ static inline bool SkStrStartsWith(const char string[], const char prefixStr[])
     SkASSERT(prefixStr);
     return !strncmp(string, prefixStr, strlen(prefixStr));
 }
-static inline bool SkStrStartsWith(const char string[], const char prefixChar) {
+static inline bool SkStrStartsWith(const char string[], char prefixChar) {
     SkASSERT(string);
     return (prefixChar == *string);
 }
 
 bool SkStrEndsWith(const char string[], const char suffixStr[]);
-bool SkStrEndsWith(const char string[], const char suffixChar);
+bool SkStrEndsWith(const char string[], char suffixChar);
 
 int SkStrStartsWithOneOf(const char string[], const char prefixes[]);
 
@@ -44,7 +44,7 @@ static inline int SkStrFind(const char string[], const char substring[]) {
     return SkToInt(first - &string[0]);
 }
 
-static inline int SkStrFindLastOf(const char string[], const char subchar) {
+static inline int SkStrFindLastOf(const char string[], char subchar) {
     const char* last = strrchr(string, subchar);
     if (nullptr == last) return -1;
     return SkToInt(last - &string[0]);
@@ -55,7 +55,7 @@ static inline bool SkStrContains(const char string[], const char substring[]) {
     SkASSERT(substring);
     return (-1 != SkStrFind(string, substring));
 }
-static inline bool SkStrContains(const char string[], const char subchar) {
+static inline bool SkStrContains(const char string[], char subchar) {
     SkASSERT(string);
     char tmp[2];
     tmp[0] = subchar;
@@ -142,25 +142,25 @@ public:
     bool startsWith(const char prefixStr[]) const {
         return SkStrStartsWith(fRec->data(), prefixStr);
     }
-    bool startsWith(const char prefixChar) const {
+    bool startsWith(char prefixChar) const {
         return SkStrStartsWith(fRec->data(), prefixChar);
     }
     bool endsWith(const char suffixStr[]) const {
         return SkStrEndsWith(fRec->data(), suffixStr);
     }
-    bool endsWith(const char suffixChar) const {
+    bool endsWith(char suffixChar) const {
         return SkStrEndsWith(fRec->data(), suffixChar);
     }
     bool contains(const char substring[]) const {
         return SkStrContains(fRec->data(), substring);
     }
-    bool contains(const char subchar) const {
+    bool contains(char subchar) const {
         return SkStrContains(fRec->data(), subchar);
     }
     int find(const char substring[]) const {
         return SkStrFind(fRec->data(), substring);
     }
-    int findLastOf(const char subchar) const {
+    int findLastOf(char subchar) const {
         return SkStrFindLastOf(fRec->data(), subchar);
     }
 

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

@@ -330,6 +330,20 @@ public:
      */
     sk_sp<SkImage> makeImageSnapshot(const SkIRect& bounds);
 
+    /** Returns an SkImage capturing the current SkSurface contents. However, the contents of the
+        SkImage are only valid as long as no other writes to the SkSurface occur. If writes to the
+        original SkSurface happen then contents of the SkImage are undefined. However, continued use
+        of the SkImage should not cause crashes or similar fatal behavior.
+
+        This API is useful for cases where the client either immediately destroys the SkSurface
+        after the SkImage is created or knows they will destroy the SkImage before writing to the
+        SkSurface again.
+
+        This API can be more performant than makeImageSnapshot as it never does an internal copy
+        of the data assuming the user frees either the SkImage or SkSurface as described above.
+     */
+    sk_sp<SkImage> makeTemporaryImage();
+
     /** Draws SkSurface contents to canvas, with its top-left corner at (x, y).
 
         If SkPaint paint is not nullptr, apply SkColorFilter, alpha, SkImageFilter, and SkBlendMode.

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

@@ -53,20 +53,18 @@ typedef uint32_t SkFontTableTag;
 class SK_API SkTypeface : public SkWeakRefCnt {
 public:
     /** Returns the typeface's intrinsic style attributes. */
-    SkFontStyle fontStyle() const {
-        return fStyle;
-    }
+    SkFontStyle fontStyle() const;
 
     /** Returns true if style() has the kBold bit set. */
-    bool isBold() const { return fStyle.weight() >= SkFontStyle::kSemiBold_Weight; }
+    bool isBold() const;
 
     /** Returns true if style() has the kItalic bit set. */
-    bool isItalic() const { return fStyle.slant() != SkFontStyle::kUpright_Slant; }
+    bool isItalic() const;
 
     /** Returns true if the typeface claims to be fixed-pitch.
      *  This is a style bit, advance widths may vary even if this returns true.
      */
-    bool isFixedPitch() const { return fIsFixedPitch; }
+    bool isFixedPitch() const;
 
     /** Copy into 'coordinates' (allocated by the caller) the design variation coordinates.
      *
@@ -287,6 +285,20 @@ public:
      */
     bool getPostScriptName(SkString* name) const;
 
+    /**
+     *  If the primary resource backing this typeface has a name (like a file
+     *  path or URL) representable by unicode code points, the `resourceName`
+     *  will be set. The primary purpose is as a user facing indication about
+     *  where the data was obtained (which font file was used).
+     *
+     *  Returns the number of resources backing this typeface.
+     *
+     *  For local font collections resource name will often be a file path. The
+     *  file path may or may not exist. If it does exist, using it to create an
+     *  SkTypeface may or may not create a similar SkTypeface to this one.
+     */
+    int getResourceName(SkString* resourceName) const;
+
     /**
      *  Return a stream for the contents of the font data, or NULL on failure.
      *  If ttcIndex is not null, it is set to the TrueTypeCollection index
@@ -349,6 +361,10 @@ protected:
     /** Sets the font style. If used, must be called in the constructor. */
     void setFontStyle(SkFontStyle style) { fStyle = style; }
 
+    virtual SkFontStyle onGetFontStyle() const; // TODO: = 0;
+
+    virtual bool onGetFixedPitch() const; // TODO: = 0;
+
     // Must return a valid scaler context. It can not return nullptr.
     virtual std::unique_ptr<SkScalerContext> onCreateScalerContext(const SkScalerContextEffects&,
                                                                    const SkDescriptor*) const = 0;
@@ -398,6 +414,7 @@ protected:
      */
     virtual void onGetFamilyName(SkString* familyName) const = 0;
     virtual bool onGetPostScriptName(SkString*) const = 0;
+    virtual int onGetResourceName(SkString* resourceName) const; // TODO: = 0;
 
     /** Returns an iterator over the family names in the font. */
     virtual LocalizedStrings* onCreateFamilyNameIterator() const = 0;
@@ -424,7 +441,7 @@ private:
     std::unique_ptr<SkAdvancedTypefaceMetrics> getAdvancedMetrics() const;
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
-    friend class SkTypeface_fontconfig;
+    friend class SkTypeface_proxy;
 
     friend class SkFontPriv;         // getGlyphToUnicodeMap