@shopify/react-native-skia 2.0.5 → 2.0.7

package/android/CMakeLists.txt

@@ -58,6 +58,7 @@ set (SKIA_SKSHAPER_LIB "skshaper")
 set (SKIA_SKPARAGRAPH_LIB "skparagraph")
 set (SKIA_SKUNICODE_CORE_LIB "skunicode_core")
 set (SKIA_SKUNICODE_ICU_LIB "skunicode_icu")
+set (SKIA_PATHOPS_LIB "pathops")
 
 
 # Clear some variables
@@ -169,6 +170,8 @@ set_property(TARGET skunicode_core PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}
 add_library(skunicode_icu STATIC IMPORTED)
 set_property(TARGET skunicode_icu PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskunicode_icu.a")
 
+add_library(pathops STATIC IMPORTED)
+set_property(TARGET pathops PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libpathops.a")
 
 find_library(
         LOG_LIB
@@ -296,6 +299,7 @@ if(${REACT_NATIVE_VERSION} GREATER_EQUAL 76)
         ${SKIA_SKPARAGRAPH_LIB}
         ${SKIA_SKUNICODE_CORE_LIB}
         ${SKIA_SKUNICODE_ICU_LIB}
+        ${SKIA_PATHOPS_LIB}
         ${SKIA_LIB}
         -ljnigraphics
         -lGLESv2
@@ -316,6 +320,7 @@ else()
         ${SKIA_SKPARAGRAPH_LIB}
         ${SKIA_SKUNICODE_CORE_LIB}
         ${SKIA_SKUNICODE_ICU_LIB}
+        ${SKIA_PATHOPS_LIB}
         ${SKIA_LIB}
         -ljnigraphics
         -lGLESv2
@@ -335,3 +340,8 @@ else()
         -lEGL
     )
 endif()
+
+# Enable Android 16kb native library alignment
+if(CMAKE_ANDROID_NDK_VERSION VERSION_LESS "27")
+    target_link_options(${PACKAGE_NAME} PRIVATE "-Wl,-z,max-page-size=16384")
+endif()

package/android/build.gradle

@@ -156,7 +156,8 @@ android {
                 arguments '-DANDROID_STL=c++_shared',
                           "-DREACT_NATIVE_VERSION=${REACT_NATIVE_VERSION}",
                           "-DNODE_MODULES_DIR=${nodeModules}",
-                          "-DPREBUILT_DIR=${prebuiltDir}"
+                          "-DPREBUILT_DIR=${prebuiltDir}",
+                          "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
 
             }
         }

package/apple/SkiaCVPixelBufferUtils.mm

@@ -30,12 +30,16 @@
 #include <TargetConditionals.h>
 #if TARGET_RT_BIG_ENDIAN
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*((char *)&fourcc), *(((char *)&fourcc) + 1),                 \
-                 *(((char *)&fourcc) + 2), *(((char *)&fourcc) + 3), 0}
+  (const char[]) {                                                             \
+    *((char *)&fourcc), *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 2),    \
+        *(((char *)&fourcc) + 3), 0                                            \
+  }
 #else
 #define FourCC2Str(fourcc)                                                     \
-  (const char[]){*(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),           \
-                 *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0}
+  (const char[]) {                                                             \
+    *(((char *)&fourcc) + 3), *(((char *)&fourcc) + 2),                        \
+        *(((char *)&fourcc) + 1), *(((char *)&fourcc) + 0), 0                  \
+  }
 #endif
 
 // pragma MARK: TextureHolder

package/cpp/api/JsiSkCanvas.h

@@ -258,9 +258,8 @@ public:
     }
 
     auto paint = JsiSkPaint::fromValue(runtime, arguments[2]);
-
-    _canvas->drawPoints((SkCanvas::PointMode)pointMode, pointsSize,
-                        points.data(), *paint);
+    auto p = SkSpan(points.data(), points.size());
+    _canvas->drawPoints((SkCanvas::PointMode)pointMode, p, *paint);
 
     return jsi::Value::undefined();
   }
@@ -403,8 +402,9 @@ public:
       glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
     }
 
-    _canvas->drawGlyphs(glyphsSize, glyphs.data(), positions.data(), origin,
-                        *font, *paint);
+    auto g = SkSpan(glyphs.data(), glyphs.size());
+    auto p = SkSpan(positions.data(), positions.size());
+    _canvas->drawGlyphs(g, p, origin, *font, *paint);
 
     return jsi::Value::undefined();
   }
@@ -597,9 +597,11 @@ public:
     if (count > 6) {
       sampling = SamplingOptionsFromValue(runtime, arguments[6]);
     }
-    _canvas->drawAtlas(atlas.get(), xforms.data(), skRects.data(),
-                       colors.empty() ? nullptr : colors.data(), skRects.size(),
-                       blendMode, sampling, nullptr, paint.get());
+    auto x = SkSpan(xforms.data(), xforms.size());
+    auto t = SkSpan(skRects.data(), skRects.size());
+    auto c = SkSpan(colors.data(), colors.size());
+    _canvas->drawAtlas(atlas.get(), x, t, c, blendMode, sampling, nullptr,
+                       paint.get());
 
     return jsi::Value::undefined();
   }

package/cpp/api/JsiSkFont.h

@@ -40,15 +40,13 @@ public:
     for (int i = 0; i < glyphsSize; i++) {
       glyphs.push_back(jsiGlyphs.getValueAtIndex(runtime, i).asNumber());
     }
+    auto widths = SkSpan(static_cast<SkScalar *>(widthPtrs.data()), glyphsSize);
+    auto g = SkSpan(glyphs.data(), glyphs.size());
     if (count > 1) {
       auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->getWidthsBounds(glyphs.data(), glyphsSize,
-                                   static_cast<SkScalar *>(widthPtrs.data()),
-                                   nullptr, paint.get());
+      getObject()->getWidthsBounds(g, widths, {}, paint.get());
     } else {
-      getObject()->getWidthsBounds(glyphs.data(), glyphsSize,
-                                   static_cast<SkScalar *>(widthPtrs.data()),
-                                   nullptr, nullptr);
+      getObject()->getWidthsBounds(g, widths, {}, nullptr);
     }
     auto jsiWidths = jsi::Array(runtime, glyphsSize);
     for (int i = 0; i < glyphsSize; i++) {
@@ -68,20 +66,17 @@ public:
     std::vector<SkGlyphID> glyphs;
     glyphs.resize(numGlyphIDs);
     int glyphsSize = static_cast<int>(numGlyphIDs);
+    auto g = SkSpan(glyphs.data(), glyphs.size());
     getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                              static_cast<SkGlyphID *>(glyphs.data()),
-                              glyphsSize);
+                              g);
     std::vector<SkScalar> widthPtrs;
     widthPtrs.resize(numGlyphIDs);
+    auto widths = SkSpan(widthPtrs.data(), widthPtrs.size());
     if (count > 1) {
       auto paint = JsiSkPaint::fromValue(runtime, arguments[1]);
-      getObject()->getWidthsBounds(glyphs.data(), glyphsSize,
-                                   static_cast<SkScalar *>(widthPtrs.data()),
-                                   nullptr, paint.get());
+      getObject()->getWidthsBounds(g, widths, {}, paint.get());
     } else {
-      getObject()->getWidthsBounds(glyphs.data(), glyphsSize,
-                                   static_cast<SkScalar *>(widthPtrs.data()),
-                                   nullptr, nullptr);
+      getObject()->getWidthsBounds(g, widths, {}, nullptr);
     }
     return jsi::Value(std::accumulate(widthPtrs.begin(), widthPtrs.end(), 0));
   }
@@ -126,9 +121,9 @@ public:
                                      SkTextEncoding::kUTF8);
     std::vector<SkGlyphID> glyphIDs;
     glyphIDs.resize(numGlyphIDs);
+    auto g = SkSpan(static_cast<SkGlyphID *>(glyphIDs.data()), glyphIDs.size());
     getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                              static_cast<SkGlyphID *>(glyphIDs.data()),
-                              numGlyphIDs);
+                              g);
     auto jsiGlyphIDs = jsi::Array(runtime, numGlyphIDs);
     for (int i = 0; i < numGlyphIDs; i++) {
       jsiGlyphIDs.setValueAtIndex(runtime, i,
@@ -162,8 +157,9 @@ public:
       throw jsi::JSError(runtime, "Not enough x,y position pairs for glyphs");
       return jsi::Value::null();
     }
-    auto sects = getObject()->getIntercepts(
-        glyphs.data(), SkToInt(glyphs.size()), positions.data(), top, bottom);
+    auto g = SkSpan(glyphs.data(), glyphs.size());
+    auto p = SkSpan(positions.data(), positions.size());
+    auto sects = getObject()->getIntercepts(g, p, top, bottom);
     auto jsiSects = jsi::Array(runtime, sects.size());
     for (int i = 0; i < sects.size(); i++) {
       jsiSects.setValueAtIndex(runtime, i,

package/cpp/api/JsiSkPath.h

@@ -24,10 +24,11 @@
 #include "include/core/SkStrokeRec.h"
 #include "include/effects/SkDashPathEffect.h"
 #include "include/effects/SkTrimPathEffect.h"
-#include "include/pathops/SkPathOps.h"
 #include "include/utils/SkParsePath.h"
 #include "include/utils/SkTextUtils.h"
 
+#include "modules/pathops/include/SkPathOps.h"
+
 #pragma clang diagnostic pop
 
 namespace RNSkia {
@@ -96,7 +97,8 @@ public:
           runtime, jsiPoints.getValueAtIndex(runtime, i).asObject(runtime));
       points.push_back(*point.get());
     }
-    getObject()->addPoly(points.data(), static_cast<int>(points.size()), close);
+    auto p = SkSpan(points.data(), points.size());
+    getObject()->addPoly(p, close);
     return thisValue.getObject(runtime);
   }
 
@@ -213,7 +215,8 @@ public:
     SkScalar off = arguments[1].asNumber();
     auto phase = arguments[2].asNumber();
     SkScalar intervals[] = {on, off};
-    auto pe = SkDashPathEffect::Make(intervals, 2, phase);
+    auto i = SkSpan(intervals, 2);
+    auto pe = SkDashPathEffect::Make(i, phase);
     if (!pe) {
       // TODO: SkDebugf("Invalid args to dash()\n");
       return jsi::Value(false);

package/cpp/api/JsiSkPathEffectFactory.h

@@ -47,10 +47,10 @@ public:
         count >= 2 && !arguments[1].isUndefined() && !arguments[1].isNull()
             ? arguments[1].asNumber()
             : 0;
+    auto i = SkSpan(intervals.data(), intervals.size());
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkPathEffect>(
-                     getContext(),
-                     SkDashPathEffect::Make(intervals.data(), size, phase)));
+                     getContext(), SkDashPathEffect::Make(i, phase)));
   }
 
   JSI_HOST_FUNCTION(MakeDiscrete) {

package/cpp/api/JsiSkPathFactory.h

@@ -13,7 +13,7 @@
 
 #include "RNSkLog.h"
 #include "include/core/SkPath.h"
-#include "include/pathops/SkPathOps.h"
+#include "modules/pathops/include/SkPathOps.h"
 
 #pragma clang diagnostic pop
 

package/cpp/api/JsiSkTextBlobFactory.h

@@ -63,8 +63,9 @@ public:
           runtime, jsiRsxforms.getValueAtIndex(runtime, i));
       rsxforms.push_back(*rsxform);
     }
-    auto textBlob = SkTextBlob::MakeFromRSXform(str.c_str(), str.length(),
-                                                rsxforms.data(), *font);
+    auto x = SkSpan(rsxforms.data(), rsxforms.size());
+    auto textBlob =
+        SkTextBlob::MakeFromRSXform(str.c_str(), str.length(), x, *font);
     return jsi::Object::createFromHostObject(
         runtime,
         std::make_shared<JsiSkTextBlob>(getContext(), std::move(textBlob)));
@@ -89,8 +90,9 @@ public:
           runtime, jsiRsxforms.getValueAtIndex(runtime, i));
       rsxforms.push_back(*rsxform);
     }
+    auto x = SkSpan(rsxforms.data(), rsxforms.size());
     auto textBlob = SkTextBlob::MakeFromRSXform(
-        glyphs.data(), glyphs.size() * bytesPerGlyph, rsxforms.data(), *font,
+        glyphs.data(), glyphs.size() * bytesPerGlyph, x, *font,
         SkTextEncoding::kGlyphID);
     return jsi::Object::createFromHostObject(
         runtime,

package/cpp/api/JsiSkTypeface.h

@@ -38,12 +38,13 @@ public:
         count > 1 && !arguments[1].isNull() && !arguments[1].isUndefined()
             ? static_cast<int>(arguments[1].asNumber())
             : getObject()->textToGlyphs(str.c_str(), str.length(),
-                                        SkTextEncoding::kUTF8, nullptr, 0);
+                                        SkTextEncoding::kUTF8,
+                                        SkSpan<SkGlyphID>(nullptr, 0));
     std::vector<SkGlyphID> glyphIDs;
     glyphIDs.resize(numGlyphIDs);
-    getObject()->textToGlyphs(str.c_str(), str.length(), SkTextEncoding::kUTF8,
-                              static_cast<SkGlyphID *>(glyphIDs.data()),
-                              numGlyphIDs);
+    getObject()->textToGlyphs(
+        str.c_str(), str.length(), SkTextEncoding::kUTF8,
+        SkSpan(static_cast<SkGlyphID *>(glyphIDs.data()), numGlyphIDs));
     auto jsiGlyphIDs = jsi::Array(runtime, numGlyphIDs);
     for (int i = 0; i < numGlyphIDs; i++) {
       jsiGlyphIDs.setValueAtIndex(runtime, i,

package/cpp/api/recorder/Drawings.h

@@ -246,15 +246,17 @@ public:
       glyphIds.reserve(numGlyphIds);
       auto ids = font->textToGlyphs(
           text.c_str(), text.length(), SkTextEncoding::kUTF8,
-          static_cast<SkGlyphID *>(glyphIds.data()), numGlyphIds);
+          SkSpan(static_cast<SkGlyphID *>(glyphIds.data()), numGlyphIds));
 
       // Get glyph widths
       int glyphsSize = static_cast<int>(ids);
       std::vector<SkScalar> widthPtrs;
       widthPtrs.resize(glyphsSize);
-      font->getWidthsBounds(glyphIds.data(), numGlyphIds,
-                            static_cast<SkScalar *>(widthPtrs.data()), nullptr,
-                            nullptr); // TODO: Should we use paint somehow here?
+      font->getWidthsBounds(
+          SkSpan(glyphIds.data(), numGlyphIds),
+          SkSpan(static_cast<SkScalar *>(widthPtrs.data()), widthPtrs.size()),
+          {},
+          nullptr); // TODO: Should we use paint somehow here?
 
       std::vector<SkRSXform> rsx;
       SkContourMeasureIter meas(path, false, 1);
@@ -295,9 +297,9 @@ public:
         rsx.push_back(SkRSXform::Make(tx, ty, adjustedX, adjustedY));
         dist += width / 2;
       }
-
-      auto blob = SkTextBlob::MakeFromRSXform(text.c_str(), text.length(),
-                                              rsx.data(), *font);
+      auto x = SkSpan(rsx.data(), rsx.size());
+      auto blob =
+          SkTextBlob::MakeFromRSXform(text.c_str(), text.length(), x, *font);
       ctx->canvas->drawTextBlob(blob, 0, 0, ctx->getPaint());
     }
   }
@@ -532,8 +534,8 @@ public:
   }
 
   void draw(DrawingCtx *ctx) {
-    ctx->canvas->drawPoints(props.mode, props.points.size(),
-                            props.points.data(), ctx->getPaint());
+    auto points = SkSpan(props.points.data(), props.points.size());
+    ctx->canvas->drawPoints(props.mode, points, ctx->getPaint());
   }
 };
 
@@ -780,10 +782,13 @@ public:
 
   void draw(DrawingCtx *ctx) {
     if (props.font.has_value()) {
-      ctx->canvas->drawGlyphs(
-          static_cast<int>(props.glyphs.glyphIds.size()),
-          props.glyphs.glyphIds.data(), props.glyphs.positions.data(),
-          SkPoint::Make(props.x, props.y), props.font.value(), ctx->getPaint());
+      auto glyphs =
+          SkSpan(props.glyphs.glyphIds.data(), props.glyphs.glyphIds.size());
+      auto positions =
+          SkSpan(props.glyphs.positions.data(), props.glyphs.positions.size());
+      ctx->canvas->drawGlyphs(glyphs, positions,
+                              SkPoint::Make(props.x, props.y),
+                              props.font.value(), ctx->getPaint());
     }
   }
 };
@@ -934,16 +939,17 @@ public:
             "colors array must have the same length as transforms/sprites");
       }
 
-      auto colors =
-          props.colors.has_value() ? props.colors.value().data() : nullptr;
+      auto colors = SkSpan(
+          props.colors.has_value() ? props.colors.value().data() : nullptr,
+          props.colors.has_value() ? props.colors.value().size() : 0);
       auto blendMode = props.blendMode.value_or(SkBlendMode::kDstOver);
       auto sampling =
           props.sampling.value_or(SkSamplingOptions(SkFilterMode::kLinear));
-
-      ctx->canvas->drawAtlas(props.image.get(), props.transforms.data(),
-                             props.sprites.data(), colors,
-                             props.transforms.size(), blendMode, sampling,
-                             nullptr, &(ctx->getPaint()));
+      auto transforms =
+          SkSpan(props.transforms.data(), props.transforms.size());
+      auto sprites = SkSpan(props.sprites.data(), props.sprites.size());
+      ctx->canvas->drawAtlas(props.image.get(), transforms, sprites, colors,
+                             blendMode, sampling, nullptr, &(ctx->getPaint()));
     }
   }
 };

package/cpp/api/recorder/PathEffects.h

@@ -54,8 +54,9 @@ public:
   }
 
   void pushPathEffect(DrawingCtx *ctx) {
-    auto pe = SkDashPathEffect::Make(props.intervals.data(),
-                                     props.intervals.size(), props.phase);
+    auto intervals = SkSpan(static_cast<SkScalar *>(props.intervals.data()),
+                            props.intervals.size());
+    auto pe = SkDashPathEffect::Make(intervals, props.phase);
     ctx->pathEffects.push_back(pe);
   }
 };

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

@@ -74,7 +74,7 @@ public:
                                                //   of fColors/fColorOffsets on input, and
                                                //   actual number of colors/offsets on
                                                //   output.
-        SkColor*    fColors        = nullptr;  //!< The colors in the gradient.
+        SkColor4f*  fColors        = nullptr;  //!< The colors in the gradient.
         SkScalar*   fColorOffsets  = nullptr;  //!< The unit offset for color transitions.
         SkPoint     fPoints[2];                //!< Type specific, see above.
         SkTileMode  fTileMode;

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

@@ -19,7 +19,7 @@ struct AHardwareBuffer;
 
 namespace SkImages {
 
-/** (See Skia bug 7447)
+/** (See skbug.com/40038695)
     Creates SkImage from Android hardware buffer.
     Returned SkImage takes a reference on the buffer.
     Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
@@ -58,13 +58,6 @@ SK_API sk_sp<SkImage> PinnableRasterFromBitmap(const SkBitmap&);
 
 }  // namespace SkImages
 
-// TODO(kjlubick) remove this after Android has been ported.
-namespace sk_image_factory {
-inline sk_sp<SkImage> MakePinnableFromRasterBitmap(const SkBitmap& b) {
-    return SkImages::PinnableRasterFromBitmap(b);
-}
-}  // namespace sk_image_factory
-
 namespace skgpu::ganesh {
 /**
  *  Will attempt to upload and lock the contents of the image as a texture, so that subsequent

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

@@ -88,6 +88,7 @@
 //#define SK_HISTOGRAM_BOOLEAN(name, sample)
 //#define SK_HISTOGRAM_ENUMERATION(name, sampleEnum, enumSize)
 //#define SK_HISTOGRAM_EXACT_LINEAR(name, sample, valueMax)
+//#define SK_HISTOGRAM_CUSTOM_EXACT_LINEAR(name, sample, value_min, value_max, bucket_count)
 //#define SK_HISTOGRAM_MEMORY_KB(name, sample)
 //#define SK_HISTOGRAM_CUSTOM_COUNTS(name, sample, countMin, countMax, bucketCount)
 //#define SK_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(name, sampleUSec, minUSec, maxUSec, bucketCount)
@@ -121,4 +122,12 @@
  */
 //#define SK_API __declspec(dllexport)
 
+/*
+ * If using DNG support, set the version of the dng_sdk being compiled against here
+ * following the versioning scheme of dng_tag_valus.h
+ * eg, DNG 1.4 is 0x01040000, DNG 1.7.1 is 0x01070100, etc...
+ * If unspecified, DNG SDK 1.4 is assumed
+ */
+// #define SK_DNG_VERSION 0x01040000
+
 #endif

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

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef skcpu_Context_DEFINED
+#define skcpu_Context_DEFINED
+
+#include "include/private/base/SkAPI.h"
+
+#include <memory>
+
+namespace skcpu {
+class Recorder;
+
+class SK_API Context {
+public:
+    struct Options {};
+
+    std::unique_ptr<Recorder> makeRecorder() const;
+
+    static std::unique_ptr<const Context> Make(const Options&);
+    static std::unique_ptr<const Context> Make();
+
+protected:
+    Context() = default;
+};
+}  // namespace skcpu
+
+#endif

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skcpu_Recorder_DEFINED
+#define skcpu_Recorder_DEFINED
+
+#include "include/core/SkRecorder.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+class SkSurface;
+class SkSurfaceProps;
+struct SkImageInfo;
+
+#include <cstddef>
+
+namespace skcpu {
+
+class SK_API Recorder : public SkRecorder {
+public:
+    /** Returns a non-null global context. Can be used as a means of transitioning onto
+     * new APIs when a skcpu::Context/Recorder has not been piped down into the code paths
+     */
+    static Recorder* TODO();
+
+    SkRecorder::Type type() const final { return SkRecorder::Type::kCPU; }
+    skcpu::Recorder* cpuRecorder() final { return this; }
+
+    /** Allocates a bitmap-backed SkSurface. SkCanvas returned by SkSurface draws directly into
+     *  those allocated pixels, which are zeroed before use. Pixel memory size is imageInfo.height()
+     *  times imageInfo.minRowBytes() or rowBytes, if provided and non-zero.
+     *
+     *  Pixel memory is deleted when SkSurface is deleted.
+     *
+     *  Validity constraints include:
+     *    - info dimensions are greater than zero;
+     *    - info contains SkColorType and SkAlphaType supported by raster surface.
+     *
+     *  @param imageInfo  width, height, SkColorType, SkAlphaType, SkColorSpace,
+     *                    of raster surface; width and height must be greater than zero
+     *  @param rowBytes   interval from one SkSurface row to the next.
+     *  @param props      LCD striping orientation and setting for device independent fonts;
+     *                    may be nullptr
+     *  @return           SkSurface if parameters are valid and memory was allocated, else nullptr.
+     */
+    sk_sp<SkSurface> makeBitmapSurface(const SkImageInfo& imageInfo,
+                                       size_t rowBytes,
+                                       const SkSurfaceProps* surfaceProps);
+    sk_sp<SkSurface> makeBitmapSurface(const SkImageInfo& imageInfo,
+                                       const SkSurfaceProps* surfaceProps = nullptr);
+};
+
+inline Recorder* AsRecorder(SkRecorder* recorder) {
+    if (!recorder) {
+        return nullptr;
+    }
+    if (recorder->type() != SkRecorder::Type::kCPU) {
+        return nullptr;
+    }
+    return static_cast<Recorder*>(recorder);
+}
+
+}  // namespace skcpu
+
+#endif