@shopify/react-native-skia 0.1.197 → 0.1.199

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;

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

@@ -5,94 +5,11 @@
  * found in the LICENSE file.
  */
 
-#ifndef SkDeferredDisplayListRecorder_DEFINED
-#define SkDeferredDisplayListRecorder_DEFINED
-
-#include "include/core/SkDeferredDisplayList.h"
-#include "include/core/SkImage.h"
-#include "include/core/SkImageInfo.h"
-#include "include/core/SkRefCnt.h"
-#include "include/core/SkSurfaceCharacterization.h"
-#include "include/core/SkTypes.h"
-
-class GrBackendFormat;
-class GrBackendTexture;
-class GrRecordingContext;
-class GrYUVABackendTextureInfo;
-class SkCanvas;
-class SkSurface;
-
-/*
- * This class is intended to be used as:
- *   Get an SkSurfaceCharacterization representing the intended gpu-backed destination SkSurface
- *   Create one of these (an SkDeferredDisplayListRecorder) on the stack
- *   Get the canvas and render into it
- *   Snap off and hold on to an SkDeferredDisplayList
- *   Once your app actually needs the pixels, call SkSurface::draw(SkDeferredDisplayList*)
- *
- * This class never accesses the GPU but performs all the cpu work it can. It
- * is thread-safe (i.e., one can break a scene into tiles and perform their cpu-side
- * work in parallel ahead of time).
- */
-class SK_API SkDeferredDisplayListRecorder {
-public:
-    SkDeferredDisplayListRecorder(const SkSurfaceCharacterization&);
-    ~SkDeferredDisplayListRecorder();
-
-    const SkSurfaceCharacterization& characterization() const {
-        return fCharacterization;
-    }
-
-    // The backing canvas will become invalid (and this entry point will return
-    // null) once 'detach' is called.
-    // Note: ownership of the SkCanvas is not transferred via this call.
-    SkCanvas* getCanvas();
-
-    sk_sp<SkDeferredDisplayList> detach();
-
-#if defined(SK_GANESH)
-    using PromiseImageTextureContext = void*;
-    using PromiseImageTextureFulfillProc =
-            sk_sp<SkPromiseImageTexture> (*)(PromiseImageTextureContext);
-    using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
-
-#ifndef SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-    /** Deprecated: Use SkImages::PromiseTextureFrom instead. */
-    sk_sp<SkImage> makePromiseTexture(const GrBackendFormat& backendFormat,
-                                      int width,
-                                      int height,
-                                      GrMipmapped mipmapped,
-                                      GrSurfaceOrigin origin,
-                                      SkColorType colorType,
-                                      SkAlphaType alphaType,
-                                      sk_sp<SkColorSpace> colorSpace,
-                                      PromiseImageTextureFulfillProc textureFulfillProc,
-                                      PromiseImageTextureReleaseProc textureReleaseProc,
-                                      PromiseImageTextureContext textureContext);
-
-    /** Deprecated: Use SkImages::PromiseTextureFromYUVA instead. */
-    sk_sp<SkImage> makeYUVAPromiseTexture(const GrYUVABackendTextureInfo& yuvaBackendTextureInfo,
-                                          sk_sp<SkColorSpace> imageColorSpace,
-                                          PromiseImageTextureFulfillProc textureFulfillProc,
-                                          PromiseImageTextureReleaseProc textureReleaseProc,
-                                          PromiseImageTextureContext textureContexts[]);
-#endif // SK_MAKE_PROMISE_TEXTURE_DISABLE_LEGACY_API
-#endif // defined(SK_GANESH)
-
-private:
-    SkDeferredDisplayListRecorder(const SkDeferredDisplayListRecorder&) = delete;
-    SkDeferredDisplayListRecorder& operator=(const SkDeferredDisplayListRecorder&) = delete;
-
-    bool init();
-
-    const SkSurfaceCharacterization             fCharacterization;
-
-#if defined(SK_GANESH)
-    sk_sp<GrRecordingContext>                   fContext;
-    sk_sp<GrRenderTargetProxy>                  fTargetProxy;
-    sk_sp<SkDeferredDisplayList::LazyProxyData> fLazyProxyData;
-    sk_sp<SkSurface>                            fSurface;
-#endif
-};
-
-#endif
+// TODO(kjlubick, robertphillips) migrate Chromium to use the new location
+#include "include/private/chromium/GrDeferredDisplayListRecorder.h" // IWYU pragma: export
+
+class GrDeferredDisplayList;
+class GrSurfaceCharacterization;
+using SkDeferredDisplayList = GrDeferredDisplayList;
+using SkDeferredDisplayListRecorder = GrDeferredDisplayListRecorder;
+using SkSurfaceCharacterization = GrSurfaceCharacterization;

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

@@ -93,7 +93,10 @@ public:
         return this->onSnapGpuDrawHandler(backendApi, matrix, clipBounds, bufferInfo);
     }
 
-    SkPicture* newPictureSnapshot();
+    /**
+     * Returns an SkPicture with the contents of this SkDrawable.
+     */
+    sk_sp<SkPicture> makePictureSnapshot();
 
     /**
      *  Return a unique value for this instance. If two calls to this return the same value,
@@ -166,7 +169,7 @@ protected:
      *  of their drawable. Note: this picture must draw the same as what would be drawn from
      *  onDraw().
      */
-    virtual SkPicture* onNewPictureSnapshot();
+    virtual sk_sp<SkPicture> onMakePictureSnapshot();
 
 private:
     int32_t fGenerationID;

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

@@ -74,6 +74,13 @@ public:
      */
     static void PurgeFontCache();
 
+    /**
+     *  If the strike cache is above the cache limit, attempt to purge strikes
+     *  with pinners. This should be called after clients release locks on
+     *  pinned strikes.
+     */
+    static void PurgePinnedFontCache();
+
     /**
      *  This function returns the memory used for temporary images and other resources.
      */
@@ -147,25 +154,6 @@ public:
      *  Call early in main() to allow Skia to use a JIT to accelerate CPU-bound operations.
      */
     static void AllowJIT();
-
-    /**
-     *  To override the default AA algorithm choice in the CPU backend, provide a function that
-     *  returns whether to use analytic (true) or supersampled (false) for a given path.
-     *
-     *  NOTE: This is a temporary API, intended for migration of all clients to one algorithm,
-     *        and should not be used.
-     */
-    typedef bool (*PathAnalyticAADeciderProc)(const SkPath&);
-    static void SetPathAnalyticAADecider(PathAnalyticAADeciderProc);
-
-    /*
-     *  Similar to above, but simply forces the CPU backend to always use analytic AA.
-     *
-     *  NOTE: This is a temporary API, intended for migration of all clients to one algorithm.
-     *        If the PathAnalyticAADeciderProc is *also* set, this setting has no effect.
-     *        Unlike that API, this function is thread-safe.
-     */
-    static void SetForceAnalyticAA(bool);
 };
 
 class SkAutoGraphics {