@shopify/react-native-skia 2.12.0-next.1 → 2.12.0

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

@@ -1,57 +0,0 @@
-// 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

@@ -1,162 +0,0 @@
-// 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

@@ -1,88 +0,0 @@
-// 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/RuntimeAwareCache.cpp

@@ -1,7 +0,0 @@
-#include "RuntimeAwareCache.h"
-
-namespace RNJsi {
-
-std::atomic<jsi::Runtime *> BaseRuntimeAwareCache::_mainRuntime{nullptr};
-
-} // namespace RNJsi

package/cpp/jsi/RuntimeAwareCache.h

@@ -1,117 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <atomic>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <utility>
-
-#include "RuntimeLifecycleMonitor.h"
-
-namespace RNJsi {
-
-namespace jsi = facebook::jsi;
-
-class BaseRuntimeAwareCache {
-public:
-  static void setMainJsRuntime(jsi::Runtime *rt) {
-    // Atomic: hot reload rewrites this from the JS thread while worklet
-    // runtime threads read it concurrently.
-    _mainRuntime.store(rt, std::memory_order_release);
-  }
-  static jsi::Runtime *getMainJsRuntime() {
-    auto *rt = _mainRuntime.load(std::memory_order_acquire);
-    assert(rt != nullptr && "Expected main Javascript runtime to be set in the "
-                            "BaseRuntimeAwareCache class.");
-
-    return rt;
-  }
-
-private:
-  static std::atomic<jsi::Runtime *> _mainRuntime;
-};
-
-/**
- * Provides a way to keep data specific to a jsi::Runtime instance that gets
- * cleaned up when that runtime is destroyed. This is necessary because JSI does
- * not allow for its associated objects to be retained past the runtime
- * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
- * after the runtime is torn down, its destructor (once it is destroyed
- * eventually) will result in a crash (JSI objects keep a pointer to memory
- * managed by the runtime, accessing that portion of the memory after runtime is
- * deleted is the root cause of that crash).
- *
- * In order to provide an efficient implementation that does not add an overhead
- * for the cases when only a single runtiome is used, which is the primary
- * usecase, the following assumption has been made: Only for secondary runtimes
- * we track destruction and clean up the store associated with that runtime. For
- * the first runtime we assume that the object holding the store is destroyed
- * prior to the destruction of that runtime.
- *
- * The above assumption makes it work without any overhead when only single
- * runtime is in use. Specifically, we don't perform any additional operations
- * related to tracking runtime lifecycle when only a single runtime is used.
- */
-template <typename T>
-class RuntimeAwareCache : public BaseRuntimeAwareCache,
-                          public RuntimeLifecycleListener {
-
-public:
-  void onRuntimeDestroyed(jsi::Runtime *rt) override {
-    if (getMainJsRuntime() != rt) {
-      // We are removing a secondary runtime. This is invoked by
-      // RuntimeLifecycleMonitor on the destroyed runtime's thread, which may
-      // run concurrently with get() on another runtime's thread.
-      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
-      _secondaryRuntimeCaches.erase(rt);
-    }
-  }
-
-  ~RuntimeAwareCache() {
-    for (auto &cache : _secondaryRuntimeCaches) {
-      RuntimeLifecycleMonitor::removeListener(
-          *static_cast<jsi::Runtime *>(cache.first), this);
-    }
-  }
-
-  T &get(jsi::Runtime &rt) {
-    // We check if we're accessing the main runtime - this is the happy path
-    // to avoid us having to lookup by runtime for caches that only has a single
-    // runtime
-    if (getMainJsRuntime() == &rt) {
-      return _primaryCache;
-    } else {
-      // Guard the secondary map: it can be mutated concurrently by get()
-      // on a worklet runtime's thread and by onRuntimeDestroyed() when
-      // another secondary runtime is torn down. The main-runtime path above
-      // stays lock-free. References into the map remain valid after the
-      // lock is released (unordered_map never invalidates references on
-      // insert/erase of other keys, and this runtime's entry can only be
-      // erased from this runtime's own thread).
-      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
-      if (_secondaryRuntimeCaches.count(&rt) == 0) {
-        // we only add listener when the secondary runtime is used, this assumes
-        // that the secondary runtime is terminated first. This lets us avoid
-        // additional complexity for the majority of cases when objects are not
-        // shared between runtimes. Otherwise we'd have to register all objecrts
-        // with the RuntimeMonitor as opposed to only registering ones that are
-        // used in secondary runtime. Note that we can't register listener here
-        // with the primary runtime as it may run on a separate thread.
-        RuntimeLifecycleMonitor::addListener(rt, this);
-
-        T cache;
-        _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
-      }
-      return _secondaryRuntimeCaches.at(&rt);
-    }
-  }
-
-private:
-  std::mutex _secondaryCachesMutex;
-  std::unordered_map<void *, T> _secondaryRuntimeCaches;
-  T _primaryCache;
-};
-
-} // namespace RNJsi

package/cpp/jsi/RuntimeLifecycleMonitor.cpp

@@ -1,72 +0,0 @@
-#include "RuntimeLifecycleMonitor.h"
-
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-
-namespace RNJsi {
-
-static std::unordered_map<jsi::Runtime *,
-                          std::unordered_set<RuntimeLifecycleListener *>>
-    listeners;
-static std::mutex listenersMutex;
-
-struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
-  jsi::Runtime *_rt;
-  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : _rt(rt) {}
-  ~RuntimeLifecycleMonitorObject() {
-    std::unordered_set<RuntimeLifecycleListener *> listenersCopy;
-    {
-      std::lock_guard<std::mutex> lock(listenersMutex);
-      auto listenersSet = listeners.find(_rt);
-      if (listenersSet != listeners.end()) {
-        listenersCopy = listenersSet->second;
-        listeners.erase(listenersSet);
-      }
-    }
-    for (auto listener : listenersCopy) {
-      listener->onRuntimeDestroyed(_rt);
-    }
-  }
-};
-
-void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
-                                          RuntimeLifecycleListener *listener) {
-  bool shouldInstallMonitor = false;
-  {
-    std::lock_guard<std::mutex> lock(listenersMutex);
-    auto listenersSet = listeners.find(&rt);
-    if (listenersSet == listeners.end()) {
-      std::unordered_set<RuntimeLifecycleListener *> newSet;
-      newSet.insert(listener);
-      listeners.emplace(&rt, std::move(newSet));
-      shouldInstallMonitor = true;
-    } else {
-      listenersSet->second.insert(listener);
-    }
-  }
-  if (shouldInstallMonitor) {
-    // We install a global host object in the provided runtime, this way we can
-    // use that host object destructor to get notified when the runtime is being
-    // terminated. We use a unique name for the object as it gets saved with the
-    // runtime's global object.
-    rt.global().setProperty(
-        rt, "__rnskia_rt_lifecycle_monitor",
-        jsi::Object::createFromHostObject(
-            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
-  }
-}
-
-void RuntimeLifecycleMonitor::removeListener(
-    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
-  std::lock_guard<std::mutex> lock(listenersMutex);
-  auto listenersSet = listeners.find(&rt);
-  if (listenersSet == listeners.end()) {
-    // nothing to do here
-  } else {
-    listenersSet->second.erase(listener);
-  }
-}
-
-} // namespace RNJsi

package/cpp/jsi/RuntimeLifecycleMonitor.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-
-namespace RNJsi {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Listener interface that allows for getting notified when a jsi::Runtime
- * instance is destroyed.
- */
-struct RuntimeLifecycleListener {
-  virtual ~RuntimeLifecycleListener() {}
-  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
-};
-
-/**
- * This class provides an API via static methods for registering and
- * unregistering runtime lifecycle listeners. The listeners can be used to
- * cleanup any data that references a given jsi::Runtime instance before it gets
- * destroyed.
- */
-struct RuntimeLifecycleMonitor {
-  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
-  static void removeListener(jsi::Runtime &rt,
-                             RuntimeLifecycleListener *listener);
-};
-
-} // namespace RNJsi

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

@@ -1,45 +0,0 @@
-/*
- * 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