@shopify/react-native-skia 0.1.234 → 0.1.237

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

@@ -24,11 +24,13 @@
 #include "include/core/SkSamplingOptions.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkSize.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkSurfaceProps.h"
 #include "include/core/SkTypes.h"
 #include "include/private/base/SkCPUTypes.h"
 #include "include/private/base/SkDeque.h"
+#include "include/private/base/SkTArray.h"
 
 #include <cstdint>
 #include <cstring>
@@ -70,6 +72,9 @@ class SkVertices;
 struct SkDrawShadowRec;
 struct SkRSXform;
 
+template<typename E>
+class SkEnumBitMask;
+
 namespace skgpu::graphite { class Recorder; }
 namespace sktext::gpu { class Slug; }
 namespace SkRecords { class Draw; }
@@ -667,7 +672,9 @@ public:
         kF16ColorType                   = 1 << 4,
     };
 
-    typedef uint32_t SaveLayerFlags;
+    using SaveLayerFlags = uint32_t;
+    using FilterSpan = SkSpan<sk_sp<SkImageFilter>>;
+    static constexpr int kMaxFiltersPerLayer = 16;
 
     /** \struct SkCanvas::SaveLayerRec
         SaveLayerRec contains the state used to create the layer.
@@ -687,7 +694,7 @@ public:
             @return                SaveLayerRec with empty fBackdrop
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
-            : SaveLayerRec(bounds, paint, nullptr, 1.f, saveLayerFlags) {}
+            : SaveLayerRec(bounds, paint, nullptr, 1.f, saveLayerFlags, /*filters=*/{}) {}
 
         /** Sets fBounds, fPaint, fBackdrop, and fSaveLayerFlags.
 
@@ -703,7 +710,7 @@ public:
         */
         SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                      SaveLayerFlags saveLayerFlags)
-            : SaveLayerRec(bounds, paint, backdrop, 1.f, saveLayerFlags) {}
+            : SaveLayerRec(bounds, paint, backdrop, 1.f, saveLayerFlags, /*filters=*/{}) {}
 
         /** hints at layer size limit */
         const SkRect*        fBounds         = nullptr;
@@ -711,6 +718,8 @@ public:
         /** modifies overlay */
         const SkPaint*       fPaint          = nullptr;
 
+        FilterSpan           fFilters        = {};
+
         /**
          *  If not null, this triggers the same initialization behavior as setting
          *  kInitWithPrevious_SaveLayerFlag on fSaveLayerFlags: the current layer is copied into
@@ -726,13 +735,23 @@ public:
         friend class SkCanvas;
         friend class SkCanvasPriv;
 
-        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
-                     SkScalar backdropScale, SaveLayerFlags saveLayerFlags)
-            : fBounds(bounds)
-            , fPaint(paint)
-            , fBackdrop(backdrop)
-            , fSaveLayerFlags(saveLayerFlags)
-            , fExperimentalBackdropScale(backdropScale) {}
+        SaveLayerRec(const SkRect* bounds,
+                     const SkPaint* paint,
+                     const SkImageFilter* backdrop,
+                     SkScalar backdropScale,
+                     SaveLayerFlags saveLayerFlags,
+                     FilterSpan filters)
+                : fBounds(bounds)
+                , fPaint(paint)
+                , fFilters(filters)
+                , fBackdrop(backdrop)
+                , fSaveLayerFlags(saveLayerFlags)
+                , fExperimentalBackdropScale(backdropScale) {
+            // We only allow the paint's image filter or the side-car list of filters -- not both.
+            SkASSERT(fFilters.empty() || !paint || !paint->getImageFilter());
+            // To keep things reasonable (during deserialization), we limit filter list size.
+            SkASSERT(fFilters.size() <= kMaxFiltersPerLayer);
+        }
 
         // Relative scale factor that the image content used to initialize the layer when the
         // kInitFromPrevious flag or a backdrop filter is used.
@@ -2283,30 +2302,33 @@ protected:
     virtual void onDrawSlug(const sktext::gpu::Slug* slug);
 
 private:
-
-    enum ShaderOverrideOpacity {
-        kNone_ShaderOverrideOpacity,        //!< there is no overriding shader (bitmap or image)
-        kOpaque_ShaderOverrideOpacity,      //!< the overriding shader is opaque
-        kNotOpaque_ShaderOverrideOpacity,   //!< the overriding shader may not be opaque
+    enum class PredrawFlags : unsigned {
+        kNone                    = 0,
+        kOpaqueShaderOverride    = 1, // The paint's shader is overridden with an opaque image
+        kNonOpaqueShaderOverride = 2, // The paint's shader is overridden but is not opaque
+        kCheckForOverwrite       = 4, // Check if the draw would overwrite the entire surface
+        kSkipMaskFilterAutoLayer = 8, // Do not apply mask filters in the AutoLayer
     };
+    // Inlined SK_DECL_BITMASK_OPS_FRIENDS to avoid including SkEnumBitMask.h
+    friend constexpr SkEnumBitMask<PredrawFlags> operator|(PredrawFlags, PredrawFlags);
+    friend constexpr SkEnumBitMask<PredrawFlags> operator&(PredrawFlags, PredrawFlags);
+    friend constexpr SkEnumBitMask<PredrawFlags> operator^(PredrawFlags, PredrawFlags);
+    friend constexpr SkEnumBitMask<PredrawFlags> operator~(PredrawFlags);
 
     // notify our surface (if we have one) that we are about to draw, so it
     // can perform copy-on-write or invalidate any cached images
     // returns false if the copy failed
     [[nodiscard]] bool predrawNotify(bool willOverwritesEntireSurface = false);
-    [[nodiscard]] bool predrawNotify(const SkRect*, const SkPaint*, ShaderOverrideOpacity);
+    [[nodiscard]] bool predrawNotify(const SkRect*, const SkPaint*, SkEnumBitMask<PredrawFlags>);
 
-    enum class CheckForOverwrite : bool {
-        kNo = false,
-        kYes = true
-    };
     // call the appropriate predrawNotify and create a layer if needed.
     std::optional<AutoLayerForImageFilter> aboutToDraw(
-        SkCanvas* canvas,
-        const SkPaint& paint,
-        const SkRect* rawBounds = nullptr,
-        CheckForOverwrite = CheckForOverwrite::kNo,
-        ShaderOverrideOpacity = kNone_ShaderOverrideOpacity);
+            const SkPaint& paint,
+            const SkRect* rawBounds,
+            SkEnumBitMask<PredrawFlags> flags);
+    std::optional<AutoLayerForImageFilter> aboutToDraw(
+            const SkPaint& paint,
+            const SkRect* rawBounds = nullptr);
 
     // The bottom-most device in the stack, only changed by init(). Image properties and the final
     // canvas pixels are determined by this device.
@@ -2323,12 +2345,16 @@ private:
     // clip, and matrix commands. There is a layer per call to saveLayer() using the
     // kFullLayer_SaveLayerStrategy.
     struct Layer {
-        sk_sp<SkDevice>      fDevice;
-        sk_sp<SkImageFilter> fImageFilter; // applied to layer *before* being drawn by paint
-        SkPaint              fPaint;
-        bool                 fDiscard;
-
-        Layer(sk_sp<SkDevice> device, sk_sp<SkImageFilter> imageFilter, const SkPaint& paint);
+        sk_sp<SkDevice>                                fDevice;
+        skia_private::STArray<1, sk_sp<SkImageFilter>> fImageFilters;
+        SkPaint                                        fPaint;
+        bool                                           fIsCoverage;
+        bool                                           fDiscard;
+
+        Layer(sk_sp<SkDevice> device,
+              FilterSpan imageFilters,
+              const SkPaint& paint,
+              bool isCoverage);
     };
 
     // Encapsulate state needed to restore from saveBehind()
@@ -2364,8 +2390,9 @@ private:
         ~MCRec();
 
         void newLayer(sk_sp<SkDevice> layerDevice,
-                      sk_sp<SkImageFilter> filter,
-                      const SkPaint& restorePaint);
+                      FilterSpan filters,
+                      const SkPaint& restorePaint,
+                      bool layerIsCoverage);
 
         void reset(SkDevice* device);
     };
@@ -2470,7 +2497,7 @@ private:
                              const SkMatrix* matrix = nullptr);
 
     void internalDrawPaint(const SkPaint& paint);
-    void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy);
+    void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy, bool coverageOnly=false);
     void internalSaveBehind(const SkRect*);
 
     void internalConcat44(const SkM44&);
@@ -2499,16 +2526,18 @@ private:
      * relative transforms between the devices).
      */
     void internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst,
-                                      const SkImageFilter* filter, const SkPaint& paint,
+                                      FilterSpan filters, const SkPaint& paint,
                                       DeviceCompatibleWithFilter compat,
-                                      SkScalar scaleFactor = 1.f);
+                                      SkScalar scaleFactor = 1.f,
+                                      bool srcIsCoverageLayer = false);
 
     /*
      *  Returns true if drawing the specified rect (or all if it is null) with the specified
      *  paint (or default if null) would overwrite the entire root device of the canvas
      *  (i.e. the canvas' surface if it had one).
      */
-    bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*, ShaderOverrideOpacity) const;
+    bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*,
+                                     SkEnumBitMask<PredrawFlags>) const;
 
     /**
      *  Returns true if the paint's imagefilter can be invoked directly, without needed a layer.

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

@@ -15,6 +15,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include <utility>
 
 class SkColorMatrix;
 class SkColorSpace;
@@ -82,8 +83,10 @@ private:
 
 class SK_API SkColorFilters {
 public:
-    static sk_sp<SkColorFilter> Compose(sk_sp<SkColorFilter> outer, sk_sp<SkColorFilter> inner) {
-        return outer ? outer->makeComposed(inner) : inner;
+    static sk_sp<SkColorFilter> Compose(const sk_sp<SkColorFilter>& outer,
+                                        sk_sp<SkColorFilter> inner) {
+        return outer ? outer->makeComposed(std::move(inner))
+                     : std::move(inner);
     }
 
     // Blends between the constant color (src) and input color (dst) based on the SkBlendMode.

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

@@ -90,6 +90,7 @@ private:
     const Segment* distanceToSegment(SkScalar distance, SkScalar* t) const;
 
     friend class SkContourMeasureIter;
+    friend class SkPathMeasurePriv;
 };
 
 class SK_API SkContourMeasureIter {

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

@@ -36,6 +36,7 @@ public:
      *  Begin a new page for the document, returning the canvas that will draw
      *  into the page. The document owns this canvas, and it will go out of
      *  scope when endPage() or close() is called, or the document is deleted.
+     *  This will call endPage() if there is a currently active page.
      */
     SkCanvas* beginPage(SkScalar width, SkScalar height, const SkRect* content = nullptr);
 

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

@@ -201,20 +201,14 @@ public:
      */
     SkFont makeWithSize(SkScalar size) const;
 
-    /** Returns SkTypeface if set, or nullptr.
-        Does not alter SkTypeface SkRefCnt.
+    /** Does not alter SkTypeface SkRefCnt.
 
-        @return  SkTypeface if previously set, nullptr otherwise
+        @return  non-null SkTypeface
     */
-    SkTypeface* getTypeface() const {return fTypeface.get(); }
-
-    /** Returns SkTypeface if set, or the default typeface.
-        Does not alter SkTypeface SkRefCnt.
-
-        @return  SkTypeface if previously set or, a pointer to the default typeface if not
-        previously set.
-    */
-    SkTypeface* getTypefaceOrDefault() const;
+    SkTypeface* getTypeface() const {
+        SkASSERT(fTypeface);
+        return fTypeface.get();
+    }
 
     /** Returns text size in points.
 
@@ -238,24 +232,20 @@ public:
 
     /** Increases SkTypeface SkRefCnt by one.
 
-        @return  SkTypeface if previously set, nullptr otherwise
+        @return  A non-null SkTypeface.
     */
-    sk_sp<SkTypeface> refTypeface() const { return fTypeface; }
-
-    /** Increases SkTypeface SkRefCnt by one.
-
-        @return  SkTypeface if previously set or, a pointer to the default typeface if not
-        previously set.
-    */
-    sk_sp<SkTypeface> refTypefaceOrDefault() const;
+    sk_sp<SkTypeface> refTypeface() const {
+        SkASSERT(fTypeface);
+        return fTypeface;
+    }
 
     /** Sets SkTypeface to typeface, decreasing SkRefCnt of the previous SkTypeface.
-        Pass nullptr to clear SkTypeface and use the default typeface. Increments
-        tf SkRefCnt by one.
+        Pass nullptr to clear SkTypeface and use an empty typeface (which draws nothing).
+        Increments tf SkRefCnt by one.
 
         @param tf  font and style used to draw text
     */
-    void setTypeface(sk_sp<SkTypeface> tf) { fTypeface = tf; }
+    void setTypeface(sk_sp<SkTypeface> tf);
 
     /** Sets text size in points.
         Has no effect if textSize is not greater than or equal to zero.

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

@@ -32,7 +32,7 @@ struct SkFontArguments {
      */
     struct Palette {
         struct Override {
-            int index;
+            uint16_t index;
             SkColor color;
         };
         int index;

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

@@ -16,7 +16,7 @@
     The metric values are consistent with the Skia y-down coordinate system.
  */
 struct SK_API SkFontMetrics {
-    bool operator==(const SkFontMetrics& that) {
+    bool operator==(const SkFontMetrics& that) const {
         return
         this->fFlags == that.fFlags &&
         this->fTop == that.fTop &&

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

@@ -112,9 +112,6 @@ public:
 
     sk_sp<SkTypeface> legacyMakeTypeface(const char familyName[], SkFontStyle style) const;
 
-    /** Return the default fontmgr. */
-    static sk_sp<SkFontMgr> RefDefault();
-
     /* Returns an empty font manager without any typeface dependencies */
     static sk_sp<SkFontMgr> RefEmpty();
 
@@ -141,10 +138,6 @@ protected:
     virtual sk_sp<SkTypeface> onMakeFromFile(const char path[], int ttcIndex) const = 0;
 
     virtual sk_sp<SkTypeface> onLegacyMakeTypeface(const char familyName[], SkFontStyle) const = 0;
-
-private:
-    /** Implemented by porting layer to return the default factory. */
-    static sk_sp<SkFontMgr> Factory();
 };
 
 #endif

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

@@ -69,6 +69,19 @@ public:
      */
     static int SetFontCacheCountLimit(int count);
 
+    /**
+     *  Return the current limit to the number of entries in the typeface cache.
+     *  A cache "entry" is associated with each typeface.
+     */
+    static int GetTypefaceCacheCountLimit();
+
+    /**
+     *  Set the limit to the number of entries in the typeface cache, and return
+     *  the previous value. Changes to this only take effect the next time
+     *  each cache object is modified.
+     */
+    static int SetTypefaceCacheCountLimit(int count);
+
     /**
      *  For debugging purposes, this will attempt to purge the font cache. It
      *  does not change the limit, but will cause subsequent font measures and

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

@@ -15,6 +15,7 @@
 #include "include/core/SkString.h"
 #include "include/effects/SkRuntimeEffect.h"
 #include "include/private/base/SkAPI.h"
+#include "include/private/base/SkTArray.h"
 
 #include <cstddef>
 #include <cstdint>
@@ -168,10 +169,7 @@ public:
      */
     SkSpan<const Uniform> uniforms() const { return SkSpan(fUniforms); }
 
-    /**
-     * Provides basic info about individual children: names, indices and runtime effect type.
-     * TODO(b/40045302): SkMesh will currently reject mesh specifications that include child effects
-     */
+    /** Provides basic info about individual children: names, indices and runtime effect type. */
     SkSpan<const Child> children() const { return SkSpan(fChildren); }
 
     /** Returns a pointer to the named child's description, or nullptr if not found. */
@@ -188,6 +186,8 @@ public:
 
     size_t stride() const { return fStride; }
 
+    SkColorSpace* colorSpace() const { return fColorSpace.get(); }
+
 private:
     friend struct SkMeshSpecificationPriv;
 
@@ -317,8 +317,6 @@ public:
      * If the mesh is invalid the returned string give contain the reason for the failure (e.g. the
      * vertex buffer was null or uniform data too small).
      */
-
-    // TODO(b/40045302): support for `children` is a work-in-progress
     static Result Make(sk_sp<SkMeshSpecification>,
                        Mode,
                        sk_sp<VertexBuffer>,
@@ -334,8 +332,6 @@ public:
      * If the mesh is invalid the returned string give contain the reason for the failure (e.g. the
      * index buffer was null or uniform data too small).
      */
-
-    // TODO(b/40045302): support for `children` is a work-in-progress
     static Result MakeIndexed(sk_sp<SkMeshSpecification>,
                               Mode,
                               sk_sp<VertexBuffer>,
@@ -383,7 +379,7 @@ private:
     sk_sp<IndexBuffer>  fIB;
 
     sk_sp<const SkData> fUniforms;
-    std::vector<ChildPtr> fChildren;
+    skia_private::STArray<2, ChildPtr> fChildren;
 
     size_t fVOffset = 0;  // Must be a multiple of spec->stride()
     size_t fVCount  = 0;
@@ -405,14 +401,14 @@ namespace SkMeshes {
  * @param  data              The data used to populate the buffer, or nullptr to create a zero-
  *                           initialized buffer.
  * @param  size              Both the size of the data in 'data' and the size of the resulting
- *                           buffer.
+ *                           buffer, in bytes.
  */
 SK_API sk_sp<SkMesh::IndexBuffer> MakeIndexBuffer(const void* data, size_t size);
 
 /**
  * Makes a copy of an index buffer. The copy will be CPU-backed.
  */
-SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(sk_sp<SkMesh::IndexBuffer>);
+SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(const sk_sp<SkMesh::IndexBuffer>&);
 
 /**
  * Makes a CPU-backed vertex buffer to be used with SkMeshes.
@@ -420,14 +416,14 @@ SK_API sk_sp<SkMesh::IndexBuffer> CopyIndexBuffer(sk_sp<SkMesh::IndexBuffer>);
  * @param  data              The data used to populate the buffer, or nullptr to create a zero-
  *                           initialized buffer.
  * @param  size              Both the size of the data in 'data' and the size of the resulting
- *                           buffer.
+ *                           buffer, in bytes.
  */
 SK_API sk_sp<SkMesh::VertexBuffer> MakeVertexBuffer(const void*, size_t size);
 
 /**
  * Makes a copy of a vertex buffer.  The copy will be CPU-backed.
  */
-SK_API sk_sp<SkMesh::VertexBuffer> CopyVertexBuffer(sk_sp<SkMesh::VertexBuffer>);
+SK_API sk_sp<SkMesh::VertexBuffer> CopyVertexBuffer(const sk_sp<SkMesh::VertexBuffer>&);
 }  // namespace SkMeshes
 
 #endif

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

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

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

@@ -79,6 +79,8 @@ public:
     void    dump();
 #endif
 
+    const SkContourMeasure* currentMeasure() const { return fContour.get(); }
+
 private:
     SkContourMeasureIter    fIter;
     sk_sp<SkContourMeasure> fContour;

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

@@ -12,12 +12,14 @@
 #include "include/private/base/SkAPI.h"
 
 #include <cstddef>
+#include <optional>
 
 class SkData;
 class SkImage;
 class SkPicture;
 class SkTypeface;
 class SkReadBuffer;
+enum SkAlphaType : int;
 namespace sktext::gpu {
     class Slug;
 }
@@ -48,10 +50,25 @@ using SkDeserialPictureProc = sk_sp<SkPicture> (*)(const void* data, size_t leng
  *
  *  This will also be used to decode the internal mipmap layers that are saved on some images.
  *
- *  Note that unlike SkDeserialPictureProc and SkDeserialTypefaceProc, return nullptr from this
- *  does not indicate failure, but is a signal for Skia to take its default action.
+ *  An explicit SkAlphaType may have been encoded in the bytestream; if not, then the passed in
+ *  optional will be not present.
+ *
+ *  Clients should set at least SkDeserialImageProc; SkDeserialImageFromDataProc may be called
+ *  if the internal implementation has a SkData copy already. Implementations of SkDeserialImageProc
+ *  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);
 
 /**
  * Slugs are currently only deserializable with a GPU backend. Clients will not be able to
@@ -78,22 +95,23 @@ struct SK_API SkSerialProcs {
 };
 
 struct SK_API SkDeserialProcs {
-    SkDeserialPictureProc   fPictureProc = nullptr;
-    void*                   fPictureCtx = nullptr;
+    SkDeserialPictureProc        fPictureProc = nullptr;
+    void*                        fPictureCtx = nullptr;
 
-    SkDeserialImageProc     fImageProc = nullptr;
-    void*                   fImageCtx = nullptr;
+    SkDeserialImageProc          fImageProc = nullptr;
+    SkDeserialImageFromDataProc  fImageDataProc = nullptr;
+    void*                        fImageCtx = nullptr;
 
-    SkSlugProc              fSlugProc = nullptr;
-    void*                   fSlugCtx = nullptr;
+    SkSlugProc                   fSlugProc = nullptr;
+    void*                        fSlugCtx = nullptr;
 
-    SkDeserialTypefaceProc  fTypefaceProc = nullptr;
-    void*                   fTypefaceCtx = nullptr;
+    SkDeserialTypefaceProc       fTypefaceProc = nullptr;
+    void*                        fTypefaceCtx = nullptr;
 
     // This looks like a flag, but it could be considered a proc as well (one that takes no
     // parameters and returns a bool). Given that there are only two valid implementations of that
     // proc, we just insert the bool directly.
-    bool                    fAllowSkSL = true;
+    bool                         fAllowSkSL = true;
 };
 
 #endif

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

@@ -52,13 +52,13 @@ struct SkSize {
     SkScalar fWidth;
     SkScalar fHeight;
 
-    static SkSize Make(SkScalar w, SkScalar h) { return {w, h}; }
+    static constexpr SkSize Make(SkScalar w, SkScalar h) { return {w, h}; }
 
-    static SkSize Make(const SkISize& src) {
+    static constexpr SkSize Make(const SkISize& src) {
         return {SkIntToScalar(src.width()), SkIntToScalar(src.height())};
     }
 
-    static SkSize MakeEmpty() { return {0, 0}; }
+    static constexpr SkSize MakeEmpty() { return {0, 0}; }
 
     void set(SkScalar w, SkScalar h) { *this = SkSize{w, h}; }
 

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

@@ -25,19 +25,6 @@ class SkStreamAsset;
 /**
  *  SkStream -- abstraction for a source of bytes. Subclasses can be backed by
  *  memory, or a file, or something else.
- *
- *  NOTE:
- *
- *  Classic "streams" APIs are sort of async, in that on a request for N
- *  bytes, they may return fewer than N bytes on a given call, in which case
- *  the caller can "try again" to get more bytes, eventually (modulo an error)
- *  receiving their total N bytes.
- *
- *  Skia streams behave differently. They are effectively synchronous, and will
- *  always return all N bytes of the request if possible. If they return fewer
- *  (the read() call returns the number of bytes read) then that means there is
- *  no more data (at EOF or hit an error). The caller should *not* call again
- *  in hopes of fulfilling more of the request.
  */
 class SK_API SkStream {
 public:
@@ -81,6 +68,9 @@ public:
     virtual size_t peek(void* /*buffer*/, size_t /*size*/) const { return 0; }
 
     /** Returns true when all the bytes in the stream have been read.
+     *  As SkStream represents synchronous I/O, isAtEnd returns false when the
+     *  final stream length isn't known yet, even when all the bytes available
+     *  so far have been read.
      *  This may return true early (when there are no more bytes to be read)
      *  or late (after the first unsuccessful read).
      */

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

@@ -604,9 +604,12 @@ public:
     const SkSurfaceProps& props() const { return fProps; }
 
     /** Inserts a list of GPU semaphores that the current GPU-backed API must wait on before
-        executing any more commands on the GPU for this surface. 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 for this surface. 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

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

@@ -59,15 +59,13 @@ public:
         // Currently this only impacts GPU backends
         kAlwaysDither_Flag              = 1 << 2,
     };
-    /** Deprecated alias used by Chromium. Will be removed. */
-    static const Flags kUseDistanceFieldFonts_Flag = kUseDeviceIndependentFonts_Flag;
 
     /** No flags, unknown pixel geometry. */
     SkSurfaceProps();
     SkSurfaceProps(uint32_t flags, SkPixelGeometry);
 
-    SkSurfaceProps(const SkSurfaceProps&);
-    SkSurfaceProps& operator=(const SkSurfaceProps&);
+    SkSurfaceProps(const SkSurfaceProps&) = default;
+    SkSurfaceProps& operator=(const SkSurfaceProps&) = default;
 
     SkSurfaceProps cloneWithPixelGeometry(SkPixelGeometry newPixelGeometry) const {
         return SkSurfaceProps(fFlags, newPixelGeometry);

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

@@ -89,6 +89,21 @@ public:
      */
     virtual void dumpWrappedState(const char* /*dumpName*/, bool /*isWrappedObject*/) {}
 
+    /**
+     * Returns true if we should dump unbudgeted objects. Unbudgeted objects can either come from
+     * wrapped objects passed into Skia from the client or from Skia created objects currently held
+     * by the client in a public Skia object (e.g. SkSurface or SkImage). This call is only used
+     * when dumping Graphite memory statistics.
+     */
+    virtual bool shouldDumpUnbudgetedObjects() const { return true; }
+
+    /**
+     * If shouldDumpUnbudgetedObjects() returns true then this function will be called to populate
+     * the output with information on whether the item being dumped is budgeted. This call is only
+     * used when dumping Graphite memory statistics.
+     */
+    virtual void dumpBudgetedState(const char* /*dumpName*/, bool /*isBudgeted*/) {}
+
 protected:
     virtual ~SkTraceMemoryDump() = default;
     SkTraceMemoryDump() = default;