@shopify/react-native-skia 2.11.1 → 2.11.2-next.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,162 @@
+// 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>(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/jsi/NativeObject.h

@@ -51,26 +51,32 @@ struct PrototypeCacheEntry {
  *
  * When used with static storage (like prototype caches), the cache persists
  * across hot reloads. But the JSI objects inside become invalid when the
- * runtime is destroyed. This wrapper tracks which runtime the cache was
- * created for and allocates a new cache when the runtime changes.
+ * runtime is destroyed. This wrapper tracks which main-runtime generation the
+ * cache was created for and allocates a new cache when the native module is
+ * reinstalled (RNSkManager construction bumps the generation).
+ *
+ * The generation is used instead of the runtime pointer on purpose: on an
+ * in-process runtime recreate (expo-updates reloadAsync, DevSettings.reload)
+ * Hermes frequently allocates the new runtime at the address of the freed
+ * one. A pointer comparison then sees "same runtime", keeps the stale cache,
+ * and create()/installConstructor() end up passing a jsi::Object owned by the
+ * dead runtime to the new one (use-after-free).
  *
  * The old cache is intentionally leaked - we cannot safely destroy JSI
  * objects after their runtime is gone.
  */
 template <typename T> struct StaticRuntimeAwareCache {
   RNJsi::RuntimeAwareCache<T> *cache = nullptr;
-  jsi::Runtime *cacheRuntime = nullptr;
-
-  RNJsi::RuntimeAwareCache<T> &get(jsi::Runtime &rt) {
-    auto mainRuntime = RNJsi::BaseRuntimeAwareCache::getMainJsRuntime();
-    if (&rt == mainRuntime && cacheRuntime != mainRuntime) {
-      // Main runtime changed (hot reload) - allocate new cache, leak old one
-      cache = new RNJsi::RuntimeAwareCache<T>();
-      cacheRuntime = mainRuntime;
-    }
-    if (cache == nullptr) {
+  uint64_t cacheGeneration = 0;
+
+  RNJsi::RuntimeAwareCache<T> &get(jsi::Runtime & /*rt*/) {
+    auto generation =
+        RNJsi::BaseRuntimeAwareCache::getMainJsRuntimeGeneration();
+    if (cache == nullptr || cacheGeneration != generation) {
+      // First use, or the main runtime was reinstalled (hot reload / OTA):
+      // allocate a fresh cache and leak the old one.
       cache = new RNJsi::RuntimeAwareCache<T>();
-      cacheRuntime = mainRuntime;
+      cacheGeneration = generation;
     }
     return *cache;
   }
@@ -143,9 +149,29 @@ public:
    */
   static void installPrototype(jsi::Runtime &runtime) {
     std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
+    ensurePrototypeLocked(runtime);
+  }
+
+  /**
+   * Look up (and install on first use) the prototype entry for this runtime.
+   *
+   * Callers must hold getPrototypeCacheMutex() and must consume the returned
+   * entry while still holding it: the lookup and the use of the prototype
+   * have to share one lock scope, because a reinstall of the native module
+   * (generation bump, see StaticRuntimeAwareCache) can swap the cache from
+   * any thread. A caller that released the lock in between would re-resolve
+   * a fresh cache with an empty entry and hand out an object without a
+   * prototype.
+   *
+   * The returned reference stays valid for the runtime's lifetime: the
+   * RuntimeAwareCache is heap-allocated and never freed, and
+   * std::unordered_map keeps references to its elements stable across
+   * rehashes.
+   */
+  static PrototypeCacheEntry &ensurePrototypeLocked(jsi::Runtime &runtime) {
     auto &entry = getPrototypeCache(runtime).get(runtime);
     if (entry.prototype.has_value()) {
-      return; // Already installed
+      return entry; // Already installed
     }
 
     // Create prototype object
@@ -264,6 +290,7 @@ public:
 
     // Cache the prototype
     entry.prototype = std::move(prototype);
+    return entry;
   }
 
   /**
@@ -274,13 +301,8 @@ public:
    * created internally by the native code).
    */
   static void installConstructor(jsi::Runtime &runtime) {
-    installPrototype(runtime);
-
     std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
-    auto &entry = getPrototypeCache(runtime).get(runtime);
-    if (!entry.prototype.has_value()) {
-      return;
-    }
+    auto &entry = ensurePrototypeLocked(runtime);
 
     // Create a constructor function that throws when called directly
     auto ctor = jsi::Function::createFromHostFunction(
@@ -308,8 +330,6 @@ public:
    */
   static jsi::Value create(jsi::Runtime &runtime,
                            std::shared_ptr<Derived> instance) {
-    installPrototype(runtime);
-
     // Store creation runtime for logging etc.
     instance->setCreationRuntime(&runtime);
 
@@ -319,18 +339,16 @@ public:
     // Attach native state
     obj.setNativeState(runtime, instance);
 
-    // Set prototype
+    // Install (on first use) and apply the prototype in a single lock scope
+    // so a concurrent cache swap cannot slip in between the two steps.
     {
       std::lock_guard<std::mutex> lock(getPrototypeCacheMutex());
-      auto &entry = getPrototypeCache(runtime).get(runtime);
-      if (entry.prototype.has_value()) {
-        // Use Object.setPrototypeOf to set the prototype
-        auto objectCtor =
-            runtime.global().getPropertyAsObject(runtime, "Object");
-        auto setPrototypeOf =
-            objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
-        setPrototypeOf.call(runtime, obj, *entry.prototype);
-      }
+      auto &entry = ensurePrototypeLocked(runtime);
+      // Use Object.setPrototypeOf to set the prototype
+      auto objectCtor = runtime.global().getPropertyAsObject(runtime, "Object");
+      auto setPrototypeOf =
+          objectCtor.getPropertyAsFunction(runtime, "setPrototypeOf");
+      setPrototypeOf.call(runtime, obj, *entry.prototype);
     }
 
     // Set memory pressure hint for GC

package/cpp/jsi/RuntimeAwareCache.cpp

@@ -3,5 +3,6 @@
 namespace RNJsi {
 
 std::atomic<jsi::Runtime *> BaseRuntimeAwareCache::_mainRuntime{nullptr};
+std::atomic<uint64_t> BaseRuntimeAwareCache::_mainRuntimeGeneration{0};
 
 } // namespace RNJsi

package/cpp/jsi/RuntimeAwareCache.h

@@ -3,6 +3,7 @@
 #include <jsi/jsi.h>
 
 #include <atomic>
+#include <cstdint>
 #include <memory>
 #include <mutex>
 #include <unordered_map>
@@ -20,6 +21,33 @@ public:
     // Atomic: hot reload rewrites this from the JS thread while worklet
     // runtime threads read it concurrently.
     _mainRuntime.store(rt, std::memory_order_release);
+    // Every (re)installation of the native module starts a new generation.
+    // Callers that hold process-wide state derived from the main runtime
+    // (see StaticRuntimeAwareCache) must key their invalidation on this
+    // counter and NOT on the runtime pointer: when the JS runtime is
+    // destroyed and recreated in-process (expo-updates OTA apply,
+    // DevSettings.reload) the new jsi::Runtime is frequently allocated at
+    // the exact address of the freed one, so a pointer comparison cannot
+    // tell a reload from the steady state.
+    _mainRuntimeGeneration.fetch_add(1, std::memory_order_acq_rel);
+  }
+  static uint64_t getMainJsRuntimeGeneration() {
+    return _mainRuntimeGeneration.load(std::memory_order_acquire);
+  }
+  /**
+   * Called when the main runtime is about to go away (RNSkManager destruction).
+   * Bumps the generation so process-wide caches keyed on it
+   * (StaticRuntimeAwareCache) stop trusting their contents before the next
+   * install(). This closes the window where a runtime allocated at the dead
+   * runtime's address would otherwise be taken for the main runtime and be
+   * handed the stale jsi::Objects of the previous one.
+   *
+   * The pointer itself is intentionally left in place: worklet runtime
+   * threads may still call getMainJsRuntime() while teardown overlaps, and
+   * that accessor asserts on nullptr.
+   */
+  static void invalidateMainJsRuntime() {
+    _mainRuntimeGeneration.fetch_add(1, std::memory_order_acq_rel);
   }
   static jsi::Runtime *getMainJsRuntime() {
     auto *rt = _mainRuntime.load(std::memory_order_acquire);
@@ -31,6 +59,7 @@ public:
 
 private:
   static std::atomic<jsi::Runtime *> _mainRuntime;
+  static std::atomic<uint64_t> _mainRuntimeGeneration;
 };
 
 /**

package/cpp/rnskia/RNSkManager.cpp

@@ -30,6 +30,11 @@ RNSkManager::RNSkManager(
 }
 
 RNSkManager::~RNSkManager() {
+  // The main runtime is going away: key out the process-wide prototype
+  // caches now rather than at the next install(), so nothing allocated at
+  // this runtime's address in between can be mistaken for it.
+  RNJsi::BaseRuntimeAwareCache::invalidateMainJsRuntime();
+
   // Free up any references
   _viewApi = nullptr;
   _jsRuntime = nullptr;

package/cpp/skia/src/gpu/graphite/ContextOptionsPriv.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_ContextOptionsPriv_DEFINED
+#define skgpu_graphite_ContextOptionsPriv_DEFINED
+
+#include "include/private/SkMath.h"
+
+#include <optional>
+
+namespace skgpu::graphite {
+
+enum class PathRendererStrategy;
+
+/**
+ * Private options that are only meant for testing within Skia's tools.
+ */
+struct ContextOptionsPriv {
+
+    int  fMaxTextureSizeOverride = SK_MaxS32;
+
+    /**
+     * If true, will store a pointer in Recorder that points back to the Context
+     * that created it. Used by readPixels() and other methods that normally require a Context.
+     */
+    bool fStoreContextRefInRecorder = false;
+
+    /**
+     * If true, enables layer based draw ordering.
+     */
+    bool fDrawListLayer = false;
+
+    /**
+     * Override Caps' default strategy heuristics to prioritize this one if set *and* is supported.
+     */
+    std::optional<PathRendererStrategy> fPathRendererStrategy;
+};
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_ContextOptionsPriv_DEFINED