@shopify/react-native-skia 0.1.234 → 0.1.237

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

@@ -24,6 +24,7 @@
 
 class SkData;
 class SkDescriptor;
+class SkFontMgr;
 class SkFontDescriptor;
 class SkScalerContext;
 class SkStream;
@@ -36,10 +37,6 @@ struct SkScalerContextRec;
 
 using SkTypefaceID = uint32_t;
 
-// SkFontID is deprecated, please use SkTypefaceID.
-using SkFontID = SkTypefaceID;
-
-
 /** Machine endian. */
 typedef uint32_t SkFontTableTag;
 
@@ -103,46 +100,13 @@ public:
      */
     SkTypefaceID uniqueID() const { return fUniqueID; }
 
-    /** Return the uniqueID for the specified typeface. If the face is null,
-        resolve it to the default font and return its uniqueID. Will never
-        return 0.
-    */
-    static SkTypefaceID UniqueID(const SkTypeface* face);
-
     /** Returns true if the two typefaces reference the same underlying font,
-        handling either being null (treating null as the default font)
+        handling either being null (treating null as not equal to any font).
      */
     static bool Equal(const SkTypeface* facea, const SkTypeface* faceb);
 
-    /** Returns the default normal typeface, which is never nullptr. */
-    static sk_sp<SkTypeface> MakeDefault();
-
-    /** Creates a new reference to the typeface that most closely matches the
-        requested familyName and fontStyle. This method allows extended font
-        face specifiers as in the SkFontStyle type. Will never return null.
-
-        @param familyName  May be NULL. The name of the font family.
-        @param fontStyle   The style of the typeface.
-        @return reference to the closest-matching typeface. Call must call
-              unref() when they are done.
-    */
-    static sk_sp<SkTypeface> MakeFromName(const char familyName[], SkFontStyle fontStyle);
-
-    /** Return a new typeface given a file. If the file does not exist, or is
-        not a valid font file, returns nullptr.
-    */
-    static sk_sp<SkTypeface> MakeFromFile(const char path[], int index = 0);
-
-    /** Return a new typeface given a stream. If the stream is
-        not a valid font file, returns nullptr. Ownership of the stream is
-        transferred, so the caller must not reference it again.
-    */
-    static sk_sp<SkTypeface> MakeFromStream(std::unique_ptr<SkStreamAsset> stream, int index = 0);
-
-    /** Return a new typeface given a SkData. If the data is null, or is not a valid font file,
-     *  returns nullptr.
-     */
-    static sk_sp<SkTypeface> MakeFromData(sk_sp<SkData>, int index = 0);
+    /** Returns a non-null typeface which contains no glyphs. */
+    static sk_sp<SkTypeface> MakeEmpty();
 
     /** Return a new typeface based on this typeface but parameterized as specified in the
         SkFontArguments. If the SkFontArguments does not supply an argument for a parameter
@@ -177,9 +141,11 @@ public:
     /** Given the data previously written by serialize(), return a new instance
         of a typeface referring to the same font. If that font is not available,
         return nullptr.
+        Goes through all registered typeface factories and lastResortMgr (if non-null).
         Does not affect ownership of SkStream.
      */
-    static sk_sp<SkTypeface> MakeDeserialize(SkStream*);
+
+    static sk_sp<SkTypeface> MakeDeserialize(SkStream*, sk_sp<SkFontMgr> lastResortMgr);
 
     /**
      *  Given an array of UTF32 character codes, return their corresponding glyph IDs.
@@ -454,21 +420,7 @@ private:
     friend class SkRandomTypeface;   // getAdvancedMetrics
     friend class SkPDFFont;          // getAdvancedMetrics
 
-    /** Style specifies the intrinsic style attributes of a given typeface */
-    enum Style {
-        kNormal = 0,
-        kBold   = 0x01,
-        kItalic = 0x02,
-
-        // helpers
-        kBoldItalic = 0x03
-    };
-    static SkFontStyle FromOldStyle(Style oldStyle);
-    static SkTypeface* GetDefaultTypeface(Style style = SkTypeface::kNormal);
-
-    friend class SkFontPriv;         // GetDefaultTypeface
-    friend class SkPaintPriv;        // GetDefaultTypeface
-    friend class SkFont;             // getGlyphToUnicodeMap
+    friend class SkFontPriv;         // getGlyphToUnicodeMap
 
 private:
     SkTypefaceID        fUniqueID;

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

@@ -86,6 +86,14 @@
     #define SK_GAMMA_EXPONENT (0.0f)  // SRGB
 #endif
 
+#if !defined(SK_GAMMA_CONTRAST)
+    // A value of 0.5 for SK_GAMMA_CONTRAST appears to be a good compromise.
+    // With lower values small text appears washed out (though correctly so).
+    // With higher values lcd fringing is worse and the smoothing effect of
+    // partial coverage is diminished.
+    #define SK_GAMMA_CONTRAST (0.5f)
+#endif
+
 #if defined(SK_HISTOGRAM_ENUMERATION)  || \
     defined(SK_HISTOGRAM_BOOLEAN)      || \
     defined(SK_HISTOGRAM_EXACT_LINEAR) || \

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

@@ -61,7 +61,7 @@ public:
         kHasTexCoords_BuilderFlag   = 1 << 0,
         kHasColors_BuilderFlag      = 1 << 1,
     };
-    class Builder {
+    class SK_API Builder {
     public:
         Builder(VertexMode mode, int vertexCount, int indexCount, uint32_t flags);
 

package/cpp/skia/include/docs/SkMultiPictureDocument.h

@@ -0,0 +1,53 @@
+/*
+ * 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 SkMultiPictureDocument_DEFINED
+#define SkMultiPictureDocument_DEFINED
+
+#include "include/core/SkPicture.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+
+#include <functional>
+
+class SkDocument;
+class SkStreamSeekable;
+class SkWStream;
+struct SkDeserialProcs;
+struct SkSerialProcs;
+
+struct SkDocumentPage {
+    sk_sp<SkPicture> fPicture;
+    SkSize fSize;
+};
+
+namespace SkMultiPictureDocument {
+/**
+ *  Writes into a file format that is similar to SkPicture::serialize()
+ *  Accepts a callback for endPage behavior
+ */
+SK_API sk_sp<SkDocument> Make(SkWStream* dst, const SkSerialProcs* = nullptr,
+                              std::function<void(const SkPicture*)> onEndPage = nullptr);
+
+/**
+ *  Returns the number of pages in the SkMultiPictureDocument.
+ */
+SK_API int ReadPageCount(SkStreamSeekable* src);
+
+/**
+ *  Read the SkMultiPictureDocument into the provided array of pages.
+ *  dstArrayCount must equal SkMultiPictureDocumentReadPageCount().
+ *  Return false on error.
+ */
+SK_API bool Read(SkStreamSeekable* src,
+                 SkDocumentPage* dstArray,
+                 int dstArrayCount,
+                 const SkDeserialProcs* = nullptr);
+}  // namespace SkMultiPictureDocument
+
+#endif  // SkMultiPictureDocument_DEFINED

package/cpp/skia/include/docs/SkPDFDocument.h

@@ -117,6 +117,12 @@ struct Metadata {
     */
     DateTime fModified = {0, 0, 0, 0, 0, 0, 0, 0};
 
+    /** The natural language of the text in the PDF. If fLang is empty, the root
+        StructureElementNode::fLang will be used (if not empty). Text not in
+        this language should be marked with StructureElementNode::fLang.
+    */
+    SkString fLang;
+
     /** The DPI (pixels-per-inch) at which features without native PDF support
         will be rasterized (e.g. draw image with perspective, draw text with
         perspective, ...)  A larger DPI would create a PDF that reflects the
@@ -145,6 +151,11 @@ struct Metadata {
     */
     StructureElementNode* fStructureElementTreeRoot = nullptr;
 
+    enum class Outline : int {
+        None = 0,
+        StructureElementHeaders = 1,
+    } fOutline = Outline::None;
+
     /** Executor to handle threaded work within PDF Backend. If this is nullptr,
         then all work will be done serially on the main thread. To have worker
         threads assist with various tasks, set this to a valid SkExecutor

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

@@ -79,8 +79,17 @@ public:
             kSRGBLinear,
             kLab,
             kOKLab,
+            // This is the same as kOKLab, except it has a simplified version of the CSS gamut
+            // mapping algorithm (https://www.w3.org/TR/css-color-4/#css-gamut-mapping)
+            // into Rec2020 space applied to it.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLabGamutMap,
             kLCH,
             kOKLCH,
+            // This is the same as kOKLCH, except it has the same gamut mapping applied to it
+            // as kOKLabGamutMap does.
+            // Warning: This space is experimental and should not be used in production.
+            kOKLCHGamutMap,
             kSRGB,
             kHSL,
             kHWB,

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

@@ -59,7 +59,7 @@ class Program;
 class SK_API SkRuntimeEffect : public SkRefCnt {
 public:
     // Reflected description of a uniform variable in the effect's SkSL
-    struct Uniform {
+    struct SK_API Uniform {
         enum class Type {
             kFloat,
             kFloat2,
@@ -180,7 +180,7 @@ public:
     }
 
     // Object that allows passing a SkShader, SkColorFilter or SkBlender as a child
-    class ChildPtr {
+    class SK_API ChildPtr {
     public:
         ChildPtr() = default;
         ChildPtr(sk_sp<SkShader> s) : fChild(std::move(s)) {}
@@ -305,11 +305,7 @@ private:
 
     const SkSL::RP::Program* getRPProgram(SkSL::DebugTracePriv* debugTrace) const;
 
-#if defined(SK_GANESH)
-    friend class GrSkSLFP;             // fBaseProgram, fSampleUsages
-    friend class GrGLSLSkSLFP;         //
-#endif
-
+    friend class GrSkSLFP;              // usesColorTransform
     friend class SkRuntimeShader;       // fBaseProgram, fMain, fSampleUsages, getRPProgram()
     friend class SkRuntimeBlender;      //
     friend class SkRuntimeColorFilter;  //

package/cpp/skia/include/gpu/GrBackendSemaphore.h

@@ -8,60 +8,41 @@
 #ifndef GrBackendSemaphore_DEFINED
 #define GrBackendSemaphore_DEFINED
 
-#include "include/gpu/GrTypes.h"
-
-#include "include/gpu/gl/GrGLTypes.h"
+#include "include/gpu/GrTypes.h"  // IWYU pragma: keep
+#include "include/private/base/SkAPI.h"
+#include "include/private/base/SkAnySubclass.h"
 
 #ifdef SK_METAL
 #include "include/gpu/mtl/GrMtlTypes.h"
 #endif
 
-#ifdef SK_VULKAN
-#include "include/gpu/vk/GrVkTypes.h"
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_BACKENDSEMAPHORE)
+#include "include/private/gpu/vk/SkiaVulkan.h"
 #endif
 
 #ifdef SK_DIRECT3D
 #include "include/private/gpu/ganesh/GrD3DTypesMinimal.h"
 #endif
 
+#include <cstddef>
+
+class GrBackendSemaphoreData;
+
 /**
  * Wrapper class for passing into and receiving data from Ganesh about a backend semaphore object.
  */
-class GrBackendSemaphore {
+class SK_API GrBackendSemaphore {
 public:
-    // For convenience we just set the backend here to OpenGL. The GrBackendSemaphore cannot be used
-    // until either init* is called, which will set the appropriate GrBackend.
-    GrBackendSemaphore()
-            : fBackend(GrBackendApi::kOpenGL), fGLSync(nullptr), fIsInitialized(false) {}
-
-#ifdef SK_DIRECT3D
-    // We only need to specify these if Direct3D is enabled, because it requires special copy
-    // characteristics.
+    // The GrBackendSemaphore cannot be used until either init* is called, which will set the
+    // appropriate GrBackend.
+    GrBackendSemaphore();
     ~GrBackendSemaphore();
     GrBackendSemaphore(const GrBackendSemaphore&);
     GrBackendSemaphore& operator=(const GrBackendSemaphore&);
-#endif
-
-    void initGL(GrGLsync sync) {
-        fBackend = GrBackendApi::kOpenGL;
-        fGLSync = sync;
-        fIsInitialized = true;
-    }
-
-#ifdef SK_VULKAN
-    void initVulkan(VkSemaphore semaphore) {
-        fBackend = GrBackendApi::kVulkan;
-        fVkSemaphore = semaphore;
-
-        fIsInitialized = true;
-    }
 
-    VkSemaphore vkSemaphore() const {
-        if (!fIsInitialized || GrBackendApi::kVulkan != fBackend) {
-            return VK_NULL_HANDLE;
-        }
-        return fVkSemaphore;
-    }
+#if defined(SK_VULKAN) && !defined(SK_DISABLE_LEGACY_VULKAN_BACKENDSEMAPHORE)
+    void initVulkan(VkSemaphore semaphore);
+    VkSemaphore vkSemaphore() const;
 #endif
 
 #ifdef SK_METAL
@@ -100,30 +81,35 @@ public:
 #endif
 
     bool isInitialized() const { return fIsInitialized; }
-
-    GrGLsync glSync() const {
-        if (!fIsInitialized || GrBackendApi::kOpenGL != fBackend) {
-            return nullptr;
-        }
-        return fGLSync;
-    }
-
+    GrBackendApi backend() const { return fBackend; }
 
 #ifdef SK_DIRECT3D
     bool getD3DFenceInfo(GrD3DFenceInfo* outInfo) const;
 #endif
 
 private:
+    friend class GrBackendSemaphorePriv;
+    friend class GrBackendSemaphoreData;
+    // Size determined by looking at the GrBackendSemaphoreData subclasses, then
+    // guessing-and-checking. Compiler will complain if this is too small - in that case,
+    // just increase the number.
+    inline constexpr static size_t kMaxSubclassSize = 16;
+    using AnySemaphoreData = SkAnySubclass<GrBackendSemaphoreData, kMaxSubclassSize>;
+
+    template <typename SemaphoreData>
+    GrBackendSemaphore(GrBackendApi api, SemaphoreData data) : fBackend(api), fIsInitialized(true) {
+        fSemaphoreData.emplace<SemaphoreData>(data);
+    }
+
 #ifdef SK_DIRECT3D
     void assignD3DFenceInfo(const GrD3DFenceInfo& info);
 #endif
 
     GrBackendApi fBackend;
+    AnySemaphoreData fSemaphoreData;
+
     union {
-        GrGLsync    fGLSync;
-#ifdef SK_VULKAN
-        VkSemaphore fVkSemaphore;
-#endif
+        void* fPlaceholder;  // TODO(293490566)
 #ifdef SK_METAL
         GrMTLHandle fMtlEvent;    // Expected to be an id<MTLEvent>
 #endif

package/cpp/skia/include/gpu/GrBackendSurface.h

@@ -25,7 +25,6 @@ class GrBackendRenderTargetData;
 
 namespace skgpu {
 class MutableTextureState;
-class MutableTextureStateRef;
 }
 
 #ifdef SK_METAL
@@ -290,7 +289,7 @@ private:
     }
 
     friend class GrVkGpu;  // for getMutableState
-    sk_sp<skgpu::MutableTextureStateRef> getMutableState() const;
+    sk_sp<skgpu::MutableTextureState> getMutableState() const;
 
 #ifdef SK_DIRECT3D
     friend class GrD3DTexture;
@@ -433,7 +432,7 @@ private:
     }
 
     friend class GrVkGpu; // for getMutableState
-    sk_sp<skgpu::MutableTextureStateRef> getMutableState() const;
+    sk_sp<skgpu::MutableTextureState> getMutableState() const;
 
 #ifdef SK_DIRECT3D
     friend class GrD3DGpu;

package/cpp/skia/include/gpu/GrContextOptions.h

@@ -20,7 +20,6 @@
 
 class SkExecutor;
 
-#if defined(SK_GANESH)
 struct SK_API GrContextOptions {
     enum class Enable {
         /** Forces an option to be disabled. */
@@ -371,10 +370,5 @@ struct SK_API GrContextOptions {
 
     GrDriverBugWorkarounds fDriverBugWorkarounds;
 };
-#else
-struct GrContextOptions {
-    struct PersistentCache {};
-};
-#endif
 
 #endif

package/cpp/skia/include/gpu/GrContextThreadSafeProxy.h

@@ -8,11 +8,8 @@
 #ifndef GrContextThreadSafeProxy_DEFINED
 #define GrContextThreadSafeProxy_DEFINED
 
-#include "include/core/SkRefCnt.h"
-
-#if defined(SK_GANESH)
-
 #include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
 #include "include/gpu/GpuTypes.h"
 #include "include/gpu/GrContextOptions.h"
 #include "include/gpu/GrTypes.h"
@@ -34,9 +31,9 @@ namespace sktext::gpu { class TextBlobRedrawCoordinator; }
  * Can be used to perform actions related to the generating GrContext in a thread safe manner. The
  * proxy does not access the 3D API (e.g. OpenGL) that backs the generating GrContext.
  */
-class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {
+class SK_API GrContextThreadSafeProxy : public SkNVRefCnt<GrContextThreadSafeProxy> {
 public:
-    ~GrContextThreadSafeProxy();
+    virtual ~GrContextThreadSafeProxy();
 
     /**
      *  Create a surface characterization for a DDL that will be replayed into the GrContext
@@ -68,7 +65,7 @@ public:
      *  @param surfaceProps                    The surface properties of the SkSurface that the DDL
      *                                         created with this characterization will be replayed
      *                                         into
-     *  @param isMipMapped                     Will the surface the DDL will be replayed into have
+     *  @param isMipmapped                     Will the surface the DDL will be replayed into have
      *                                         space allocated for mipmaps?
      *  @param willUseGLFBO0                   Will the surface the DDL will be replayed into be
      *                                         backed by GL FBO 0. This flag is only valid if using
@@ -81,24 +78,39 @@ public:
      *                                         command buffer via a GrVkSecondaryCBDrawContext? If
      *                                         this is true then the following is required:
      *                                         isTexureable = false
-     *                                         isMipMapped = false
+     *                                         isMipmapped = false
      *                                         willUseGLFBO0 = false
      *                                         vkRTSupportsInputAttachment = false
      */
     GrSurfaceCharacterization createCharacterization(
-                                  size_t cacheMaxResourceBytes,
-                                  const SkImageInfo& ii,
-                                  const GrBackendFormat& backendFormat,
-                                  int sampleCount,
-                                  GrSurfaceOrigin origin,
-                                  const SkSurfaceProps& surfaceProps,
-                                  bool isMipMapped,
-                                  bool willUseGLFBO0 = false,
-                                  bool isTextureable = true,
-                                  GrProtected isProtected = GrProtected::kNo,
-                                  bool vkRTSupportsInputAttachment = false,
-                                  bool forVulkanSecondaryCommandBuffer = false);
-
+            size_t cacheMaxResourceBytes,
+            const SkImageInfo& ii,
+            const GrBackendFormat& backendFormat,
+            int sampleCount,
+            GrSurfaceOrigin origin,
+            const SkSurfaceProps& surfaceProps,
+            skgpu::Mipmapped isMipmapped,
+            bool willUseGLFBO0 = false,
+            bool isTextureable = true,
+            skgpu::Protected isProtected = GrProtected::kNo,
+            bool vkRTSupportsInputAttachment = false,
+            bool forVulkanSecondaryCommandBuffer = false);
+
+#if !defined(SK_DISABLE_LEGACY_CREATE_CHARACTERIZATION)
+    GrSurfaceCharacterization createCharacterization(
+            size_t cacheMaxResourceBytes,
+            const SkImageInfo& ii,
+            const GrBackendFormat& backendFormat,
+            int sampleCount,
+            GrSurfaceOrigin origin,
+            const SkSurfaceProps& surfaceProps,
+            bool isMipmapped,
+            bool willUseGLFBO0 = false,
+            bool isTextureable = true,
+            skgpu::Protected isProtected = GrProtected::kNo,
+            bool vkRTSupportsInputAttachment = false,
+            bool forVulkanSecondaryCommandBuffer = false);
+#endif
     /*
      * Retrieve the default GrBackendFormat for a given SkColorType and renderability.
      * It is guaranteed that this backend format will be the one used by the following
@@ -138,12 +150,13 @@ public:
     GrContextThreadSafeProxyPriv priv();
     const GrContextThreadSafeProxyPriv priv() const;  // NOLINT(readability-const-return-type)
 
-private:
-    friend class GrContextThreadSafeProxyPriv; // for ctor and hidden methods
-
+protected:
     // DDL TODO: need to add unit tests for backend & maybe options
     GrContextThreadSafeProxy(GrBackendApi, const GrContextOptions&);
 
+private:
+    friend class GrContextThreadSafeProxyPriv;  // for ctor and hidden methods
+
     void abandonContext();
     bool abandoned() const;
 
@@ -152,6 +165,13 @@ private:
     // `init` method on GrContext_Base).
     void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);
 
+    virtual bool isValidCharacterizationForVulkan(sk_sp<const GrCaps>,
+                                                  bool isTextureable,
+                                                  skgpu::Mipmapped isMipmapped,
+                                                  skgpu::Protected isProtected,
+                                                  bool vkRTSupportsInputAttachment,
+                                                  bool forVulkanSecondaryCommandBuffer);
+
     const GrBackendApi                                      fBackend;
     const GrContextOptions                                  fOptions;
     const uint32_t                                          fContextID;
@@ -162,8 +182,4 @@ private:
     std::atomic<bool>                                       fAbandoned{false};
 };
 
-#else // !defined(SK_GANESH)
-class SK_API GrContextThreadSafeProxy final : public SkNVRefCnt<GrContextThreadSafeProxy> {};
-#endif
-
 #endif

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

@@ -41,9 +41,7 @@ class SkTaskGroup;
 class SkTraceMemoryDump;
 enum SkColorType : int;
 enum class SkTextureCompressionType;
-struct GrGLInterface;
 struct GrMockOptions;
-struct GrVkBackendContext; // IWYU pragma: keep
 struct GrD3DBackendContext; // IWYU pragma: keep
 struct GrMtlBackendContext; // IWYU pragma: keep
 
@@ -62,28 +60,6 @@ enum class BackendSurfaceAccess;
 
 class SK_API GrDirectContext : public GrRecordingContext {
 public:
-#if defined(SK_GL) && !defined(SK_DISABLE_LEGACY_GL_GRDIRECTCONTEXT_FACTORIES)
-    /**
-     * Creates a GrDirectContext for a backend context. If no GrGLInterface is provided then the
-     * result of GrGLMakeNativeInterface() is used if it succeeds.
-     */
-    static sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>, const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeGL(sk_sp<const GrGLInterface>);
-    static sk_sp<GrDirectContext> MakeGL(const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeGL();
-#endif
-
-#ifdef SK_VULKAN
-    /**
-     * The Vulkan context (VkQueue, VkDevice, VkInstance) must be kept alive until the returned
-     * GrDirectContext is destroyed. This also means that any objects created with this
-     * GrDirectContext (e.g. SkSurfaces, SkImages, etc.) must also be released as they may hold
-     * refs on the GrDirectContext. Once all these objects and the GrDirectContext are released,
-     * then it is safe to delete the vulkan objects.
-     */
-    static sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&, const GrContextOptions&);
-    static sk_sp<GrDirectContext> MakeVulkan(const GrVkBackendContext&);
-#endif
 
 #ifdef SK_METAL
     /**
@@ -357,14 +333,17 @@ public:
 
     /**
      * Inserts a list of GPU semaphores that the current GPU-backed API must wait on before
-     * executing any more commands on the GPU. If this call returns false, then the GPU back-end
-     * will not wait on any passed in semaphores, and the client will still own the semaphores,
-     * regardless of the value of deleteSemaphoresAfterWait.
+     * executing any more commands on the GPU. We only guarantee blocking transfer and fragment
+     * shader work, but may block earlier stages as well depending on the backend.If this call
+     * returns false, then the GPU back-end will not wait on any passed in semaphores, and the
+     * client will still own the semaphores, regardless of the value of deleteSemaphoresAfterWait.
      *
      * If deleteSemaphoresAfterWait is false then Skia will not delete the semaphores. In this case
      * it is the client's responsibility to not destroy or attempt to reuse the semaphores until it
      * knows that Skia has finished waiting on them. This can be done by using finishedProcs on
      * flush calls.
+     *
+     * This is not supported on the GL backend.
      */
     bool wait(int numSemaphores, const GrBackendSemaphore* waitSemaphores,
               bool deleteSemaphoresAfterWait = true);
@@ -416,13 +395,13 @@ public:
      *  @param image    the non-null image to flush.
      *  @param info     flush options
      */
-    GrSemaphoresSubmitted flush(sk_sp<const SkImage> image, const GrFlushInfo& info);
-    void flush(sk_sp<const SkImage> image);
+    GrSemaphoresSubmitted flush(const sk_sp<const SkImage>& image, const GrFlushInfo& info);
+    void flush(const sk_sp<const SkImage>& image);
 
     /** Version of flush() that uses a default GrFlushInfo. Also submits the flushed work to the
      *   GPU.
      */
-    void flushAndSubmit(sk_sp<const SkImage> image);
+    void flushAndSubmit(const sk_sp<const SkImage>& image);
 
     /** 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
@@ -952,7 +931,9 @@ public:
     const GrDirectContextPriv priv() const;  // NOLINT(readability-const-return-type)
 
 protected:
-    GrDirectContext(GrBackendApi backend, const GrContextOptions& options);
+    GrDirectContext(GrBackendApi backend,
+                    const GrContextOptions& options,
+                    sk_sp<GrContextThreadSafeProxy> proxy);
 
     bool init() override;