react-native-skia 0.0.1 → 2.15.0

package/cpp/skia/include/gpu/ganesh/GrDriverBugWorkarounds.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDriverBugWorkarounds_DEFINED
+#define GrDriverBugWorkarounds_DEFINED
+
+// External embedders of Skia can override this to use their own list
+// of workaround names.
+#ifdef SK_GPU_WORKAROUNDS_HEADER
+#include SK_GPU_WORKAROUNDS_HEADER
+#else
+// To regenerate this file, set gn arg "skia_generate_workarounds = true"
+// or invoke `bazel run //tools:generate_workarounds`
+// This is not rebuilt by default to avoid embedders having to have extra
+// build steps.
+#include "include/gpu/ganesh/GrDriverBugWorkaroundsAutogen.h"
+#endif
+
+#include "include/core/SkTypes.h"
+
+#include <cstdint>
+#include <vector>
+
+enum GrDriverBugWorkaroundType {
+#define GPU_OP(type, name) type,
+  GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
+#undef GPU_OP
+  NUMBER_OF_GPU_DRIVER_BUG_WORKAROUND_TYPES
+};
+
+class SK_API GrDriverBugWorkarounds {
+ public:
+  GrDriverBugWorkarounds() = default;
+  GrDriverBugWorkarounds(const GrDriverBugWorkarounds&) = default;
+  ~GrDriverBugWorkarounds() = default;
+
+  explicit GrDriverBugWorkarounds(const std::vector<int32_t>& workarounds);
+
+  GrDriverBugWorkarounds& operator=(const GrDriverBugWorkarounds&) = default;
+
+  // Turn on any workarounds listed in |workarounds| (but don't turn any off).
+  void applyOverrides(const GrDriverBugWorkarounds& workarounds);
+
+#define GPU_OP(type, name) bool name = false;
+  GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)
+#undef GPU_OP
+};
+
+#endif

package/cpp/skia/include/gpu/ganesh/GrDriverBugWorkaroundsAutogen.h

@@ -0,0 +1,49 @@
+// Copyright 2018 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is auto-generated from build_workaround_header.py
+// DO NOT EDIT!
+
+#ifndef GPU_DRIVER_BUG_WORKAROUNDS
+#define GPU_DRIVER_BUG_WORKAROUNDS(GPU_OP)               \
+  GPU_OP(ADD_AND_TRUE_TO_LOOP_CONDITION,                 \
+         add_and_true_to_loop_condition)                 \
+  GPU_OP(DISABLE_BLEND_EQUATION_ADVANCED,                \
+         disable_blend_equation_advanced)                \
+  GPU_OP(DISABLE_DISCARD_FRAMEBUFFER,                    \
+         disable_discard_framebuffer)                    \
+  GPU_OP(DISABLE_DUAL_SOURCE_BLENDING_SUPPORT,           \
+         disable_dual_source_blending_support)           \
+  GPU_OP(DISABLE_TEXTURE_STORAGE,                        \
+         disable_texture_storage)                        \
+  GPU_OP(DISALLOW_LARGE_INSTANCED_DRAW,                  \
+         disallow_large_instanced_draw)                  \
+  GPU_OP(EMULATE_ABS_INT_FUNCTION,                       \
+         emulate_abs_int_function)                       \
+  GPU_OP(ENSURE_PREVIOUS_FRAMEBUFFER_NOT_DELETED,        \
+         ensure_previous_framebuffer_not_deleted)        \
+  GPU_OP(FLUSH_ON_FRAMEBUFFER_CHANGE,                    \
+         flush_on_framebuffer_change)                    \
+  GPU_OP(FLUSH_QUERIES_BEFORE_DELETING_OR_UNBINDING_FBO, \
+         flush_queries_before_deleting_or_unbinding_fbo) \
+  GPU_OP(FORCE_UPDATE_SCISSOR_STATE_WHEN_BINDING_FBO0,   \
+         force_update_scissor_state_when_binding_fbo0)   \
+  GPU_OP(GL_CLEAR_BROKEN,                                \
+         gl_clear_broken)                                \
+  GPU_OP(MAX_FRAGMENT_UNIFORM_VECTORS_32,                \
+         max_fragment_uniform_vectors_32)                \
+  GPU_OP(MAX_MSAA_SAMPLE_COUNT_4,                        \
+         max_msaa_sample_count_4)                        \
+  GPU_OP(PACK_PARAMETERS_WORKAROUND_WITH_PACK_BUFFER,    \
+         pack_parameters_workaround_with_pack_buffer)    \
+  GPU_OP(REMOVE_POW_WITH_CONSTANT_EXPONENT,              \
+         remove_pow_with_constant_exponent)              \
+  GPU_OP(REWRITE_DO_WHILE_LOOPS,                         \
+         rewrite_do_while_loops)                         \
+  GPU_OP(UNBIND_ATTACHMENTS_ON_BOUND_RENDER_FBO_DELETE,  \
+         unbind_attachments_on_bound_render_fbo_delete)  \
+  GPU_OP(UNFOLD_SHORT_CIRCUIT_AS_TERNARY_OPERATION,      \
+         unfold_short_circuit_as_ternary_operation)      \
+
+#endif  // GPU_DRIVER_BUG_WORKAROUNDS

package/cpp/skia/include/gpu/ganesh/GrExternalTextureGenerator.h

@@ -0,0 +1,54 @@
+/*
+ * 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 GrExternalTextureGenerator_DEFINED
+#define GrExternalTextureGenerator_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/ganesh/GrBackendSurface.h"
+#include "include/private/SkAPI.h"
+#include "include/private/gpu/ganesh/GrTextureGenerator.h"
+
+#include <memory>
+
+class GrRecordingContext;
+class GrSurfaceProxyView;
+class SkImage;
+enum class GrImageTexGenPolicy : int;
+namespace skgpu { enum class Mipmapped : bool; }
+struct SkImageInfo;
+
+class GrExternalTexture {
+public:
+    virtual ~GrExternalTexture() = default;
+    virtual GrBackendTexture getBackendTexture() = 0;
+    virtual void dispose() = 0;
+};
+
+class SK_API GrExternalTextureGenerator : public GrTextureGenerator {
+public:
+    explicit GrExternalTextureGenerator(const SkImageInfo& info);
+
+    GrSurfaceProxyView onGenerateTexture(GrRecordingContext*,
+                                         const SkImageInfo&,
+                                         skgpu::Mipmapped,
+                                         GrImageTexGenPolicy) override;
+    virtual std::unique_ptr<GrExternalTexture> generateExternalTexture(GrRecordingContext *,
+                                                                       skgpu::Mipmapped) = 0;
+};
+
+namespace SkImages {
+/**
+ *   Like SkImages::DeferredFromGenerator except allows for the use of GrTextureGenerator.
+ *
+ *   @param gen producer of textures
+ *   @return    created SkImage, or nullptr
+ */
+SK_API sk_sp<SkImage> DeferredFromTextureGenerator(std::unique_ptr<GrTextureGenerator> gen);
+}
+
+#endif  // GrExternalTextureGenerator_DEFINED

package/cpp/skia/include/gpu/ganesh/GrRecordingContext.h

@@ -0,0 +1,300 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrRecordingContext_DEFINED
+#define GrRecordingContext_DEFINED
+
+#include "include/core/SkColorType.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkString.h" // IWYU pragma: keep
+#include "include/core/SkTypes.h"
+#include "include/private/SkTArray.h"
+#include "include/private/gpu/ganesh/GrContext_Base.h"
+#include "include/private/gpu/ganesh/GrImageContext.h"
+
+#include <map>
+#include <memory>
+#include <string>
+
+class GrAuditTrail;
+class GrContextThreadSafeProxy;
+class GrDirectContext;
+class GrDrawingManager;
+class GrOnFlushCallbackObject;
+class GrProgramDesc;
+class GrProgramInfo;
+class GrProxyProvider;
+class GrRecordingContextPriv;
+class GrThreadSafeCache;
+class SkArenaAlloc;
+class SkCapabilities;
+class SkJSONWriter;
+class SkGaneshRecorder;
+class SkRecorder;
+
+namespace skcpu {
+class ContextImpl;
+class Recorder;
+}  // namespace skcpu
+
+namespace sktext::gpu {
+class SubRunAllocator;
+class TextBlobRedrawCoordinator;
+}
+
+class GrRecordingContext : public GrImageContext {
+public:
+    ~GrRecordingContext() override;
+
+    /**
+     * Reports whether the GrDirectContext associated with this GrRecordingContext is abandoned.
+     * When called on a GrDirectContext it may actively check whether the underlying 3D API
+     * device/context has been disconnected before reporting the status. If so, calling this
+     * method will transition the GrDirectContext to the abandoned state.
+     */
+    bool abandoned() override { return GrImageContext::abandoned(); }
+
+    /*
+     * Can a SkSurface be created with the given color type. To check whether MSAA is supported
+     * use maxSurfaceSampleCountForColorType().
+     */
+    SK_API bool colorTypeSupportedAsSurface(SkColorType colorType) const {
+        if (colorType == kR16G16_unorm_SkColorType       ||
+            colorType == kA16_unorm_SkColorType          ||
+            colorType == kA16_float_SkColorType          ||
+            colorType == kR16_unorm_SkColorType          ||
+            colorType == kR16_float_SkColorType          ||
+            colorType == kR16G16_float_SkColorType       ||
+            colorType == kR16G16B16A16_unorm_SkColorType ||
+            colorType == kGray_8_SkColorType) {
+            return false;
+        }
+
+        return this->maxSurfaceSampleCountForColorType(colorType) > 0;
+    }
+
+    /**
+     * Gets the maximum supported texture size.
+     */
+    SK_API int maxTextureSize() const;
+
+    /**
+     * Gets the maximum supported render target size.
+     */
+    SK_API int maxRenderTargetSize() const;
+
+    /**
+     * Can a SkImage be created with the given color type.
+     */
+    SK_API bool colorTypeSupportedAsImage(SkColorType) const;
+
+    /**
+     * Does this context support protected content?
+     */
+    SK_API bool supportsProtectedContent() const;
+
+    /**
+     * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA
+     * rendering is supported for the color type. 0 is returned if rendering to this color type
+     * is not supported at all.
+     */
+    SK_API int maxSurfaceSampleCountForColorType(SkColorType colorType) const {
+        return GrImageContext::maxSurfaceSampleCountForColorType(colorType);
+    }
+
+    SK_API sk_sp<const SkCapabilities> skCapabilities() const;
+
+    SK_API SkRecorder* asRecorder();
+    SK_API std::unique_ptr<skcpu::Recorder> makeCPURecorder();
+
+    // Provides access to functions that aren't part of the public API.
+    GrRecordingContextPriv priv();
+    const GrRecordingContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+    // The collection of specialized memory arenas for different types of data recorded by a
+    // GrRecordingContext. Arenas does not maintain ownership of the pools it groups together.
+    class Arenas {
+    public:
+        Arenas(SkArenaAlloc*, sktext::gpu::SubRunAllocator*);
+
+        // For storing pipelines and other complex data as-needed by ops
+        SkArenaAlloc* recordTimeAllocator() { return fRecordTimeAllocator; }
+
+        // For storing GrTextBlob SubRuns
+        sktext::gpu::SubRunAllocator* recordTimeSubRunAllocator() {
+            return fRecordTimeSubRunAllocator;
+        }
+
+    private:
+        SkArenaAlloc* fRecordTimeAllocator;
+        sktext::gpu::SubRunAllocator* fRecordTimeSubRunAllocator;
+    };
+
+protected:
+    friend class GrRecordingContextPriv;    // for hidden functions
+    friend class GrDeferredDisplayList;     // for OwnedArenas
+    friend class GrDeferredDisplayListPriv; // for ProgramData
+
+    // Like Arenas, but preserves ownership of the underlying pools.
+    class OwnedArenas {
+    public:
+        OwnedArenas(bool ddlRecording);
+        ~OwnedArenas();
+
+        Arenas get();
+
+        OwnedArenas& operator=(OwnedArenas&&);
+
+    private:
+        bool fDDLRecording;
+        std::unique_ptr<SkArenaAlloc> fRecordTimeAllocator;
+        std::unique_ptr<sktext::gpu::SubRunAllocator> fRecordTimeSubRunAllocator;
+    };
+
+    GrRecordingContext(sk_sp<GrContextThreadSafeProxy>, bool ddlRecording);
+
+    bool init() override;
+
+    void abandonContext() override;
+
+    GrDrawingManager* drawingManager();
+
+    // There is no going back from this method. It should only be called to control the timing
+    // during abandon or destruction of the context.
+    void destroyDrawingManager();
+
+    Arenas arenas() { return fArenas.get(); }
+    // This entry point should only be used for DDL creation where we want the ops' lifetime to
+    // match that of the DDL.
+    OwnedArenas&& detachArenas();
+
+    GrProxyProvider* proxyProvider() { return fProxyProvider.get(); }
+    const GrProxyProvider* proxyProvider() const { return fProxyProvider.get(); }
+
+    struct ProgramData {
+        ProgramData(std::unique_ptr<const GrProgramDesc>, const GrProgramInfo*);
+        ProgramData(ProgramData&&);                     // for SkTArray
+        ProgramData(const ProgramData&) = delete;
+        ~ProgramData();
+
+        const GrProgramDesc& desc() const { return *fDesc; }
+        const GrProgramInfo& info() const { return *fInfo; }
+
+    private:
+        // TODO: store the GrProgramDescs in the 'fRecordTimeData' arena
+        std::unique_ptr<const GrProgramDesc> fDesc;
+        // The program infos should be stored in 'fRecordTimeData' so do not need to be ref
+        // counted or deleted in the destructor.
+        const GrProgramInfo* fInfo = nullptr;
+    };
+
+    // This entry point gives the recording context a chance to cache the provided
+    // programInfo. The DDL context takes this opportunity to store programInfos as a sidecar
+    // to the DDL.
+    virtual void recordProgramInfo(const GrProgramInfo*) {}
+    // This asks the recording context to return any programInfos it may have collected
+    // via the 'recordProgramInfo' call. It is up to the caller to ensure that the lifetime
+    // of the programInfos matches the intended use. For example, in DDL-record mode it
+    // is known that all the programInfos will have been allocated in an arena with the
+    // same lifetime at the DDL itself.
+    virtual void detachProgramData(skia_private::TArray<ProgramData>*) {}
+
+    sktext::gpu::TextBlobRedrawCoordinator* getTextBlobRedrawCoordinator();
+    const sktext::gpu::TextBlobRedrawCoordinator* getTextBlobRedrawCoordinator() const;
+
+    GrThreadSafeCache* threadSafeCache();
+    const GrThreadSafeCache* threadSafeCache() const;
+
+    /**
+     * Registers an object for flush-related callbacks. (See GrOnFlushCallbackObject.)
+     *
+     * NOTE: the drawing manager tracks this object as a raw pointer; it is up to the caller to
+     * ensure its lifetime is tied to that of the context.
+     */
+    void addOnFlushCallbackObject(GrOnFlushCallbackObject*);
+
+    GrRecordingContext* asRecordingContext() override { return this; }
+
+    class Stats {
+    public:
+        Stats() = default;
+
+#if GR_GPU_STATS
+        void reset() { *this = {}; }
+
+        int numPathMasksGenerated() const { return fNumPathMasksGenerated; }
+        void incNumPathMasksGenerated() { fNumPathMasksGenerated++; }
+
+        int numPathMaskCacheHits() const { return fNumPathMaskCacheHits; }
+        void incNumPathMasksCacheHits() { fNumPathMaskCacheHits++; }
+
+#if defined(GPU_TEST_UTILS)
+        void dump(SkString* out) const;
+        void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
+                               skia_private::TArray<double>* values) const;
+#endif
+
+    private:
+        int fNumPathMasksGenerated{0};
+        int fNumPathMaskCacheHits{0};
+
+#else // GR_GPU_STATS
+        void incNumPathMasksGenerated() {}
+        void incNumPathMasksCacheHits() {}
+
+#if defined(GPU_TEST_UTILS)
+        void dump(SkString*) const {}
+        void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
+                               skia_private::TArray<double>* values) const {}
+#endif
+#endif // GR_GPU_STATS
+    } fStats;
+
+#if GR_GPU_STATS && defined(GPU_TEST_UTILS)
+    struct DMSAAStats {
+        void dumpKeyValuePairs(skia_private::TArray<SkString>* keys,
+                               skia_private::TArray<double>* values) const;
+        void dump() const;
+        void merge(const DMSAAStats&);
+        int fNumRenderPasses = 0;
+        int fNumMultisampleRenderPasses = 0;
+        std::map<std::string, int> fTriggerCounts;
+    };
+
+    DMSAAStats fDMSAAStats;
+#endif
+
+    Stats* stats() { return &fStats; }
+    const Stats* stats() const { return &fStats; }
+    void dumpJSON(SkJSONWriter*) const;
+
+protected:
+    // Delete last in case other objects call it during destruction.
+    std::unique_ptr<GrAuditTrail>     fAuditTrail;
+
+private:
+    OwnedArenas                       fArenas;
+
+    std::unique_ptr<GrProxyProvider> fProxyProvider;
+    // Depends on fProxyProvider (drawing tasks reference proxies). Must be destroyed first.
+    std::unique_ptr<GrDrawingManager> fDrawingManager;
+    std::unique_ptr<const skcpu::ContextImpl> fCPUContext;
+    std::unique_ptr<SkGaneshRecorder> fRecorder;
+
+#if defined(GPU_TEST_UTILS)
+    int fSuppressWarningMessages = 0;
+#endif
+};
+
+/**
+ * Safely cast a possibly-null base context to direct context.
+ */
+static inline GrDirectContext* GrAsDirectContext(GrContext_Base* base) {
+    return base ? base->asDirectContext() : nullptr;
+}
+
+#endif

package/cpp/skia/include/gpu/ganesh/GrTypes.h

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2010 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrTypes_DEFINED
+#define GrTypes_DEFINED
+
+#include "include/core/SkTypes.h"
+#include "include/gpu/GpuTypes.h"
+#include "include/private/SkTo.h" // IWYU pragma: keep
+
+#include <cstddef>
+#include <cstdint>
+class GrBackendSemaphore;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Possible 3D APIs that may be used by Ganesh.
+ */
+enum class GrBackendApi : unsigned {
+    kOpenGL,
+    kVulkan,
+    kMetal,
+    kDirect3D,
+
+    /**
+     * Mock is a backend that does not draw anything. It is used for unit tests
+     * and to measure CPU overhead.
+     */
+    kMock,
+
+    /**
+     * Ganesh doesn't support some context types (e.g. Dawn) and will return Unsupported.
+     */
+    kUnsupported,
+
+    /**
+     * Added here to support the legacy GrBackend enum value and clients who referenced it using
+     * GrBackend::kOpenGL_GrBackend.
+     */
+    kOpenGL_GrBackend = kOpenGL,
+};
+
+/**
+ * Previously the above enum was not an enum class but a normal enum. To support the legacy use of
+ * the enum values we define them below so that no clients break.
+ */
+typedef GrBackendApi GrBackend;
+
+static constexpr GrBackendApi kMetal_GrBackend = GrBackendApi::kMetal;
+static constexpr GrBackendApi kVulkan_GrBackend = GrBackendApi::kVulkan;
+static constexpr GrBackendApi kMock_GrBackend = GrBackendApi::kMock;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/*
+ * Can a GrBackendObject be rendered to?
+ */
+using GrRenderable = skgpu::Renderable;
+
+/*
+ * Used to say whether texture is backed by protected memory.
+ */
+using GrProtected = skgpu::Protected;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ * GPU SkImage and SkSurfaces can be stored such that (0, 0) in texture space may correspond to
+ * either the top-left or bottom-left content pixel.
+ */
+enum GrSurfaceOrigin : int {
+    kTopLeft_GrSurfaceOrigin,
+    kBottomLeft_GrSurfaceOrigin,
+};
+
+/**
+ * A GrContext's cache of backend context state can be partially invalidated.
+ * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
+ */
+enum GrGLBackendState {
+    kRenderTarget_GrGLBackendState     = 1 << 0,
+    // Also includes samplers bound to texture units.
+    kTextureBinding_GrGLBackendState   = 1 << 1,
+    // View state stands for scissor and viewport
+    kView_GrGLBackendState             = 1 << 2,
+    kBlend_GrGLBackendState            = 1 << 3,
+    kMSAAEnable_GrGLBackendState       = 1 << 4,
+    kVertex_GrGLBackendState           = 1 << 5,
+    kStencil_GrGLBackendState          = 1 << 6,
+    kPixelStore_GrGLBackendState       = 1 << 7,
+    kProgram_GrGLBackendState          = 1 << 8,
+    kFixedFunction_GrGLBackendState    = 1 << 9,
+    kMisc_GrGLBackendState             = 1 << 10,
+    kALL_GrGLBackendState              = 0xffff
+};
+
+/**
+ * This value translates to reseting all the context state for any backend.
+ */
+static const uint32_t kAll_GrBackendState = 0xffffffff;
+
+typedef void* GrGpuFinishedContext;
+typedef void (*GrGpuFinishedProc)(GrGpuFinishedContext finishedContext);
+typedef void (*GrGpuFinishedWithStatsProc)(GrGpuFinishedContext finishedContext,
+                                           const skgpu::GpuStats&);
+
+typedef void* GrGpuSubmittedContext;
+typedef void (*GrGpuSubmittedProc)(GrGpuSubmittedContext submittedContext, bool success);
+
+typedef void* GrDirectContextDestroyedContext;
+typedef void (*GrDirectContextDestroyedProc)(GrDirectContextDestroyedContext destroyedContext);
+
+/**
+ * Struct to supply options to flush calls.
+ *
+ * After issuing all commands, fNumSemaphore semaphores will be signaled by the gpu. The client
+ * passes in an array of fNumSemaphores GrBackendSemaphores. In general these GrBackendSemaphore's
+ * can be either initialized or not. If they are initialized, the backend uses the passed in
+ * semaphore. If it is not initialized, a new semaphore is created and the GrBackendSemaphore
+ * object is initialized with that semaphore. The semaphores are not sent to the GPU until the next
+ * GrContext::submit call is made. See the GrContext::submit for more information.
+ *
+ * The client will own and be responsible for deleting the underlying semaphores that are stored
+ * and returned in initialized GrBackendSemaphore objects. The GrBackendSemaphore objects
+ * themselves can be deleted as soon as this function returns.
+ *
+ * If a finishedProc or finishedWithStatsProc is provided, the proc will be called when all work
+ * submitted to the gpu from this flush call and all previous flush calls has finished on the GPU.
+ * If the flush call fails due to an error and nothing ends up getting sent to the GPU, the finished
+ * proc is called immediately. If both types of proc are provided then finishedWithStatsProc is
+ * preferred.
+ *
+ * When finishedWithStatsProc is called the GpuStats passed will contain valid values for stats
+ * by requested by gpuStatsFlags, assuming the stats are supported by the underlying backend GPU
+ * context and the GPU work completed successfully.
+ *
+ * If a submittedProc is provided, the submittedProc will be called when all work from this flush
+ * call is submitted to the GPU. If the flush call fails due to an error and nothing will get sent
+ * to the GPU, the submitted proc is called immediately. It is possibly that when work is finally
+ * submitted, that the submission actual fails. In this case we will not reattempt to do the
+ * submission. Skia notifies the client of these via the success bool passed into the submittedProc.
+ * The submittedProc is useful to the client to know when semaphores that were sent with the flush
+ * have actually been submitted to the GPU so that they can be waited on (or deleted if the submit
+ * fails).
+ * GrBackendSemaphores are not supported for the GL backend and will be ignored if set.
+ */
+struct GrFlushInfo {
+    size_t fNumSemaphores = 0;
+    skgpu::GpuStatsFlags fGpuStatsFlags = skgpu::GpuStatsFlags::kNone;
+    GrBackendSemaphore* fSignalSemaphores = nullptr;
+    GrGpuFinishedProc fFinishedProc = nullptr;
+    GrGpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
+    GrGpuFinishedContext fFinishedContext = nullptr;
+    GrGpuSubmittedProc fSubmittedProc = nullptr;
+    GrGpuSubmittedContext fSubmittedContext = nullptr;
+};
+
+/**
+ * Enum used as return value when flush with semaphores so the client knows whether the valid
+ * semaphores will be submitted on the next GrContext::submit call.
+ */
+enum class GrSemaphoresSubmitted : bool {
+    kNo = false,
+    kYes = true
+};
+
+enum class GrPurgeResourceOptions {
+    kAllResources,
+    kScratchResourcesOnly,
+};
+
+enum class GrSyncCpu : bool {
+    kNo = false,
+    kYes = true,
+};
+
+enum class GrMarkFrameBoundary : bool {
+    kNo = false,
+    kYes = true,
+};
+
+struct GrSubmitInfo {
+    GrSyncCpu fSync = GrSyncCpu::kNo;
+    GrMarkFrameBoundary fMarkBoundary = GrMarkFrameBoundary::kNo;
+    uint64_t fFrameID = 0;
+};
+
+#endif