@shopify/react-native-skia 2.11.2 → 2.12.0

package/cpp/skia/include/core/SkCanvas.h

@@ -2529,7 +2529,6 @@ private:
     std::unique_ptr<SkRasterHandleAllocator> fAllocator;
 
     SkSurface_Base*  fSurfaceBase;
-    virtual SkSurface_Base* getSurfaceBase() const { return fSurfaceBase; }
     void setSurfaceBase(SkSurface_Base* sb) {
         fSurfaceBase = sb;
     }

package/cpp/skia/include/core/SkContext.h

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkContext_DEFINED
+#define SkContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/SkAPI.h"
+
+class SkContextPriv;
+class SkResourceCache;
+class SkSharedContext;
+class SkStrikeCache;
+class SkTraceMemoryDump;
+class SkTypefaceCache;
+struct SkContextOptions;
+
+/**
+ * @brief SkContext is a central context object that serves as the mandatory first point of
+ * initialization for all Skia clients. SkContext consolidates global state, management of shared
+ * resources, and internal caches.
+ */
+class SK_API SkContext final {
+public:
+    SkContext(const SkContext&) = delete;
+    SkContext(SkContext&&) = delete;
+    SkContext& operator=(const SkContext&) = delete;
+    SkContext& operator=(SkContext&&) = delete;
+
+    ~SkContext();
+
+    SkContextPriv priv();
+    const SkContextPriv priv() const;
+
+private:
+    SkContext(sk_sp<SkSharedContext>);
+
+    SkResourceCache* resourceCache() const;
+    SkStrikeCache* fontCache() const;
+    SkTypefaceCache* typefaceCache() const;
+
+    size_t fontCacheLimit() const;
+    size_t setFontCacheLimit(size_t bytes);
+    size_t fontCacheUsed() const;
+
+    int fontCacheCountLimit() const;
+    int setFontCacheCountLimit(int count);
+    int fontCacheCountUsed() const;
+
+    void purgeFontCache();
+    void purgePinnedFontCache();
+
+    void dumpMemoryStatistics(SkTraceMemoryDump* dump);
+
+    sk_sp<SkSharedContext> fSharedContext;
+};
+
+#endif  // SkContext_DEFINED

package/cpp/skia/include/core/SkContextOptions.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright 2026 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkContextOptions_DEFINED
+#define SkContextOptions_DEFINED
+
+#include "include/private/SkAPI.h"
+
+struct SK_API SkContextOptions {};
+
+#endif  // SkContextOptions_DEFINED

package/cpp/skia/include/core/SkMilestone.h

@@ -5,5 +5,5 @@
  * found in the LICENSE file.
  */
 #ifndef SK_MILESTONE
-#define SK_MILESTONE 152
+#define SK_MILESTONE 154
 #endif

package/cpp/skia/include/core/SkPicture.h

@@ -16,12 +16,16 @@
 #include <atomic>
 #include <cstddef>
 #include <cstdint>
+#include <memory>
 
+class SkBBoxHierarchy;
 class SkCanvas;
 class SkData;
 class SkMatrix;
+class SkRecord;
 class SkStream;
 class SkWStream;
+class SkSnapshotArray;
 enum class SkFilterMode;
 struct SkDeserialProcs;
 struct SkSerialProcs;
@@ -33,8 +37,8 @@ struct SkSerialProcs;
     SkPicture records drawing commands made to SkCanvas. The command stream may be
     played in whole or in part at a later time.
 
-    SkPicture is an abstract class. SkPicture may be generated by SkPictureRecorder
-    or SkDrawable, or from SkPicture previously saved to SkData or SkStream.
+    SkPicture may be generated by SkPictureRecorder or SkDrawable, or from a
+    SkPicture previously saved to SkData or SkStream.
 
     SkPicture may contain any SkCanvas drawing command, as well as one or more
     SkCanvas matrix or SkCanvas clip. SkPicture has a cull SkRect, which is used as
@@ -84,7 +88,8 @@ public:
         @param procs  custom serial data decoders; may be nullptr
         @return       SkPicture constructed from data
     */
-    static sk_sp<SkPicture> MakeFromData(const void* data, size_t size,
+    static sk_sp<SkPicture> MakeFromData(const void* data,
+                                         size_t size,
                                          const SkDeserialProcs* procs = nullptr);
 
     /** \class SkPicture::AbortCallback
@@ -133,7 +138,7 @@ public:
 
         example: https://fiddle.skia.org/c/@Picture_playback
     */
-    virtual void playback(SkCanvas* canvas, AbortCallback* callback = nullptr) const = 0;
+    void playback(SkCanvas* canvas, AbortCallback* callback = nullptr) const;
 
     /** Returns cull SkRect for this picture, passed in when SkPicture was created.
         Returned SkRect does not specify clipping SkRect for SkPicture; cull is hint
@@ -146,7 +151,7 @@ public:
 
         example: https://fiddle.skia.org/c/@Picture_cullRect
     */
-    virtual SkRect cullRect() const = 0;
+    SkRect cullRect() const { return fCullRect; }
 
     /** Returns a non-zero value unique among SkPicture in Skia process.
 
@@ -212,11 +217,12 @@ public:
 
         @param nested  if true, include the op-counts of nested pictures as well, else
                        just return count the ops in the top-level picture.
-        @return  approximate operation count
+        @return  approximate operation count. If 0 is returned, we say the SkPicture is "empty"
+                    meaning its cullRect is the result of an SkRect::MakeEmpty().
 
         example: https://fiddle.skia.org/c/@Picture_approximateOpCount
     */
-    virtual int approximateOpCount(bool nested = false) const = 0;
+    int approximateOpCount(bool nested = false) const;
 
     /** Returns the approximate byte size of SkPicture. Does not include large objects
         referenced by SkPicture.
@@ -225,7 +231,7 @@ public:
 
         example: https://fiddle.skia.org/c/@Picture_approximateBytesUsed
     */
-    virtual size_t approximateBytesUsed() const = 0;
+    size_t approximateBytesUsed() const;
 
     /** Return a new shader that will draw with this picture.
      *
@@ -240,18 +246,23 @@ public:
      *                  bounds.
      *  @return     Returns a new shader object. Note: this function never returns null.
      */
-    sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, SkFilterMode mode,
-                               const SkMatrix* localMatrix, const SkRect* tileRect) const;
+    sk_sp<SkShader> makeShader(SkTileMode tmx,
+                               SkTileMode tmy,
+                               SkFilterMode mode,
+                               const SkMatrix* localMatrix,
+                               const SkRect* tileRect) const;
 
     sk_sp<SkShader> makeShader(SkTileMode tmx, SkTileMode tmy, SkFilterMode mode) const {
         return this->makeShader(tmx, tmy, mode, nullptr, nullptr);
     }
 
 private:
-    // Allowed subclasses.
-    SkPicture();
-    friend class SkBigPicture;
-    friend class SkEmptyPicture;
+    SkPicture(const SkRect& cull,
+              sk_sp<const SkRecord> record,
+              std::unique_ptr<const SkSnapshotArray> drawablePicts,
+              sk_sp<const SkBBoxHierarchy> bbh,
+              size_t approxBytesUsedBySubPictures);
+
     friend class SkPicturePriv;
 
     void serialize(SkWStream*, const SkSerialProcs*, class SkRefCntSet* typefaces,
@@ -273,9 +284,6 @@ private:
     static bool BufferIsSKP(class SkReadBuffer*, struct SkPictInfo*);
     friend bool SkPicture_StreamIsSKP(SkStream*, struct SkPictInfo*);
 
-    // Returns NULL if this is not an SkBigPicture.
-    virtual const class SkBigPicture* asSkBigPicture() const { return nullptr; }
-
     static bool IsValidPictInfo(const struct SkPictInfo& info);
     static sk_sp<SkPicture> Forwardport(const struct SkPictInfo&,
                                         const class SkPictureData*,
@@ -284,7 +292,17 @@ private:
     struct SkPictInfo createHeader() const;
     class SkPictureData* backport() const;
 
-    uint32_t fUniqueID;
+    // When fRecord is nullptr, then we treat the SkPicture as a "placeholder"
+    // placeholders provide the bare minimum to operate on an SkPicture
+    bool isPlaceholder() const { return !fRecord; }
+
+    const uint32_t fUniqueID;
+    const SkRect fCullRect;
+    const size_t fApproxBytesUsedBySubPictures;
+    const sk_sp<const SkRecord> fRecord;
+    const std::unique_ptr<const SkSnapshotArray> fDrawablePicts;
+    const sk_sp<const SkBBoxHierarchy> fBBH;
+
     mutable std::atomic<bool> fAddedToCache{false};
 };
 

package/cpp/skia/include/core/SkRecorder.h

@@ -7,7 +7,9 @@
 #ifndef SkRecorder_DEFINED
 #define SkRecorder_DEFINED
 
+#include "include/core/SkPicture.h"
 #include "include/private/SkAPI.h"
+#include "include/private/SkTArray.h"
 
 class SkCanvas;
 class SkSurface;
@@ -34,11 +36,17 @@ public:
 
     virtual skcpu::Recorder* cpuRecorder() = 0;
 
+protected:
+    skia_private::TArray<sk_sp<SkPicture>> fCapturedPictures;
+
 private:
 
     /**
     * Attempts to create and return an SkCaptureCanvas that wraps the provided base canvas.
     * Returns nullptr if capture is not enabled.
+    *
+    * TODO: When implementing in all Recorder subclasses, see if the implementations can be shared
+    * and moved here.
     */
     virtual SkCanvas* makeCaptureCanvas(SkCanvas*) = 0;
     virtual void createCaptureBreakpoint(SkSurface*) = 0;

package/cpp/skia/include/core/SkSerialProcs.h

@@ -47,8 +47,7 @@ using SkSerialTypefaceProc = SkSerialReturnType (*)(SkTypeface*, void* ctx);
 using SkDeserialPictureProc = sk_sp<SkPicture> (*)(const void* data, size_t length, void* ctx);
 
 /**
- *  Called with the encoded form of an image. The proc can return an image object, or if it
- *  returns nullptr, then Skia will take its default action to try to create an image from the data.
+ *  Called with the encoded form of an image. If this is not set, no image decoding will be done.
  *
  *  This will also be used to decode the internal mipmap layers that are saved on some images.
  *
@@ -60,14 +59,11 @@ using SkDeserialPictureProc = sk_sp<SkPicture> (*)(const void* data, size_t leng
  *  must make a copy of any data they needed after the proc finishes, since the data will go away
  *  after serialization ends.
  */
-#if !defined(SK_LEGACY_DESERIAL_IMAGE_PROC)
-using SkDeserialImageProc = sk_sp<SkImage> (*)(const void* data, size_t length, void* ctx);
-#else
 using SkDeserialImageProc = sk_sp<SkImage> (*)(const void* data,
                                                size_t length,
                                                std::optional<SkAlphaType>,
                                                void* ctx);
-#endif
+
 using SkDeserialImageFromDataProc = sk_sp<SkImage> (*)(sk_sp<SkData>,
                                                        std::optional<SkAlphaType>,
                                                        void* ctx);

package/cpp/skia/include/effects/SkImageFilters.h

@@ -414,12 +414,21 @@ public:
      * This allows Skia to provide sampleable values for the image filter without worrying about
      * boundary conditions.
      *
+     * By default the output of a runtime shader is unbounded, since Skia cannot know what colors
+     * the SkSL will produce for pixels outside of its inputs' bounds. If
+     * 'restrictOutputToInputBounds' is true, the caller promises that the SkSL evaluates to
+     * transparent black wherever its child shaders are transparent black, so the filter's output
+     * bounds can be restricted to the union of its inputs' output bounds (the source image's
+     * bounds when 'input' is null). This lets downstream filters (e.g. a blur with a non-decal
+     * tile mode) see the original content bounds instead of an unbounded result.
+     *
      * This requires a GPU backend or SkSL to be compiled in.
     */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeEffectBuilder& builder,
                                               SkScalar sampleRadius,
                                               std::string_view childShaderName,
-                                              sk_sp<SkImageFilter> input);
+                                              sk_sp<SkImageFilter> input,
+                                              bool restrictOutputToInputBounds = false);
 
     /**
      *  Create a filter that fills the output with the per-pixel evaluation of the SkShader produced
@@ -453,13 +462,17 @@ public:
      * childShaderNames) will be evaluated with coordinates at most 'maxSampleRadius' away from the
      * coordinate provided to the runtime shader itself.
      *
+     * If 'restrictOutputToInputBounds' is true, the filter's output bounds are restricted to the
+     * union of its inputs' output bounds; see the single-child variant for details.
+     *
      *  This requires a GPU backend or SkSL to be compiled in.
      */
     static sk_sp<SkImageFilter> RuntimeShader(const SkRuntimeEffectBuilder& builder,
                                               SkScalar maxSampleRadius,
                                               std::string_view childShaderNames[],
                                               const sk_sp<SkImageFilter> inputs[],
-                                              int inputCount);
+                                              int inputCount,
+                                              bool restrictOutputToInputBounds = false);
 
     enum class Dither : bool {
         kNo = false,

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

@@ -320,14 +320,34 @@ public:
     bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores,
               bool deleteSemaphoresAfterWait = true);
 
+    /*
+     * Result of a flush call. A flush can be successful w/ or w/o any semaphores being flushed.
+     * In some circumstances an unsuccessful flush can still have flushed the semaphores but
+     * the rendering results should be discarded.
+     */
+    struct FlushResult {
+        // This implicit cast is temporary and recreates the success/semaphore-submission
+        // conflation of the old API. This can be removed when all clients have been
+        // updated to the new return value.
+        operator GrSemaphoresSubmitted() const {
+            return fSuccess ? GrSemaphoresSubmitted::kYes : GrSemaphoresSubmitted::kNo;
+        }
+
+        bool fSuccess = false;                    // Did the flush succeed
+        // Were any semaphores submitted during the flush process. Will be kNo if no
+        // semaphores were specified.
+        GrSemaphoresSubmitted fSubmitted = GrSemaphoresSubmitted::kNo;
+    };
+
     /**
      * Call to ensure all drawing to the context has been flushed and submitted to the underlying 3D
      * API. This is equivalent to calling GrContext::flush with a default GrFlushInfo followed by
      * GrContext::submit(sync).
      */
-    void flushAndSubmit(GrSyncCpu sync = GrSyncCpu::kNo) {
-        this->flush(GrFlushInfo());
-        this->submit(sync);
+    FlushResult flushAndSubmit(GrSyncCpu sync = GrSyncCpu::kNo) {
+        FlushResult result = this->flush(GrFlushInfo());
+        result.fSuccess &= this->submit(sync);
+        return result;
     }
 
     /**
@@ -341,22 +361,22 @@ public:
      *         buffer or encoder objects. However, these objects are not sent to the gpu until a
      *         submission occurs.
      *
-     * If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be
-     * submitted to the gpu during the next submit call (it is possible Skia failed to create a
-     * subset of the semaphores). The client should not wait on these semaphores until after submit
-     * has been called, and must keep them alive until then. If this call returns
-     * GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on
-     * the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in with
-     * the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the
-     * client is still responsible for deleting any initialized semaphores.
+     * If FlushResult.fSubmitted is GrSemaphoresSubmitted::kYes, only initialized
+     * GrBackendSemaphores will be submitted to the gpu during the next submit call (it is possible
+     * Skia failed to create a subset of the semaphores). The client should not wait on these
+     * semaphores until after submit has been called, and must keep them alive until then. If
+     * fSubmitted is GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores
+     * to be signaled on the GPU. Thus the client should not have the GPU wait on any of the
+     * semaphores passed in with the GrFlushInfo. Regardless of whether semaphores were submitted
+     * to the GPU or not, the client is still responsible for deleting any initialized semaphores.
      * Regardless of semaphore submission the context will still be flushed. It should be
-     * emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not
-     * happen. It simply means there were no semaphores submitted to the GPU. A caller should only
-     * take this as a failure if they passed in semaphores to be submitted.
+     * emphasized that a fSubmitted value of GrSemaphoresSubmitted::kNo does not mean the flush
+     * did not happen. It simply means there were no semaphores submitted to the GPU. A caller
+     * should only take this as a failure if they passed in semaphores to be submitted.
      */
-    GrSemaphoresSubmitted flush(const GrFlushInfo& info);
+    FlushResult flush(const GrFlushInfo& info);
 
-    void flush() { this->flush(GrFlushInfo()); }
+    void flush() { (void) this->flush(GrFlushInfo()); }
 
     /** Flushes any pending uses of texture-backed images in the GPU backend. If the image is not
      *  texture-backed (including promise texture images) or if the GrDirectContext does not
@@ -367,13 +387,18 @@ public:
      *  @param image    the non-null image to flush.
      *  @param info     flush options
      */
-    GrSemaphoresSubmitted flush(const sk_sp<const SkImage>& image, const GrFlushInfo& info);
-    void flush(const sk_sp<const SkImage>& image);
+    FlushResult flush(const sk_sp<const SkImage>& image, const GrFlushInfo& info);
+
+    void flush(const sk_sp<const SkImage>& image) { (void) this->flush(image, {}); }
 
     /** Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the
-     *   GPU.
+     *  GPU.
      */
-    void flushAndSubmit(const sk_sp<const SkImage>& image);
+    FlushResult flushAndSubmit(const sk_sp<const SkImage>& image) {
+        FlushResult result = this->flush(image, {});
+        result.fSuccess &= this->submit();
+        return result;
+    }
 
     /** Issues pending SkSurface commands to the GPU-backed API objects and resolves any SkSurface
      *  MSAA. A call to GrDirectContext::submit is always required to ensure work is actually sent
@@ -400,19 +425,20 @@ public:
      *  The GrFlushInfo describes additional options to flush. Please see documentation at
      *  GrFlushInfo for more info.
      *
-     *  If the return is GrSemaphoresSubmitted::kYes, only initialized GrBackendSemaphores will be
-     *  submitted to the gpu during the next submit call (it is possible Skia failed to create a
-     *  subset of the semaphores). The client should not wait on these semaphores until after submit
-     *  has been called, but must keep them alive until then. If a submit flag was passed in with
-     *  the flush these valid semaphores can we waited on immediately. If this call returns
-     *  GrSemaphoresSubmitted::kNo, the GPU backend will not submit any semaphores to be signaled on
-     *  the GPU. Thus the client should not have the GPU wait on any of the semaphores passed in
-     *  with the GrFlushInfo. Regardless of whether semaphores were submitted to the GPU or not, the
-     *  client is still responsible for deleting any initialized semaphores.
-     *  Regardless of semaphore submission the context will still be flushed. It should be
-     *  emphasized that a return value of GrSemaphoresSubmitted::kNo does not mean the flush did not
-     *  happen. It simply means there were no semaphores submitted to the GPU. A caller should only
-     *  take this as a failure if they passed in semaphores to be submitted.
+     *  If FlushResult.fSubmitted is GrSemaphoresSubmitted::kYes, only initialized
+     *  GrBackendSemaphores will be submitted to the gpu during the next submit call (it is
+     *  possible Skia failed to create a subset of the semaphores). The client should not wait on
+     *  these semaphores until after submit has been called, but must keep them alive until then.
+     *  If a submit flag was passed in with the flush these valid semaphores can we waited on
+     *  immediately. If this fSubmitted is GrSemaphoresSubmitted::kNo, the GPU backend will not
+     *  submit any semaphores to be signaled on the GPU. Thus the client should not have the GPU
+     *  wait on any of the semaphores passed in with the GrFlushInfo. Regardless of whether
+     *  semaphores were submitted to the GPU or not, the client is still responsible for deleting
+     *  any initialized semaphores. Regardless of semaphore submission the context will still be
+     *  flushed. It should be emphasized that a fSubmitted value of GrSemaphoresSubmitted::kNo
+     *  does not mean the flush did not happen. It simply means there were no semaphores submitted
+     *  to the GPU. A caller should only take this as a failure if they passed in semaphores to
+     *  be submitted.
      *
      *  Pending surface commands are flushed regardless of the return result.
      *
@@ -420,9 +446,9 @@ public:
      *  @param access  type of access the call will do on the backend object after flush
      *  @param info    flush options
      */
-    GrSemaphoresSubmitted flush(SkSurface* surface,
-                                SkSurfaces::BackendSurfaceAccess access,
-                                const GrFlushInfo& info);
+    FlushResult flush(SkSurface* surface,
+                      SkSurfaces::BackendSurfaceAccess access,
+                      const GrFlushInfo& info);
 
     /**
      *  Same as above except:
@@ -443,9 +469,16 @@ public:
      *  @param info     flush options
      *  @param newState optional state change request after flush
      */
-    GrSemaphoresSubmitted flush(SkSurface* surface,
-                                const GrFlushInfo& info,
-                                const skgpu::MutableTextureState* newState = nullptr);
+    FlushResult flush(SkSurface* surface,
+                      const GrFlushInfo& info,
+                      const skgpu::MutableTextureState* newState = nullptr);
+
+    /**
+     * Flushes the given surface with the default GrFlushInfo.
+     *
+     *  Has no effect on a CPU-backed surface.
+     */
+    void flush(SkSurface* surface) { (void) this->flush(surface, GrFlushInfo(), nullptr); }
 
     /** Call to ensure all reads/writes of the surface have been issued to the underlying 3D API.
      *  Skia will correctly order its own draws and pixel operations. This must to be used to ensure
@@ -455,14 +488,7 @@ public:
      *
      *  Has no effect on a CPU-backed surface.
      */
-    void flushAndSubmit(SkSurface* surface, GrSyncCpu sync = GrSyncCpu::kNo);
-
-    /**
-     * Flushes the given surface with the default GrFlushInfo.
-     *
-     *  Has no effect on a CPU-backed surface.
-     */
-    void flush(SkSurface* surface);
+    FlushResult flushAndSubmit(SkSurface* surface, GrSyncCpu sync = GrSyncCpu::kNo);
 
     /**
      * Submit outstanding work to the gpu from all previously un-submitted flushes. The return

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

@@ -11,6 +11,7 @@
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSurface.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
 #include "include/gpu/ganesh/GrTypes.h"
 #include "include/private/SkAPI.h"
 
@@ -209,10 +210,12 @@ namespace skgpu::ganesh {
 // Clients should strive to call GrDirectContext::flush directly. However, there exist some
 // places where the GrDirectContext is hard to find, these helpers allow for the flushing of the
 // provided surface. This is a no-op if the surface is nullptr or not GPU backed.
-SK_API GrSemaphoresSubmitted Flush(sk_sp<SkSurface>);
-SK_API GrSemaphoresSubmitted Flush(SkSurface*);
-SK_API void FlushAndSubmit(sk_sp<SkSurface>);
-SK_API void FlushAndSubmit(SkSurface*);
+SK_API GrDirectContext::FlushResult Flush(sk_sp<SkSurface>);
+SK_API GrDirectContext::FlushResult Flush(SkSurface*);
+
+SK_API GrDirectContext::FlushResult FlushAndSubmit(sk_sp<SkSurface>);
+SK_API GrDirectContext::FlushResult FlushAndSubmit(SkSurface*);
+
 }  // namespace skgpu::ganesh
 
 #endif

package/cpp/skia/include/gpu/ganesh/d3d/GrD3DDirectContext.h

@@ -11,9 +11,13 @@
 #include "include/core/SkRefCnt.h"
 #include "include/private/SkAPI.h"
 
+#include <memory>
+
 class GrDirectContext;
+class SkContext;
 struct GrContextOptions;
 struct GrD3DBackendContext;
+struct SkContextOptions;
 
 namespace GrDirectContexts {
 /**
@@ -25,4 +29,12 @@ SK_API sk_sp<GrDirectContext> MakeD3D(const GrD3DBackendContext& backendContext,
 SK_API sk_sp<GrDirectContext> MakeD3D(const GrD3DBackendContext& backendContext);
 }  // namespace GrDirectContexts
 
+namespace SkContexts {
+
+// Creates a context wrapping a Ganesh GPU backend with D3D
+std::unique_ptr<SkContext> MakeGanesh(const GrD3DBackendContext& backendContext,
+                            const SkContextOptions& options);
+
+}  // namespace SkContexts
+
 #endif

package/cpp/skia/include/gpu/ganesh/gl/GrGLDirectContext.h

@@ -11,9 +11,13 @@
 #include "include/core/SkRefCnt.h"
 #include "include/private/SkAPI.h"
 
+#include <memory>
+
 class GrDirectContext;
+class SkContext;
 struct GrContextOptions;
 struct GrGLInterface;
+struct SkContextOptions;
 
 namespace GrDirectContexts {
 /**
@@ -27,4 +31,11 @@ SK_API sk_sp<GrDirectContext> MakeGL();
 #endif
 }
 
+namespace SkContexts {
+
+// Creates a context wrapping a Ganesh GPU backend with OpenGL
+std::unique_ptr<SkContext> MakeGanesh(sk_sp<const GrGLInterface>, const SkContextOptions& options);
+
+}  // namespace SkContexts
+
 #endif

package/cpp/skia/include/gpu/ganesh/mtl/GrMtlDirectContext.h

@@ -11,9 +11,13 @@
 #include "include/core/SkRefCnt.h"
 #include "include/private/SkAPI.h"
 
+#include <memory>
+
 class GrDirectContext;
+class SkContext;
 struct GrContextOptions;
 struct GrMtlBackendContext;
+struct SkContextOptions;
 
 namespace GrDirectContexts {
 /**
@@ -27,4 +31,11 @@ SK_API sk_sp<GrDirectContext> MakeMetal(const GrMtlBackendContext&, const GrCont
 SK_API sk_sp<GrDirectContext> MakeMetal(const GrMtlBackendContext&);
 }  // namespace GrDirectContexts
 
+namespace SkContexts {
+
+// Creates a context wrapping a Ganesh GPU backend with Metal
+std::unique_ptr<SkContext> MakeGanesh(const GrMtlBackendContext& mtlContext, const SkContextOptions& options);
+
+}  // namespace SkContexts
+
 #endif

package/cpp/skia/include/gpu/ganesh/vk/GrVkDirectContext.h

@@ -11,8 +11,12 @@
 #include "include/core/SkRefCnt.h"
 #include "include/private/SkAPI.h"
 
+#include <memory>
+
 class GrDirectContext;
+class SkContext;
 struct GrContextOptions;
+struct SkContextOptions;
 namespace skgpu {
 struct VulkanBackendContext;
 }
@@ -30,4 +34,13 @@ SK_API sk_sp<GrDirectContext> MakeVulkan(const skgpu::VulkanBackendContext&,
 SK_API sk_sp<GrDirectContext> MakeVulkan(const skgpu::VulkanBackendContext&);
 }
 
+namespace SkContexts {
+
+// Creates a context wrapping a Ganesh GPU backend with Vulkan
+std::unique_ptr<SkContext> MakeGanesh(const skgpu::VulkanBackendContext& vkContext,
+                            const SkContextOptions& options);
+
+}  // namespace SkContexts
+
+
 #endif

package/cpp/skia/include/gpu/graphite/ContextOptions.h

@@ -135,6 +135,12 @@ struct SK_API ContextOptions {
     bool fSetBackendLabels = false;
 #endif
 
+    /**
+     * Enabling switches Graphite from the existing sort-based draw ordering to the new layer-based
+     * system.
+     */
+    bool fUseDrawListLayer = false;
+
     /**
      * Client-provided context that is passed to the client-provided PipelineCachingCallback
      * and the (deprecated) PipelineCallback.