react-native-skia 3.0.1 → 3.0.3

package/apple/RNSkMetalCanvasProvider.mm

@@ -1,31 +1,13 @@
 #import "RNSkMetalCanvasProvider.h"
 
-#import "RNSkLog.h"
-
-#if defined(SK_GRAPHITE)
 #import "RNDawnContext.h"
-#else
-#import "MetalContext.h"
-#endif
-
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wdocumentation"
-
-#import "include/core/SkCanvas.h"
-#import "include/core/SkColorSpace.h"
-#import "include/core/SkSurface.h"
-
-#import <include/gpu/ganesh/GrBackendSurface.h>
-#import <include/gpu/ganesh/GrDirectContext.h>
-#import <include/gpu/ganesh/SkSurfaceGanesh.h>
+#import "RNSkLog.h"
 
-#pragma clang diagnostic pop
+#include <cmath>
 
 RNSkMetalCanvasProvider::RNSkMetalCanvasProvider(
-    std::function<void()> requestRedraw,
-    std::shared_ptr<RNSkia::RNSkPlatformContext> context, bool useP3ColorSpace)
-    : RNSkCanvasProvider(requestRedraw), _context(context),
-      _useP3ColorSpace(useP3ColorSpace) {
+    std::shared_ptr<RNSkia::RNSkPlatformContext> context)
+    : _context(std::move(context)) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wunguarded-availability-new"
   _layer = [CAMetalLayer layer];
@@ -61,38 +43,7 @@ static bool appIsBackgrounded() {
 #endif // !TARGET_OS_OSX
 }
 
-/**
- Render to a canvas
- */
-bool RNSkMetalCanvasProvider::renderToCanvas(
-    const std::function<void(SkCanvas *)> &cb) {
-  if (!_ctx) {
-    return false;
-  }
-
-  if ([[NSThread currentThread] isMainThread]) {
-    if (appIsBackgrounded()) {
-      // Request a redraw in the next run loop callback
-      _requestRedraw();
-      // and don't draw now since it might cause errors in the metal renderer if
-      // we try to render while in the background. (see above issue)
-      return false;
-    }
-
-    auto surface = _ctx->getSurface();
-    if (!surface) {
-      return false;
-    }
-    auto canvas = surface->getCanvas();
-    cb(canvas);
-    _ctx->present();
-    return true;
-  }
-  return false;
-};
-
-#if defined(SK_GRAPHITE)
-bool RNSkMetalCanvasProvider::getGraphiteTargetInfo(
+bool RNSkMetalCanvasProvider::getTargetInfo(
     RNSkia::RNSkGraphiteTargetInfo *info) {
   std::lock_guard<std::mutex> lock(_targetInfoMutex);
   if (!_hasTargetInfo) {
@@ -102,49 +53,67 @@ bool RNSkMetalCanvasProvider::getGraphiteTargetInfo(
   return true;
 }
 
+bool RNSkMetalCanvasProvider::getLayoutSize(int *width, int *height) {
+  std::lock_guard<std::mutex> lock(_targetInfoMutex);
+  if (_layoutWidth <= 0 || _layoutHeight <= 0) {
+    return false;
+  }
+  *width = _layoutWidth;
+  *height = _layoutHeight;
+  return true;
+}
+
 bool RNSkMetalCanvasProvider::presentRecordings(
     const std::vector<skgpu::graphite::Recording *> &recordings) {
   if (!_ctx || ![[NSThread currentThread] isMainThread]) {
     return false;
   }
   if (appIsBackgrounded()) {
-    _requestRedraw();
+    requestRedraw();
     return false;
   }
   return static_cast<RNSkia::DawnWindowContext *>(_ctx.get())
       ->presentRecordings(recordings);
 }
-#endif
+
+bool RNSkMetalCanvasProvider::presentImage(const sk_sp<SkImage> &image) {
+  if (!_ctx || ![[NSThread currentThread] isMainThread]) {
+    return false;
+  }
+  if (appIsBackgrounded()) {
+    requestRedraw();
+    return false;
+  }
+  return static_cast<RNSkia::DawnWindowContext *>(_ctx.get())
+      ->presentImage(image);
+}
 
 void RNSkMetalCanvasProvider::setSize(int width, int height) {
   _layer.frame = CGRectMake(0, 0, width, height);
-  auto w = width * _context->getPixelDensity();
-  auto h = height * _context->getPixelDensity();
-#if defined(SK_GRAPHITE)
-  _ctx = RNSkia::DawnContext::getInstance().MakeWindow((__bridge void *)_layer,
-                                                       w, h, _highBitDepth);
+  // The layout is on the pixel grid: round rather than truncate, so that a
+  // product like 1169.9999 gives the pixel size the layout means.
+  int w = static_cast<int>(std::lround(width * _context->getPixelDensity()));
+  int h = static_cast<int>(std::lround(height * _context->getPixelDensity()));
+  _ctx = RNSkia::DawnContext::getInstance().MakeWindow(
+      (__bridge void *)_layer, w, h, _highBitDepth,
+      _context->prefersP3ColorSpace());
   {
     auto *window = static_cast<RNSkia::DawnWindowContext *>(_ctx.get());
     std::lock_guard<std::mutex> lock(_targetInfoMutex);
+    _layoutWidth = w;
+    _layoutHeight = h;
     _targetInfo.width = window->getWidth();
     _targetInfo.height = window->getHeight();
     _targetInfo.colorType = window->getColorType();
+    _targetInfo.useP3ColorSpace = window->usesP3ColorSpace();
     _targetInfo.textureInfo = window->getTextureInfo();
     _hasTargetInfo = true;
   }
-#else
-  _ctx = MetalContext::getInstance().MakeWindow(_layer, w, h, _useP3ColorSpace,
-                                                _highBitDepth);
-#endif
-  _requestRedraw();
+  requestRedraw();
 }
 
 CALayer *RNSkMetalCanvasProvider::getLayer() { return _layer; }
 
-void RNSkMetalCanvasProvider::setUseP3ColorSpace(bool useP3ColorSpace) {
-  _useP3ColorSpace = useP3ColorSpace;
-}
-
 void RNSkMetalCanvasProvider::setHighBitDepth(bool highBitDepth) {
   if (_highBitDepth == highBitDepth) {
     return;

package/apple/RNSkiaModule.mm

@@ -39,6 +39,16 @@ RCT_EXPORT_MODULE()
   return YES;
 }
 
+- (instancetype)init {
+  if (self = [super init]) {
+    // Created on the main queue (see requiresMainQueueSetup): the screen is
+    // asked for its color gamut here, where UIKit may be used. The platform
+    // context is created on the JS thread and only reads the answer.
+    RNSkia::RNSkApplePlatformContext::mainScreenSupportsP3();
+  }
+  return self;
+}
+
 - (void)
     installJSIBindingsWithRuntime:(facebook::jsi::Runtime &)runtime
                       callInvoker:

package/apple/SkiaView.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#import <CoreFoundation/CoreFoundation.h>
+#if !TARGET_OS_OSX
+#import <UIKit/UIKit.h>
+#else
+#import <React/RCTUIKit.h>
+#endif // !TARGET_OS_OSX
+
+#import <React/RCTViewComponentView.h>
+
+/**
+ * The Fabric component behind <Canvas>, <SkiaPictureView> and
+ * <SkiaGraphiteView>: a CAMetalLayer presenting Graphite recordings on the
+ * display link. The frames are recorded by the native render thread pool
+ * (declarative content) or by JS (SkiaViewApi.makeGraphiteContext).
+ */
+@interface SkiaView : RCTViewComponentView
+
+@end

package/apple/SkiaView.mm

@@ -0,0 +1,210 @@
+#import "SkiaView.h"
+
+#import <QuartzCore/CADisplayLink.h>
+#import <QuartzCore/CATransaction.h>
+
+#import <React/RCTConversions.h>
+#import <React/RCTConvert.h>
+#import <React/RCTFabricComponentsPlugins.h>
+
+#import <react/renderer/components/rnskia/ComponentDescriptors.h>
+#import <react/renderer/components/rnskia/EventEmitters.h>
+#import <react/renderer/components/rnskia/Props.h>
+#import <react/renderer/components/rnskia/RCTComponentViewHelpers.h>
+
+#include <memory>
+
+#import "RNSkManager.h"
+#import "RNSkMetalCanvasProvider.h"
+#import "RNSkView.h"
+#import "RNSkiaModule.h"
+
+using namespace facebook::react;
+
+@implementation SkiaView {
+  // The native view and the layer it presents into. Both exist while the
+  // view is in the hierarchy (see willMoveToSuperview:).
+  std::shared_ptr<RNSkia::RNSkView> _view;
+  std::shared_ptr<RNSkMetalCanvasProvider> _provider;
+  // Owned by the module, which outlives its views (see finalizeUpdates:).
+  RNSkia::RNSkManager *_manager;
+  size_t _nativeId;
+  bool _highBitDepth;
+#if !TARGET_OS_OSX
+  CADisplayLink *_displayLink;
+#endif
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    _manager = [RNSkiaModule latestActiveSkManager].get();
+    _nativeId = 0;
+    _highBitDepth = false;
+    static const auto defaultProps = std::make_shared<const SkiaViewProps>();
+    _props = defaultProps;
+  }
+  return self;
+}
+
+#pragma mark - Lifecycle
+
+// The native view lives while the view is in the hierarchy: it is created
+// when the view gets a superview and torn down when it leaves it, so that a
+// view kept around by a transition does not keep a surface.
+#if !TARGET_OS_OSX
+- (void)willMoveToSuperview:(UIView *)newSuperView {
+  [super willMoveToSuperview:newSuperView];
+#else
+- (void)viewWillMoveToSuperview:(NSView *)newSuperView {
+  [super viewWillMoveToSuperview:newSuperView];
+#endif // !TARGET_OS_OSX
+  if (newSuperView == nullptr || _view != nullptr || _manager == nullptr) {
+    return;
+  }
+  auto context = _manager->getPlatformContext();
+  _provider = std::make_shared<RNSkMetalCanvasProvider>(context);
+  _view = std::make_shared<RNSkia::RNSkView>(context, _provider);
+  [self.layer addSublayer:_provider->getLayer()];
+  if (_nativeId != 0) {
+    _manager->setSkiaView(_nativeId, _view);
+  }
+  _provider->setHighBitDepth(_highBitDepth);
+  __weak SkiaView *weakSelf = self;
+  _view->setFrameScheduler([weakSelf]() { [weakSelf scheduleFrame]; });
+}
+
+- (void)removeFromSuperview {
+  [self stopDisplayLink];
+  if (_view != nullptr) {
+    [_provider->getLayer() removeFromSuperlayer];
+    if (_nativeId != 0 && _manager != nullptr) {
+      _manager->setSkiaView(_nativeId, nullptr);
+    }
+    _view = nullptr;
+    _provider = nullptr;
+  }
+  [super removeFromSuperview];
+}
+
+- (void)dealloc {
+  [self stopDisplayLink];
+  [self unregisterView];
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  [self stopDisplayLink];
+  [self unregisterView];
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+  if (updateMask == RNComponentViewUpdateMaskAll) {
+    // this flag is only set when the view is inserted and we want to set the
+    // manager here since the view could be recycled or the app could be
+    // refreshed and we would have a stale manager then
+    _manager = [RNSkiaModule latestActiveSkManager].get();
+  }
+}
+
+- (void)unregisterView {
+  if (_manager != nullptr && _nativeId != 0) {
+    _manager->unregisterSkiaView(_nativeId);
+  }
+}
+
+#pragma mark - Frames
+
+// Presents on the display link: armed when a recording is submitted, paused
+// again once the queue is empty. macOS has no CADisplayLink on the minimum
+// deployment target, so frames are presented as soon as the main thread gets
+// to them there.
+- (void)scheduleFrame {
+#if !TARGET_OS_OSX
+  if (_displayLink == nil) {
+    _displayLink = [CADisplayLink displayLinkWithTarget:self
+                                               selector:@selector(onFrame:)];
+    [_displayLink addToRunLoop:[NSRunLoop mainRunLoop]
+                       forMode:NSRunLoopCommonModes];
+  }
+  _displayLink.paused = NO;
+#else
+  if (_view != nullptr) {
+    _view->presentFrame();
+  }
+#endif
+}
+
+#if !TARGET_OS_OSX
+- (void)onFrame:(CADisplayLink *)link {
+  if (_view == nullptr || !_view->presentFrame()) {
+    link.paused = YES;
+  }
+}
+#endif
+
+- (void)stopDisplayLink {
+#if !TARGET_OS_OSX
+  [_displayLink invalidate];
+  _displayLink = nil;
+#endif
+}
+
+#pragma mark - Render
+
+- (void)drawRect:(CGRect)rect {
+  // The OS asked for a draw: present what the view holds right away.
+  if (_view != nullptr) {
+    _view->redraw();
+  }
+}
+
+#pragma mark - Layout
+
+- (void)layoutSubviews {
+  [super layoutSubviews];
+  if (_provider != nullptr) {
+    [CATransaction begin];
+    [CATransaction setDisableActions:YES];
+    _provider->setSize(self.bounds.size.width, self.bounds.size.height);
+    [CATransaction commit];
+  }
+}
+
+#pragma mark - Props
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<SkiaViewComponentDescriptor>();
+}
+
+- (void)updateProps:(const Props::Shared &)props
+           oldProps:(const Props::Shared &)oldProps {
+  const auto &newProps = *std::static_pointer_cast<const SkiaViewProps>(props);
+  [super updateProps:props oldProps:oldProps];
+  int nativeId =
+      [[RCTConvert NSString:RCTNSStringFromString(newProps.nativeId)] intValue];
+  [self bindNativeId:nativeId];
+  [self setHighBitDepth:newProps.highBitDepth];
+  // opaque, androidSurfaceType and androidZOrderOnTop select the backing view
+  // on Android; a CAMetalLayer composites like any other layer.
+}
+
+// Not setNativeId:, which is the setter of RCTViewComponentView's nativeId
+// (the string Fabric assigns from the nativeID prop).
+- (void)bindNativeId:(size_t)nativeId {
+  _nativeId = nativeId;
+  if (_view != nullptr) {
+    _manager->registerSkiaView(nativeId, _view);
+  }
+}
+
+- (void)setHighBitDepth:(bool)highBitDepth {
+  _highBitDepth = highBitDepth;
+  if (_provider != nullptr) {
+    _provider->setHighBitDepth(highBitDepth);
+  }
+}
+
+@end
+
+Class<RCTComponentViewProtocol> SkiaViewCls(void) { return SkiaView.class; }

package/cpp/api/JsiSkApi.h

@@ -6,9 +6,7 @@
 
 #include "JsiSkNativeObjects.h"
 
-#ifdef SK_GRAPHITE
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #include "JsiNativeBuffer.h"
 #include "JsiSkAnimatedImage.h"
@@ -167,19 +165,12 @@ public:
     return JsiSkColor::createCtor()(runtime, thisValue, arguments, count);
   }
   JSI_HOST_FUNCTION(getNativeDevice) {
-#ifdef SK_GRAPHITE
     // Raw WGPUDevice pointer of the Graphite device, as a BigInt. Consumed by
     // react-native-webgpu's importDevice(), which AddRefs it; the pointer
     // stays owned by DawnContext and is valid for the process lifetime.
     auto &dawnContext = DawnContext::getInstance();
     return jsi::BigInt::fromUint64(
-        runtime,
-        reinterpret_cast<uint64_t>(dawnContext.getWGPUDevice().Get()));
-#else
-    throw jsi::JSError(runtime,
-                       "getNativeDevice() is only available with the Graphite "
-                       "backend. Rebuild with SK_GRAPHITE enabled.");
-#endif
+        runtime, reinterpret_cast<uint64_t>(dawnContext.getWGPUDevice().Get()));
   }
 
   JSI_HOST_FUNCTION(Recorder) {
@@ -191,9 +182,7 @@ public:
   // property access returns a fresh JS wrapper around the shared factory
   // instance.
   std::shared_ptr<JsiSkSVGFactory> getSVGFactory() { return _svgFactory; }
-  std::shared_ptr<JsiSkImageFactory> getImageFactory() {
-    return _imageFactory;
-  }
+  std::shared_ptr<JsiSkImageFactory> getImageFactory() { return _imageFactory; }
   std::shared_ptr<JsiSkAnimatedImageFactory> getAnimatedImageFactory() {
     return _animatedImageFactory;
   }

package/cpp/api/JsiSkCanvas.h

@@ -24,9 +24,7 @@
 
 #include "utils/RNSkTypedArray.h"
 
-#if defined(SK_GRAPHITE)
 #include "rnskia/RNDawnContext.h"
-#endif
 
 #include <jsi/jsi.h>
 
@@ -42,10 +40,6 @@
 #include "include/core/SkSurface.h"
 #include "include/core/SkTypeface.h"
 
-#if !defined(SK_GRAPHITE)
-#include "include/gpu/ganesh/GrDirectContext.h"
-#endif
-
 #pragma clang diagnostic pop
 
 namespace RNSkia {
@@ -56,9 +50,7 @@ class JsiSkCanvas : public JsiSkNativeObject<JsiSkCanvas> {
 public:
   static constexpr const char *CLASS_NAME = "Canvas";
 
-  void drawPaint(std::shared_ptr<SkPaint> paint) {
-    _canvas->drawPaint(*paint);
-  }
+  void drawPaint(std::shared_ptr<SkPaint> paint) { _canvas->drawPaint(*paint); }
 
   void drawLine(double x1, double y1, double x2, double y2,
                 std::shared_ptr<SkPaint> paint) {
@@ -355,8 +347,7 @@ public:
 
   void clipPath(std::shared_ptr<SkPathBuilder> path, double op,
                 bool doAntiAlias) {
-    _canvas->clipPath(path->snapshot(), static_cast<SkClipOp>(op),
-                      doAntiAlias);
+    _canvas->clipPath(path->snapshot(), static_cast<SkClipOp>(op), doAntiAlias);
   }
 
   void clipRect(std::shared_ptr<SkRect> rect, double op, bool doAntiAlias) {
@@ -410,9 +401,7 @@ public:
 
   void concat(std::shared_ptr<SkMatrix> matrix) { _canvas->concat(*matrix); }
 
-  void drawPicture(sk_sp<SkPicture> picture) {
-    _canvas->drawPicture(picture);
-  }
+  void drawPicture(sk_sp<SkPicture> picture) { _canvas->drawPicture(picture); }
 
   JSI_HOST_FUNCTION(drawAtlas) {
     auto atlas = JsiSkImage::fromValue(runtime, arguments[0]);
@@ -518,7 +507,6 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
-#if defined(SK_GRAPHITE)
     // Graphite records draws lazily and offers no synchronous GPU readback. If
     // this canvas belongs to a surface, snap & submit its recording, snapshot
     // it to a CPU raster image and read from that (mirroring
@@ -540,7 +528,6 @@ public:
       }
       return dest;
     }
-#endif
 
     if (!_canvas->readPixels(*info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
@@ -599,8 +586,7 @@ public:
     installMethod(runtime, prototype, "drawColor", &JsiSkCanvas::drawColor);
     installMethod(runtime, prototype, "clear", &JsiSkCanvas::clear);
     installMethod(runtime, prototype, "concat", &JsiSkCanvas::concat);
-    installMethod(runtime, prototype, "drawPicture",
-                  &JsiSkCanvas::drawPicture);
+    installMethod(runtime, prototype, "drawPicture", &JsiSkCanvas::drawPicture);
     installHostMethod(runtime, prototype, "drawAtlas", &JsiSkCanvas::drawAtlas);
     installHostMethod(runtime, prototype, "readPixels",
                       &JsiSkCanvas::readPixels);

package/cpp/api/JsiSkGraphiteContext.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#if defined(SK_GRAPHITE)
-
 #include <memory>
 #include <utility>
 
@@ -10,7 +8,7 @@
 #include "JsiSkCanvas.h"
 #include "JsiSkGraphiteRecording.h"
 #include "JsiSkNativeObjects.h"
-#include "rnskia/RNSkGraphiteView.h"
+#include "rnskia/RNSkGraphiteTarget.h"
 
 namespace RNSkia {
 
@@ -78,5 +76,3 @@ private:
 };
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/cpp/api/JsiSkGraphiteRecording.h

@@ -1,14 +1,12 @@
 #pragma once
 
-#if defined(SK_GRAPHITE)
-
 #include <memory>
 #include <utility>
 
 #include <jsi/jsi.h>
 
 #include "JsiSkNativeObjects.h"
-#include "rnskia/RNSkGraphiteView.h"
+#include "rnskia/RNSkGraphiteTarget.h"
 
 namespace RNSkia {
 
@@ -40,5 +38,3 @@ public:
 };
 
 } // namespace RNSkia
-
-#endif // SK_GRAPHITE

package/cpp/api/JsiSkImage.h

@@ -17,12 +17,8 @@
 #include "JsiTextureInfo.h"
 #include "utils/RNSkTypedArray.h"
 
-#if defined(SK_GRAPHITE)
 #include "include/gpu/graphite/Context.h"
 #include "rnskia/RNDawnContext.h"
-#else
-#include "include/gpu/ganesh/GrDirectContext.h"
-#endif
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -187,18 +183,7 @@ public:
                       ? static_cast<SkEncodedImageFormat>(*formatParam)
                       : SkEncodedImageFormat::kPNG;
     auto quality = qualityParam.has_value() ? *qualityParam : 100.0;
-    auto image = getObject();
-#if defined(SK_GRAPHITE)
-    image = DawnContext::getInstance().MakeRasterImage(image);
-#else
-    if (image->isTextureBacked()) {
-      auto grContext = getContext()->getDirectContext();
-      image = image->makeRasterImage(grContext);
-      if (!image) {
-        return nullptr;
-      }
-    }
-#endif
+    auto image = DawnContext::getInstance().MakeRasterImage(getObject());
     sk_sp<SkData> data;
 
     if (format == SkEncodedImageFormat::kJPEG) {
@@ -236,10 +221,10 @@ public:
         count >= 1 && !arguments[0].isUndefined() && !arguments[0].isNull()
             ? JsiOptional<double>(arguments[0].asNumber())
             : JsiOptional<double>();
-    JsiOptional<double> quality = count >= 2 && arguments[1].isNumber()
-                                      ? JsiOptional<double>(
-                                            arguments[1].asNumber())
-                                      : JsiOptional<double>();
+    JsiOptional<double> quality =
+        count >= 2 && arguments[1].isNumber()
+            ? JsiOptional<double>(arguments[1].asNumber())
+            : JsiOptional<double>();
     auto data = encodeImageData(format, quality);
     if (!data) {
       return jsi::Value::null();
@@ -310,38 +295,19 @@ public:
             .getArrayBuffer(runtime);
     auto bfrPtr = reinterpret_cast<void *>(buffer.data(runtime));
 
-#if defined(SK_GRAPHITE)
-    // Graphite offers no synchronous GPU readback, so fall back to a CPU raster
-    // copy of the image (a no-op when the image is already raster) and read the
-    // pixels from that. This matches the Ganesh behaviour for non-texture and
-    // texture-backed images alike.
+    // Graphite offers no synchronous GPU readback, so read from a CPU raster
+    // copy of the image (a no-op when the image is already raster).
     auto image = DawnContext::getInstance().MakeRasterImage(getObject());
     if (!image ||
         !image->readPixels(nullptr, info, bfrPtr, bytesPerRow, srcX, srcY)) {
       return jsi::Value::null();
     }
-#else
-    auto grContext = getContext()->getDirectContext();
-    if (!getObject()->readPixels(grContext, info, bfrPtr, bytesPerRow, srcX,
-                                 srcY)) {
-      return jsi::Value::null();
-    }
-#endif
     return dest;
   }
 
   std::variant<std::nullptr_t, std::shared_ptr<JsiSkImage>>
   makeNonTextureImage() {
-#if defined(SK_GRAPHITE)
     auto rasterImage = DawnContext::getInstance().MakeRasterImage(getObject());
-#else
-    auto grContext = getContext()->getDirectContext();
-    auto image = getObject();
-    if (!grContext) {
-      throw std::runtime_error("No GPU context available.");
-    }
-    auto rasterImage = image->makeRasterImage(grContext);
-#endif
     if (!rasterImage) {
       return nullptr;
     }