react-native-skia 3.0.1 → 3.0.3

package/cpp/api/JsiSkImageFactory.h

@@ -13,9 +13,7 @@
 #include "JsiSkNativeObjects.h"
 #include "jsi/JsiPromises.h"
 
-#ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#endif
 
 namespace RNSkia {
 
@@ -109,7 +107,6 @@ public:
   // device: both packages link one Dawn and share one wgpu::Instance.
 
   JSI_HOST_FUNCTION(MakeImageFromNativeTexture) {
-#ifdef SK_GRAPHITE
     if (count < 1 || !arguments[0].isBigInt()) {
       throw std::runtime_error("MakeImageFromNativeTexture requires a "
                                "WGPUTexture pointer (BigInt), e.g. "
@@ -137,15 +134,9 @@ public:
     }
     return makeJsiObject(
         runtime, std::make_shared<JsiSkImage>(getContext(), std::move(image)));
-#else
-    throw std::runtime_error(
-        "MakeImageFromNativeTexture is only available with the Graphite "
-        "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
   }
 
   JSI_HOST_FUNCTION(MakeNativeTextureFromImage) {
-#ifdef SK_GRAPHITE
     if (count < 1) {
       throw std::runtime_error(
           "MakeNativeTextureFromImage requires an SkImage argument");
@@ -165,11 +156,6 @@ public:
     // releases it when the JS GPUTexture is destroyed.
     return jsi::BigInt::fromUint64(
         runtime, reinterpret_cast<uint64_t>(texture.MoveToCHandle()));
-#else
-    throw std::runtime_error(
-        "MakeNativeTextureFromImage is only available with the Graphite "
-        "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
   }
 
   size_t getMemoryPressure() override { return 1024; }

package/cpp/api/JsiSkSurface.h

@@ -15,15 +15,12 @@
 #include "JsiSkCanvas.h"
 #include "JsiSkImage.h"
 
-#if defined(SK_GRAPHITE)
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
 #include "include/core/SkSurface.h"
-#include "include/gpu/ganesh/GrDirectContext.h"
 
 #pragma clang diagnostic pop
 
@@ -87,7 +84,6 @@ public:
     // submitted work. Required before a native consumer on a different command
     // queue reads this surface's texture via getNativeTextureUnstable(). #3916
     bool sync = syncParam.has_value() && *syncParam;
-#if defined(SK_GRAPHITE)
     // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder;
     // only Graphite-backed surfaces need to snap and submit a recording.
     if (auto *recorder = surface->recorder()) {
@@ -96,11 +92,6 @@ public:
           recording.get(), sync ? skgpu::graphite::SyncToCpu::kYes
                                 : skgpu::graphite::SyncToCpu::kNo);
     }
-#else
-    if (auto dContext = GrAsDirectContext(surface->recordingContext())) {
-      dContext->flushAndSubmit(sync ? GrSyncCpu::kYes : GrSyncCpu::kNo);
-    }
-#endif
   }
 
   JSI_HOST_FUNCTION(makeImageSnapshot) {
@@ -113,14 +104,12 @@ public:
     } else {
       image = surface->makeImageSnapshot();
     }
-#if defined(SK_GRAPHITE)
     // A raster surface (e.g. Skia.Surface.Make) has no Graphite recorder; its
     // snapshot is already a valid CPU image, so skip the recording submit.
     if (auto *recorder = surface->recorder()) {
       auto recording = recorder->snap();
       DawnContext::getInstance().submitRecording(recording.get());
     }
-#endif
     if (count > 1 && arguments[1].isObject()) {
       auto jsiImage = getJsiObject<JsiSkImage>(runtime, arguments[1]);
       jsiImage->setObject(image);
@@ -173,11 +162,8 @@ public:
     size_t estimated = pixelBytes;
 
     auto canvas = surface->getCanvas();
-    const bool isGpuBacked =
-        surface->recordingContext() != nullptr ||
-        surface->recorder() != nullptr ||
-        (canvas && (canvas->recordingContext() != nullptr ||
-                    canvas->recorder() != nullptr));
+    const bool isGpuBacked = surface->recorder() != nullptr ||
+                             (canvas && canvas->recorder() != nullptr);
 
     if (isGpuBacked) {
       // Account for a resolved texture and depth/stencil attachments.

package/cpp/api/JsiSkSurfaceFactory.h

@@ -10,9 +10,7 @@
 
 #include "JsiSkSurface.h"
 
-#ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -68,7 +66,6 @@ public:
   // directly into a texture created on the shared device, so WebGPU can
   // sample what Skia drew without any copy.
   JSI_HOST_FUNCTION(MakeFromNativeTexture) {
-#ifdef SK_GRAPHITE
     if (count < 1 || !arguments[0].isBigInt()) {
       throw std::runtime_error("MakeFromNativeTexture requires a WGPUTexture "
                                "pointer (BigInt), e.g. texture.nativePointer");
@@ -91,11 +88,6 @@ public:
     }
     return makeJsiObject(runtime, std::make_shared<JsiSkSurface>(
                                       getContext(), std::move(surface)));
-#else
-    throw std::runtime_error(
-        "MakeFromNativeTexture is only available with the Graphite backend. "
-        "Rebuild with SK_GRAPHITE enabled.");
-#endif
   }
 
   size_t getMemoryPressure() override { return 2048; }

package/cpp/rnskia/RNDawnContext.h

@@ -406,7 +406,8 @@ public:
 
   // Create onscreen surface with window
   std::unique_ptr<WindowContext> MakeWindow(void *window, int width, int height,
-                                            bool highBitDepth = false) {
+                                            bool highBitDepth = false,
+                                            bool useP3ColorSpace = false) {
     // 1. Create Surface
     wgpu::SurfaceDescriptor surfaceDescriptor;
 #ifdef __APPLE__
@@ -422,7 +423,7 @@ public:
         wgpu::Instance(instance->Get()).CreateSurface(&surfaceDescriptor);
     return std::make_unique<DawnWindowContext>(
         getRecorder(), backendContext.fDevice, surface, window, width, height,
-        highBitDepth);
+        highBitDepth, useP3ColorSpace);
   }
 
   skgpu::graphite::Recorder *getRecorder() {

package/cpp/rnskia/RNDawnInterop.cpp

@@ -1,5 +1,3 @@
-#ifdef SK_GRAPHITE
-
 #include "RNDawnContext.h"
 
 // Runtime discovery surface for react-native-webgpu.
@@ -15,5 +13,3 @@ extern "C" __attribute__((visibility("default"))) WGPUInstance
 rnskia_getWGPUInstance() {
   return RNSkia::DawnContext::getInstance().getWGPUInstance().Get();
 }
-
-#endif

package/cpp/rnskia/RNDawnUtils.h

@@ -8,6 +8,7 @@
 
 #include "dawn/native/DawnNative.h"
 
+#include "include/core/SkColorSpace.h"
 #include "include/core/SkColorType.h"
 #include "include/gpu/graphite/dawn/DawnBackendContext.h"
 #include "utils/RNSkLog.h"
@@ -42,6 +43,17 @@ static const wgpu::TextureFormat HighBitDepthTextureFormat =
     wgpu::TextureFormat::RGB10A2Unorm;
 #endif
 
+// The color space a view renders in: Display P3 (with the sRGB transfer
+// function) where the platform prefers it (a wide gamut display on Apple
+// platforms, see RNSkPlatformContext::prefersP3ColorSpace), sRGB otherwise.
+// Colors are managed either way: content looks the same in both, Display P3
+// only adds the colors sRGB cannot represent.
+inline sk_sp<SkColorSpace> viewColorSpace(bool useP3ColorSpace) {
+  return useP3ColorSpace ? SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
+                                                 SkNamedGamut::kDisplayP3)
+                         : SkColorSpace::MakeSRGB();
+}
+
 // Usage requested for a window texture when the surface supports it (see
 // DawnWindowContext::supportedSurfaceUsage), and assumed for a Graphite
 // recording made before its window exists: TextureBinding lets a render pass
@@ -137,7 +149,6 @@ requestDevice(dawn::native::Adapter &nativeAdapter,
 #endif
       "disable_lazy_clear_for_mapped_at_creation_buffer",
       "allow_unsafe_apis",
-      "use_user_defined_labels_in_backend",
       "disable_robustness",
   };
   wgpu::DawnTogglesDescriptor togglesDesc;

package/cpp/rnskia/RNDawnWindowContext.cpp

@@ -29,7 +29,8 @@ bool DawnWindowContext::presentRecordings(
   auto backendTex = skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
   SkSurfaceProps surfaceProps;
   auto surface = SkSurfaces::WrapBackendTexture(
-      _recorder, backendTex, SkColorSpace::MakeSRGB(), &surfaceProps);
+      _recorder, backendTex, DawnUtils::viewColorSpace(_useP3ColorSpace),
+      &surfaceProps);
   if (!surface) {
     return false;
   }
@@ -42,4 +43,14 @@ bool DawnWindowContext::presentRecordings(
   return success;
 }
 
+bool DawnWindowContext::presentImage(const sk_sp<SkImage> &image) {
+  auto surface = getSurface();
+  if (!surface) {
+    return false;
+  }
+  surface->getCanvas()->drawImage(image, 0, 0);
+  present();
+  return true;
+}
+
 } // namespace RNSkia

package/cpp/rnskia/RNDawnWindowContext.h

@@ -30,9 +30,11 @@ class DawnWindowContext : public WindowContext {
 public:
   DawnWindowContext(skgpu::graphite::Recorder *recorder, wgpu::Device device,
                     wgpu::Surface surface, void *nativeSurface, int width,
-                    int height, bool highBitDepth = false)
+                    int height, bool highBitDepth = false,
+                    bool useP3ColorSpace = false)
       : _recorder(recorder), _device(device), _surface(surface),
-        _nativeSurface(nativeSurface), _width(width), _height(height) {
+        _nativeSurface(nativeSurface), _useP3ColorSpace(useP3ColorSpace),
+        _width(width), _height(height) {
     _format = DawnUtils::PreferredTextureFormat;
     _colorType = DawnUtils::PreferedColorType;
     if (highBitDepth) {
@@ -59,10 +61,10 @@ public:
         skgpu::graphite::SampleCount::k1, skgpu::Mipmapped::kNo, _format,
         texture.GetUsage(), wgpu::TextureAspect::All);
     auto backendTex = skgpu::graphite::BackendTextures::MakeDawn(texture.Get());
-    sk_sp<SkColorSpace> colorSpace = SkColorSpace::MakeSRGB();
     SkSurfaceProps surfaceProps;
     auto surface = SkSurfaces::WrapBackendTexture(
-        _recorder, backendTex, _colorType, colorSpace, &surfaceProps);
+        _recorder, backendTex, _colorType,
+        DawnUtils::viewColorSpace(_useP3ColorSpace), &surfaceProps);
     return surface;
   }
 
@@ -74,8 +76,16 @@ public:
   bool presentRecordings(
       const std::vector<skgpu::graphite::Recording *> &recordings);
 
+  // Draws an image at the origin of the current swapchain texture (on the
+  // window's own recorder) and presents it.
+  bool presentImage(const sk_sp<SkImage> &image);
+
   SkColorType getColorType() const { return _colorType; }
 
+  // Whether the window is in Display P3 rather than sRGB: a deferred canvas
+  // must be recorded in the color space of the window it is replayed onto.
+  bool usesP3ColorSpace() const { return _useP3ColorSpace; }
+
   // The texture description a deferred canvas must be recorded with to be
   // replayed onto this window.
   skgpu::graphite::TextureInfo getTextureInfo() const {
@@ -110,9 +120,10 @@ private:
 #endif
     _surface.Configure(&config);
 #ifdef __APPLE__
-    // Float formats need the layer tagged as (gamma-encoded) extended sRGB so
-    // the sRGB-encoded values display identically to the 8-bit path.
-    applyCAMetalLayerColorSpace(_nativeSurface, _format);
+    // The layer is tagged with the gamut the window renders in; float formats
+    // need the (gamma-encoded) extended variant so the values display
+    // identically to the 8-bit path.
+    applyCAMetalLayerColorSpace(_nativeSurface, _format, _useP3ColorSpace);
 #endif
   }
 
@@ -157,6 +168,7 @@ private:
   wgpu::Device _device;
   wgpu::Surface _surface;
   [[maybe_unused]] void *_nativeSurface;
+  bool _useP3ColorSpace;
   wgpu::TextureFormat _format;
   wgpu::TextureUsage _usage = wgpu::TextureUsage::RenderAttachment;
   SkColorType _colorType;

package/cpp/rnskia/RNMetalLayerColorSpace.h

@@ -7,9 +7,11 @@
 namespace RNSkia {
 
 // Tags the CAMetalLayer with the colorspace matching the configured texture
-// format. Implemented in apple/MetalLayerColorSpace.mm.
+// format and the gamut the view renders in. Implemented in
+// apple/MetalLayerColorSpace.mm.
 void applyCAMetalLayerColorSpace(void *nativeSurface,
-                                 wgpu::TextureFormat format);
+                                 wgpu::TextureFormat format,
+                                 bool useP3ColorSpace);
 
 } // namespace RNSkia
 

package/cpp/rnskia/RNSkCanvasProvider.h

@@ -0,0 +1,231 @@
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <utility>
+#include <vector>
+
+#include "RNDawnContext.h"
+#include "RNDawnUtils.h"
+#include "RNSkPlatformContext.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkImage.h"
+#include "include/core/SkSurface.h"
+#include "include/gpu/graphite/Recording.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/gpu/graphite/dawn/DawnGraphiteTypes.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+/**
+ * Describes the texture a recording is replayed onto: the pixel size, the
+ * format and the color space of a window (or offscreen) surface. A deferred
+ * canvas is recorded against this description, so it can be created before
+ * the surface itself exists.
+ */
+struct RNSkGraphiteTargetInfo {
+  int width = 0;
+  int height = 0;
+  SkColorType colorType = kUnknown_SkColorType;
+  // Display P3 rather than sRGB (see DawnUtils::viewColorSpace). The colors
+  // of a recording are converted to the color space of its target when it is
+  // recorded, not when it is replayed.
+  bool useP3ColorSpace = false;
+  skgpu::graphite::TextureInfo textureInfo;
+};
+
+/**
+ * The surface a view presents into: a platform window (a CAMetalLayer, an
+ * ANativeWindow) or an offscreen surface. It describes its target texture to
+ * whoever records for the view and replays their recordings onto it.
+ */
+class RNSkCanvasProvider {
+public:
+  virtual ~RNSkCanvasProvider() = default;
+
+  /** Width of the surface, in pixels. */
+  virtual int getWidth() = 0;
+
+  /** Height of the surface, in pixels. */
+  virtual int getHeight() = 0;
+
+  /**
+   Describes the current target texture. Safe to call from any thread;
+   returns false while there is no surface to describe.
+   */
+  virtual bool getTargetInfo(RNSkGraphiteTargetInfo *info) = 0;
+
+  /**
+   The size in pixels the surface will have, known from the platform layout
+   before the surface itself exists (on Android the surface only appears a
+   frame after the view is laid out). Safe to call from any thread; returns
+   false until the view is laid out. A frame recorded against this size is
+   presented as is once the surface appears, where one recorded against a
+   size derived from the layout in points could be off by a pixel and would
+   not cover the surface.
+   */
+  virtual bool getLayoutSize(int *width, int *height) { return false; }
+
+  /**
+   Replays the recordings, in order, onto the target texture and presents
+   it. Called on the thread that owns the surface. Returns false when the
+   surface cannot present right now (there is none, or the app is in the
+   background): nothing was consumed.
+   */
+  virtual bool presentRecordings(
+      const std::vector<skgpu::graphite::Recording *> &recordings) = 0;
+
+  /**
+   Draws an image at the origin of the target texture and presents it. Same
+   thread and return value as presentRecordings(). Used for a recording whose
+   size or color space differs from the target's: it is replayed into a
+   texture of its own first (see RNSkView::present).
+   */
+  virtual bool presentImage(const sk_sp<SkImage> &image) = 0;
+
+  /**
+   Installed by the view owning the provider: asks it for a frame when the
+   surface appears or changes size.
+   */
+  void setRequestRedraw(std::function<void()> requestRedraw) {
+    _requestRedraw = std::move(requestRedraw);
+  }
+
+protected:
+  void requestRedraw() {
+    if (_requestRedraw) {
+      _requestRedraw();
+    }
+  }
+
+private:
+  std::function<void()> _requestRedraw;
+};
+
+/**
+ * An offscreen surface the content of a view is replayed into for a snapshot.
+ * A recording is replayed as is, so the surface takes the color space of the
+ * recordings it is meant for.
+ */
+class RNSkOffscreenCanvasProvider : public RNSkCanvasProvider {
+public:
+  RNSkOffscreenCanvasProvider(
+      const std::shared_ptr<RNSkPlatformContext> &context, int width,
+      int height, bool useP3ColorSpace = false)
+      : _width(width), _height(height), _pd(context->getPixelDensity()),
+        _useP3ColorSpace(useP3ColorSpace),
+        _surface(
+            context->makeOffscreenSurface(width, height, useP3ColorSpace)) {}
+
+  virtual ~RNSkOffscreenCanvasProvider() = default;
+
+  /** The canvas of the surface, in pixels; nullptr without a surface. */
+  SkCanvas *getCanvas() { return _surface ? _surface->getCanvas() : nullptr; }
+
+  /**
+   A GPU image of the surface, usable by any recorder of the context once
+   this returns; nullptr without a surface.
+   */
+  sk_sp<SkImage> makeImage() {
+    if (_surface == nullptr) {
+      return nullptr;
+    }
+    auto image = _surface->makeImageSnapshot();
+    // The snapshot is a copy task on the surface's recorder: submitted here,
+    // so that the image is complete for whoever draws it next.
+    if (auto *recorder = _surface->recorder()) {
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+    }
+    return image;
+  }
+
+  /**
+   Returns a snapshot of the current surface/canvas
+   */
+  sk_sp<SkImage> makeSnapshot(SkRect *bounds) {
+    if (_surface == nullptr) {
+      return nullptr;
+    }
+    sk_sp<SkImage> image;
+    if (bounds != nullptr) {
+      SkIRect b =
+          SkIRect::MakeXYWH(bounds->x() * _pd, bounds->y() * _pd,
+                            bounds->width() * _pd, bounds->height() * _pd);
+      image = _surface->makeImageSnapshot(b);
+    } else {
+      image = _surface->makeImageSnapshot();
+    }
+    // Only Graphite-backed surfaces have a recorder to snap/submit; a raster
+    // surface's snapshot is already a valid CPU image.
+    if (auto *recorder = _surface->recorder()) {
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+    }
+    return DawnContext::getInstance().MakeRasterImage(image);
+  }
+
+  int getWidth() override { return _width; }
+
+  int getHeight() override { return _height; }
+
+  bool getTargetInfo(RNSkGraphiteTargetInfo *info) override {
+    if (_surface == nullptr || _surface->recorder() == nullptr) {
+      return false;
+    }
+    // Graphite gives its render targets the sampled+renderable usage, a
+    // superset of what a deferred canvas asks for.
+    auto colorType = _surface->imageInfo().colorType();
+    info->width = _width;
+    info->height = _height;
+    info->colorType = colorType;
+    info->useP3ColorSpace = _useP3ColorSpace;
+    info->textureInfo = skgpu::graphite::TextureInfos::MakeDawn(
+        skgpu::graphite::DawnTextureInfo(
+            skgpu::graphite::SampleCount::k1, skgpu::Mipmapped::kNo,
+            DawnUtils::textureFormatForColorType(colorType),
+            DawnUtils::DefaultTargetUsage, wgpu::TextureAspect::All));
+    return true;
+  }
+
+  bool presentRecordings(
+      const std::vector<skgpu::graphite::Recording *> &recordings) override {
+    auto *recorder = _surface ? _surface->recorder() : nullptr;
+    if (recorder == nullptr) {
+      return false;
+    }
+    // A new surface clears itself in its first pass, which its own recorder
+    // only records when it next snaps. The recordings go straight to the
+    // context, so that clear would run after them and wipe them: record and
+    // submit it first (the explicit clear makes sure the pass is emitted).
+    if (!_cleared) {
+      _surface->getCanvas()->clear(SK_ColorTRANSPARENT);
+      DawnContext::getInstance().submitRecording(recorder->snap().get());
+      _cleared = true;
+    }
+    return DawnContext::getInstance().insertRecordings(recordings,
+                                                       _surface.get());
+  }
+
+  bool presentImage(const sk_sp<SkImage> &image) override {
+    if (_surface == nullptr) {
+      return false;
+    }
+    _surface->getCanvas()->drawImage(image, 0, 0);
+    return true;
+  }
+
+private:
+  int _width;
+  int _height;
+  float _pd;
+  bool _useP3ColorSpace;
+  sk_sp<SkSurface> _surface;
+  bool _cleared = false;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/RNSkGraphiteProducer.cpp

@@ -1,15 +1,13 @@
 // Everything that needs a complete Recorder lives here rather than in
 // RNSkGraphiteProducer.h (which the view headers include on their own).
-#if defined(SK_GRAPHITE)
-
 #include "RNSkGraphiteProducer.h"
 
 #include <memory>
 #include <utility>
 
-#include "RNSkGraphiteView.h"
-#include "RNSkPictureView.h"
+#include "RNSkGraphiteTarget.h"
 #include "RNSkThreadPool.h"
+#include "api/recorder/DrawingCtx.h"
 #include "api/recorder/RNRecorder.h"
 #include "utils/RNSkLog.h"
 
@@ -20,6 +18,21 @@ namespace RNSkia {
 
 RNSkGraphiteProducer::~RNSkGraphiteProducer() = default;
 
+void RNSkGraphiteProducer::drawContent(SkCanvas *canvas, Recorder *recorder,
+                                       const sk_sp<SkPicture> &picture,
+                                       float pixelDensity) {
+  canvas->clear(SK_ColorTRANSPARENT);
+  canvas->save();
+  canvas->scale(pixelDensity, pixelDensity);
+  if (recorder != nullptr) {
+    DrawingCtx ctx(canvas);
+    recorder->play(&ctx);
+  } else if (picture != nullptr) {
+    canvas->drawPicture(picture);
+  }
+  canvas->restore();
+}
+
 void RNSkGraphiteProducer::setTarget(
     std::shared_ptr<RNSkGraphiteTarget> target) {
   std::lock_guard<std::mutex> lock(_mutex);
@@ -67,6 +80,18 @@ bool RNSkGraphiteProducer::hasContent() {
   return _recorder != nullptr || _picture != nullptr;
 }
 
+bool RNSkGraphiteProducer::applyUpdatesTo(
+    const std::shared_ptr<Recorder> &recorder, jsi::Runtime &runtime,
+    double recorderId, const jsi::Array &values) {
+  if (recorder == nullptr || recorder->id != recorderId) {
+    return false;
+  }
+  // The values are written into the commands by the next replay, which the
+  // caller schedules: the mapper never waits for a draw.
+  recorder->readUpdates(runtime, values);
+  return true;
+}
+
 bool RNSkGraphiteProducer::applyUpdates(jsi::Runtime &runtime,
                                         double recorderId,
                                         const jsi::Array &values) {
@@ -75,13 +100,12 @@ bool RNSkGraphiteProducer::applyUpdates(jsi::Runtime &runtime,
     std::lock_guard<std::mutex> lock(_mutex);
     recorder = _recorder;
   }
-  if (recorder == nullptr || recorder->id != recorderId) {
-    return false;
-  }
   // Outside the lock: a commit replacing the recorder must not wait for the
   // read. Should it land while this runs, the values go into the retired
   // recorder and the commit's own frame draws the new one.
-  recorder->readUpdates(runtime, values);
+  if (!applyUpdatesTo(recorder, runtime, recorderId, values)) {
+    return false;
+  }
   std::lock_guard<std::mutex> lock(_mutex);
   _dirty = true;
   kickLocked();
@@ -142,14 +166,14 @@ void RNSkGraphiteProducer::produce() {
         // The deferred canvas already draws in points.
         drawContent(canvas, recorder.get(), picture, /* pixelDensity= */ 1.0f);
       } catch (const std::exception &e) {
-        RNSkLogger::logToConsole(
-            "GraphiteCanvas: replaying the scene failed: %s", e.what());
+        RNSkLogger::logToConsole("Canvas: replaying the scene failed: %s",
+                                 e.what());
       }
       try {
         recording = target->finishRecording();
       } catch (const std::exception &e) {
-        RNSkLogger::logToConsole(
-            "GraphiteCanvas: recording the frame failed: %s", e.what());
+        RNSkLogger::logToConsole("Canvas: recording the frame failed: %s",
+                                 e.what());
       }
     }
   }
@@ -185,5 +209,3 @@ void RNSkGraphiteProducer::renderInto(SkCanvas *canvas, float pixelDensity) {
 }
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE