@shopify/react-native-skia 2.0.0-next.1 → 2.0.0-next.3

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

@@ -8,11 +8,13 @@
 #ifndef skgpu_graphite_ContextOptions_DEFINED
 #define skgpu_graphite_ContextOptions_DEFINED
 
+#include "include/core/SkRefCnt.h"
 #include "include/private/base/SkAPI.h"
 #include "include/private/base/SkMath.h"
 
 #include <optional>
 
+class SkData;
 namespace skgpu { class ShaderErrorHandler; }
 
 namespace skgpu::graphite {
@@ -85,12 +87,12 @@ struct SK_API ContextOptions {
     bool fSupportBilerpFromGlyphAtlas = false;
 
     /**
-     * Disable caching of glyph uploads at the start of each Recording. These can add additional
-     * overhead and are only necessary if Recordings are replayed or played out of order.
-     *
-     * Deprecated, now only used to set requireOrderedRecordings Caps.
+     * For the moment, if Recordings are replayed in the order they are recorded, then
+     * Graphite can make certain assumptions that allow for better performance. Otherwise
+     * we have to flush some caches at the start of each Recording to ensure that they can
+     * be played back properly.
      */
-    bool fDisableCachedGlyphUploads = false;
+    bool fRequireOrderedRecordings = false;
 
     static constexpr size_t kDefaultContextBudget = 256 * (1 << 20);
     /**
@@ -118,6 +120,22 @@ struct SK_API ContextOptions {
      */
     std::optional<uint64_t> fVulkanVMALargeHeapBlockSize;
 
+    /** Client-provided context that is passed to client-provided PipelineCallback. */
+    using PipelineCallbackContext = void*;
+    /**  Client-provided callback that is called whenever Graphite encounters a new Pipeline. */
+    using PipelineCallback = void (*)(PipelineCallbackContext context, sk_sp<SkData> pipelineData);
+
+    /**
+     *  These two members allow a client to register a callback that will be invoked
+     *  whenever Graphite encounters a new Pipeline. The callback will be passed an
+     *  sk_sp<SkData> that a client can take ownership of and serialize. The SkData
+     *  contains all the information Graphite requires to recreate the Pipeline at
+     *  a later date. The SkData is versioned however, so must be regenerated and
+     *  re-serialized when it becomes out of date.
+     */
+    PipelineCallbackContext fPipelineCallbackContext = nullptr;
+    PipelineCallback fPipelineCallback = nullptr;
+
     /**
      * Private options that are only meant for testing within Skia's tools.
      */

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

@@ -30,13 +30,23 @@ class Task;
 using GpuFinishedContext = void*;
 using GpuFinishedProc = void (*)(GpuFinishedContext finishedContext, CallbackResult);
 
+using GpuFinishedWithStatsProc = void (*)(GpuFinishedContext finishedContext,
+                                          CallbackResult,
+                                          const GpuStats&);
+
 /**
  * The fFinishedProc is called when the Recording has been submitted and finished on the GPU, or
  * when there is a failure that caused it not to be submitted. The callback will always be called
  * and the caller can use the callback to know it is safe to free any resources associated with
  * the Recording that they may be holding onto. If the Recording is successfully submitted to the
  * GPU the callback will be called with CallbackResult::kSuccess once the GPU has finished. All
- * other cases where some failure occured it will be called with CallbackResult::kFailed.
+ * other cases where some failure occurred it will be called with CallbackResult::kFailed.
+ *
+ * Alternatively, the client can provide fFinishedProcWithStats. This provides additional
+ * information about execution of the recording on the GPU. Only the stats requested using
+ * fStatsFlags will be valid and only if CallbackResult is kSuccess. If both fFinishedProc
+ * and fFinishedProcWithStats are provided the latter is preferred and the former won't be
+ * called.
  *
  * The fTargetSurface, if provided, is used as a target for any draws recorded onto a deferred
  * canvas returned from Recorder::makeDeferredCanvas. This target surface must be provided iff
@@ -74,8 +84,10 @@ struct InsertRecordingInfo {
     size_t fNumSignalSemaphores = 0;
     BackendSemaphore* fSignalSemaphores = nullptr;
 
+    GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone;
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
+    GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
 };
 
 /**
@@ -87,8 +99,15 @@ struct InsertRecordingInfo {
  * other cases where some failure occured it will be called with CallbackResult::kFailed.
  */
 struct InsertFinishInfo {
+    InsertFinishInfo() = default;
+    InsertFinishInfo(GpuFinishedContext context, GpuFinishedProc proc)
+            : fFinishedContext{context}, fFinishedProc{proc} {}
+    InsertFinishInfo(GpuFinishedContext context, GpuFinishedWithStatsProc proc)
+            : fFinishedContext{context}, fFinishedWithStatsProc{proc} {}
     GpuFinishedContext fFinishedContext = nullptr;
     GpuFinishedProc fFinishedProc = nullptr;
+    GpuFinishedWithStatsProc fFinishedWithStatsProc = nullptr;
+    GpuStatsFlags fGpuStatsFlags = GpuStatsFlags::kNone;
 };
 
 /**

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

@@ -15,6 +15,7 @@
 #include "include/gpu/GpuTypes.h"
 
 #include <string_view>
+#include <tuple>
 
 class SkYUVAInfo;
 class SkYUVAPixmaps;

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_LogPriority_DEFINED
+#define skgpu_graphite_LogPriority_DEFINED
+
+/**
+ * Note: this file may be included in clients' SkUserConfig.h files, so including any other headers
+ * in this file should be avoided.
+ */
+
+namespace skgpu::graphite {
+/**
+ * SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY can be defined to one of these values (in
+ * SkUserConfig.h) to control Graphite's logging behavior.
+ *
+ * For example:
+ * ```
+ * #define SKGPU_GRAPHITE_LOWEST_ACTIVE_LOG_PRIORITY skgpu::graphite::LogPriority::kWarning
+ * ```
+ * Would cause Graphite to log warnings, non-fatal errors, and fatal errors.
+ * However, debug logs would be omitted.
+ */
+enum class LogPriority : int {
+    kFatal = 0,
+    kError = 1,
+    kWarning = 2,
+    kDebug = 3,
+};
+};  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_LogPriority_DEFINED

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_PrecompileContext_DEFINED
+#define skgpu_graphite_PrecompileContext_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SingleOwner.h"
+
+#include <chrono>
+#include <memory>
+
+namespace skgpu::graphite {
+
+class SharedContext;
+class PrecompileContextPriv;
+class ResourceProvider;
+
+class SK_API PrecompileContext {
+public:
+    ~PrecompileContext();
+
+    /**
+     * Purge Pipelines that haven't been used in the past 'msNotUsed' milliseconds
+     * regardless of whether the pipeline cache is under budget.
+     *
+     * @param msNotUsed   Pipelines not used in these last milliseconds will be cleaned up.
+     */
+    void purgePipelinesNotUsedInMs(std::chrono::milliseconds msNotUsed);
+
+    // Provides access to functions that aren't part of the public API.
+    PrecompileContextPriv priv();
+    const PrecompileContextPriv priv() const;  // NOLINT(readability-const-return-type)
+
+private:
+    friend class PrecompileContextPriv;
+    friend class Context; // for ctor
+
+    PrecompileContext(sk_sp<SharedContext>);
+
+    mutable SingleOwner fSingleOwner;
+    sk_sp<SharedContext> fSharedContext;
+    std::unique_ptr<ResourceProvider> fResourceProvider;
+};
+
+}  // namespace skgpu::graphite
+
+#endif // skgpu_graphite_PrecompileContext_DEFINED

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

@@ -209,6 +209,12 @@ public:
      */
     size_t maxBudgetedBytes() const;
 
+    /**
+     * Sets the size of Recorders's gpu memory cache budget in bytes. If the new budget is lower
+     * than the current budget, the cache will try to free resources to get under the new budget.
+     */
+    void setMaxBudgetedBytes(size_t bytes);
+
     /**
      * Enumerates all cached GPU resources owned by the Recorder and dumps their memory to
      * traceMemoryDump.

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

@@ -9,6 +9,7 @@
 #define skgpu_graphite_Recording_DEFINED
 
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
 #include "include/private/base/SkTArray.h"
 
 #include <memory>
@@ -21,6 +22,7 @@ class RefCntedCallback;
 
 namespace skgpu::graphite {
 
+class Caps;
 class CommandBuffer;
 class RecordingPriv;
 class Resource;
@@ -44,7 +46,7 @@ private:
     // replay, and it handles the target proxy's instantiation with the provided target.
     class LazyProxyData {
     public:
-        LazyProxyData(const TextureInfo&);
+        LazyProxyData(const Caps*, SkISize dimensions, const TextureInfo&);
 
         TextureProxy* lazyProxy();
         sk_sp<TextureProxy> refLazyProxy();

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

@@ -8,27 +8,19 @@
 #ifndef skgpu_graphite_MtlGraphiteTypes_DEFINED
 #define skgpu_graphite_MtlGraphiteTypes_DEFINED
 
+#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
+
 #include "include/core/SkTypes.h"
 
-#if __OBJC__  // <Metal/Metal.h> only works when compiled for Objective C
-#include "include/gpu/graphite/BackendTexture.h"
 #include "include/gpu/graphite/GraphiteTypes.h"
-#include "include/gpu/graphite/TextureInfo.h"
-#include "include/ports/SkCFObject.h"
+#include "include/gpu/graphite/mtl/MtlGraphiteTypesUtils.h"
 #include "include/private/base/SkAPI.h"
 
 #import <CoreFoundation/CoreFoundation.h>
 #import <Metal/Metal.h>
 #import <TargetConditionals.h>
 
-#if TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(13.0), tvos(13.0))
-#else  // TARGET_OS_SIMULATOR
-#define SK_API_AVAILABLE_CA_METAL_LAYER SK_API_AVAILABLE(macos(10.11), ios(8.0), tvos(9.0))
-#endif  // TARGET_OS_SIMULATOR
-
 namespace skgpu::graphite {
-
 struct SK_API MtlTextureInfo {
     uint32_t fSampleCount = 1;
     skgpu::Mipmapped fMipmapped = skgpu::Mipmapped::kNo;
@@ -53,31 +45,7 @@ struct SK_API MtlTextureInfo {
             , fStorageMode(storageMode)
             , fFramebufferOnly(framebufferOnly) {}
 };
-
-namespace TextureInfos {
-SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
-SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
-
-SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
-}  // namespace TextureInfos
-
-namespace BackendTextures {
-// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
-// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
-SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
-
-SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
-}  // namespace BackendTextures
-
-namespace BackendSemaphores {
-// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
-SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
-
-SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
-SK_API uint64_t GetMtlValue(const BackendSemaphore&);
-}  // namespace BackendSemaphores
-
-} // namespace skgpu::graphite
+}  // namespace skgpu::graphite
 
 #endif  // __OBJC__
 

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

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2024 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+#define skgpu_graphite_MtlGraphiteTypesUtils_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#include "include/gpu/graphite/BackendTexture.h"
+#include "include/gpu/graphite/TextureInfo.h"
+#include "include/private/base/SkAPI.h"
+
+#import <CoreFoundation/CoreFoundation.h>
+
+namespace skgpu::graphite {
+
+struct SK_API MtlTextureInfo;
+
+namespace TextureInfos {
+SK_API TextureInfo MakeMetal(const MtlTextureInfo&);
+SK_API TextureInfo MakeMetal(CFTypeRef mtlTexture);
+
+SK_API bool GetMtlTextureInfo(const TextureInfo&, MtlTextureInfo*);
+}  // namespace TextureInfos
+
+namespace BackendTextures {
+// The BackendTexture will not call retain or release on the passed in CFTypeRef. Thus the
+// client must keep the CFTypeRef valid until they are no longer using the BackendTexture.
+SK_API BackendTexture MakeMetal(SkISize dimensions, CFTypeRef mtlTexture);
+
+SK_API CFTypeRef GetMtlTexture(const BackendTexture&);
+}  // namespace BackendTextures
+
+namespace BackendSemaphores {
+// TODO(b/286088355) Determine creator's responsibility for setting refcnt.
+SK_API BackendSemaphore MakeMetal(CFTypeRef mtlEvent, uint64_t value);
+
+SK_API CFTypeRef GetMtlEvent(const BackendSemaphore&);
+SK_API uint64_t GetMtlValue(const BackendSemaphore&);
+}  // namespace BackendSemaphores
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_MtlGraphiteTypesUtils_DEFINED

package/cpp/skia/include/gpu/graphite/precompile/Precompile.h

@@ -15,6 +15,7 @@ namespace skgpu::graphite {
 
 class Context;
 class PaintOptions;
+class PrecompileContext;
 
 /**
  *  Describes the required properties of a RenderPass that will be combined with the
@@ -33,12 +34,12 @@ struct SK_API RenderPassProperties {
  * drawing. Graphite will always be able to perform an inline compilation if some SkPaint
  * combination was omitted from precompilation.
  *
- *   @param context              the Context to which the actual draws will be submitted
+ *   @param precompileContext    thread-safe helper holding required portions of the Context
  *   @param paintOptions         captures a set of SkPaints that will be drawn
  *   @param drawTypes            communicates which primitives those paints will be drawn with
  *   @param renderPassProperties describes the RenderPasses needed for the desired Pipelines
  */
-void SK_API Precompile(Context* context,
+void SK_API Precompile(PrecompileContext* precompileContext,
                        const PaintOptions& paintOptions,
                        DrawTypeFlags drawTypes,
                        SkSpan<const RenderPassProperties> renderPassProperties);

package/cpp/skia/include/pathops/SkPathOps.h

@@ -65,7 +65,15 @@ bool SK_API Simplify(const SkPath& path, SkPath* result);
     @param result The tight bounds of the path.
     @return True if the bounds could be computed.
   */
-bool SK_API TightBounds(const SkPath& path, SkRect* result);
+[[deprecated]]
+static inline bool TightBounds(const SkPath& path, SkRect* result) {
+    auto rect = path.computeTightBounds();
+    if (rect.isFinite()) {
+        *result = rect;
+        return true;
+    }
+    return false;
+}
 
 /** Set the result with fill type winding to area equivalent to path.
     Returns true if successful. Does not detect if path contains contours which

package/cpp/skia/include/ports/SkFontMgr_FontConfigInterface.h

@@ -13,8 +13,11 @@
 
 class SkFontMgr;
 class SkFontConfigInterface;
+class SkFontScanner;
 
 /** Creates a SkFontMgr which wraps a SkFontConfigInterface. */
 SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci);
+SK_API sk_sp<SkFontMgr> SkFontMgr_New_FCI(sk_sp<SkFontConfigInterface> fci,
+                                          std::unique_ptr<SkFontScanner> scanner);
 
 #endif // #ifndef SkFontMgr_FontConfigInterface_DEFINED

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

@@ -28,15 +28,6 @@
 class SkMatrix;
 class SkRRect;
 
-// These are computed from a stream of verbs
-struct SkPathVerbAnalysis {
-    bool     valid;
-    int      points, weights;
-    unsigned segmentMask;
-};
-SkPathVerbAnalysis sk_path_analyze_verbs(const uint8_t verbs[], int count);
-
-
 /**
  * Holds the path verbs and points. It is versioned by a generation ID. None of its public methods
  * modify the contents. To modify or append to the verbs/points wrap the SkPathRef in an
@@ -541,7 +532,12 @@ private:
 
     void callGenIDChangeListeners();
 
+    PointsArray fPoints;
+    VerbsArray fVerbs;
+    ConicWeightsArray fConicWeights;
+
     mutable SkRect   fBounds;
+    SkRect           fArcOval;
 
     enum {
         kEmptyGenID = 1, // GenID reserved for path ref with zero points and zero verbs.
@@ -549,27 +545,25 @@ private:
     mutable uint32_t    fGenerationID;
     SkIDChangeListener::List fGenIDChangeListeners;
 
-    PointsArray fPoints;
-    VerbsArray fVerbs;
-    ConicWeightsArray fConicWeights;
-
     SkDEBUGCODE(std::atomic<int> fEditorsAttached;) // assert only one editor in use at any time.
 
-    mutable uint8_t  fBoundsIsDirty;
-    mutable bool     fIsFinite;    // only meaningful if bounds are valid
+    SkScalar    fArcStartAngle;
+    SkScalar    fArcSweepAngle;
 
     PathType fType;
-    // Both the circle and rrect special cases have a notion of direction and starting point
-    // The next two variables store that information for either.
-    bool     fRRectOrOvalIsCCW;
+
+    mutable uint8_t  fBoundsIsDirty;
+
     uint8_t  fRRectOrOvalStartIdx;
     uint8_t  fSegmentMask;
     // If the path is an arc, these four variables store that information.
     // We should just store an SkArc, but alignment would cost us 8 more bytes.
     SkArc::Type fArcType;
-    SkRect      fArcOval;
-    SkScalar    fArcStartAngle;
-    SkScalar    fArcSweepAngle;
+
+    mutable bool     fIsFinite;    // only meaningful if bounds are valid
+    // Both the circle and rrect special cases have a notion of direction and starting point
+    // The next two variables store that information for either.
+    bool     fRRectOrOvalIsCCW;
 
     friend class PathRefTest_Private;
     friend class ForceIsRRect_Private; // unit test isRRect

package/cpp/skia/include/private/base/SkAttributes.h

@@ -56,20 +56,26 @@
  * Used to ignore sanitizer warnings.
  */
 #if !defined(SK_NO_SANITIZE)
-#  define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
+  #if defined(__has_attribute)
+    #if __has_attribute(no_sanitize)
+      // This should be for clang and versions of gcc >= 8.0
+      #define SK_NO_SANITIZE(A) SK_ATTRIBUTE(no_sanitize(A))
+    #else
+      // For compilers that don't support sanitization, just do nothing.
+      #define SK_NO_SANITIZE(A)
+    #endif
+  #else // no __has_attribute, e.g. MSVC
+    #define SK_NO_SANITIZE(A)
+  #endif
 #endif
 
 /**
- * Helper macro to define no_sanitize attributes only with clang.
+ * Used to ignore CFI sanitizer warnings, supported only by Clang at the moment.
  */
-#if defined(__clang__) && defined(__has_attribute)
-  #if __has_attribute(no_sanitize)
-    #define SK_CLANG_NO_SANITIZE(A) SK_NO_SANITIZE(A)
-  #endif
-#endif
-
-#if !defined(SK_CLANG_NO_SANITIZE)
-  #define SK_CLANG_NO_SANITIZE(A)
+#if defined(__clang__)
+  #define SK_NO_SANITIZE_CFI SK_NO_SANITIZE("cfi")
+#else
+  #define SK_NO_SANITIZE_CFI
 #endif
 
 /**

package/cpp/skia/include/private/base/SkMutex.h

@@ -14,6 +14,14 @@
 #include "include/private/base/SkThreadAnnotations.h"
 #include "include/private/base/SkThreadID.h"
 
+/**
+ * class SkMutex
+ *
+ * This allows us to have a mutex without needing the one in
+ * the C++ std library which does not work with all clients.
+ * go/cstyle#Disallowed_Stdlib
+ */
+
 class SK_CAPABILITY("mutex") SkMutex {
 public:
     constexpr SkMutex() = default;

package/cpp/skia/include/private/base/SkTArray.h

@@ -617,7 +617,7 @@ private:
     // unpredictable location in memory. Of course, TArray won't actually use fItemArray in this
     // way, and we don't want to construct a T before the user requests one. There's no real risk
     // here, so disable CFI when doing these casts.
-    SK_CLANG_NO_SANITIZE("cfi")
+    SK_NO_SANITIZE_CFI
     static T* TCast(void* buffer) {
         return (T*)buffer;
     }

package/cpp/skia/include/private/base/SkTDArray.h

@@ -13,9 +13,9 @@
 #include "include/private/base/SkDebug.h"
 #include "include/private/base/SkTo.h"
 
-#include <algorithm>
 #include <cstddef>
 #include <initializer_list>
+#include <utility>
 
 class SK_SPI SkTDStorage {
 public:

package/cpp/skia/include/private/base/SkTemplates.h

@@ -15,6 +15,7 @@
 #include "include/private/base/SkTLogic.h"
 #include "include/private/base/SkTo.h"
 
+#include <algorithm>
 #include <array>
 #include <cstddef>
 #include <cstdint>
@@ -94,7 +95,8 @@ public:
 
 
 namespace skia_private {
-/** Allocate an array of T elements, and free the array in the destructor
+/** Allocate an array of T elements on the heap. Once this goes out of scope, the
+ *  elements will be cleaned up "auto"matically.
  */
 template <typename T> class AutoTArray  {
 public:
@@ -164,7 +166,10 @@ private:
     size_t fSize = 0;
 };
 
-/** Wraps AutoTArray, with room for kCountRequested elements preallocated.
+/** Like AutoTArray with room for kCountRequested elements preallocated on
+ *  the Stack. If count exceeds the space of the preallocation, the elements
+ *  will live on the heap. Once this goes out of scope, the elements will be
+ *  cleaned up "auto"matically.
  */
 template <int kCountRequested, typename T> class AutoSTArray {
 public:
@@ -256,17 +261,25 @@ private:
 #if defined(SK_BUILD_FOR_GOOGLE3)
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max,
     // but some functions have multiple large stack allocations.
-    static const int kMaxBytes = 4 * 1024;
-    static const int kCount = kCountRequested * sizeof(T) > kMaxBytes
+    static constexpr int kMaxBytes = 4 * 1024;
+    static constexpr int kMinCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountRequested;
 #else
-    static const int kCount = kCountRequested;
+    static constexpr int kMinCount = kCountRequested;
 #endif
 
-    int fCount;
+    // Because we are also storing an int, there is a tiny bit of padding that
+    // the C++ compiler adds after fStorage if sizeof(T) <= alignof(T*).
+    // Thus, we can expand how many elements are stored on the stack to make use of this
+    // (e.g. 1 extra element for 4 byte T if kCountRequested was even).
+    static_assert(alignof(int) <= alignof(T*) || alignof(int) <= alignof(T));
+    static constexpr int kCount =
+            SkAlignTo(kMinCount*sizeof(T) + sizeof(int), std::max(alignof(T*), alignof(T))) / sizeof(T);
+
     T* fArray;
-    alignas(T) char fStorage[kCount * sizeof(T)];
+    alignas(T) std::byte fStorage[kCount * sizeof(T)];
+    int fCount;
 };
 
 /** Manages an array of T elements, freeing the array in the destructor.
@@ -409,16 +422,16 @@ public:
 
 private:
     // Since we use uint32_t storage, we might be able to get more elements for free.
-    static const size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
+    static constexpr size_t kCountWithPadding = SkAlign4(kCountRequested*sizeof(T)) / sizeof(T);
 #if defined(SK_BUILD_FOR_GOOGLE3)
     // Stack frame size is limited for SK_BUILD_FOR_GOOGLE3. 4k is less than the actual max, but some functions
     // have multiple large stack allocations.
-    static const size_t kMaxBytes = 4 * 1024;
-    static const size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
+    static constexpr size_t kMaxBytes = 4 * 1024;
+    static constexpr size_t kCount = kCountRequested * sizeof(T) > kMaxBytes
         ? kMaxBytes / sizeof(T)
         : kCountWithPadding;
 #else
-    static const size_t kCount = kCountWithPadding;
+    static constexpr size_t kCount = kCountWithPadding;
 #endif
 
     T*          fPtr;

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -539,7 +539,7 @@ SK_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers)
 enum class GrColorType {
     kUnknown,
     kAlpha_8,
-    kBGR_565,
+    kBGR_565,    // This corresponds to kRGB_565_SkColorType, which is misnamed.
     kRGB_565,
     kABGR_4444,  // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
     kRGBA_8888,

package/cpp/skia/include/sksl/SkSLDebugTrace.h

@@ -16,9 +16,6 @@ namespace SkSL {
 
 class DebugTrace : public SkRefCnt {
 public:
-    /** Serializes a debug trace to JSON which can be parsed by our debugger. */
-    virtual void writeTrace(SkWStream* w) const = 0;
-
     /** Generates a human-readable dump of the debug trace. */
     virtual void dump(SkWStream* o) const = 0;
 };