@shopify/react-native-skia 1.3.12 → 1.4.0

package/android/CMakeLists.txt

@@ -10,7 +10,8 @@ set (SKIA_LIB "skia")
 set (SKIA_SVG_LIB "svg")
 set (SKIA_SKSHAPER_LIB "skshaper")
 set (SKIA_SKPARAGRAPH_LIB "skparagraph")
-set (SKIA_SKUNICODE_LIB "skunicode")
+set (SKIA_SKUNICODE_CORE_LIB "skunicode_core")
+set (SKIA_SKUNICODE_ICU_LIB "skunicode_icu")
 
 # Clear some variables
 unset(LIBRN_DIR CACHE)
@@ -116,8 +117,11 @@ set_property(TARGET skshaper PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libsk
 add_library(skparagraph STATIC IMPORTED)
 set_property(TARGET skparagraph PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskparagraph.a")
 
-add_library(skunicode STATIC IMPORTED)
-set_property(TARGET skunicode PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskunicode.a")
+add_library(skunicode_core STATIC IMPORTED)
+set_property(TARGET skunicode_core PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskunicode_core.a")
+
+add_library(skunicode_icu STATIC IMPORTED)
+set_property(TARGET skunicode_icu PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskunicode_icu.a")
 
 
 find_library(
@@ -235,7 +239,8 @@ target_link_libraries(
         ${SKIA_SVG_LIB}
         ${SKIA_SKSHAPER_LIB}
         ${SKIA_SKPARAGRAPH_LIB}
-        ${SKIA_SKUNICODE_LIB}
+        ${SKIA_SKUNICODE_CORE_LIB}
+        ${SKIA_SKUNICODE_ICU_LIB}
         ${SKIA_LIB}
         -ljnigraphics
         -lGLESv2

package/android/cpp/rnskia-android/RNSkAndroidPlatformContext.h

@@ -54,6 +54,12 @@ public:
     return SkiaOpenGLSurfaceFactory::makeOffscreenSurface(width, height);
   }
 
+  std::shared_ptr<SkiaContext>
+  makeContextFromNativeSurface(void *surface, int width, int height) override {
+    return SkiaOpenGLSurfaceFactory::makeContext(
+        reinterpret_cast<ANativeWindow *>(surface), width, height);
+  }
+
   sk_sp<SkImage> makeImageFromNativeBuffer(void *buffer) override {
     return SkiaOpenGLSurfaceFactory::makeImageFromHardwareBuffer(buffer);
   }

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.cpp

@@ -218,4 +218,85 @@ sk_sp<SkSurface> WindowSurfaceHolder::getSurface() {
   return _skSurface;
 }
 
+sk_sp<SkSurface> AndroidSkiaContext::getSurface() {
+  if (_skSurface == nullptr) {
+
+    // Setup OpenGL and Skia
+    if (!SkiaOpenGLHelper::createSkiaDirectContextIfNecessary(
+            &ThreadContextHolder::ThreadSkiaOpenGLContext)) {
+      RNSkLogger::logToConsole(
+          "Could not create Skia Surface from native window / surface. "
+          "Failed creating Skia Direct Context");
+      return nullptr;
+    }
+
+    // Now we can create a surface
+    _glSurface = SkiaOpenGLHelper::createWindowedSurface(_window);
+    if (_glSurface == EGL_NO_SURFACE) {
+      RNSkLogger::logToConsole(
+          "Could not create EGL Surface from native window / surface.");
+      return nullptr;
+    }
+
+    // Now make this one current
+    if (!SkiaOpenGLHelper::makeCurrent(
+            &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface)) {
+      RNSkLogger::logToConsole(
+          "Could not create EGL Surface from native window / surface. Could "
+          "not set new surface as current surface.");
+      return nullptr;
+    }
+
+    // Set up parameters for the render target so that it
+    // matches the underlying OpenGL context.
+    GrGLFramebufferInfo fboInfo;
+
+    // We pass 0 as the framebuffer id, since the
+    // underlying Skia GrGlGpu will read this when wrapping the context in the
+    // render target and the GrGlGpu object.
+    fboInfo.fFBOID = 0;
+    fboInfo.fFormat = 0x8058; // GL_RGBA8
+
+    GLint stencil;
+    glGetIntegerv(GL_STENCIL_BITS, &stencil);
+
+    GLint samples;
+    glGetIntegerv(GL_SAMPLES, &samples);
+
+    auto colorType = kN32_SkColorType;
+
+    auto maxSamples =
+        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
+            ->maxSurfaceSampleCountForColorType(colorType);
+
+    if (samples > maxSamples) {
+      samples = maxSamples;
+    }
+
+    auto renderTarget = GrBackendRenderTargets::MakeGL(_width, _height, samples,
+                                                       stencil, fboInfo);
+
+    SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
+
+    struct ReleaseContext {
+      EGLSurface glSurface;
+    };
+
+    auto releaseCtx = new ReleaseContext({_glSurface});
+
+    // Create surface object
+    _skSurface = SkSurfaces::WrapBackendRenderTarget(
+        ThreadContextHolder::ThreadSkiaOpenGLContext.directContext.get(),
+        renderTarget, kBottomLeft_GrSurfaceOrigin, colorType, nullptr, &props,
+        [](void *addr) {
+          auto releaseCtx = reinterpret_cast<ReleaseContext *>(addr);
+          SkiaOpenGLHelper::destroySurface(releaseCtx->glSurface);
+          delete releaseCtx;
+        },
+        reinterpret_cast<void *>(releaseCtx));
+  }
+
+  return _skSurface;
+}
+
 } // namespace RNSkia

package/android/cpp/rnskia-android/SkiaOpenGLSurfaceFactory.h

@@ -13,6 +13,7 @@
 #include <thread>
 #include <unordered_map>
 
+#include "SkiaContext.h"
 #include "SkiaOpenGLHelper.h"
 
 #pragma clang diagnostic push
@@ -139,6 +140,40 @@ private:
   int _height = 0;
 };
 
+class AndroidSkiaContext : public SkiaContext {
+public:
+  AndroidSkiaContext(ANativeWindow *window, int width, int height)
+      : _window(window), _width(width), _height(height) {}
+
+  ~AndroidSkiaContext() {}
+
+  sk_sp<SkSurface> getSurface() override;
+
+  void present() override {
+    if (!SkiaOpenGLHelper::makeCurrent(
+            &ThreadContextHolder::ThreadSkiaOpenGLContext, _glSurface)) {
+      RNSkLogger::logToConsole(
+          "Could not create EGL Surface from native window / surface. Could "
+          "not set new surface as current surface.");
+      return;
+    }
+    // Flush and submit the direct context
+    ThreadContextHolder::ThreadSkiaOpenGLContext.directContext
+        ->flushAndSubmit();
+
+    // Swap buffers
+    SkiaOpenGLHelper::swapBuffers(&ThreadContextHolder::ThreadSkiaOpenGLContext,
+                                  _glSurface);
+  }
+
+private:
+  ANativeWindow *_window;
+  sk_sp<SkSurface> _skSurface = nullptr;
+  EGLSurface _glSurface = EGL_NO_SURFACE;
+  int _width = 0;
+  int _height = 0;
+};
+
 class SkiaOpenGLSurfaceFactory {
 public:
   /**
@@ -152,6 +187,11 @@ public:
   static sk_sp<SkImage>
   makeImageFromHardwareBuffer(void *buffer, bool requireKnownFormat = false);
 
+  static std::shared_ptr<AndroidSkiaContext>
+  makeContext(ANativeWindow *surface, int width, int height) {
+    return std::make_shared<AndroidSkiaContext>(surface, width, height);
+  }
+
   /**
    * Creates a windowed Skia Surface holder.
    * @param width Initial width of surface

package/cpp/api/JsiSkApi.h

@@ -50,6 +50,7 @@
 #include "JsiSkTypefaceFactory.h"
 #include "JsiSkTypefaceFontProviderFactory.h"
 #include "JsiSkVertices.h"
+#include "JsiSkiaContext.h"
 #include "JsiVideo.h"
 
 namespace RNSkia {
@@ -69,6 +70,7 @@ public:
     // slow to do it on demand
     JsiSkFontMgrFactory::getFontMgr(getContext());
     installFunction("Video", JsiVideo::createCtor(context));
+    installFunction("Context", JsiSkiaContext::createCtor(context));
     installFunction("Font", JsiSkFont::createCtor(context));
     installFunction("Paint", JsiSkPaint::createCtor(context));
     installFunction("RSXform", JsiSkRSXform::createCtor(context));

package/cpp/api/JsiSkPath.h

@@ -27,7 +27,6 @@
 #include "include/pathops/SkPathOps.h"
 #include "include/utils/SkParsePath.h"
 #include "include/utils/SkTextUtils.h"
-#include "src/core/SkPathPriv.h"
 
 #pragma clang diagnostic pop
 
@@ -510,51 +509,54 @@ public:
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkPath>(getContext(), std::move(result)));
   }
-
   JSI_HOST_FUNCTION(toCmds) {
     auto path = *getObject();
-    auto cmds = jsi::Array(runtime, path.countVerbs());
-    auto j = 0;
-    for (auto [verb, pts, w] : SkPathPriv::Iterate(path)) {
+    std::vector<jsi::Array> cmdList;
+    SkPoint pts[4];
+    SkPath::Iter iter(path, false);
+    SkPath::Verb verb;
+
+    while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
       switch (verb) {
-      case SkPathVerb::kMove: {
+      case SkPath::kMove_Verb: {
         auto cmd = jsi::Array(runtime, 3);
         cmd.setValueAtIndex(runtime, 0, static_cast<double>(MOVE));
         cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[0].x()));
         cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[0].y()));
-        cmds.setValueAtIndex(runtime, j, cmd);
+        cmdList.push_back(std::move(cmd));
         break;
       }
-      case SkPathVerb::kLine: {
+      case SkPath::kLine_Verb: {
         auto cmd = jsi::Array(runtime, 3);
         cmd.setValueAtIndex(runtime, 0, static_cast<double>(LINE));
         cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
         cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
-        cmds.setValueAtIndex(runtime, j, cmd);
+        cmdList.push_back(std::move(cmd));
         break;
       }
-      case SkPathVerb::kQuad: {
+      case SkPath::kQuad_Verb: {
         auto cmd = jsi::Array(runtime, 5);
         cmd.setValueAtIndex(runtime, 0, static_cast<double>(QUAD));
         cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
         cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
         cmd.setValueAtIndex(runtime, 3, static_cast<double>(pts[2].x()));
         cmd.setValueAtIndex(runtime, 4, static_cast<double>(pts[2].y()));
-        cmds.setValueAtIndex(runtime, j, cmd);
+        cmdList.push_back(std::move(cmd));
         break;
       }
-      case SkPathVerb::kConic: {
+      case SkPath::kConic_Verb: {
         auto cmd = jsi::Array(runtime, 6);
         cmd.setValueAtIndex(runtime, 0, static_cast<double>(CONIC));
         cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
         cmd.setValueAtIndex(runtime, 2, static_cast<double>(pts[1].y()));
         cmd.setValueAtIndex(runtime, 3, static_cast<double>(pts[2].x()));
         cmd.setValueAtIndex(runtime, 4, static_cast<double>(pts[2].y()));
-        cmd.setValueAtIndex(runtime, 5, static_cast<double>(*w));
-        cmds.setValueAtIndex(runtime, j, cmd);
+        cmd.setValueAtIndex(runtime, 5,
+                            static_cast<double>(iter.conicWeight()));
+        cmdList.push_back(std::move(cmd));
         break;
       }
-      case SkPathVerb::kCubic: {
+      case SkPath::kCubic_Verb: {
         auto cmd = jsi::Array(runtime, 7);
         cmd.setValueAtIndex(runtime, 0, static_cast<double>(CUBIC));
         cmd.setValueAtIndex(runtime, 1, static_cast<double>(pts[1].x()));
@@ -563,18 +565,26 @@ public:
         cmd.setValueAtIndex(runtime, 4, static_cast<double>(pts[2].y()));
         cmd.setValueAtIndex(runtime, 5, static_cast<double>(pts[3].x()));
         cmd.setValueAtIndex(runtime, 6, static_cast<double>(pts[3].y()));
-        cmds.setValueAtIndex(runtime, j, cmd);
+        cmdList.push_back(std::move(cmd));
         break;
       }
-      case SkPathVerb::kClose: {
+      case SkPath::kClose_Verb: {
         auto cmd = jsi::Array(runtime, 1);
         cmd.setValueAtIndex(runtime, 0, static_cast<double>(CLOSE));
-        cmds.setValueAtIndex(runtime, j, cmd);
+        cmdList.push_back(std::move(cmd));
         break;
       }
+      default:
+        break;
       }
-      j++;
     }
+
+    // Create the jsi::Array with the exact size
+    auto cmds = jsi::Array(runtime, cmdList.size());
+    for (size_t i = 0; i < cmdList.size(); ++i) {
+      cmds.setValueAtIndex(runtime, i, cmdList[i]);
+    }
+
     return cmds;
   }
 

package/cpp/api/JsiSkRuntimeEffect.h

@@ -22,6 +22,13 @@ namespace RNSkia {
 
 namespace jsi = facebook::jsi;
 
+// Helper to see a bit pattern as a float (w/o aliasing warnings)
+static inline float SkBits2Float(uint32_t bits) {
+  float value;
+  memcpy(&value, &bits, sizeof(float));
+  return value;
+}
+
 struct RuntimeEffectUniform {
   int columns;
   int rows;

package/cpp/api/JsiSkiaContext.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <memory>
+#include <numeric>
+#include <utility>
+#include <vector>
+
+#include "JsiSkHostObjects.h"
+#include "RNSkLog.h"
+#include <jsi/jsi.h>
+
+#include "JsiSkPaint.h"
+#include "JsiSkPoint.h"
+#include "JsiSkRect.h"
+#include "JsiSkTypeface.h"
+
+#include "SkiaContext.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkFont.h"
+#include "include/core/SkFontMetrics.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class JsiSkiaContext : public JsiSkWrappingSharedPtrHostObject<SkiaContext> {
+public:
+  EXPORT_JSI_API_TYPENAME(JsiSkiaContext, SkiaContext)
+
+  JSI_HOST_FUNCTION(getSurface) {
+    auto surface = getObject()->getSurface();
+    return jsi::Object::createFromHostObject(
+        runtime,
+        std::make_shared<JsiSkSurface>(getContext(), std::move(surface)));
+  }
+
+  JSI_HOST_FUNCTION(present) {
+    getObject()->present();
+    return jsi::Value::undefined();
+  }
+
+  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkiaContext, getSurface),
+                       JSI_EXPORT_FUNC(JsiSkiaContext, present))
+
+  JsiSkiaContext(std::shared_ptr<RNSkPlatformContext> context,
+                 std::shared_ptr<SkiaContext> ctx)
+      : JsiSkWrappingSharedPtrHostObject(std::move(context), std::move(ctx)) {}
+
+  /**
+   * Creates the function for construction a new instance of the SkFont
+   * wrapper
+   * @param context Platform context
+   * @return A function for creating a new host object wrapper for the SkFont
+   * class
+   */
+  static const jsi::HostFunctionType
+  createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+    return JSI_HOST_FUNCTION_LAMBDA {
+      jsi::BigInt pointer = arguments[0].asBigInt(runtime);
+      const uintptr_t nativeBufferPointer = pointer.asUint64(runtime);
+      void *surface = reinterpret_cast<void *>(nativeBufferPointer);
+      auto width = static_cast<int>(arguments[1].asNumber());
+      auto height = static_cast<int>(arguments[2].asNumber());
+      auto result =
+          context->makeContextFromNativeSurface(surface, width, height);
+      // Return the newly constructed object
+      return jsi::Object::createFromHostObject(
+          runtime, std::make_shared<JsiSkiaContext>(std::move(context),
+                                                    std::move(result)));
+    };
+  }
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkPlatformContext.h

@@ -11,6 +11,7 @@
 
 #include "RNSkDispatchQueue.h"
 #include "RNSkVideo.h"
+#include "SkiaContext.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -134,6 +135,9 @@ public:
    */
   virtual sk_sp<SkSurface> makeOffscreenSurface(int width, int height) = 0;
 
+  virtual std::shared_ptr<SkiaContext>
+  makeContextFromNativeSurface(void *surface, int width, int height) = 0;
+
   /**
    * Creates an image from a native buffer.
    * - On iOS, this is a `CVPixelBufferRef`

package/cpp/rnskia/SkiaContext.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkImage.h"
+#include "include/core/SkSurface.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+class SkiaContext {
+public:
+  virtual ~SkiaContext() = default;
+  virtual sk_sp<SkSurface> getSurface() = 0;
+  virtual void present() = 0;
+};
+
+} // namespace RNSkia

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

@@ -11,8 +11,8 @@
 
 #if defined(SK_BUILD_FOR_ANDROID) && __ANDROID_API__ >= 26
 
-#include "include/gpu/GrBackendSurface.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/gpu/ganesh/GrTypes.h"
 
 class GrDirectContext;
 

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkImage.h"
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 
 class SkColorSpace;
 class GrDirectContext;

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

@@ -10,7 +10,7 @@
 
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSurface.h"
-#include "include/gpu/GrTypes.h"
+#include "include/gpu/ganesh/GrTypes.h"
 
 class SkColorSpace;
 class GrDirectContext;

package/cpp/skia/include/codec/SkAndroidCodec.h

@@ -264,19 +264,23 @@ public:
     SkCodec* codec() const { return fCodec.get(); }
 
     /**
-     *  Retrieve the gainmap for an image.
+     *  Retrieve the gainmap codec for an image.
      *
-     *  @param outInfo                On success, this is populated with the parameters for
-     *                                rendering this gainmap. This parameter must be non-nullptr.
+     *  @param outInfo          On success, this is populated with the parameters for
+     *                          rendering this gainmap. This parameter must be non-nullptr.
      *
-     *  @param outGainmapImageStream  On success, this is populated with a stream from which the
-     *                                gainmap image may be decoded. This parameter is optional, and
-     *                                may be set to nullptr.
+     *  @param outGainmapCodec  On success, this is populated with a codec from which the
+     *                          gainmap image may be decoded. This parameter is optional, and
+     *                          may be set to nullptr.
      *
-     *  @return                       If this has a gainmap image and that gainmap image was
-     *                                successfully extracted then return true. Otherwise return
-     *                                false.
+     *  @return                 If this has a gainmap image and that gainmap image was
+     *                          successfully extracted then return true. Otherwise return
+     *                          false.
      */
+    bool getGainmapAndroidCodec(SkGainmapInfo* outInfo, std::unique_ptr<SkAndroidCodec>* outCodec);
+
+    // TODO(issues.skia.org/363544350): This API only works for JPEG images. Remove this API once
+    // it is no longer used.
     bool getAndroidGainmap(SkGainmapInfo* outInfo,
                            std::unique_ptr<SkStream>* outGainmapImageStream);
 

package/cpp/skia/include/codec/SkCodec.h

@@ -24,6 +24,7 @@
 #include <cstddef>
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string_view>
 #include <tuple>
 #include <vector>
@@ -290,6 +291,12 @@ public:
      */
     SkEncodedImageFormat getEncodedFormat() const { return this->onGetEncodedFormat(); }
 
+    /**
+     *  Return the underlying encoded data stream. This may be nullptr if the original
+     *  stream could not be duplicated.
+     */
+    virtual std::unique_ptr<SkStream> getEncodedData() const;
+
     /**
      *  Whether or not the memory passed to getPixels is zero initialized.
      */
@@ -642,11 +649,6 @@ public:
     //   is residing in dst's memory.
     static constexpr int kNoFrame = -1;
 
-    // This transitional definition was added in August 2018, and will eventually be removed.
-#ifdef SK_LEGACY_SKCODEC_NONE_ENUM
-    static constexpr int kNone = kNoFrame;
-#endif
-
     /**
      *  Information about individual frames in a multi-framed image.
      */
@@ -793,6 +795,10 @@ protected:
         return fSrcXformFormat;
     }
 
+    virtual bool onGetGainmapCodec(SkGainmapInfo*, std::unique_ptr<SkCodec>*) { return false; }
+
+    // TODO(issues.skia.org/363544350): This API only works for JPEG images. Remove this API once
+    // it is no longer used.
     virtual bool onGetGainmapInfo(SkGainmapInfo*, std::unique_ptr<SkStream>*) { return false; }
 
     virtual SkISize onGetScaledDimensions(float /*desiredScale*/) const {
@@ -1056,6 +1062,23 @@ struct SK_API Decoder {
 // will replace the existing one (in the same position). This is not thread-safe, so make sure all
 // initialization is done before the first call.
 void SK_API Register(Decoder d);
+
+/**
+ *  Return a SkImage produced by the codec, but attempts to defer image allocation until the
+ *  image is actually used/drawn. This deferral allows the system to cache the result, either on the
+ *  CPU or on the GPU, depending on where the image is drawn. If memory is low, the cache may
+ *  be purged, causing the next draw of the image to have to re-decode.
+ *
+ *  If alphaType is nullopt, the image's alpha type will be chosen automatically based on the
+ *  image format. Transparent images will default to kPremul_SkAlphaType. If alphaType contains
+ *  kPremul_SkAlphaType or kUnpremul_SkAlphaType, that alpha type will be used. Forcing opaque
+ *  (passing kOpaque_SkAlphaType) is not allowed, and will return nullptr.
+ *
+ *  @param codec    A non-null codec (e.g. from SkPngDecoder::Decode)
+ *  @return         created SkImage, or nullptr
+ */
+SK_API sk_sp<SkImage> DeferredImage(std::unique_ptr<SkCodec> codec,
+                                    std::optional<SkAlphaType> alphaType = std::nullopt);
 }
 
 #endif // SkCodec_DEFINED

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

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkArc_DEFINED
+#define SkArc_DEFINED
+
+#include "include/core/SkRect.h"
+#include "include/core/SkScalar.h"
+
+// Represents an arc along an oval boundary, or a closed wedge of the oval.
+struct SkArc {
+    enum class Type : bool {
+        kArc,   // An arc along the perimeter of the oval
+        kWedge  // A closed wedge that includes the oval's center
+    };
+
+    SkArc() = default;
+    SkArc(const SkArc& arc) = default;
+    SkArc& operator=(const SkArc& arc) = default;
+
+    const SkRect& oval() const { return fOval; }
+    SkScalar startAngle() const { return fStartAngle; }
+    SkScalar sweepAngle() const { return fSweepAngle; }
+    bool isWedge() const { return fType == Type::kWedge; }
+
+    friend bool operator==(const SkArc& a, const SkArc& b) {
+        return a.fOval == b.fOval && a.fStartAngle == b.fStartAngle &&
+               a.fSweepAngle == b.fSweepAngle && a.fType == b.fType;
+    }
+
+    friend bool operator!=(const SkArc& a, const SkArc& b) { return !(a == b); }
+
+    // Preferred factory that explicitly states which type of arc
+    static SkArc Make(const SkRect& oval,
+                      SkScalar startAngleDegrees,
+                      SkScalar sweepAngleDegrees,
+                      Type type) {
+        return SkArc(oval, startAngleDegrees, sweepAngleDegrees, type);
+    }
+
+    // Deprecated factory to assist with legacy code based on `useCenter`
+    static SkArc Make(const SkRect& oval,
+                      SkScalar startAngleDegrees,
+                      SkScalar sweepAngleDegrees,
+                      bool useCenter) {
+        return SkArc(
+                oval, startAngleDegrees, sweepAngleDegrees, useCenter ? Type::kWedge : Type::kArc);
+    }
+
+    // Bounds of oval containing the arc.
+    SkRect   fOval = SkRect::MakeEmpty();
+
+    // Angle in degrees where the arc begins. Zero means horizontally to the right.
+    SkScalar fStartAngle = 0;
+    // Sweep angle in degrees; positive is clockwise.
+    SkScalar fSweepAngle = 0;
+
+    Type     fType = Type::kArc;
+
+private:
+    SkArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, Type type)
+            : fOval(oval), fStartAngle(startAngle), fSweepAngle(sweepAngle), fType(type) {}
+};
+
+#endif

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

@@ -266,6 +266,16 @@ public:
     */
     bool setAlphaType(SkAlphaType alphaType);
 
+    /** Sets the SkColorSpace associated with this SkBitmap.
+
+        The raw pixel data is not altered by this call; no conversion is
+        performed.
+
+        This changes SkColorSpace in SkPixelRef; all bitmaps sharing SkPixelRef
+        are affected.
+    */
+    void setColorSpace(sk_sp<SkColorSpace> colorSpace);
+
     /** Returns pixel address, the base address corresponding to the pixel origin.
 
         @return  pixel address