@shopify/react-native-skia 0.1.196 → 0.1.199

package/cpp/skia/include/codec/SkJpegDecoder.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkJpegDecoder_DEFINED
+#define SkJpegDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkJpegDecoder {
+
+/** Returns true if this data claims to be a JPEG image. */
+SK_API bool IsJpeg(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a JPEG.
+ *
+ *  If the bytes are not a JPEG, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "jpeg", IsJpeg, Decode };
+}
+
+}  // namespace SkJpegDecoder
+
+#endif  // SkJpegDecoder_DEFINED

package/cpp/skia/include/codec/SkJpegxlDecoder.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkJpegxlDecoder_DEFINED
+#define SkJpegxlDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkJpegxlDecoder {
+
+/** Returns true if this data claims to be a JPEGXL image. */
+SK_API bool IsJpegxl(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a JPEGXL.
+ *
+ *  If the bytes are not a JPEGXL, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "jpegxl", IsJpegxl, Decode };
+}
+
+}  // namespace SkJpegxlDecoder
+
+#endif  // SkJpegxlDecoder_DEFINED

package/cpp/skia/include/codec/SkPngDecoder.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkPngDecoder_DEFINED
+#define SkPngDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkPngDecoder {
+
+/** Returns true if this data claims to be a PNG image. */
+SK_API bool IsPng(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a PNG.
+ *
+ *  If the bytes are not a PNG, returns nullptr.
+ *
+ *  DecodeContext, if non-null, is expected to be a SkPngChunkReader*
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "png", IsPng, Decode };
+}
+
+}  // namespace SkPngDecoder
+
+#endif  // SkPngDecoder_DEFINED

package/cpp/skia/include/codec/SkRawDecoder.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkRawDecoder_DEFINED
+#define SkRawDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkRawDecoder {
+
+inline bool IsRaw(const void*, size_t) {
+    // Raw formats are tricky to detect just by reading in the first several bytes.
+    // For example, PIEX might need to read 10k bytes to detect Sony's arw format
+    // https://github.com/google/piex/blob/f1e15dd837c04347504149f71db67a78fbeddc73/src/image_type_recognition/image_type_recognition_lite.cc#L152
+    // Thus, we just assume everything might be a RAW file and check it last.
+    return true;
+}
+
+/**
+ *  Attempts to decode the given bytes as a raw image.
+ *
+ *  If the bytes are not a raw, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+// This decoder will always be checked last, no matter when it is registered.
+inline SkCodecs::Decoder Decoder() {
+    return { "raw", IsRaw, Decode };
+}
+
+}  // namespace SkRawDecoder
+
+#endif  // SkRawDecoder_DEFINED

package/cpp/skia/include/codec/SkWbmpDecoder.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkWbmpDecoder_DEFINED
+#define SkWbmpDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkWbmpDecoder {
+
+/** Returns true if this data claims to be a WBMP image. */
+SK_API bool IsWbmp(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a WBMP.
+ *
+ *  If the bytes are not a WBMP, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "wbmp", IsWbmp, Decode };
+}
+
+}  // namespace SkWbmpDecoder
+
+#endif  // SkWbmpDecoder_DEFINED

package/cpp/skia/include/codec/SkWebpDecoder.h

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkWebpDecoder_DEFINED
+#define SkWebpDecoder_DEFINED
+
+#include "include/codec/SkCodec.h"
+#include "include/core/SkRefCnt.h"
+
+class SkData;
+class SkStream;
+
+#include <memory>
+
+namespace SkWebpDecoder {
+
+/** Returns true if this data claims to be a WEBP image. */
+SK_API bool IsWebp(const void*, size_t);
+
+/**
+ *  Attempts to decode the given bytes as a WEBP.
+ *
+ *  If the bytes are not a WEBP, returns nullptr.
+ *
+ *  DecodeContext is ignored
+ */
+SK_API std::unique_ptr<SkCodec> Decode(std::unique_ptr<SkStream>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+SK_API std::unique_ptr<SkCodec> Decode(sk_sp<SkData>,
+                                       SkCodec::Result*,
+                                       SkCodecs::DecodeContext = nullptr);
+
+inline SkCodecs::Decoder Decoder() {
+    return { "webp", IsWebp, Decode };
+}
+
+}  // namespace SkWebpDecoder
+
+#endif  // SkWebpDecoder_DEFINED

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

@@ -8,9 +8,13 @@
 #ifndef SkBBHFactory_DEFINED
 #define SkBBHFactory_DEFINED
 
-#include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTypes.h"
+
+// TODO(kjlubick) fix client users and then make this a forward declare
+#include "include/core/SkRect.h"  // IWYU pragma: keep
+
+#include <cstddef>
 #include <vector>
 
 class SkBBoxHierarchy : public SkRefCnt {

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

@@ -26,8 +26,6 @@ public:
 private:
     SkBlender() = default;
     friend class SkBlenderBase;
-
-    using INHERITED = SkFlattenable;
 };
 
 #endif

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

@@ -74,15 +74,6 @@ namespace skgpu::graphite { class Recorder; }
 namespace sktext::gpu { class Slug; }
 namespace SkRecords { class Draw; }
 
-#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_GANESH)
-class GrBackendRenderTarget;
-#endif
-
-// TODO:
-// This is not ideal but Chrome is depending on a forward decl of GrSlug here.
-// It should be removed once Chrome has migrated to sktext::gpu::Slug.
-using GrSlug = sktext::gpu::Slug;
-
 /** \class SkCanvas
     SkCanvas provides an interface for drawing, and how the drawing is clipped and transformed.
     SkCanvas contains a stack of SkMatrix and clip values.
@@ -2183,12 +2174,6 @@ public:
 
     ///////////////////////////////////////////////////////////////////////////
 
-#if defined(SK_BUILD_FOR_ANDROID_FRAMEWORK) && defined(SK_GANESH)
-    // These methods exist to support WebView in Android Framework.
-    SkIRect topLayerBounds() const;
-    GrBackendRenderTarget topLayerBackendRenderTarget() const;
-#endif
-
     /**
      *  Returns the global clip as a region. If the clip contains AA, then only the bounds
      *  of the clip may be returned.
@@ -2300,16 +2285,14 @@ protected:
 
     virtual void onDiscard();
 
-#if (defined(SK_GANESH) || defined(SK_GRAPHITE))
-    /** Experimental
+    /**
      */
     virtual sk_sp<sktext::gpu::Slug> onConvertGlyphRunListToSlug(
             const sktext::GlyphRunList& glyphRunList, const SkPaint& paint);
 
-    /** Experimental
+    /**
      */
     virtual void onDrawSlug(const sktext::gpu::Slug* slug);
-#endif
 
 private:
 
@@ -2457,19 +2440,17 @@ private:
     SkCanvas& operator=(SkCanvas&&) = delete;
     SkCanvas& operator=(const SkCanvas&) = delete;
 
-#if (defined(SK_GANESH) || defined(SK_GRAPHITE))
     friend class sktext::gpu::Slug;
-    /** Experimental
+    /**
      * Convert a SkTextBlob to a sktext::gpu::Slug using the current canvas state.
      */
     sk_sp<sktext::gpu::Slug> convertBlobToSlug(const SkTextBlob& blob, SkPoint origin,
                                                const SkPaint& paint);
 
-    /** Experimental
+    /**
      * Draw an sktext::gpu::Slug given the current canvas state.
      */
     void drawSlug(const sktext::gpu::Slug* slug);
-#endif
 
     /** Experimental
      *  Saves the specified subset of the current pixels in the current layer,

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

@@ -8,12 +8,20 @@
 #ifndef SkColorFilter_DEFINED
 #define SkColorFilter_DEFINED
 
-#include "include/core/SkBlendMode.h"
 #include "include/core/SkColor.h"
 #include "include/core/SkFlattenable.h"
+#include "include/core/SkRefCnt.h"
+#include "include/private/base/SkAPI.h"
+
+#include <cstddef>
+#include <cstdint>
 
 class SkColorMatrix;
 class SkColorSpace;
+class SkColorTable;
+
+enum class SkBlendMode;
+struct SkDeserialProcs;
 
 /**
 *  ColorFilters are optional objects in the drawing pipeline. When present in
@@ -113,6 +121,11 @@ public:
                                           const uint8_t tableG[256],
                                           const uint8_t tableB[256]);
 
+    /**
+     * Create a table colorfilter that holds a ref to the shared color table.
+     */
+    static sk_sp<SkColorFilter> Table(sk_sp<SkColorTable> table);
+
     /**
      *  Create a colorfilter that multiplies the RGB channels by one color, and
      *  then adds a second color, pinning the result for each component to

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

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2023 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkColorTable_DEFINED
+#define SkColorTable_DEFINED
+
+#include "include/core/SkBitmap.h"
+#include "include/core/SkRefCnt.h"
+
+class SkReadBuffer;
+class SkWriteBuffer;
+
+/**
+ * SkColorTable holds the lookup tables for each channel (ARGB) used to define the filter behavior
+ * of `SkColorFilters::Table`, and provides a way to share the table data between client code and
+ * the returned SkColorFilter. Once created, an SkColorTable is immutable.
+*/
+class SkColorTable : public SkRefCnt {
+public:
+    // Creates a new SkColorTable with 'table' used for all four channels. The table is copied into
+    // the SkColorTable.
+    static sk_sp<SkColorTable> Make(const uint8_t table[256]) {
+        return Make(table, table, table, table);
+    }
+
+    // Creates a new SkColorTable with the per-channel lookup tables. Each non-null table is copied
+    // into the SkColorTable. Null parameters are interpreted as the identity table.
+    static sk_sp<SkColorTable> Make(const uint8_t tableA[256],
+                                    const uint8_t tableR[256],
+                                    const uint8_t tableG[256],
+                                    const uint8_t tableB[256]);
+
+    // Per-channel constant value lookup (0-255).
+    const uint8_t* alphaTable() const { return fTable.getAddr8(0, 0); }
+    const uint8_t* redTable()   const { return fTable.getAddr8(0, 1); }
+    const uint8_t* greenTable() const { return fTable.getAddr8(0, 2); }
+    const uint8_t* blueTable()  const { return fTable.getAddr8(0, 3); }
+
+    void flatten(SkWriteBuffer& buffer) const;
+
+    static sk_sp<SkColorTable> Deserialize(SkReadBuffer& buffer);
+
+private:
+    friend class SkTableColorFilter; // for bitmap()
+
+    SkColorTable(const SkBitmap& table) : fTable(table) {}
+
+    // The returned SkBitmap is immutable; attempting to modify its pixel data will trigger asserts
+    // in debug builds and cause undefined behavior in release builds.
+    const SkBitmap& bitmap() const { return fTable; }
+
+    SkBitmap fTable; // A 256x4 A8 image
+};
+
+#endif // SkColorTable_DEFINED

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

@@ -102,6 +102,9 @@ public:
     SkContourMeasureIter(const SkPath& path, bool forceClosed, SkScalar resScale = 1);
     ~SkContourMeasureIter();
 
+    SkContourMeasureIter(SkContourMeasureIter&&);
+    SkContourMeasureIter& operator=(SkContourMeasureIter&&);
+
     /**
      *  Reset the Iter with a path.
      *  The parts of the path that are needed are copied, so the client is free to modify/delete

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

@@ -5,107 +5,11 @@
  * found in the LICENSE file.
  */
 
-#ifndef SkDeferredDisplayList_DEFINED
-#define SkDeferredDisplayList_DEFINED
-
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSurfaceCharacterization.h"
-#include "include/core/SkTypes.h"
-
-class SkDeferredDisplayListPriv;
-class SkPromiseImageTexture;
-
-#if defined(SK_GANESH)
-#include "include/gpu/GrRecordingContext.h"
-#include "include/private/base/SkTArray.h"
-#include <map>
-class GrRenderTask;
-class GrRenderTargetProxy;
-#else
-using GrRenderTargetProxy = SkRefCnt;
-#endif
-
-/*
- * This class contains pre-processed gpu operations that can be replayed into
- * an SkSurface via SkSurface::draw(SkDeferredDisplayList*).
- */
-class SkDeferredDisplayList : public SkNVRefCnt<SkDeferredDisplayList> {
-public:
-    SK_API ~SkDeferredDisplayList();
-
-    SK_API const SkSurfaceCharacterization& characterization() const {
-        return fCharacterization;
-    }
-
-#if defined(SK_GANESH)
-    /**
-     * Iterate through the programs required by the DDL.
-     */
-    class SK_API ProgramIterator {
-    public:
-        ProgramIterator(GrDirectContext*, SkDeferredDisplayList*);
-        ~ProgramIterator();
-
-        // This returns true if any work was done. Getting a cache hit does not count as work.
-        bool compile();
-        bool done() const;
-        void next();
-
-    private:
-        GrDirectContext*                                 fDContext;
-        const skia_private::TArray<GrRecordingContext::ProgramData>& fProgramData;
-        int                                              fIndex;
-    };
-#endif
-
-    // Provides access to functions that aren't part of the public API.
-    SkDeferredDisplayListPriv priv();
-    const SkDeferredDisplayListPriv priv() const;  // NOLINT(readability-const-return-type)
-
-private:
-    friend class GrDrawingManager; // for access to 'fRenderTasks', 'fLazyProxyData', 'fArenas'
-    friend class SkDeferredDisplayListRecorder; // for access to 'fLazyProxyData'
-    friend class SkDeferredDisplayListPriv;
-
-    // This object is the source from which the lazy proxy backing the DDL will pull its backing
-    // texture when the DDL is replayed. It has to be separately ref counted bc the lazy proxy
-    // can outlive the DDL.
-    class LazyProxyData : public SkRefCnt {
-#if defined(SK_GANESH)
-    public:
-        // Upon being replayed - this field will be filled in (by the DrawingManager) with the
-        // proxy backing the destination SkSurface. Note that, since there is no good place to
-        // clear it, it can become a dangling pointer. Additionally, since the renderTargetProxy
-        // doesn't get a ref here, the SkSurface that owns it must remain alive until the DDL
-        // is flushed.
-        // TODO: the drawing manager could ref the renderTargetProxy for the DDL and then add
-        // a renderingTask to unref it after the DDL's ops have been executed.
-        GrRenderTargetProxy* fReplayDest = nullptr;
-#endif
-    };
-
-    SK_API SkDeferredDisplayList(const SkSurfaceCharacterization& characterization,
-                                 sk_sp<GrRenderTargetProxy> fTargetProxy,
-                                 sk_sp<LazyProxyData>);
-
-#if defined(SK_GANESH)
-    const skia_private::TArray<GrRecordingContext::ProgramData>& programData() const {
-        return fProgramData;
-    }
-#endif
-
-    const SkSurfaceCharacterization fCharacterization;
-
-#if defined(SK_GANESH)
-    // These are ordered such that the destructor cleans op tasks up first (which may refer back
-    // to the arena and memory pool in their destructors).
-    GrRecordingContext::OwnedArenas fArenas;
-    skia_private::TArray<sk_sp<GrRenderTask>>   fRenderTasks;
-
-    skia_private::TArray<GrRecordingContext::ProgramData> fProgramData;
-    sk_sp<GrRenderTargetProxy>      fTargetProxy;
-    sk_sp<LazyProxyData>            fLazyProxyData;
-#endif
-};
-
-#endif
+// TODO(kjlubick, robertphillips) migrate Chromium to use the new location and name
+#include "include/private/chromium/GrDeferredDisplayList.h" // IWYU pragma: export
+
+class GrDeferredDisplayListRecorder;
+class GrSurfaceCharacterization;
+using SkDeferredDisplayList = GrDeferredDisplayList;
+using SkDeferredDisplayListRecorder = GrDeferredDisplayListRecorder;
+using SkSurfaceCharacterization = GrSurfaceCharacterization;