@shopify/react-native-skia 0.1.128 → 0.1.131

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

@@ -0,0 +1,303 @@
+/*
+ * Copyright 2021 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkMesh_DEFINED
+#define SkMesh_DEFINED
+
+#include "include/core/SkTypes.h"
+
+#ifdef SK_ENABLE_SKSL
+#include "include/core/SkAlphaType.h"
+#include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkString.h"
+
+#include <memory>
+#include <vector>
+
+class GrDirectContext;
+class SkColorSpace;
+class SkData;
+
+namespace SkSL { struct Program; }
+
+/**
+ * A specification for custom meshes. Specifies the vertex buffer attributes and stride, the
+ * vertex program that produces a user-defined set of varyings, a fragment program that ingests
+ * the interpolated varyings and produces local coordinates and optionally a color.
+ *
+ * The signature of the vertex program must be:
+ *   float2 main(Attributes, out Varyings)
+ * where the return value is a local position that will be transformed by SkCanvas's matrix.
+ *
+ * The signature of the fragment program must be either:
+ *   (float2|void) main(Varyings)
+ * or
+ *   (float2|void) main(Varyings, out (half4|float4) color)
+ *
+ * where the return value is the local coordinates that will be used to access SkShader. If the
+ * return type is void then the interpolated position from vertex shader return is used as the local
+ * coordinate. If the color variant is used it will be blended with SkShader (or SkPaint color in
+ * absence of a shader) using the SkBlender provided to the SkCanvas draw call.
+ */
+class SkMeshSpecification : public SkNVRefCnt<SkMeshSpecification> {
+public:
+    /** These values are enforced when creating a specification. */
+    static constexpr size_t kMaxStride       = 1024;
+    static constexpr size_t kMaxAttributes   = 8;
+    static constexpr size_t kStrideAlignment = 4;
+    static constexpr size_t kOffsetAlignment = 4;
+    static constexpr size_t kMaxVaryings     = 6;
+
+    struct Attribute {
+        enum class Type : uint32_t {  // CPU representation     Shader Type
+            kFloat,                   // float                  float
+            kFloat2,                  // two floats             float2
+            kFloat3,                  // three floats           float3
+            kFloat4,                  // four floats            float4
+            kUByte4_unorm,            // four bytes             half4
+
+            kLast = kUByte4_unorm
+        };
+        Type     type;
+        size_t   offset;
+        SkString name;
+    };
+
+    struct Varying {
+        enum class Type : uint32_t {
+            kFloat,   // "float"
+            kFloat2,  // "float2"
+            kFloat3,  // "float3"
+            kFloat4,  // "float4"
+            kHalf,    // "half"
+            kHalf2,   // "half2"
+            kHalf3,   // "half3"
+            kHalf4,   // "half4"
+
+            kLast = kHalf4
+        };
+        Type     type;
+        SkString name;
+    };
+
+    ~SkMeshSpecification();
+
+    struct Result {
+        sk_sp<SkMeshSpecification> specification;
+        SkString                   error;
+    };
+
+    /**
+     * If successful the return is a specification and an empty error string. Otherwise, it is a
+     * null specification a non-empty error string.
+     *
+     * @param attributes     The vertex attributes that will be consumed by 'vs'. Attributes need
+     *                       not be tightly packed but attribute offsets must be aligned to
+     *                       kOffsetAlignment and offset + size may not be greater than
+     *                       'vertexStride'. At least one attribute is required.
+     * @param vertexStride   The offset between successive attribute values. This must be aligned to
+     *                       kStrideAlignment.
+     * @param varyings       The varyings that will be written by 'vs' and read by 'fs'. This may
+     *                       be empty.
+     * @param vs             The vertex shader code that computes a vertex position and the varyings
+     *                       from the attributes.
+     * @param fs             The fragment code that computes a local coordinate and optionally a
+     *                       color from the varyings. The local coordinate is used to sample
+     *                       SkShader.
+     * @param cs             The colorspace of the color produced by 'fs'. Ignored if 'fs's main()
+     *                       function does not have a color out param.
+     * @param at             The alpha type of the color produced by 'fs'. Ignored if 'fs's main()
+     *                       function does not have a color out param. Cannot be kUnknown.
+     */
+    static Result Make(SkSpan<const Attribute> attributes,
+                       size_t                  vertexStride,
+                       SkSpan<const Varying>   varyings,
+                       const SkString&         vs,
+                       const SkString&         fs);
+    static Result Make(SkSpan<const Attribute> attributes,
+                       size_t                  vertexStride,
+                       SkSpan<const Varying>   varyings,
+                       const SkString&         vs,
+                       const SkString&         fs,
+                       sk_sp<SkColorSpace>     cs);
+    static Result Make(SkSpan<const Attribute> attributes,
+                       size_t                  vertexStride,
+                       SkSpan<const Varying>   varyings,
+                       const SkString&         vs,
+                       const SkString&         fs,
+                       sk_sp<SkColorSpace>     cs,
+                       SkAlphaType             at);
+
+    SkSpan<const Attribute> attributes() const { return SkMakeSpan(fAttributes); }
+
+    size_t stride() const { return fStride; }
+
+private:
+    friend struct SkMeshSpecificationPriv;
+
+    enum class ColorType {
+        kNone,
+        kHalf4,
+        kFloat4,
+    };
+
+    static Result MakeFromSourceWithStructs(SkSpan<const Attribute> attributes,
+                                            size_t                  stride,
+                                            SkSpan<const Varying>   varyings,
+                                            const SkString&         vs,
+                                            const SkString&         fs,
+                                            sk_sp<SkColorSpace>     cs,
+                                            SkAlphaType             at);
+
+    SkMeshSpecification(SkSpan<const Attribute>,
+                        size_t,
+                        SkSpan<const Varying>,
+                        std::unique_ptr<SkSL::Program>,
+                        std::unique_ptr<SkSL::Program>,
+                        ColorType,
+                        bool hasLocalCoords,
+                        sk_sp<SkColorSpace>,
+                        SkAlphaType);
+
+    SkMeshSpecification(const SkMeshSpecification&) = delete;
+    SkMeshSpecification(SkMeshSpecification&&) = delete;
+
+    SkMeshSpecification& operator=(const SkMeshSpecification&) = delete;
+    SkMeshSpecification& operator=(SkMeshSpecification&&) = delete;
+
+    const std::vector<Attribute>   fAttributes;
+    const std::vector<Varying>     fVaryings;
+    std::unique_ptr<SkSL::Program> fVS;
+    std::unique_ptr<SkSL::Program> fFS;
+    size_t                         fStride;
+    uint32_t                       fHash;
+    ColorType                      fColorType;
+    bool                           fHasLocalCoords;
+    sk_sp<SkColorSpace>            fColorSpace;
+    SkAlphaType                    fAlphaType;
+};
+
+/**
+ * A vertex buffer, a topology, optionally an index buffer, and a compatible SkMeshSpecification.
+ *
+ * The data in the vertex buffer is expected to contain the attributes described by the spec
+ * for vertexCount vertices beginning at vertexOffset. vertexOffset must be aligned to the
+ * SkMeshSpecification's vertex stride. The size of the buffer must be at least vertexOffset +
+ * spec->stride()*vertexCount (even if vertex attributes contains pad at the end of the stride). If
+ * the specified bounds does not contain all the points output by the spec's vertex program when
+ * applied to the vertices in the custom mesh then the result is undefined.
+ *
+ * MakeIndexed may be used to create an indexed mesh. indexCount indices are read from the index
+ * buffer at the specified offset which must be aligned to 2. The indices are always unsigned 16bit
+ * integers. The index count must be at least 3.
+ *
+ * If Make() is used the implicit index sequence is 0, 1, 2, 3, ... and vertexCount must be at least
+ * 3.
+ */
+class SkMesh {
+public:
+    class IndexBuffer  : public SkRefCnt {};
+    class VertexBuffer : public SkRefCnt {};
+
+    SkMesh();
+    ~SkMesh();
+
+    SkMesh(const SkMesh&);
+    SkMesh(SkMesh&&);
+
+    SkMesh& operator=(const SkMesh&);
+    SkMesh& operator=(SkMesh&&);
+
+    /**
+     * Makes an index buffer to be used with SkMeshes. The SkData is used to determine the
+     * size and contents of the buffer. The buffer may be CPU- or GPU-backed depending on whether
+     * GrDirectContext* is nullptr.
+     *
+     * @param  GrDirectContext*   If nullptr a CPU-backed object is returned that owns the SkData.
+     *                            Otherwise, the data is uploaded to the GPU and a GPU-backed buffer
+     *                            is returned. It may only be used to draw into SkSurfaces that
+     *                            are backed by the passed GrDirectContext.
+     * @param  sk_sp<SkData>      required. The data used to populate the buffer.
+     */
+    static sk_sp<IndexBuffer> MakeIndexBuffer(GrDirectContext*, sk_sp<const SkData>);
+
+    /**
+     * Makes a vertex buffer to be used with SkMeshes. The SkData is used to determine the
+     * size and contents of the buffer.The buffer may be CPU- or GPU-backed depending on whether
+     * GrDirectContext* is nullptr.
+     *
+     * @param  GrDirectContext*   If nullptr a CPU-backed object is returned that owns the SkData.
+     *                            Otherwise, the data is uploaded to the GPU and a GPU-backed buffer
+     *                            is returned. It may only be used to draw into SkSurfaces that
+     *                            are backed by the passed GrDirectContext.
+     * @param  sk_sp<SkData>      required. The data used to populate the buffer.
+     */
+    static sk_sp<VertexBuffer> MakeVertexBuffer(GrDirectContext*, sk_sp<const SkData>);
+
+    enum class Mode { kTriangles, kTriangleStrip };
+
+    static SkMesh Make(sk_sp<SkMeshSpecification>,
+                       Mode,
+                       sk_sp<VertexBuffer>,
+                       size_t vertexCount,
+                       size_t vertexOffset,
+                       const SkRect& bounds);
+
+    static SkMesh MakeIndexed(sk_sp<SkMeshSpecification>,
+                              Mode,
+                              sk_sp<VertexBuffer>,
+                              size_t vertexCount,
+                              size_t vertexOffset,
+                              sk_sp<IndexBuffer>,
+                              size_t indexCount,
+                              size_t indexOffset,
+                              const SkRect& bounds);
+
+    sk_sp<SkMeshSpecification> spec() const { return fSpec; }
+
+    Mode mode() const { return fMode; }
+
+    sk_sp<VertexBuffer> vertexBuffer() const { return fVB; }
+
+    size_t vertexOffset() const { return fVOffset; }
+    size_t vertexCount()  const { return fVCount;  }
+
+    sk_sp<IndexBuffer> indexBuffer() const { return fIB; }
+
+    size_t indexOffset() const { return fIOffset; }
+    size_t indexCount()  const { return fICount;  }
+
+    SkRect bounds() const { return fBounds; }
+
+    bool isValid() const;
+
+private:
+    friend struct SkMeshPriv;
+
+    bool validate() const;
+
+    sk_sp<SkMeshSpecification> fSpec;
+
+    sk_sp<VertexBuffer> fVB;
+    sk_sp<IndexBuffer>  fIB;
+
+    size_t fVOffset = 0;  // Must be a multiple of spec->stride()
+    size_t fVCount  = 0;
+
+    size_t fIOffset = 0;  // Must be a multiple of sizeof(uint16_t)
+    size_t fICount  = 0;
+
+    Mode fMode = Mode::kTriangles;
+
+    SkRect fBounds = SkRect::MakeEmpty();
+};
+
+#endif  // SK_ENABLE_SKSL
+
+#endif

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

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

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

@@ -0,0 +1,30 @@
+/*
+ * Copyright 2022 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkOpenTypeSVGDecoder_DEFINED
+#define SkOpenTypeSVGDecoder_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkCanvas;
+
+class SkOpenTypeSVGDecoder {
+public:
+    /** Each instance probably owns an SVG DOM.
+     *  The instance may be cached so needs to report how much memory it retains.
+     */
+    virtual size_t approximateSize() = 0;
+    virtual bool render(SkCanvas&, int upem, SkGlyphID glyphId,
+                        SkColor foregroundColor, SkSpan<SkColor> palette) = 0;
+    virtual ~SkOpenTypeSVGDecoder() = default;
+};
+
+#endif  // SkOpenTypeSVGDecoder_DEFINED

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

@@ -11,9 +11,10 @@
 #include "include/core/SkBlendMode.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkRefCnt.h"
-#include "include/private/SkTOptional.h"
 #include "include/private/SkTo.h"
 
+#include <optional>
+
 class SkBlender;
 class SkColorFilter;
 class SkColorSpace;
@@ -470,7 +471,7 @@ public:
      *  enum in the optional's value(). If it cannot, then the returned optional does not
      *  contain a value.
      */
-    skstd::optional<SkBlendMode> asBlendMode() const;
+    std::optional<SkBlendMode> asBlendMode() const;
 
     /**
      *  Queries the blender, and if it can be represented as a SkBlendMode, return that mode,
@@ -649,23 +650,7 @@ public:
         @param storage  computed bounds of geometry; may not be nullptr
         @return         fast computed bounds
     */
-    const SkRect& computeFastBounds(const SkRect& orig, SkRect* storage) const {
-        // Things like stroking, etc... will do math on the bounds rect, assuming that it's sorted.
-        SkASSERT(orig.isSorted());
-        SkPaint::Style style = this->getStyle();
-        // ultra fast-case: filling with no effects that affect geometry
-        if (kFill_Style == style) {
-            uintptr_t effects = 0;
-            effects |= reinterpret_cast<uintptr_t>(this->getMaskFilter());
-            effects |= reinterpret_cast<uintptr_t>(this->getPathEffect());
-            effects |= reinterpret_cast<uintptr_t>(this->getImageFilter());
-            if (!effects) {
-                return orig;
-            }
-        }
-
-        return this->doComputeFastBounds(orig, storage, style);
-    }
+    const SkRect& computeFastBounds(const SkRect& orig, SkRect* storage) const;
 
     /**     (to be made private)
 

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

@@ -10,16 +10,21 @@
 
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPathTypes.h"
-#include "include/private/SkPathRef.h"
+#include "include/core/SkRefCnt.h"
 #include "include/private/SkTo.h"
 
 #include <initializer_list>
+#include <tuple>
 
 class SkAutoPathBoundsUpdate;
 class SkData;
+class SkPathRef;
 class SkRRect;
 class SkWStream;
 
+enum class SkPathConvexity;
+enum class SkPathFirstDirection;
+
 // WIP -- define this locally, and fix call-sites to use SkPathBuilder (skbug.com/9000)
 //#define SK_HIDE_PATH_EDIT_METHODS
 
@@ -225,9 +230,7 @@ public:
 
     /** Returns true if the path is convex. If necessary, it will first compute the convexity.
      */
-    bool isConvex() const {
-        return SkPathConvexity::kConvex == this->getConvexity();
-    }
+    bool isConvex() const;
 
     /** Returns true if this path is recognized as an oval or circle.
 
@@ -285,10 +288,7 @@ public:
 
         @return  true if the path contains no SkPath::Verb array
     */
-    bool isEmpty() const {
-        SkDEBUGCODE(this->validate();)
-        return 0 == fPathRef->countVerbs();
-    }
+    bool isEmpty() const;
 
     /** Returns if contour is closed.
         Contour is closed if SkPath SkPath::Verb array was last modified by close(). When stroked,
@@ -306,10 +306,7 @@ public:
 
         @return  true if all SkPoint values are finite
     */
-    bool isFinite() const {
-        SkDEBUGCODE(this->validate();)
-        return fPathRef->isFinite();
-    }
+    bool isFinite() const;
 
     /** Returns true if the path is volatile; it will not be altered or discarded
         by the caller after it is drawn. SkPath by default have volatile set false, allowing
@@ -482,9 +479,7 @@ public:
 
         @return  bounds of all SkPoint in SkPoint array
     */
-    const SkRect& getBounds() const {
-        return fPathRef->getBounds();
-    }
+    const SkRect& getBounds() const;
 
     /** Updates internal bounds so that subsequent calls to getBounds() are instantaneous.
         Unaltered copies of SkPath may also access cached bounds through getBounds().
@@ -1409,7 +1404,7 @@ public:
 
         @return  SegmentMask bits or zero
     */
-    uint32_t getSegmentMasks() const { return fPathRef->getSegmentMasks(); }
+    uint32_t getSegmentMasks() const;
 
     /** \enum SkPath::Verb
         Verb instructs SkPath how to interpret one or more SkPoint and optional conic weight;
@@ -1759,7 +1754,7 @@ public:
 
         @return  true if SkPath data is consistent
     */
-    bool isValid() const { return this->isValidImpl() && fPathRef->isValid(); }
+    bool isValid() const;
 
 private:
     SkPath(sk_sp<SkPathRef>, SkPathFillType, bool isVolatile, SkPathConvexity,
@@ -1810,12 +1805,14 @@ private:
 
     SkPathConvexity computeConvexity() const;
 
+    bool isValidImpl() const;
     /** Asserts if SkPath data is inconsistent.
         Debugging check intended for internal use only.
      */
-    SkDEBUGCODE(void validate() const { SkASSERT(this->isValidImpl()); } )
-    bool isValidImpl() const;
-    SkDEBUGCODE(void validateRef() const { fPathRef->validate(); } )
+#ifdef SK_DEBUG
+    void validate() const;
+    void validateRef() const;
+#endif
 
     // called by stroker to see if all points (in the last contour) are equal and worthy of a cap
     bool isZeroLengthSincePoint(int startPtIndex) const;
@@ -1823,18 +1820,10 @@ private:
     /** Returns if the path can return a bound at no cost (true) or will have to
         perform some computation (false).
      */
-    bool hasComputedBounds() const {
-        SkDEBUGCODE(this->validate();)
-        return fPathRef->hasComputedBounds();
-    }
-
+    bool hasComputedBounds() const;
 
     // 'rect' needs to be sorted
-    void setBounds(const SkRect& rect) {
-        SkPathRef::Editor ed(&fPathRef);
-
-        ed.setBounds(rect);
-    }
+    void setBounds(const SkRect& rect);
 
     void setPt(int index, SkScalar x, SkScalar y);
 
@@ -1852,9 +1841,7 @@ private:
     */
     SkPathConvexity getConvexity() const;
 
-    SkPathConvexity getConvexityOrUnknown() const {
-        return (SkPathConvexity)fConvexity.load(std::memory_order_relaxed);
-    }
+    SkPathConvexity getConvexityOrUnknown() const;
 
     // Compares the cached value with a freshly computed one (computeConvexity())
     bool isConvexityAccurate() const;

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

@@ -11,6 +11,7 @@
 #include "include/core/SkMatrix.h"
 #include "include/core/SkPath.h"
 #include "include/core/SkPathTypes.h"
+#include "include/core/SkRefCnt.h"
 #include "include/private/SkTDArray.h"
 
 class SK_API SkPathBuilder {
@@ -241,9 +242,6 @@ private:
     int fIsAStart = -1;     // tracks direction iff fIsA is not unknown
     bool fIsACCW  = false;  // tracks direction iff fIsA is not unknown
 
-    // for testing
-    SkPathConvexity fOverrideConvexity = SkPathConvexity::kUnknown;
-
     int countVerbs() const { return fVerbs.count(); }
 
     // called right before we add a (non-move) verb
@@ -258,9 +256,6 @@ private:
 
     SkPathBuilder& privateReverseAddPath(const SkPath&);
 
-    // For testing
-    void privateSetConvexity(SkPathConvexity c) { fOverrideConvexity = c; }
-
     friend class SkPathPriv;
 };
 

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

@@ -112,7 +112,7 @@ private:
 
     void setTemporarilyImmutable();
     void restoreMutability();
-    friend class SkSurface_Raster;   // For the two methods above.
+    friend class SkSurface_Raster;  // For temporary immutable methods above.
 
     void setImmutableWithID(uint32_t genID);
     friend void SkBitmapCache_setImmutableWithID(SkPixelRef*, uint32_t);

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

@@ -12,6 +12,7 @@
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkSamplingOptions.h"
 
+class SkColorSpace;
 class SkData;
 struct SkMask;
 
@@ -170,7 +171,7 @@ public:
 
         @return  SkColorSpace in SkImageInfo, or nullptr
     */
-    SkColorSpace* colorSpace() const { return fInfo.colorSpace(); }
+    SkColorSpace* colorSpace() const;
 
     /** Returns smart pointer to SkColorSpace, the range of colors, associated with
         SkImageInfo. The smart pointer tracks the number of objects sharing this
@@ -180,7 +181,7 @@ public:
 
         @return  SkColorSpace in SkImageInfo wrapped in a smart pointer
     */
-    sk_sp<SkColorSpace> refColorSpace() const { return fInfo.refColorSpace(); }
+    sk_sp<SkColorSpace> refColorSpace() const;
 
     /** Returns true if SkAlphaType is kOpaque_SkAlphaType.
         Does not check if SkColorType allows alpha, or if any pixel value has

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

@@ -18,7 +18,7 @@
  *  [ fSSin      fSCos    fTy ]
  *  [     0          0      1 ]
  */
-struct SkRSXform {
+struct SK_API SkRSXform {
     static SkRSXform Make(SkScalar scos, SkScalar ssin, SkScalar tx, SkScalar ty) {
         SkRSXform xform = { scos, ssin, tx, ty };
         return xform;

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

@@ -9,6 +9,8 @@
 #define SkImageSampling_DEFINED
 
 #include "include/core/SkTypes.h"
+
+#include <algorithm>
 #include <new>
 
 enum class SkFilterMode {
@@ -52,6 +54,7 @@ struct SkCubicResampler {
 };
 
 struct SK_API SkSamplingOptions {
+    const int              maxAniso = 0;
     const bool             useCubic = false;
     const SkCubicResampler cubic    = {0, 0};
     const SkFilterMode     filter   = SkFilterMode::kNearest;
@@ -66,27 +69,35 @@ struct SK_API SkSamplingOptions {
     }
 
     SkSamplingOptions(SkFilterMode fm, SkMipmapMode mm)
-        : useCubic(false)
-        , filter(fm)
+        : filter(fm)
         , mipmap(mm) {}
 
     explicit SkSamplingOptions(SkFilterMode fm)
-        : useCubic(false)
-        , filter(fm)
+        : filter(fm)
         , mipmap(SkMipmapMode::kNone) {}
 
     explicit SkSamplingOptions(const SkCubicResampler& c)
         : useCubic(true)
         , cubic(c) {}
 
+    static SkSamplingOptions Aniso(int maxAniso) {
+        return SkSamplingOptions{std::max(maxAniso, 1)};
+    }
+
     bool operator==(const SkSamplingOptions& other) const {
-        return useCubic == other.useCubic
+        return maxAniso == other.maxAniso
+            && useCubic == other.useCubic
             && cubic.B  == other.cubic.B
             && cubic.C  == other.cubic.C
             && filter   == other.filter
             && mipmap   == other.mipmap;
     }
     bool operator!=(const SkSamplingOptions& other) const { return !(*this == other); }
+
+    bool isAniso() const { return maxAniso != 0; }
+
+private:
+    SkSamplingOptions(int maxAniso) : maxAniso(maxAniso) {}
 };
 
 #endif

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

@@ -33,11 +33,8 @@ public:
     constexpr SkSpan(const SkSpan<U>& that) : fPtr(that.data()), fSize{that.size()} {}
     constexpr SkSpan(const SkSpan& o) = default;
 
-    constexpr SkSpan& operator=(const SkSpan& that) {
-        fPtr = that.fPtr;
-        fSize = that.fSize;
-        return *this;
-    }
+    constexpr SkSpan& operator=(const SkSpan& that) = default;
+
     constexpr T& operator [] (size_t i) const {
         SkASSERT(i < this->size());
         return fPtr[i];
@@ -60,6 +57,9 @@ public:
         SkASSERT(postfixLen <= this->size());
         return SkSpan{fPtr + (this->size() - postfixLen), postfixLen};
     }
+    constexpr SkSpan<T> subspan(size_t offset) const {
+        return this->subspan(offset, this->size() - offset);
+    }
     constexpr SkSpan<T> subspan(size_t offset, size_t count) const {
         SkASSERT(offset <= this->size());
         SkASSERT(count <= this->size() - offset);