chore(🪨): Update Graphite build (#3170)

Author: wcandillon

.github/workflows/build-skia-graphite.yml

@@ -64,9 +64,6 @@ jobs:
             ./externals/skia/out/android/arm/libskparagraph.a
             ./externals/skia/out/android/arm/libskunicode_core.a
             ./externals/skia/out/android/arm/libskunicode_icu.a
-            ./externals/skia/out/android/arm/libdawn_native_static.a
-            ./externals/skia/out/android/arm/libdawn_platform_static.a
-            ./externals/skia/out/android/arm/libdawn_proc_static.a
 
       - name: Upload artifacts - Android arm64 (Graphite)
         if: github.ref == 'refs/heads/main'
@@ -82,9 +79,6 @@ jobs:
             ./externals/skia/out/android/arm64/libskparagraph.a
             ./externals/skia/out/android/arm64/libskunicode_core.a
             ./externals/skia/out/android/arm64/libskunicode_icu.a
-            ./externals/skia/out/android/arm64/libdawn_native_static.a
-            ./externals/skia/out/android/arm64/libdawn_platform_static.a
-            ./externals/skia/out/android/arm64/libdawn_proc_static.a
 
       - name: Upload artifacts - Android x86 (Graphite)
         if: github.ref == 'refs/heads/main'
@@ -100,9 +94,6 @@ jobs:
             ./externals/skia/out/android/x86/libskparagraph.a
             ./externals/skia/out/android/x86/libskunicode_core.a
             ./externals/skia/out/android/x86/libskunicode_icu.a
-            ./externals/skia/out/android/x86/libdawn_native_static.a
-            ./externals/skia/out/android/x86/libdawn_platform_static.a
-            ./externals/skia/out/android/x86/libdawn_proc_static.a
 
       - name: Upload artifacts - Android x64 (Graphite)
         if: github.ref == 'refs/heads/main'
@@ -118,9 +109,6 @@ jobs:
             ./externals/skia/out/android/x64/libskparagraph.a
             ./externals/skia/out/android/x64/libskunicode_core.a
             ./externals/skia/out/android/x64/libskunicode_icu.a
-            ./externals/skia/out/android/x64/libdawn_native_static.a
-            ./externals/skia/out/android/x64/libdawn_platform_static.a
-            ./externals/skia/out/android/x64/libdawn_proc_static.a
 
       - name: Upload artifacts - Apple xcframeworks (Graphite)
         if: github.ref == 'refs/heads/main'

apps/example/ios/Podfile.lock

@@ -2193,7 +2193,7 @@ SPEC CHECKSUMS:
   React-Mapbuffer: 3c11cee7737609275c7b66bd0b1de475f094cedf
   React-microtasksnativemodule: 843f352b32aacbe13a9c750190d34df44c3e6c2c
   react-native-safe-area-context: 0f14bce545abcdfbff79ce2e3c78c109f0be283e
-  react-native-skia: cde44b3bdb773204750a79d01ee74b85480287b1
+  react-native-skia: 87d730aeeb02c54280ad5e42b443cc110a2e43ce
   react-native-slider: bb7eb4732940fab78217e1c096bb647d8b0d1cf3
   React-NativeModulesApple: 88433b6946778bea9c153e27b671de15411bf225
   React-perflogger: 9e8d3c0dc0194eb932162812a168aa5dc662f418

packages/skia/android/CMakeLists.txt

@@ -4,16 +4,50 @@ cmake_minimum_required(VERSION 3.4.1)
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 17)
 
-# Import prebuilt SKIA libraries path first to check for Dawn libraries
+# Import prebuilt SKIA libraries path
 set (SKIA_LIBS_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../libs/android/${ANDROID_ABI}")
 
-# Check if Dawn libraries exist, if so enable SK_GRAPHITE
-if(EXISTS "${SKIA_LIBS_PATH}/libdawn_native_static.a")
+# Import libskia first so we can check for symbols
+add_library(skia STATIC IMPORTED)
+set_property(TARGET skia PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskia.a")
+
+# Check if Graphite symbols are available in libskia using nm/objdump
+set(SK_GRAPHITE_AVAILABLE OFF)
+
+if(EXISTS "${SKIA_LIBS_PATH}/libskia.a")
+    # Look for specific Dawn function symbols that indicate Graphite support
+    execute_process(
+        COMMAND nm "${SKIA_LIBS_PATH}/libskia.a"
+        COMMAND grep "dawn::\\|wgpu\\|_ZN4dawn\\|DawnDevice\\|dawn_native"
+        OUTPUT_VARIABLE NM_OUTPUT
+        ERROR_QUIET
+        RESULT_VARIABLE NM_RESULT
+    )
+    
+    if(NM_RESULT EQUAL 0 AND NOT "${NM_OUTPUT}" STREQUAL "")
+        set(SK_GRAPHITE_AVAILABLE ON)
+    else()
+        # Fallback to objdump if nm doesn't work
+        execute_process(
+            COMMAND objdump -t "${SKIA_LIBS_PATH}/libskia.a"
+            COMMAND grep "dawn::\\|wgpu\\|_ZN4dawn\\|DawnDevice\\|dawn_native"
+            OUTPUT_VARIABLE OBJDUMP_OUTPUT
+            ERROR_QUIET
+            RESULT_VARIABLE OBJDUMP_RESULT
+        )
+        
+        if(OBJDUMP_RESULT EQUAL 0 AND NOT "${OBJDUMP_OUTPUT}" STREQUAL "")
+            set(SK_GRAPHITE_AVAILABLE ON)
+        endif()
+    endif()
+endif()
+
+if(SK_GRAPHITE_AVAILABLE)
     set(SK_GRAPHITE ON)
-    message("-- SK_GRAPHITE: ON (Dawn libraries found)")
+    message("-- SK_GRAPHITE: ON (Graphite symbols found in libskia)")
 else()
     set(SK_GRAPHITE OFF)
-    message("-- SK_GRAPHITE: OFF (Dawn libraries not found)")
+    message("-- SK_GRAPHITE: OFF (Graphite symbols not found in libskia)")
 endif()
 
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_BUILD_FOR_ANDROID -DSK_IMAGE_READ_PIXELS_DISABLE_LEGACY_API -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
@@ -45,21 +79,10 @@ link_directories(../libs/android/${ANDROID_ABI}/)
 
 if(SK_GRAPHITE)
     add_definitions(-DSK_GRAPHITE)
-    set(DAWN_NATIVE_LIB "libdawn_native_static")
-    set(DAWN_PLATFORM_LIB "libdawn_platform_static")
-    set(DAWN_PROC_LIB "libdawn_proc_static")
     set(BACKEND_SOURCES
     #TODO: is this source needed to be added?
         "${PROJECT_SOURCE_DIR}/../cpp/rnskia/DawnWindowContext.cpp"
     )
-    add_library(libdawn_native_static STATIC IMPORTED)
-    set_property(TARGET libdawn_native_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_native_static.a")
-
-    add_library(libdawn_platform_static STATIC IMPORTED)
-    set_property(TARGET libdawn_platform_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_platform_static.a")
-
-    add_library(libdawn_proc_static STATIC IMPORTED)
-    set_property(TARGET libdawn_proc_static PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libdawn_proc_static.a")
 else()
     add_definitions(-DSK_GL -DSK_GANESH)
     set(BACKEND_SOURCES
@@ -131,9 +154,6 @@ target_include_directories(
         ${libfbjni_include_DIRS}
 )
 
-add_library(skia STATIC IMPORTED)
-set_property(TARGET skia PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libskia.a")
-
 add_library(svg STATIC IMPORTED)
 set_property(TARGET svg PROPERTY IMPORTED_LOCATION "${SKIA_LIBS_PATH}/libsvg.a")
 
@@ -307,9 +327,6 @@ endif()
 if(SK_GRAPHITE)
     target_link_libraries(${PACKAGE_NAME}
         ${COMMON_LIBS}
-        ${DAWN_NATIVE_LIB}
-        ${DAWN_PLATFORM_LIB}
-        ${DAWN_PROC_LIB}
     )
 else()
     target_link_libraries(${PACKAGE_NAME}

packages/skia/apple/MetalWindowContext.mm

@@ -25,10 +25,12 @@
   _layer.drawableSize = CGSizeMake(width, height);
   BOOL supportsWideColor = NO;
   if (@available(iOS 10.0, *)) {
-    supportsWideColor = [UIScreen mainScreen].traitCollection.displayGamut == UIDisplayGamutP3;
+    supportsWideColor =
+        [UIScreen mainScreen].traitCollection.displayGamut == UIDisplayGamutP3;
   }
   if (supportsWideColor) {
-    CGColorSpaceRef colorSpace = CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3);
+    CGColorSpaceRef colorSpace =
+        CGColorSpaceCreateWithName(kCGColorSpaceDisplayP3);
     _layer.colorspace = colorSpace;
     CGColorSpaceRelease(colorSpace);
   }

packages/skia/apple/RNSkApplePlatformContext.mm

@@ -190,7 +190,7 @@
   if (!GrBackendTextures::GetMtlTextureInfo(texture, &textureInfo)) {
     throw std::runtime_error("Couldn't get Metal texture info");
   }
-  result.mtlTexture = textureInfo.fTexture.get(); 
+  result.mtlTexture = textureInfo.fTexture.get();
   return result;
 }
 

packages/skia/cpp/api/JsiSkImageFactory.h

@@ -93,8 +93,8 @@ class JsiSkImageFactory : public JsiSkHostObject {
     }
     if (count > 4 && arguments[4].isObject() &&
         arguments[4].asObject(runtime).isHostObject(runtime)) {
-      auto jsiImage = arguments[4].asObject(runtime).asHostObject<JsiSkImage>(
-          runtime);
+      auto jsiImage =
+          arguments[4].asObject(runtime).asHostObject<JsiSkImage>(runtime);
       jsiImage->setObject(image);
       return jsi::Value(runtime, arguments[4]);
     }

packages/skia/cpp/api/JsiSkSurface.h

@@ -76,7 +76,8 @@ class JsiSkSurface : public JsiSkWrappingSkPtrHostObject<SkSurface> {
     DawnContext::getInstance().submitRecording(recording.get());
 #endif
     if (count > 1 && arguments[1].isObject()) {
-      auto jsiImage = arguments[1].asObject(runtime).asHostObject<JsiSkImage>(runtime);
+      auto jsiImage =
+          arguments[1].asObject(runtime).asHostObject<JsiSkImage>(runtime);
       jsiImage->setObject(image);
       return jsi::Value(runtime, arguments[1]);
     }

packages/skia/cpp/rnskia/DawnContext.h

@@ -221,7 +221,16 @@ class DawnContext {
     }
   }
 
-  void tick() { backendContext.fTick(backendContext.fInstance); }
+  ~DawnContext() {
+    backendContext.fDevice = nullptr;
+    tick();
+  }
+
+  void tick() {
+    if (backendContext.fTick) {
+      backendContext.fTick(backendContext.fInstance);
+    }
+  }
 
   skgpu::graphite::Recorder *getRecorder() {
     static thread_local skgpu::graphite::RecorderOptions recorderOptions;

packages/skia/cpp/rnskia/DawnUtils.h

@@ -5,6 +5,7 @@
 #include "dawn/dawn_proc.h"
 #include "dawn/native/DawnNative.h"
 
+#include "RNSkLog.h"
 #include "include/core/SkColorType.h"
 #include "include/gpu/graphite/dawn/DawnBackendContext.h"
 
@@ -25,23 +26,29 @@ createDawnBackendContext(dawn::native::Instance *instance) {
 
   auto useTintIR = false;
   static constexpr const char *kToggles[] = {
+#if !defined(SK_DEBUG)
+      "skip_validation",
+#endif
+      "disable_lazy_clear_for_mapped_at_creation_buffer",
       "allow_unsafe_apis",
       "use_user_defined_labels_in_backend",
       "disable_robustness",
       "use_tint_ir",
   };
   wgpu::DawnTogglesDescriptor togglesDesc;
-  togglesDesc.enabledToggleCount =
-      (sizeof(kToggles) / sizeof(kToggles[0])) - (useTintIR ? 0 : 1);
+  togglesDesc.enabledToggleCount = std::size(kToggles) - (useTintIR ? 0 : 1);
   togglesDesc.enabledToggles = kToggles;
 
+  dawn::native::Adapter matchedAdaptor;
+
   wgpu::RequestAdapterOptions options;
 #ifdef __APPLE__
   constexpr auto kDefaultBackendType = wgpu::BackendType::Metal;
 #elif __ANDROID__
   constexpr auto kDefaultBackendType = wgpu::BackendType::Vulkan;
 #endif
   options.backendType = kDefaultBackendType;
+  options.featureLevel = wgpu::FeatureLevel::Core;
   options.nextInChain = &togglesDesc;
 
   std::vector<dawn::native::Adapter> adapters =
@@ -50,7 +57,78 @@ createDawnBackendContext(dawn::native::Instance *instance) {
     throw std::runtime_error("No matching adapter found");
   }
 
-  wgpu::Adapter adapter = adapters[0].Get();
+  // Sort adapters by adapterType(DiscreteGPU, IntegratedGPU, CPU) and
+  // backendType(Metal, Vulkan, OpenGL, OpenGLES, WebGPU).
+  std::sort(adapters.begin(), adapters.end(),
+            [](dawn::native::Adapter a, dawn::native::Adapter b) {
+              wgpu::Adapter wgpuA = a.Get();
+              wgpu::Adapter wgpuB = b.Get();
+              wgpu::AdapterInfo infoA;
+              wgpu::AdapterInfo infoB;
+              wgpuA.GetInfo(&infoA);
+              wgpuB.GetInfo(&infoB);
+              return std::tuple(infoA.adapterType, infoA.backendType) <
+                     std::tuple(infoB.adapterType, infoB.backendType);
+            });
+
+  for (const auto &adapter : adapters) {
+    wgpu::Adapter wgpuAdapter = adapter.Get();
+    wgpu::AdapterInfo props;
+    wgpuAdapter.GetInfo(&props);
+    if (kDefaultBackendType == props.backendType) {
+      matchedAdaptor = adapter;
+      break;
+    }
+  }
+
+  if (!matchedAdaptor) {
+    throw std::runtime_error("No matching adapter found");
+  }
+
+  wgpu::Adapter adapter = matchedAdaptor.Get();
+
+  // Log selected adapter info
+  wgpu::AdapterInfo adapterInfo;
+  adapter.GetInfo(&adapterInfo);
+  std::string deviceName =
+      adapterInfo.device.data
+          ? std::string(adapterInfo.device.data, adapterInfo.device.length)
+          : "Unknown";
+  std::string description = adapterInfo.description.data
+                                ? std::string(adapterInfo.description.data,
+                                              adapterInfo.description.length)
+                                : "Unknown";
+
+  std::string backendName;
+  switch (adapterInfo.backendType) {
+  case wgpu::BackendType::Metal:
+    backendName = "Metal";
+    break;
+  case wgpu::BackendType::Vulkan:
+    backendName = "Vulkan";
+    break;
+  case wgpu::BackendType::OpenGL:
+    backendName = "OpenGL";
+    break;
+  case wgpu::BackendType::OpenGLES:
+    backendName = "OpenGLES";
+    break;
+  case wgpu::BackendType::WebGPU:
+    backendName = "WebGPU";
+    break;
+  case wgpu::BackendType::Null:
+    backendName = "Null";
+    break;
+  default:
+    backendName = "Undefined (" +
+                  std::to_string(static_cast<int>(adapterInfo.backendType)) +
+                  ")";
+    break;
+  }
+
+  RNSkia::RNSkLogger::logToConsole(
+      "Selected Dawn adapter - Backend: %s, Device: %s, Description: %s",
+      backendName.c_str(), deviceName.c_str(), description.c_str());
 
   std::vector<wgpu::FeatureName> features;
   if (adapter.HasFeature(wgpu::FeatureName::MSAARenderToSingleSampled)) {
@@ -86,6 +164,15 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   if (adapter.HasFeature(wgpu::FeatureName::DawnPartialLoadResolveTexture)) {
     features.push_back(wgpu::FeatureName::DawnPartialLoadResolveTexture);
   }
+  if (adapter.HasFeature(wgpu::FeatureName::TimestampQuery)) {
+    features.push_back(wgpu::FeatureName::TimestampQuery);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment)) {
+    features.push_back(wgpu::FeatureName::DawnTexelCopyBufferRowAlignment);
+  }
+  if (adapter.HasFeature(wgpu::FeatureName::ImplicitDeviceSynchronization)) {
+    features.push_back(wgpu::FeatureName::ImplicitDeviceSynchronization);
+  }
 #ifdef __APPLE__
   if (adapter.HasFeature(wgpu::FeatureName::SharedTextureMemoryIOSurface)) {
     features.push_back(wgpu::FeatureName::SharedTextureMemoryIOSurface);
@@ -101,8 +188,23 @@ createDawnBackendContext(dawn::native::Instance *instance) {
   desc.requiredFeatureCount = features.size();
   desc.requiredFeatures = features.data();
   desc.nextInChain = &togglesDesc;
-
-  wgpu::Device device = adapter.CreateDevice(&desc);
+  desc.SetDeviceLostCallback(
+      wgpu::CallbackMode::AllowSpontaneous,
+      [](const wgpu::Device &, wgpu::DeviceLostReason reason,
+         wgpu::StringView message) {
+        if (reason != wgpu::DeviceLostReason::Destroyed) {
+          SK_ABORT("Device lost: %.*s\n", static_cast<int>(message.length),
+                   message.data);
+        }
+      });
+  desc.SetUncapturedErrorCallback(
+      [](const wgpu::Device &, wgpu::ErrorType, wgpu::StringView message) {
+        SkDebugf("Device error: %.*s\n", static_cast<int>(message.length),
+                 message.data);
+      });
+
+  wgpu::Device device =
+      wgpu::Device::Acquire(matchedAdaptor.CreateDevice(&desc));
   SkASSERT(device);
 
   skgpu::graphite::DawnBackendContext backendContext;