mono/skia: Graphite-on-WebGPU patches for Emscripten

Threads Skia's Graphite/Dawn backend through Emscripten's bundled
WebGPU shim (-sUSE_WEBGPU=1) so it links cleanly into libSkiaSharp.a
under is_canvaskit=true. Five surgical edits:

* include/c/sk_graphite_dawn.h + src/c/sk_graphite_dawn.cpp -- new
  sk_graphite_dawn_backend_texture_new C entry point that wraps a
  caller-supplied WGPUTexture (e.g. canvas.getContext('webgpu')
  .getCurrentTexture()) via BackendTextures::MakeDawn. The wrapper
  does not retain or release the WGPUTexture; any SkSurface/SkImage
  that wraps it will retain for its own lifetime.

* src/gpu/graphite/dawn/DawnCaps.cpp -- guard YCbCr/biplanar texture
  formats (R8BG8Biplanar420Unorm, R10X6BG10X6Biplanar420Unorm,
  R8BG8A8Triplanar420Unorm, OpaqueYCbCrAndroid, DualSourceBlending,
  TextureFormatsTier1) under #if !defined(__EMSCRIPTEN__). These
  wgpu::TextureFormat enum values do not exist in Emscripten's
  bundled webgpu_cpp.h and would fail to compile.

* src/gpu/graphite/dawn/DawnBuffer.cpp -- replace SKGPU_LOG(...) macro
  with explicit SKGPU_LOG_D / SKGPU_LOG_E; Emscripten's preprocessor
  rejects the macro form in this position.

* third_party/dawn/BUILD.gn -- skip the native Dawn CMake build AND
  the libdawn_combined.a link step when is_canvaskit=true. On
  Emscripten the wgpu_* symbols are provided by -sUSE_WEBGPU=1 at
  the consumer's final link step; building native Dawn for WASM is
  both unnecessary and breaks (the Dawn CMake build assumes desktop
  toolchains).

Build prerequisite (out-of-tree): externals/dawn requires one extra
#include in third_party/externals/dawn/include/tint/tint.h --
'src/tint/api/common/bindings.h'. Dawn isn't a git submodule of skia
(it is checked out via DEPS), so we cannot land that patch here.
Apply it separately if a fresh DEPS sync is needed and Dawn pre-m146.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ramezgerges

include/c/sk_graphite_dawn.h

@@ -38,6 +38,18 @@ SK_C_API sk_graphite_context_t* sk_graphite_context_make_dawn(
     const sk_graphite_dawn_backend_context_t* bc,
     const sk_graphite_context_options_t* opts /* nullable -> defaults */);
 
+// Wrap an externally-allocated WGPUTexture as a Graphite BackendTexture. The
+// shim queries width/height/format/usage directly from the texture, so this
+// is the path for WebGPU swap-chain textures (canvas.getContext('webgpu')
+// .getCurrentTexture()).
+//
+// Lifetime: the BackendTexture does NOT retain or release the WGPUTexture —
+// caller keeps it alive for the wrapper's lifetime. Any SkSurface/SkImage that
+// wraps this BackendTexture *will* retain it for its own lifetime, so caller
+// can drop their reference once the Surface is built.
+SK_C_API sk_graphite_backend_texture_t* sk_graphite_dawn_backend_texture_new(
+    void* wgpuTexture);  // WGPUTexture
+
 SK_C_PLUS_PLUS_END_GUARD
 
 #endif  // sk_graphite_dawn_DEFINED

src/c/sk_graphite_dawn.cpp

@@ -11,9 +11,11 @@
 
 #if defined(SK_GRAPHITE) && defined(SK_DAWN)
 
+#include "include/gpu/graphite/BackendTexture.h"
 #include "include/gpu/graphite/Context.h"
 #include "include/gpu/graphite/ContextOptions.h"
 #include "include/gpu/graphite/dawn/DawnBackendContext.h"
+#include "include/gpu/graphite/dawn/DawnGraphiteTypes.h"
 
 #include "src/c/sk_types_priv.h"
 
@@ -61,10 +63,18 @@ extern "C" SK_C_API sk_graphite_context_t* sk_graphite_context_make_dawn(
     return reinterpret_cast<sk_graphite_context_t*>(context.release());
 }
 
+extern "C" SK_C_API sk_graphite_backend_texture_t* sk_graphite_dawn_backend_texture_new(void* wgpuTexture) {
+    if (!wgpuTexture) return nullptr;
+    auto bt = gr::BackendTextures::MakeDawn(static_cast<WGPUTexture>(wgpuTexture));
+    if (!bt.isValid()) return nullptr;
+    return reinterpret_cast<sk_graphite_backend_texture_t*>(new gr::BackendTexture(bt));
+}
+
 #else  // !(SK_GRAPHITE && SK_DAWN)
 
 extern "C" SK_C_API sk_graphite_dawn_backend_context_t* sk_graphite_dawn_backend_context_new(const sk_graphite_dawn_backend_context_init_t*) { return nullptr; }
 extern "C" SK_C_API void sk_graphite_dawn_backend_context_delete(sk_graphite_dawn_backend_context_t*) {}
 extern "C" SK_C_API sk_graphite_context_t* sk_graphite_context_make_dawn(const sk_graphite_dawn_backend_context_t*, const sk_graphite_context_options_t*) { return nullptr; }
+extern "C" SK_C_API sk_graphite_backend_texture_t* sk_graphite_dawn_backend_texture_new(void*) { return nullptr; }
 
 #endif  // SK_GRAPHITE && SK_DAWN

src/gpu/graphite/dawn/DawnBuffer.cpp

@@ -55,7 +55,11 @@ void log_map_error(WGPUBufferMapAsyncStatus status, const char*) {
             statusStr = "<other>";
             break;
     }
-    SKGPU_LOG(priority, "Buffer async map failed with status %s.", statusStr);
+    if (priority == SkLogPriority::kDebug) {
+        SKGPU_LOG_D("Buffer async map failed with status %s.", statusStr);
+    } else {
+        SKGPU_LOG_E("Buffer async map failed with status %s.", statusStr);
+    }
 }
 
 #else

src/gpu/graphite/dawn/DawnCaps.cpp

@@ -82,10 +82,10 @@ static constexpr wgpu::TextureFormat kFormats[] = {
         wgpu::TextureFormat::ETC2RGBA8Unorm,
         wgpu::TextureFormat::ETC2RGBA8UnormSrgb,
 
+#if !defined(__EMSCRIPTEN__)
         wgpu::TextureFormat::R8BG8Biplanar420Unorm,
         wgpu::TextureFormat::R10X6BG10X6Biplanar420Unorm,
 
-#if !defined(__EMSCRIPTEN__)
         wgpu::TextureFormat::OpaqueYCbCrAndroid,
 #endif
 
@@ -501,9 +501,13 @@ void DawnCaps::initShaderCaps(const wgpu::Device& device) {
     // WGSL supports shader derivatives in the fragment shader
     shaderCaps->fShaderDerivativeSupport = true;
 
+#if !defined(__EMSCRIPTEN__)
+    // DualSourceBlending is a Dawn-extension feature not exposed by Emscripten's
+    // bundled webgpu.h; gate it the same way as FramebufferFetch below.
     if (device.HasFeature(wgpu::FeatureName::DualSourceBlending)) {
         shaderCaps->fDualSourceBlendingSupport = true;
     }
+#endif
 #if !defined(__EMSCRIPTEN__)
     if (device.HasFeature(wgpu::FeatureName::FramebufferFetch)) {
         shaderCaps->fFBFetchSupport = true;
@@ -550,9 +554,15 @@ void DawnCaps::initFormatTable(const wgpu::Device& device) {
     {
         info = &fFormatTable[GetFormatIndex(wgpu::TextureFormat::R8Unorm)];
         info->fFlags = FormatInfo::kAllFlags;
+#if defined(__EMSCRIPTEN__)
+        // TextureFormatsTier1 is a Dawn-extension feature not exposed by
+        // Emscripten's bundled webgpu.h. Conservatively drop the storage flag.
+        info->fFlags &= ~FormatInfo::kStorage_Flag;
+#else
         if (!device.HasFeature(wgpu::FeatureName::TextureFormatsTier1)) {
             info->fFlags &= ~FormatInfo::kStorage_Flag;
         }
+#endif
         info->fColorTypeInfoCount = 3;
         info->fColorTypeInfos = std::make_unique<ColorTypeInfo[]>(info->fColorTypeInfoCount);
         int ctIdx = 0;

third_party/dawn/BUILD.gn

@@ -154,7 +154,12 @@ config("dawn_api_config") {
   } else {
     libs = []
   }
-  libs += [ "$root_out_dir/$_dawn_lib_name" ]
+  # On WASM/canvaskit builds we let Emscripten's bundled webgpu.h resolve the
+  # wgpu_* symbols via -sUSE_WEBGPU=1 at the final link. There's no
+  # libdawn_combined.a produced (see below), so don't reference it as a lib.
+  if (!is_canvaskit) {
+    libs += [ "$root_out_dir/$_dawn_lib_name" ]
+  }
 
   # https://dawn.googlesource.com/dawn/+/647c352f57aa8a4c2666258455158a36c0c385af/src/dawn/native/BUILD.gn#645
   if (is_mac || is_ios) {
@@ -291,7 +296,11 @@ action("dawn_cmake") {
 }
 
 group("dawn") {
-  public_deps = [ ":dawn_cmake" ]
+  if (!is_canvaskit) {
+    # canvaskit (incl. our WASM-Graphite build) does NOT build native Dawn
+    # because Emscripten's webgpu_cpp.h + -sUSE_WEBGPU=1 provide the wgpu API.
+    public_deps = [ ":dawn_cmake" ]
+  }
 
   public_configs = [ ":dawn_api_config" ]
 }