@shopify/react-native-skia 0.1.129 → 0.1.130

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

@@ -8,41 +8,52 @@
 #ifndef SkImage_DEFINED
 #define SkImage_DEFINED
 
-#include "include/core/SkImageEncoder.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSamplingOptions.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkShader.h"
 #include "include/core/SkTileMode.h"
-#include "include/private/SkTOptional.h"
 #if SK_SUPPORT_GPU
 #include "include/gpu/GrTypes.h"
 #endif
+#if SK_GRAPHITE_ENABLED
+#include "include/gpu/graphite/GraphiteTypes.h"
+#endif
 #include <functional>  // std::function
+#include <optional>
 
 #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
 #include <android/hardware_buffer.h>
 #endif
 
-class SkData;
+class GrBackendFormat;
+class GrBackendTexture;
+class GrContextThreadSafeProxy;
+class GrDirectContext;
+class GrRecordingContext;
+class GrYUVABackendTextureInfo;
+class GrYUVABackendTextures;
 class SkCanvas;
+class SkData;
 class SkImage;
 class SkImageFilter;
 class SkImageGenerator;
 class SkMipmap;
 class SkPaint;
 class SkPicture;
+class SkPixmap;
 class SkPromiseImageTexture;
 class SkSurface;
 class SkYUVAPixmaps;
-class GrBackendFormat;
-class GrBackendTexture;
-class GrDirectContext;
-class GrRecordingContext;
-class GrContextThreadSafeProxy;
-class GrYUVABackendTextureInfo;
-class GrYUVABackendTextures;
+
+enum class SkEncodedImageFormat;
+
+#if SK_GRAPHITE_ENABLED
+namespace skgpu::graphite {
+class Recorder;
+};
+#endif
 
 /** \class SkImage
     SkImage describes a two dimensional array of pixels to draw. The pixels may be
@@ -184,7 +195,7 @@ public:
         example: https://fiddle.skia.org/c/@Image_MakeFromEncoded
     */
     static sk_sp<SkImage> MakeFromEncoded(sk_sp<SkData> encoded,
-                                          skstd::optional<SkAlphaType> alphaType = skstd::nullopt);
+                                          std::optional<SkAlphaType> alphaType = std::nullopt);
 
     /*
      * Experimental:
@@ -264,7 +275,7 @@ public:
         @param width       width of full SkImage
         @param height      height of full SkImage
         @param type        type of compression used
-        @param mipMapped   does 'data' contain data for all the mipmap levels?
+        @param mipmapped   does 'data' contain data for all the mipmap levels?
         @param isProtected do the contents of 'data' require DRM protection (on Vulkan)?
         @return            created SkImage, or nullptr
     */
@@ -272,7 +283,7 @@ public:
                                                     sk_sp<SkData> data,
                                                     int width, int height,
                                                     CompressionType type,
-                                                    GrMipmapped mipMapped = GrMipmapped::kNo,
+                                                    GrMipmapped mipmapped = GrMipmapped::kNo,
                                                     GrProtected isProtected = GrProtected::kNo);
 
     /** User function called when supplied texture may be deleted.
@@ -390,12 +401,21 @@ public:
         @param colorSpace      range of colors; may be nullptr
         @return                created SkImage, or nullptr
     */
+    static sk_sp<SkImage> MakeFromAdoptedTexture(GrRecordingContext* context,
+                                                 const GrBackendTexture& backendTexture,
+                                                 GrSurfaceOrigin textureOrigin,
+                                                 SkColorType colorType);
     static sk_sp<SkImage> MakeFromAdoptedTexture(GrRecordingContext* context,
                                                  const GrBackendTexture& backendTexture,
                                                  GrSurfaceOrigin textureOrigin,
                                                  SkColorType colorType,
-                                                 SkAlphaType alphaType = kPremul_SkAlphaType,
-                                                 sk_sp<SkColorSpace> colorSpace = nullptr);
+                                                 SkAlphaType alphaType);
+    static sk_sp<SkImage> MakeFromAdoptedTexture(GrRecordingContext* context,
+                                                 const GrBackendTexture& backendTexture,
+                                                 GrSurfaceOrigin textureOrigin,
+                                                 SkColorType colorType,
+                                                 SkAlphaType alphaType,
+                                                 sk_sp<SkColorSpace> colorSpace);
 
     /** Creates an SkImage from YUV[A] planar textures. This requires that the textures stay valid
         for the lifetime of the image. The ReleaseContext can be used to know when it is safe to
@@ -442,7 +462,7 @@ public:
     */
     static sk_sp<SkImage> MakeFromYUVAPixmaps(GrRecordingContext* context,
                                               const SkYUVAPixmaps& pixmaps,
-                                              GrMipMapped buildMips = GrMipmapped::kNo,
+                                              GrMipmapped buildMips = GrMipmapped::kNo,
                                               bool limitToMaxTextureSize = false,
                                               sk_sp<SkColorSpace> imageColorSpace = nullptr);
 
@@ -472,7 +492,7 @@ public:
         @param gpuContextProxy     the thread-safe proxy of the gpu context. required.
         @param backendFormat       format of promised gpu texture
         @param dimensions          width & height of promised gpu texture
-        @param mipMapped           mip mapped state of promised gpu texture
+        @param mipmapped           mip mapped state of promised gpu texture
         @param origin              surface origin of promised gpu texture
         @param colorType           color type of promised gpu texture
         @param alphaType           alpha type of promised gpu texture
@@ -485,7 +505,7 @@ public:
     static sk_sp<SkImage> MakePromiseTexture(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
                                              const GrBackendFormat& backendFormat,
                                              SkISize dimensions,
-                                             GrMipmapped mipMapped,
+                                             GrMipmapped mipmapped,
                                              GrSurfaceOrigin origin,
                                              SkColorType colorType,
                                              SkAlphaType alphaType,
@@ -722,7 +742,7 @@ public:
     */
     bool peekPixels(SkPixmap* pixmap) const;
 
-    /** Returns true the contents of SkImage was created on or uploaded to GPU memory,
+    /** Returns true if the contents of SkImage was created on or uploaded to GPU memory,
         and is available as a GPU texture.
 
         @return  true if SkImage is a GPU texture
@@ -1101,14 +1121,14 @@ public:
 #if SK_SUPPORT_GPU
     /** Returns SkImage backed by GPU texture associated with context. Returned SkImage is
         compatible with SkSurface created with dstColorSpace. The returned SkImage respects
-        mipMapped setting; if mipMapped equals GrMipmapped::kYes, the backing texture
+        mipmapped setting; if mipmapped equals GrMipmapped::kYes, the backing texture
         allocates mip map levels.
 
-        The mipMapped parameter is effectively treated as kNo if MIP maps are not supported by the
+        The mipmapped parameter is effectively treated as kNo if MIP maps are not supported by the
         GPU.
 
         Returns original SkImage if the image is already texture-backed, the context matches, and
-        mipMapped is compatible with the backing GPU texture. SkBudgeted is ignored in this case.
+        mipmapped is compatible with the backing GPU texture. SkBudgeted is ignored in this case.
 
         Returns nullptr if context is nullptr, or if SkImage was created with another
         GrDirectContext.
@@ -1122,6 +1142,31 @@ public:
     sk_sp<SkImage> makeTextureImage(GrDirectContext*,
                                     GrMipmapped = GrMipmapped::kNo,
                                     SkBudgeted = SkBudgeted::kYes) const;
+#endif
+#ifdef SK_GRAPHITE_ENABLED
+    /** Graphite version of makeTextureImage.
+
+        Returns SkImage backed by GPU texture, using Recorder for creation and uploads if necessary.
+        The returned SkImage respects mipmapped setting for non-GPU SkImages; if mipmapped
+        equals GrMipmapped::kYes, the backing texture allocates mip map levels.
+
+        It is assumed that MIP maps are always supported by the GPU.
+
+        Returns original SkImage if the image is already texture-backed, the recorder matches, and
+        mipmapped is compatible with the backing GPU texture. If mipmapped is not compatible,
+        it will return nullptr.
+
+        Returns nullptr if recorder is nullptr, or if SkImage was created with another
+        Recorder and work on that Recorder has not been submitted.
+
+        @param Recorder        the Recorder to use for storing commands
+        @param Mipmapped       whether created SkImage texture must allocate mip map levels
+        @return                created SkImage, or nullptr
+    */
+    sk_sp<SkImage> makeTextureImage(skgpu::graphite::Recorder*,
+                                    skgpu::graphite::Mipmapped = skgpu::graphite::Mipmapped::kNo,
+                                    SkBudgeted = SkBudgeted::kYes) const;
+
 #endif
 
     /** Returns raster image or lazy image. Copies SkImage backed by GPU texture into

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

@@ -8,9 +8,6 @@
 #ifndef SkImageEncoder_DEFINED
 #define SkImageEncoder_DEFINED
 
-// TODO: update clients so we can remove this include, they should IWYU
-#include "include/core/SkBitmap.h"
-
 #include "include/core/SkData.h"
 #include "include/core/SkEncodedImageFormat.h"
 #include "include/core/SkPixmap.h"

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

@@ -13,7 +13,8 @@
 #include "include/core/SkImage.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkYUVAPixmaps.h"
-#include "include/private/SkTOptional.h"
+
+#include <optional>
 
 class GrRecordingContext;
 class GrSurfaceProxyView;
@@ -158,7 +159,7 @@ public:
      *  kOpaque_SkAlphaType is not supported, and will return NULL.
      */
     static std::unique_ptr<SkImageGenerator> MakeFromEncoded(
-            sk_sp<SkData>, skstd::optional<SkAlphaType> = skstd::nullopt);
+            sk_sp<SkData>, std::optional<SkAlphaType> = std::nullopt);
 
     /** Return a new image generator backed by the specified picture.  If the size is empty or
      *  the picture is NULL, this returns NULL.
@@ -204,7 +205,7 @@ private:
     // It is called from NewFromEncoded() after it has checked for any runtime factory.
     // The SkData will never be NULL, as that will have been checked by NewFromEncoded.
     static std::unique_ptr<SkImageGenerator> MakeFromEncodedImpl(sk_sp<SkData>,
-                                                                 skstd::optional<SkAlphaType>);
+                                                                 std::optional<SkAlphaType>);
 
     SkImageGenerator(SkImageGenerator&&) = delete;
     SkImageGenerator(const SkImageGenerator&) = delete;

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

@@ -8,9 +8,11 @@
 #ifndef SkImageInfo_DEFINED
 #define SkImageInfo_DEFINED
 
-#include "include/core/SkColorSpace.h"
+#include "include/core/SkAlphaType.h"
+#include "include/core/SkColorType.h"
 #include "include/core/SkMath.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 
 #include "include/private/SkTFitsIn.h"
@@ -18,93 +20,7 @@
 
 class SkReadBuffer;
 class SkWriteBuffer;
-
-/** \enum SkImageInfo::SkAlphaType
-    Describes how to interpret the alpha component of a pixel. A pixel may
-    be opaque, or alpha, describing multiple levels of transparency.
-
-    In simple blending, alpha weights the draw color and the destination
-    color to create a new color. If alpha describes a weight from zero to one:
-
-    new color = draw color * alpha + destination color * (1 - alpha)
-
-    In practice alpha is encoded in two or more bits, where 1.0 equals all bits set.
-
-    RGB may have alpha included in each component value; the stored
-    value is the original RGB multiplied by alpha. Premultiplied color
-    components improve performance.
-*/
-enum SkAlphaType : int {
-    kUnknown_SkAlphaType,                          //!< uninitialized
-    kOpaque_SkAlphaType,                           //!< pixel is opaque
-    kPremul_SkAlphaType,                           //!< pixel components are premultiplied by alpha
-    kUnpremul_SkAlphaType,                         //!< pixel components are independent of alpha
-    kLastEnum_SkAlphaType = kUnpremul_SkAlphaType, //!< last valid value
-};
-
-/** Returns true if SkAlphaType equals kOpaque_SkAlphaType.
-
-    kOpaque_SkAlphaType is a hint that the SkColorType is opaque, or that all
-    alpha values are set to their 1.0 equivalent. If SkAlphaType is
-    kOpaque_SkAlphaType, and SkColorType is not opaque, then the result of
-    drawing any pixel with a alpha value less than 1.0 is undefined.
-*/
-static inline bool SkAlphaTypeIsOpaque(SkAlphaType at) {
-    return kOpaque_SkAlphaType == at;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-/** \enum SkImageInfo::SkColorType
-    Describes how pixel bits encode color. A pixel may be an alpha mask, a grayscale, RGB, or ARGB.
-
-    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
-    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
-    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
-
-    kA16_float_SkColorType,          //!< pixel with a half float for alpha
-    kR16G16_float_SkColorType,       //!< pixel with a half float for red and green
-
-    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
-
-    kSRGBA_8888_SkColorType,
-
-    kLastEnum_SkColorType     = kSRGBA_8888_SkColorType, //!< last valid value
-
-#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
-    kN32_SkColorType          = kBGRA_8888_SkColorType,//!< native 32-bit BGRA encoding
-
-#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
-    kN32_SkColorType          = kRGBA_8888_SkColorType,//!< native 32-bit RGBA encoding
-
-#else
-    #error "SK_*32_SHIFT values must correspond to BGRA or RGBA byte order"
-#endif
-};
+class SkColorSpace;
 
 /** Returns the number of bytes required to store a pixel, including unused padding.
     Returns zero if ct is kUnknown_SkColorType or invalid.
@@ -183,7 +99,8 @@ public:
 
         @return  empty SkImageInfo
     */
-    SkColorInfo() = default;
+    SkColorInfo();
+    ~SkColorInfo();
 
     /** Creates SkColorInfo from SkColorType ct, SkAlphaType at, and optionally SkColorSpace cs.
 
@@ -194,17 +111,16 @@ public:
         combination is supported.
         @return        created SkColorInfo
     */
-    SkColorInfo(SkColorType ct, SkAlphaType at, sk_sp<SkColorSpace> cs)
-            : fColorSpace(std::move(cs)), fColorType(ct), fAlphaType(at) {}
+    SkColorInfo(SkColorType ct, SkAlphaType at, sk_sp<SkColorSpace> cs);
 
-    SkColorInfo(const SkColorInfo&) = default;
-    SkColorInfo(SkColorInfo&&) = default;
+    SkColorInfo(const SkColorInfo&);
+    SkColorInfo(SkColorInfo&&);
 
-    SkColorInfo& operator=(const SkColorInfo&) = default;
-    SkColorInfo& operator=(SkColorInfo&&) = default;
+    SkColorInfo& operator=(const SkColorInfo&);
+    SkColorInfo& operator=(SkColorInfo&&);
 
-    SkColorSpace* colorSpace() const { return fColorSpace.get(); }
-    sk_sp<SkColorSpace> refColorSpace() const { return fColorSpace; }
+    SkColorSpace* colorSpace() const;
+    sk_sp<SkColorSpace> refColorSpace() const;
     SkColorType colorType() const { return fColorType; }
     SkAlphaType alphaType() const { return fAlphaType; }
 
@@ -213,16 +129,13 @@ public:
             || SkColorTypeIsAlwaysOpaque(fColorType);
     }
 
-    bool gammaCloseToSRGB() const { return fColorSpace && fColorSpace->gammaCloseToSRGB(); }
+    bool gammaCloseToSRGB() const;
 
     /** Does other represent the same color type, alpha type, and color space? */
-    bool operator==(const SkColorInfo& other) const {
-        return fColorType == other.fColorType && fAlphaType == other.fAlphaType &&
-               SkColorSpace::Equals(fColorSpace.get(), other.fColorSpace.get());
-    }
+    bool operator==(const SkColorInfo& other) const;
 
     /** Does other represent a different color type, alpha type, or color space? */
-    bool operator!=(const SkColorInfo& other) const { return !(*this == other); }
+    bool operator!=(const SkColorInfo& other) const;
 
     /** Creates SkColorInfo with same SkColorType, SkColorSpace, with SkAlphaType set
         to newAlphaType.
@@ -230,23 +143,17 @@ public:
         Created SkColorInfo contains newAlphaType even if it is incompatible with
         SkColorType, in which case SkAlphaType in SkColorInfo is ignored.
     */
-    SkColorInfo makeAlphaType(SkAlphaType newAlphaType) const {
-        return SkColorInfo(this->colorType(), newAlphaType, this->refColorSpace());
-    }
+    SkColorInfo makeAlphaType(SkAlphaType newAlphaType) const;
 
     /** Creates new SkColorInfo with same SkAlphaType, SkColorSpace, with SkColorType
         set to newColorType.
     */
-    SkColorInfo makeColorType(SkColorType newColorType) const {
-        return SkColorInfo(newColorType, this->alphaType(), this->refColorSpace());
-    }
+    SkColorInfo makeColorType(SkColorType newColorType) const;
 
     /** Creates SkColorInfo with same SkAlphaType, SkColorType, with SkColorSpace
         set to cs. cs may be nullptr.
     */
-    SkColorInfo makeColorSpace(sk_sp<SkColorSpace> cs) const {
-        return SkColorInfo(this->colorType(), this->alphaType(), std::move(cs));
-    }
+    SkColorInfo makeColorSpace(sk_sp<SkColorSpace> cs) const;
 
     /** Returns number of bytes per pixel required by SkColorType.
         Returns zero if colorType() is kUnknown_SkColorType.
@@ -306,14 +213,12 @@ public:
         @param cs      range of colors; may be nullptr
         @return        created SkImageInfo
     */
+    static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at);
     static SkImageInfo Make(int width, int height, SkColorType ct, SkAlphaType at,
-                            sk_sp<SkColorSpace> cs = nullptr) {
-        return SkImageInfo({width, height}, {ct, at, std::move(cs)});
-    }
+                            sk_sp<SkColorSpace> cs);
+    static SkImageInfo Make(SkISize dimensions, SkColorType ct, SkAlphaType at);
     static SkImageInfo Make(SkISize dimensions, SkColorType ct, SkAlphaType at,
-                            sk_sp<SkColorSpace> cs = nullptr) {
-        return SkImageInfo(dimensions, {ct, at, std::move(cs)});
-    }
+                            sk_sp<SkColorSpace> cs);
 
     /** Creates SkImageInfo from integral dimensions and SkColorInfo colorInfo,
 
@@ -347,10 +252,8 @@ public:
         @param cs      range of colors; may be nullptr
         @return        created SkImageInfo
     */
-    static SkImageInfo MakeN32(int width, int height, SkAlphaType at,
-                               sk_sp<SkColorSpace> cs = nullptr) {
-        return Make({width, height}, kN32_SkColorType, at, std::move(cs));
-    }
+    static SkImageInfo MakeN32(int width, int height, SkAlphaType at);
+    static SkImageInfo MakeN32(int width, int height, SkAlphaType at, sk_sp<SkColorSpace> cs);
 
     /** Creates SkImageInfo from integral dimensions width and height, kN32_SkColorType,
         SkAlphaType at, with sRGB SkColorSpace.
@@ -380,9 +283,8 @@ public:
         @param cs      range of colors; may be nullptr
         @return        created SkImageInfo
     */
-    static SkImageInfo MakeN32Premul(int width, int height, sk_sp<SkColorSpace> cs = nullptr) {
-        return Make({width, height}, kN32_SkColorType, kPremul_SkAlphaType, std::move(cs));
-    }
+    static SkImageInfo MakeN32Premul(int width, int height);
+    static SkImageInfo MakeN32Premul(int width, int height, sk_sp<SkColorSpace> cs);
 
     /** Creates SkImageInfo from integral dimensions width and height, kN32_SkColorType,
         kPremul_SkAlphaType, with SkColorSpace set to nullptr.
@@ -397,9 +299,8 @@ public:
         @param cs          range of colors; may be nullptr
         @return            created SkImageInfo
     */
-    static SkImageInfo MakeN32Premul(SkISize dimensions, sk_sp<SkColorSpace> cs = nullptr) {
-        return Make(dimensions, kN32_SkColorType, kPremul_SkAlphaType, std::move(cs));
-    }
+    static SkImageInfo MakeN32Premul(SkISize dimensions);
+    static SkImageInfo MakeN32Premul(SkISize dimensions, sk_sp<SkColorSpace> cs);
 
     /** Creates SkImageInfo from integral dimensions width and height, kAlpha_8_SkColorType,
         kPremul_SkAlphaType, with SkColorSpace set to nullptr.
@@ -408,18 +309,14 @@ public:
         @param height  pixel row count; must be zero or greater
         @return        created SkImageInfo
     */
-    static SkImageInfo MakeA8(int width, int height) {
-        return Make({width, height}, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr);
-    }
+    static SkImageInfo MakeA8(int width, int height);
     /** Creates SkImageInfo from integral dimensions, kAlpha_8_SkColorType,
         kPremul_SkAlphaType, with SkColorSpace set to nullptr.
 
         @param dimensions   pixel row and column count; must be zero or greater
         @return             created SkImageInfo
     */
-    static SkImageInfo MakeA8(SkISize dimensions) {
-        return Make(dimensions, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr);
-    }
+    static SkImageInfo MakeA8(SkISize dimensions);
 
     /** Creates SkImageInfo from integral dimensions width and height, kUnknown_SkColorType,
         kUnknown_SkAlphaType, with SkColorSpace set to nullptr.
@@ -431,9 +328,7 @@ public:
         @param height  pixel row count; must be zero or greater
         @return        created SkImageInfo
     */
-    static SkImageInfo MakeUnknown(int width, int height) {
-        return Make({width, height}, kUnknown_SkColorType, kUnknown_SkAlphaType, nullptr);
-    }
+    static SkImageInfo MakeUnknown(int width, int height);
 
     /** Creates SkImageInfo from integral dimensions width and height set to zero,
         kUnknown_SkColorType, kUnknown_SkAlphaType, with SkColorSpace set to nullptr.
@@ -468,7 +363,7 @@ public:
 
         @return  SkColorSpace, or nullptr
     */
-    SkColorSpace* colorSpace() const { return fColorInfo.colorSpace(); }
+    SkColorSpace* colorSpace() const;
 
     /** Returns smart pointer to SkColorSpace, the range of colors. The smart pointer
         tracks the number of objects sharing this SkColorSpace reference so the memory
@@ -478,7 +373,7 @@ public:
 
         @return  SkColorSpace wrapped in a smart pointer
     */
-    sk_sp<SkColorSpace> refColorSpace() const { return fColorInfo.refColorSpace(); }
+    sk_sp<SkColorSpace> refColorSpace() const;
 
     /** Returns if SkImageInfo describes an empty area of pixels by checking if either
         width or height is zero or smaller.
@@ -571,9 +466,7 @@ public:
         @param cs  range of colors; may be nullptr
         @return    created SkImageInfo
     */
-    SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const {
-        return Make(fDimensions, fColorInfo.makeColorSpace(std::move(cs)));
-    }
+    SkImageInfo makeColorSpace(sk_sp<SkColorSpace> cs) const;
 
     /** Returns number of bytes per pixel required by SkColorType.
         Returns zero if colorType( is kUnknown_SkColorType.