react-native-skia 2.15.0 → 3.0.1

package/cpp/dawn/include/webgpu/webgpu_cpp_chained_struct.h

@@ -0,0 +1,57 @@
+// Copyright 2023 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifdef __EMSCRIPTEN__
+#error "Do not include this header. Use the headers provided by Emdawnwebgpu instead."
+#endif
+
+#ifndef WEBGPU_CPP_CHAINED_STRUCT_H_
+#define WEBGPU_CPP_CHAINED_STRUCT_H_
+
+#include <cstddef>
+#include <cstdint>
+
+// This header file declares the ChainedStruct structures separately from the WebGPU
+// headers so that dependencies can directly extend structures without including the larger header
+// which exposes capabilities that may require correctly set proc tables.
+namespace wgpu {
+
+    enum class SType : uint32_t;
+
+    struct ChainedStruct {
+        ChainedStruct const * nextInChain = nullptr;
+        SType sType = SType(0u);
+    };
+
+    struct ChainedStructOut {
+        ChainedStructOut * nextInChain = nullptr;
+        SType sType = SType(0u);
+    };
+
+}  // namespace wgpu}
+
+#endif // WEBGPU_CPP_CHAINED_STRUCT_H_

package/cpp/dawn/include/webgpu/webgpu_enum_class_bitmasks.h

@@ -0,0 +1,163 @@
+// Copyright 2017 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef WEBGPU_ENUM_CLASS_BITMASKS_H_
+#define WEBGPU_ENUM_CLASS_BITMASKS_H_
+
+#include <type_traits>
+
+// The operators in wgpu:: namespace need be introduced into other namespaces with
+// using-declarations for C++ Argument Dependent Lookup to work.
+#define WGPU_IMPORT_BITMASK_OPERATORS \
+    using wgpu::operator|;            \
+    using wgpu::operator&;            \
+    using wgpu::operator^;            \
+    using wgpu::operator~;            \
+    using wgpu::operator&=;           \
+    using wgpu::operator|=;           \
+    using wgpu::operator^=;           \
+    using wgpu::HasZeroOrOneBits;
+
+namespace wgpu {
+
+template <typename T>
+struct IsWGPUBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T, typename Enable = void>
+struct LowerBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T>
+struct LowerBitmask<T, typename std::enable_if<IsWGPUBitmask<T>::enable>::type> {
+    static constexpr bool enable = true;
+    using type = T;
+    constexpr static T Lower(T t) { return t; }
+};
+
+template <typename T>
+struct BoolConvertible {
+    using Integral = typename std::underlying_type<T>::type;
+
+    explicit constexpr BoolConvertible(Integral value) : value(value) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    constexpr operator bool() const { return value != 0; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    constexpr operator T() const { return static_cast<T>(value); }
+
+    Integral value;
+};
+
+template <typename T>
+struct LowerBitmask<BoolConvertible<T>> {
+    static constexpr bool enable = true;
+    using type = T;
+    static constexpr type Lower(BoolConvertible<T> t) { return t; }
+};
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator|(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) |
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator&(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) &
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator^(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) ^
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <typename T1>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator~(T1 t) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(
+        static_cast<Integral>(~static_cast<Integral>(LowerBitmask<T1>::Lower(t))));
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator&=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l & r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator|=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l | r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator^=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l ^ r;
+    return l;
+}
+
+template <typename T>
+constexpr bool HasZeroOrOneBits(T value) {
+    using Integral = typename std::underlying_type<T>::type;
+    return (static_cast<Integral>(value) & (static_cast<Integral>(value) - 1)) == 0;
+}
+
+}  // namespace wgpu
+
+#endif  // WEBGPU_ENUM_CLASS_BITMASKS_H_

package/cpp/dawn/include/webgpu/webgpu_glfw.h

@@ -0,0 +1,88 @@
+// Copyright 2022 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef INCLUDE_WEBGPU_WEBGPU_GLFW_H_
+#define INCLUDE_WEBGPU_WEBGPU_GLFW_H_
+
+#ifdef __cplusplus
+#include <memory>
+
+#include "webgpu/webgpu_cpp.h"
+#else
+#include "webgpu/webgpu.h"
+#endif
+
+#if defined(WGPU_GLFW_SHARED_LIBRARY)
+#if defined(_WIN32)
+#if defined(WGPU_GLFW_IMPLEMENTATION)
+#define WGPU_GLFW_EXPORT __declspec(dllexport)
+#else
+#define WGPU_GLFW_EXPORT __declspec(dllimport)
+#endif
+#else  // defined(_WIN32)
+#if defined(WGPU_GLFW_IMPLEMENTATION)
+#define WGPU_GLFW_EXPORT __attribute__((visibility("default")))
+#else
+#define WGPU_GLFW_EXPORT
+#endif
+#endif  // defined(_WIN32)
+#else   // defined(WGPU_GLFW_SHARED_LIBRARY)
+#define WGPU_GLFW_EXPORT
+#endif  // defined(WGPU_GLFW_SHARED_LIBRARY)
+
+struct GLFWwindow;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+WGPU_GLFW_EXPORT WGPUSurface wgpuGlfwCreateSurfaceForWindow(const WGPUInstance instance,
+                                                            struct GLFWwindow* window);
+
+#ifdef __cplusplus
+}
+
+namespace wgpu::glfw {
+
+// Does the necessary setup on the GLFWwindow to allow creating a wgpu::Surface with it and
+// calls `instance.CreateSurface` with the correct descriptor for this window.
+// Returns a null wgpu::Surface on failure.
+WGPU_GLFW_EXPORT wgpu::Surface CreateSurfaceForWindow(const wgpu::Instance& instance,
+                                                      GLFWwindow* window);
+
+// Use for testing only. Does everything that CreateSurfaceForWindow does except the call to
+// CreateSurface. Useful to be able to modify the descriptor for testing, or when trying to
+// avoid using the global proc table.
+// NOLINTNEXTLINE(build/include_what_you_use)
+WGPU_GLFW_EXPORT std::unique_ptr<wgpu::ChainedStruct, void (*)(wgpu::ChainedStruct*)>
+SetupWindowAndGetSurfaceDescriptor(GLFWwindow* window);
+
+}  // namespace wgpu::glfw
+
+#endif
+
+#endif  // INCLUDE_WEBGPU_WEBGPU_GLFW_H_

package/cpp/rnskia/RNDawnContext.h

@@ -144,6 +144,11 @@ public:
   }
 
   sk_sp<SkImage> MakeImageFromBuffer(void *buffer) {
+#if defined(__ANDROID__) && __ANDROID_API__ < 26
+    // AHardwareBuffer is only available from API 26
+    (void)buffer;
+    return nullptr;
+#else
 #ifdef __APPLE__
     wgpu::SharedTextureMemoryIOSurfaceDescriptor platformDesc;
     auto ioSurface = CVPixelBufferGetIOSurface((CVPixelBufferRef)buffer);
@@ -213,6 +218,7 @@ public:
       return nullptr;
     }
     return nullptr;
+#endif
   }
 
   // Create offscreen surface

package/cpp/rnskia/RNSkGraphiteProducer.cpp

@@ -0,0 +1,189 @@
+// 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 "RNSkThreadPool.h"
+#include "api/recorder/RNRecorder.h"
+#include "utils/RNSkLog.h"
+
+#include "include/core/SkCanvas.h"
+#include "include/core/SkPicture.h"
+
+namespace RNSkia {
+
+RNSkGraphiteProducer::~RNSkGraphiteProducer() = default;
+
+void RNSkGraphiteProducer::setTarget(
+    std::shared_ptr<RNSkGraphiteTarget> target) {
+  std::lock_guard<std::mutex> lock(_mutex);
+  _target = std::move(target);
+  _dirty = true;
+  kickLocked();
+}
+
+void RNSkGraphiteProducer::setRecorder(std::shared_ptr<Recorder> recorder) {
+  sk_sp<SkPicture> picture;
+  if (recorder != nullptr && recorder->variables.empty()) {
+    picture = recorder->makePicture();
+    recorder = nullptr;
+  }
+  replaceContent(std::move(recorder), std::move(picture), /* dirty= */ true);
+}
+
+void RNSkGraphiteProducer::setPicture(sk_sp<SkPicture> picture) {
+  replaceContent(nullptr, std::move(picture), /* dirty= */ true);
+}
+
+void RNSkGraphiteProducer::clear() {
+  replaceContent(nullptr, nullptr, /* dirty= */ false);
+}
+
+void RNSkGraphiteProducer::replaceContent(std::shared_ptr<Recorder> recorder,
+                                          sk_sp<SkPicture> picture,
+                                          bool dirty) {
+  std::shared_ptr<Recorder> retiredRecorder;
+  sk_sp<SkPicture> retiredPicture;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    retiredRecorder = std::exchange(_recorder, std::move(recorder));
+    retiredPicture = std::exchange(_picture, std::move(picture));
+    _dirty = dirty;
+    if (dirty) {
+      kickLocked();
+    }
+  }
+  // Both are released here, outside the lock.
+}
+
+bool RNSkGraphiteProducer::hasContent() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  return _recorder != nullptr || _picture != nullptr;
+}
+
+bool RNSkGraphiteProducer::applyUpdates(jsi::Runtime &runtime,
+                                        double recorderId,
+                                        const jsi::Array &values) {
+  std::shared_ptr<Recorder> recorder;
+  {
+    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);
+  std::lock_guard<std::mutex> lock(_mutex);
+  _dirty = true;
+  kickLocked();
+  return true;
+}
+
+bool RNSkGraphiteProducer::requestFrame() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  _dirty = true;
+  kickLocked();
+  return _target != nullptr && (_recorder != nullptr || _picture != nullptr);
+}
+
+void RNSkGraphiteProducer::onFramePresented() {
+  std::lock_guard<std::mutex> lock(_mutex);
+  _presentPending = false;
+  if (_dirty) {
+    kickLocked();
+  }
+}
+
+void RNSkGraphiteProducer::kickLocked() {
+  if (_inFlight || _presentPending || _target == nullptr ||
+      (_recorder == nullptr && _picture == nullptr)) {
+    return;
+  }
+  _inFlight = true;
+  std::weak_ptr<RNSkGraphiteProducer> weakThis = weak_from_this();
+  RNSkThreadPool::getInstance().post([weakThis]() {
+    if (auto self = weakThis.lock()) {
+      self->produce();
+    }
+  });
+}
+
+void RNSkGraphiteProducer::produce() {
+  std::shared_ptr<RNSkGraphiteTarget> target;
+  std::shared_ptr<Recorder> recorder;
+  sk_sp<SkPicture> picture;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    target = _target;
+    recorder = _recorder;
+    picture = _picture;
+    _dirty = false;
+  }
+  std::shared_ptr<RNSkGraphiteRecording> recording;
+  if (target && (recorder || picture)) {
+    SkCanvas *canvas = nullptr;
+    try {
+      canvas = target->beginRecording();
+    } catch (const std::exception &) {
+      // No surface and no layout yet: the view asks for a frame once it
+      // has a size.
+    }
+    if (canvas != nullptr) {
+      try {
+        // 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());
+      }
+      try {
+        recording = target->finishRecording();
+      } catch (const std::exception &e) {
+        RNSkLogger::logToConsole(
+            "GraphiteCanvas: recording the frame failed: %s", e.what());
+      }
+    }
+  }
+  std::lock_guard<std::mutex> lock(_mutex);
+  _inFlight = false;
+  if (recording != nullptr) {
+    // The next job starts when this frame is on screen. Submitted under the
+    // lock: a frame presented in between (a redraw replaying the last one)
+    // would otherwise clear the flag before the recording is even queued.
+    _presentPending = true;
+    target->submit(std::move(recording));
+    return;
+  }
+  // Nothing was recorded: keep the content dirty so that the next request
+  // (a surface, a resize) records it. A request that landed while this job
+  // ran was only noted as dirty; it starts the next job now.
+  const bool requested = _dirty;
+  _dirty = true;
+  if (requested) {
+    kickLocked();
+  }
+}
+
+void RNSkGraphiteProducer::renderInto(SkCanvas *canvas, float pixelDensity) {
+  std::shared_ptr<Recorder> recorder;
+  sk_sp<SkPicture> picture;
+  {
+    std::lock_guard<std::mutex> lock(_mutex);
+    recorder = _recorder;
+    picture = _picture;
+  }
+  drawContent(canvas, recorder.get(), picture, pixelDensity);
+}
+
+} // namespace RNSkia
+
+#endif // SK_GRAPHITE

package/cpp/rnskia/RNSkGraphiteProducer.h

@@ -0,0 +1,116 @@
+#pragma once
+
+#if defined(SK_GRAPHITE)
+
+#include <memory>
+#include <mutex>
+
+#include <jsi/jsi.h>
+
+#include "include/core/SkRefCnt.h"
+
+class SkCanvas;
+class SkPicture;
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+class Recorder;
+class RNSkGraphiteTarget;
+
+/**
+ * Records the declarative content of a SkiaGraphiteView (a Recorder handed
+ * over by <GraphiteCanvas>, or a picture) into Graphite recordings, on the
+ * render thread pool.
+ *
+ * Three threads meet here. The JS thread hands over the content. A Reanimated
+ * mapper, on the UI runtime, reads the shared values into the recorder's
+ * pending writes: that is the only step that needs a JS runtime, and it never
+ * waits for a replay. A pool thread replays the commands (the recorder writes
+ * the pending values into them first) into a deferred canvas of the view's
+ * target and submits the recording; the main thread presents it on the next
+ * vsync.
+ *
+ * Pacing: a view has at most one job in flight and at most one recording
+ * waiting to be presented. Updates that arrive meanwhile only mark the content
+ * dirty; the next presented frame starts the next job. A producer that
+ * outruns the display therefore records once per vsync, and the queue of the
+ * target never grows.
+ */
+class RNSkGraphiteProducer
+    : public std::enable_shared_from_this<RNSkGraphiteProducer> {
+public:
+  RNSkGraphiteProducer() = default;
+  ~RNSkGraphiteProducer();
+
+  /** The target to record into. Main thread. */
+  void setTarget(std::shared_ptr<RNSkGraphiteTarget> target);
+
+  /**
+   Takes ownership of the recorder (or releases it with nullptr). A recording
+   without shared values is played once into a picture: nothing will ever
+   update it, and drawing a picture is cheaper than replaying commands.
+   */
+  void setRecorder(std::shared_ptr<Recorder> recorder);
+
+  /** Content from the static container: a picture to replay. */
+  void setPicture(sk_sp<SkPicture> picture);
+
+  bool hasContent();
+
+  /**
+   Drops the content without scheduling a frame: the host view is being torn
+   down.
+   */
+  void clear();
+
+  /**
+   Reads the shared values on the calling runtime into the recorder and
+   schedules a frame. Returns false when there is no recorder to update, or
+   another recording than recorderId (a stale mapper).
+   */
+  bool applyUpdates(jsi::Runtime &runtime, double recorderId,
+                    const jsi::Array &values);
+
+  /**
+   Marks the content dirty and schedules a frame if one can start. Returns
+   whether a frame is coming at all: there is content and a target to record
+   it into.
+   */
+  bool requestFrame();
+
+  /** The view presented a frame: the next one may start. */
+  void onFramePresented();
+
+  /**
+   Replays the current content into a canvas, on the calling thread (a
+   snapshot). The canvas draws in pixels, this applies the density.
+   */
+  void renderInto(SkCanvas *canvas, float pixelDensity);
+
+private:
+  /**
+   Swaps the content under the lock and releases the previous one outside of
+   it: the recorder's destructor hands the commands to the main thread, and a
+   pool thread still replaying it keeps it alive until it is done. Pending
+   writes go away with their recorder.
+   */
+  void replaceContent(std::shared_ptr<Recorder> recorder,
+                      sk_sp<SkPicture> picture, bool dirty);
+  void kickLocked();
+  void produce();
+
+  // Content and scheduling state.
+  std::mutex _mutex;
+  std::shared_ptr<RNSkGraphiteTarget> _target;
+  std::shared_ptr<Recorder> _recorder;
+  sk_sp<SkPicture> _picture;
+  bool _dirty = false;
+  bool _inFlight = false;
+  bool _presentPending = false;
+};
+
+} // namespace RNSkia
+
+#endif // SK_GRAPHITE