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

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.

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

@@ -266,8 +266,7 @@ enum DrawTypeFlags : uint16_t {
 
     // kDrawVertices should be used to generate Pipelines that use the following RenderSteps:
     //    VerticesRenderStep[*] for:
-    //        [Tris], [TrisTexCoords], [TrisColor], [TrisColorTexCoords],
-    //        [Tristrips], [TristripsTexCoords], [TristripsColor], [TristripsColorTexCoords]
+    //        [Pos], [PosTexCoords], [PosColor], [PosColorTexCoords],
     kDrawVertices     = 1 << 5,
 
     // kCircularArc renders filled circular arcs, with or without the center included, and
@@ -297,7 +296,7 @@ enum DrawTypeFlags : uint16_t {
     // This draw type covers all the methods Skia uses to draw drop shadows. It can be used to
     // generate Pipelines which, as part of their labels, have:
     //     the AnalyticBlurRenderStep
-    //     VerticesRenderStep[TrisColor] with a GaussianColorFilter
+    //     VerticesRenderStep[PosColor] with a GaussianColorFilter
     // For this draw type the PaintOptions parameter to Precompile() will be ignored.
     kDropShadows      = 1 << 11,
 
@@ -307,7 +306,9 @@ enum DrawTypeFlags : uint16_t {
     //    AnalyticAndAtlasClip
     kAnalyticClip     = 1 << 12,
 
-    kLast = kAnalyticClip,
+    kDrawMesh         = 1 << 13,
+
+    kLast = kDrawMesh,
 };
 
 } // namespace skgpu::graphite

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

@@ -24,6 +24,14 @@ class SharedContext;
 class PrecompileContextPriv;
 class ResourceProvider;
 
+// The PrecompileContext is spawned from a generating Context via Context::makePrecompileContext.
+// It should only be used on a single thread but that can be different from the main thread (i.e.,
+// the one the Context is operating on). Many PrecompileContext's can be operating in parallel
+// but the majority of the benefit will be from the threaded compilation within the
+// PrecompileContext. As for that, the PipelineContext(s) borrow(s) the Executor from the
+// generating Context. To make lifetime management of the Executor reasonable, if the
+// Context is deleted before its PrecompileContexts, the PrecompileContexts will lose access
+// to the Executor and revert to single threaded compilation.
 class SK_API PrecompileContext {
 public:
     ~PrecompileContext();
@@ -99,9 +107,9 @@ private:
 
     explicit PrecompileContext(sk_sp<SharedContext>);
 
+    // The PrecompileContext should not be used on multiple threads
     mutable SingleOwner fSingleOwner;
     sk_sp<SharedContext> fSharedContext;
-    std::unique_ptr<ResourceProvider> fResourceProvider;
 };
 
 }  // namespace skgpu::graphite

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

@@ -52,7 +52,6 @@ class BackendTexture;
 class Context;
 class Device;
 class DrawBufferManager;
-class StorageBufferManager;
 class ImageProvider;
 class PaintParamsKeyBuilder;
 class PipelineDataGatherer;
@@ -299,7 +298,6 @@ private:
     std::unique_ptr<UploadBufferManager> fUploadBufferManager;
     // Depends on fUploadBufferManager (holds a pointer to it). Must be destroyed first.
     std::unique_ptr<DrawBufferManager> fDrawBufferManager;
-    sk_sp<StorageBufferManager> fStorageBufferManager;
     std::unique_ptr<ProxyReadCountMap> fProxyReadCounts;
 
     skia_private::STArray<kMaxKeyAndDataBuilders, std::unique_ptr<KeyAndDataBuilder>>

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

@@ -18,6 +18,7 @@
 #include <vector>
 
 struct SkISize;
+class SkPicture;
 
 namespace skgpu {
 class RefCntedCallback;
@@ -93,6 +94,8 @@ private:
     std::unique_ptr<LazyProxyData> fTargetProxyData;
 
     skia_private::TArray<sk_sp<RefCntedCallback>> fFinishedProcs;
+
+    skia_private::TArray<sk_sp<SkPicture>> fCapturedPictures;
 };
 
 } // namespace skgpu::graphite

package/cpp/skia/include/gpu/graphite/dawn/DawnBackendContext.h

@@ -13,6 +13,9 @@
 
 #include <memory>
 
+class SkContext;
+struct SkContextOptions;
+
 namespace skgpu::graphite {
 
 class Context;
@@ -74,4 +77,9 @@ SK_API std::unique_ptr<Context> MakeDawn(const DawnBackendContext&, const Contex
 
 } // namespace skgpu::graphite
 
+namespace SkContexts {
+std::unique_ptr<SkContext> MakeGraphite(const skgpu::graphite::DawnBackendContext& dawnContext,
+                                        const SkContextOptions& options);
+}  // namespace SkContexts
+
 #endif // skgpu_graphite_DawnBackendContext_DEFINED

package/cpp/skia/include/gpu/graphite/mtl/MtlBackendContext.h

@@ -15,6 +15,9 @@
 #import <CoreFoundation/CoreFoundation.h>
 #include <memory>
 
+class SkContext;
+struct SkContextOptions;
+
 namespace skgpu::graphite {
 
 // The MtlBackendContext contains all of the base Metal objects needed by the graphite Metal
@@ -31,4 +34,12 @@ SK_API std::unique_ptr<Context> MakeMetal(const MtlBackendContext&, const Contex
 
 } // namespace skgpu::graphite
 
+namespace SkContexts {
+
+// Creates a context wrapping a Graphite GPU backend using Metal
+std::unique_ptr<SkContext> MakeGraphite(const skgpu::graphite::MtlBackendContext& mtlContext,
+                              const SkContextOptions& options);
+
+}  // namespace SkContexts
+
 #endif // skgpu_graphite_MtlBackendContext_DEFINED

package/cpp/skia/include/gpu/graphite/vk/VulkanGraphiteContext.h

@@ -12,6 +12,9 @@
 
 #include "include/private/SkAPI.h"
 
+struct SkContextOptions;
+class SkContext;
+
 // NOTE: Because there is already a VulkanBackendContext header shared between Ganesh and Graphite,
 // this is named VulkanGraphiteContext.h to supply just the factory function (differing from the
 // public headers exposed by other backends).
@@ -28,4 +31,12 @@ SK_API std::unique_ptr<Context> MakeVulkan(const VulkanBackendContext&, const Co
 
 } // namespace skgpu::graphite
 
+namespace SkContexts {
+
+// Creates a context wrapping a Graphite GPU backend with Vulkan
+std::unique_ptr<SkContext> MakeGraphite(const skgpu::VulkanBackendContext& vkContext,
+                            const SkContextOptions& options);
+
+}  // namespace SkContexts
+
 #endif // skgpu_graphite_VulkanGraphiteUtils_DEFINED

package/cpp/skia/include/private/SkLog.h

@@ -16,29 +16,11 @@
 #include "include/private/SkLogPriority.h"
 
 #if !defined(SkLog)
-// To be implemented per platform.
+// Implemented per platform.
 void SkLogVAList(SkLogPriority priority, const char format[], va_list args) SK_PRINTF_LIKE(2, 0);
 void SK_SPI SkLog(SkLogPriority priority, const char format[], ...) SK_PRINTF_LIKE(2, 3);
 #endif
 
-/**
- * TODO (b/469441457): SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY Was the config used to set the log
- * priority, so we check for that define as well. Eventually, we should move clients using this
- * define to the new one.
- */
-#if defined(SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY)
-    static constexpr SkLogPriority MapGraphitePriority(skgpu::graphite::LogPriority priority) {
-        switch (priority) {
-            case skgpu::graphite::LogPriority::kError:   return SkLogPriority::kError;
-            case skgpu::graphite::LogPriority::kWarning: return SkLogPriority::kWarning;
-            case skgpu::graphite::LogPriority::kInfo:    return SkLogPriority::kInfo;
-            case skgpu::graphite::LogPriority::kDebug:   return SkLogPriority::kDebug;
-            default: return SkLogPriority::kDebug;
-        }
-    }
-    #define SKIA_LOWEST_ACTIVE_LOG_PRIORITY MapGraphitePriority(SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY)
-#endif
-
 #if !defined(SKIA_LOWEST_ACTIVE_LOG_PRIORITY)
 #ifdef SK_DEBUG
     #define SKIA_LOWEST_ACTIVE_LOG_PRIORITY SkLogPriority::kDebug

package/cpp/skia/include/private/chromium/GrVkSecondaryCBDrawContext.h

@@ -11,6 +11,7 @@
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTypes.h"
+#include "include/gpu/ganesh/GrDirectContext.h"
 
 #include <memory>
 
@@ -72,7 +73,7 @@ public:
 
     // Records all the draws to the imported secondary command buffer and sets any dependent
     // offscreen draws to the GPU.
-    void flush();
+    GrDirectContext::FlushResult flush();
 
     /** Inserts a list of GPU semaphores that Skia will have the driver wait on before executing
         commands for this secondary CB. The wait semaphores will get added to the VkCommandBuffer

package/cpp/skia/include/utils/SkLogHandler.h

@@ -0,0 +1,53 @@
+/*
+ * 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 SkLogHandler_DEFINED
+#define SkLogHandler_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkLogPriority.h"
+
+#include <cstdarg>
+
+/**
+ * SkLogHandler defines an interface for receiving Skia log messages.
+ * Clients can implement this interface and install it via SetInstance.
+ */
+class SK_API SkLogHandler : public SkRefCnt {
+public:
+    ~SkLogHandler() override = default;
+
+    /**
+     * Called when a log message is generated (must pass compile-time priority).
+     * Must be thread-safe since multiple threads may be logging at the same time.
+     * @param priority The priority of the log message.
+     * @param format   The format string of the log message.
+     * @param args     The arguments for the format string.
+     */
+    virtual void onLog(SkLogPriority priority, const char format[], va_list args) = 0;
+
+    /**
+     * Installs a custom log handler. Returns true if successful (i.e., it's the first call).
+     * Skia only allows one SkLogHandler to be set and it cannot change after being set.
+     */
+    static bool SetInstance(sk_sp<SkLogHandler>);
+
+    /**
+     * Returns the current log handler. If none has been set, returns nullptr.
+     */
+    static sk_sp<SkLogHandler> GetInstance();
+
+protected:
+    SkLogHandler() = default;
+
+private:
+    SkLogHandler(const SkLogHandler&) = delete;
+    SkLogHandler& operator=(const SkLogHandler&) = delete;
+};
+
+#endif // SkLogHandler_DEFINED

package/cpp/skia/include/utils/SkNWayCanvas.h

@@ -95,6 +95,7 @@ protected:
                              const SkPaint*) override;
     void onDrawAtlas2(const SkImage*, const SkRSXform[], const SkRect[], const SkColor[], int,
                   SkBlendMode, const SkSamplingOptions&, const SkRect*, const SkPaint*) override;
+    void onDrawMesh(const SkMesh&, sk_sp<SkBlender>, const SkPaint&) override;
 
     void onDrawVerticesObject(const SkVertices*, SkBlendMode, const SkPaint&) override;
     void onDrawShadowRec(const SkPath&, const SkDrawShadowRec&) override;

package/cpp/skia/modules/skcms/src/Transform_inl.h

@@ -1113,11 +1113,9 @@ STAGE(unpremul, NoCtx) {
 }
 
 STAGE(matrix_3x3, const skcms_Matrix3x3* matrix) {
-    const float* m = &matrix->vals[0][0];
-
-    F R = m[0]*r + m[1]*g + m[2]*b,
-      G = m[3]*r + m[4]*g + m[5]*b,
-      B = m[6]*r + m[7]*g + m[8]*b;
+    F R = matrix->vals[0][0]*r + matrix->vals[0][1]*g + matrix->vals[0][2]*b,
+      G = matrix->vals[1][0]*r + matrix->vals[1][1]*g + matrix->vals[1][2]*b,
+      B = matrix->vals[2][0]*r + matrix->vals[2][1]*g + matrix->vals[2][2]*b;
 
     r = R;
     g = G;
@@ -1125,11 +1123,12 @@ STAGE(matrix_3x3, const skcms_Matrix3x3* matrix) {
 }
 
 STAGE(matrix_3x4, const skcms_Matrix3x4* matrix) {
-    const float* m = &matrix->vals[0][0];
-
-    F R = m[0]*r + m[1]*g + m[ 2]*b + m[ 3],
-      G = m[4]*r + m[5]*g + m[ 6]*b + m[ 7],
-      B = m[8]*r + m[9]*g + m[10]*b + m[11];
+    F R = matrix->vals[0][0]*r + matrix->vals[0][1]*g + matrix->vals[0][2]*b
+        + matrix->vals[0][3],
+      G = matrix->vals[1][0]*r + matrix->vals[1][1]*g + matrix->vals[1][2]*b
+        + matrix->vals[1][3],
+      B = matrix->vals[2][0]*r + matrix->vals[2][1]*g + matrix->vals[2][2]*b
+        + matrix->vals[2][3];
 
     r = R;
     g = G;

package/cpp/skia/modules/skcms/src/skcms_internals.h

@@ -57,9 +57,14 @@ extern "C" {
             #define SKCMS_HAS_MUSTTAIL 1
         #endif
     #elif defined(__GNUC__) && !defined(SKCMS_HAS_MUSTTAIL)
-        // GCC on riscv64 does not support our tail call functions
-        // cf. https://gcc.gnu.org/bugzilla/show_bug.cgi?id=121784
-        #if __has_cpp_attribute(clang::musttail) && !defined(__riscv)
+        // GCC on RISCV, MIPS, PowerPC, LoongArch, and Windows (MinGW)
+        // does not support our tail call functions
+        // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=121784).
+        #if __has_cpp_attribute(clang::musttail) && !defined(__riscv) \
+                                                 && !defined(__mips__) \
+                                                 && !defined(__powerpc__) \
+                                                 && !defined(__loongarch__) \
+                                                 && !defined(_WIN32)
             #define SKCMS_HAS_MUSTTAIL 1
         #else
             #define SKCMS_HAS_MUSTTAIL 0