@shopify/react-native-skia 0.1.192 → 0.1.194

package/android/CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.4.1)
 
 set (CMAKE_VERBOSE_MAKEFILE ON)
 set (CMAKE_CXX_STANDARD 17)
-set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_GL -DSK_BUILD_FOR_ANDROID -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
+set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSK_GL -DSK_GANESH -DSK_BUILD_FOR_ANDROID -DFOLLY_NO_CONFIG=1 -DFOLLY_HAVE_CLOCK_GETTIME=1 -DFOLLY_HAVE_MEMRCHR=1 -DFOLLY_USE_LIBCPP=1 -DFOLLY_MOBILE=1 -DON_ANDROID -DONANDROID")
 
 set (PACKAGE_NAME "rnskia")
 set (SKIA_LIB "skia")

package/android/build.gradle

@@ -278,6 +278,7 @@ if (ENABLE_PREFAB) {
         into "${project.buildDir}/headers/rnskia/"
         includeEmptyDirs = false
         include "**/*.h"
+        duplicatesStrategy = 'include'
         eachFile {
             String path = it.path
 

package/android/cpp/jni/JniPlatformContext.cpp

@@ -101,7 +101,7 @@ sk_sp<SkImage> JniPlatformContext::takeScreenshotFromViewTag(size_t tag) {
   // Create pixmap from pixels and make a copy of it so that
   // the SkImage owns its own pixels
   SkPixmap pm(skInfo, pixels, bmi.stride);
-  auto skImage = SkImage::MakeRasterCopy(pm);
+  auto skImage = SkImages::RasterFromPixmapCopy(pm);
 
   // Unlock pixels
   AndroidBitmap_unlockPixels(env, bitmap);

package/android/src/main/java/com/shopify/reactnative/skia/ViewScreenshotService.java

@@ -58,123 +58,124 @@ public class ViewScreenshotService {
         paint.setDither(true);
 
         // Render the main view and its children
-        final Canvas c = new Canvas(bitmap);
-        view.draw(c);
+        final Canvas canvas = new Canvas(bitmap);
 
-        // Enumerate children
-        final List<View> childrenList = getAllChildren(view);
+        // Renders view with child views to canvas
+        renderViewToCanvas(canvas, view, paint);
 
-        for (final View child : childrenList) {
-            // skip any child that we don't know how to process
-            if (child instanceof TextureView) {
-                // skip all invisible to user child views
-                if (child.getVisibility() != VISIBLE) continue;
+        return bitmap;
+    }
 
-                final TextureView tvChild = (TextureView) child;
-                tvChild.setOpaque(false); // <-- switch off background fill
-
-                // TextureView should use bitmaps with matching size,
-                // otherwise content of the TextureView will be scaled to provided bitmap dimensions
-                final Bitmap childBitmapBuffer = tvChild.getBitmap(Bitmap.createBitmap(child.getWidth(), child.getHeight(), Bitmap.Config.ARGB_8888));
-
-                final int countCanvasSave = c.save();
-                applyTransformations(c, view, child);
-
-                // due to re-use of bitmaps for screenshot, we can get bitmap that is bigger in size than requested
-                c.drawBitmap(childBitmapBuffer, 0, 0, paint);
-
-                c.restoreToCount(countCanvasSave);
-            } else if (child instanceof SurfaceView) {
-                final SurfaceView svChild = (SurfaceView)child;
-                final CountDownLatch latch = new CountDownLatch(1);
-
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
-                    final Bitmap childBitmapBuffer = Bitmap.createBitmap(child.getWidth(), child.getHeight(), Bitmap.Config.ARGB_8888);
-                    try {
-                        PixelCopy.request(svChild, childBitmapBuffer, new PixelCopy.OnPixelCopyFinishedListener() {
-                            @Override
-                            public void onPixelCopyFinished(int copyResult) {
-                                final int countCanvasSave = c.save();
-                                applyTransformations(c, view, child);
-                                c.drawBitmap(childBitmapBuffer, 0, 0, paint);
-                                c.restoreToCount(countCanvasSave);
-                                latch.countDown();
-                            }
-                        }, new Handler(Looper.getMainLooper()));
-                        latch.await(SURFACE_VIEW_READ_PIXELS_TIMEOUT, TimeUnit.SECONDS);
-                    } catch (Exception e) {
-                        Log.e(TAG, "Cannot PixelCopy for " + svChild, e);
-                    }
-                } else {
-                    Bitmap cache = svChild.getDrawingCache();
-                    if (cache != null) {
-                        c.drawBitmap(svChild.getDrawingCache(), 0, 0, paint);
-                    }
+    private static void renderViewToCanvas(Canvas canvas, View view, Paint paint) {
+        // Apply transformations for the current view
+        canvas.save();
+        applyTransformations(canvas, view);
+
+        // Draw children if the view has children
+        if ((view instanceof ViewGroup)) {
+            // Draw children
+            ViewGroup group = (ViewGroup) view;
+
+            // Hide visible children - this needs to be done because view.draw(canvas)
+            // will render all visible non-texture/surface views directly - causing
+            // views to be rendered twice - once by view.draw() and once when we
+            // enumerate children. We therefore need to turn off rendering of visible
+            // children before we call view.draw:
+            List<View> visibleChildren = new ArrayList<>();
+            for (int i = 0; i < group.getChildCount(); i++) {
+                View child = group.getChildAt(i);
+                if (child.getVisibility() == VISIBLE) {
+                    visibleChildren.add(child);
+                    child.setVisibility(View.INVISIBLE);
                 }
             }
-        }
-
-        return bitmap;
-    }
 
-    private static List<View> getAllChildren(@NonNull final View v) {
-        if (!(v instanceof ViewGroup)) {
-            final ArrayList<View> viewArrayList = new ArrayList<>();
-            viewArrayList.add(v);
+            // Draw ourselves
+            view.draw(canvas);
 
-            return viewArrayList;
-        }
+            // Enable children again
+            for (int i = 0; i < visibleChildren.size(); i++) {
+                View child = visibleChildren.get(i);
+                child.setVisibility(VISIBLE);
+            }
 
-        final ArrayList<View> result = new ArrayList<>();
+            // Draw children
+            for (int i = 0; i < group.getChildCount(); i++) {
+                View child = group.getChildAt(i);
 
-        ViewGroup viewGroup = (ViewGroup) v;
-        for (int i = 0; i < viewGroup.getChildCount(); i++) {
-            View child = viewGroup.getChildAt(i);
+                // skip all invisible to user child views
+                if (child.getVisibility() != VISIBLE) continue;
 
-            //Do not add any parents, just add child elements
-            result.addAll(getAllChildren(child));
+                // skip any child that we don't know how to process
+                if (child instanceof TextureView) {
+                    final TextureView tvChild = (TextureView) child;
+                    tvChild.setOpaque(false); // <-- switch off background fill
+
+                    canvas.save();
+                    applyTransformations(canvas, child);
+
+                    // TextureView should use bitmaps with matching size,
+                    // otherwise content of the TextureView will be scaled to provided bitmap dimensions
+                    final Bitmap childBitmapBuffer = tvChild.getBitmap(Bitmap.createBitmap(child.getWidth(), child.getHeight(), Bitmap.Config.ARGB_8888));
+                    canvas.drawBitmap(childBitmapBuffer, 0, 0, paint);
+
+                    canvas.restore();
+
+                } else if (child instanceof SurfaceView) {
+                    final SurfaceView svChild = (SurfaceView) child;
+                    final CountDownLatch latch = new CountDownLatch(1);
+
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                        final Bitmap childBitmapBuffer = Bitmap.createBitmap(child.getWidth(), child.getHeight(), Bitmap.Config.ARGB_8888);
+                        try {
+                            PixelCopy.request(svChild, childBitmapBuffer, copyResult -> {
+                                canvas.save();
+                                applyTransformations(canvas, child);
+                                canvas.drawBitmap(childBitmapBuffer, 0, 0, paint);
+                                canvas.restore();
+                                latch.countDown();
+                            }, new Handler(Looper.getMainLooper()));
+                            latch.await(SURFACE_VIEW_READ_PIXELS_TIMEOUT, TimeUnit.SECONDS);
+                        } catch (Exception e) {
+                            Log.e(TAG, "Cannot PixelCopy for " + svChild, e);
+                        }
+                    } else {
+                        Bitmap cache = svChild.getDrawingCache();
+                        if (cache != null) {
+                            canvas.save();
+                            applyTransformations(canvas, child);
+                            canvas.drawBitmap(svChild.getDrawingCache(), 0, 0, paint);
+                            canvas.restore();
+                        }
+                    }
+                } else {
+                    // Regular views needs to be rendered again to ensure correct z-index
+                    // order with texture views and surface views.
+                    renderViewToCanvas(canvas, child, paint);
+                }
+            }
+        } else {
+            // Draw ourselves
+            view.draw(canvas);
         }
 
-        return result;
+        // Restore canvas
+        canvas.restore();
     }
 
-    /**
-     * Concat all the transformation matrix's from parent to child.
-     */
     @NonNull
-    @SuppressWarnings("UnusedReturnValue")
-    private static Matrix applyTransformations(final Canvas c, @NonNull final View root, @NonNull final View child) {
-        final Matrix transform = new Matrix();
-        final LinkedList<View> ms = new LinkedList<>();
-
-        // find all parents of the child view
-        View iterator = child;
-        do {
-            ms.add(iterator);
-
-            iterator = (View) iterator.getParent();
-        } while (iterator != root);
-
-        // apply transformations from parent --> child order
-        Collections.reverse(ms);
-
-        for (final View v : ms) {
-            c.save();
-
-            // apply each view transformations, so each child will be affected by them
-            final float dx = v.getLeft() + ((v != child) ? v.getPaddingLeft() : 0) + v.getTranslationX();
-            final float dy = v.getTop() + ((v != child) ? v.getPaddingTop() : 0) + v.getTranslationY();
-            c.translate(dx, dy);
-            c.rotate(v.getRotation(), v.getPivotX(), v.getPivotY());
-            c.scale(v.getScaleX(), v.getScaleY());
-
-            // compute the matrix just for any future use
-            transform.postTranslate(dx, dy);
-            transform.postRotate(v.getRotation(), v.getPivotX(), v.getPivotY());
-            transform.postScale(v.getScaleX(), v.getScaleY());
-        }
-
-        return transform;
+    private static void applyTransformations(final Canvas c, @NonNull final View view) {
+        // Get the transformation matrix of the view
+        final Matrix matrix = view.getMatrix();
+
+        // Create a new matrix for translation
+        final Matrix translateMatrix = new Matrix();
+        final float dx = view.getLeft() + view.getPaddingLeft() + view.getTranslationX();
+        final float dy = view.getTop() + view.getPaddingTop() + view.getTranslationY();
+        translateMatrix.setTranslate(dx, dy);
+
+        // Pre-concatenate the current matrix of the canvas with the translation and transformation matrices of the view
+        c.concat(translateMatrix);
+        c.concat(matrix);
     }
-
 }

package/cpp/api/JsiSkImage.h

@@ -14,7 +14,9 @@
 #include "SkBase64.h"
 #include "SkImage.h"
 #include "SkStream.h"
-#include <include/codec/SkCodec.h>
+#include "codec/SkEncodedImageFormat.h"
+#include "include/encode/SkJpegEncoder.h"
+#include "include/encode/SkPngEncoder.h"
 
 #pragma clang diagnostic pop
 
@@ -70,7 +72,15 @@ public:
     auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
 
     // Get data
-    auto data = getObject()->encodeToData(format, quality);
+    sk_sp<SkData> data;
+    if (format == SkEncodedImageFormat::kJPEG) {
+      SkJpegEncoder::Options options;
+      options.fQuality = quality;
+      data = SkJpegEncoder::Encode(nullptr, getObject().get(), options);
+    } else {
+      SkPngEncoder::Options options;
+      data = SkPngEncoder::Encode(nullptr, getObject().get(), options);
+    }
     auto arrayCtor =
         runtime.global().getPropertyAsFunction(runtime, "Uint8Array");
     size_t size = data->size();
@@ -95,8 +105,19 @@ public:
                    : SkEncodedImageFormat::kPNG;
 
     auto quality = count == 2 ? arguments[1].asNumber() : 100.0;
-
-    auto data = getObject()->encodeToData(format, quality);
+    auto image = getObject();
+    if (image->isTextureBacked()) {
+      image = image->makeNonTextureImage();
+    }
+    sk_sp<SkData> data;
+    if (format == SkEncodedImageFormat::kJPEG) {
+      SkJpegEncoder::Options options;
+      options.fQuality = quality;
+      data = SkJpegEncoder::Encode(nullptr, image.get(), options);
+    } else {
+      SkPngEncoder::Options options;
+      data = SkPngEncoder::Encode(nullptr, image.get(), options);
+    }
     auto len = SkBase64::Encode(data->bytes(), data->size(), nullptr);
     auto buffer = std::string(len, 0);
     SkBase64::Encode(data->bytes(), data->size(),

package/cpp/api/JsiSkImageFactory.h

@@ -18,7 +18,7 @@ class JsiSkImageFactory : public JsiSkHostObject {
 public:
   JSI_HOST_FUNCTION(MakeImageFromEncoded) {
     auto data = JsiSkData::fromValue(runtime, arguments[0]);
-    auto image = SkImage::MakeFromEncoded(data);
+    auto image = SkImages::DeferredFromEncodedData(data);
     if (image == nullptr) {
       return jsi::Value::null();
     }
@@ -30,7 +30,7 @@ public:
     auto imageInfo = JsiSkImageInfo::fromValue(runtime, arguments[0]);
     auto pixelData = JsiSkData::fromValue(runtime, arguments[1]);
     auto bytesPerRow = arguments[2].asNumber();
-    auto image = SkImage::MakeRasterData(*imageInfo, pixelData, bytesPerRow);
+    auto image = SkImages::RasterFromData(*imageInfo, pixelData, bytesPerRow);
     if (image == nullptr) {
       return jsi::Value::null();
     }

package/cpp/api/JsiSkPath.h

@@ -7,6 +7,7 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkHostObjects.h"
+#include "JsiSkMatrix.h"
 #include "JsiSkPoint.h"
 #include "JsiSkRRect.h"
 #include "JsiSkRect.h"
@@ -20,13 +21,12 @@
 #include "SkPathEffect.h"
 #include "SkPathOps.h"
 #include "SkPathTypes.h"
+#include "SkPathUtils.h"
 #include "SkString.h"
 #include "SkStrokeRec.h"
 #include "SkTextUtils.h"
 #include "SkTrimPathEffect.h"
 
-#include "JsiSkMatrix.h"
-
 #pragma clang diagnostic pop
 
 namespace RNSkia {
@@ -284,8 +284,11 @@ public:
 
     auto jsiPrecision = opts.getProperty(runtime, "precision");
     auto precision = jsiPrecision.isUndefined() ? 1 : jsiPrecision.asNumber();
-    auto result = p.getFillPath(path, &path, nullptr, precision);
-    getObject()->swap(path);
+    auto result =
+        skpathutils::FillPathWithPaint(path, p, &path, nullptr, precision);
+    if (result) {
+      getObject()->swap(path);
+    }
     return result ? thisValue.getObject(runtime) : jsi::Value::null();
   }
 
@@ -320,8 +323,7 @@ public:
 
   JSI_HOST_FUNCTION(toSVGString) {
     SkPath path = *getObject();
-    SkString s;
-    SkParsePath::ToSVGString(path, &s);
+    auto s = SkParsePath::ToSVGString(path);
     return jsi::String::createFromUtf8(runtime, s.c_str());
   }
 

package/cpp/rnskia/dom/base/Declaration.h

@@ -24,17 +24,15 @@ public:
   void push(T el) { _elements.push(el); }
 
   // Clears and returns all elements
-  std::vector<T> popAll() { return popMultiple(_elements.size()); }
-
-  // Pops the number of items up to limit
-  std::vector<T> popMultiple(size_t limit) {
-    auto size = std::min(limit, _elements.size());
+  std::vector<T> popAll() {
+    auto size = _elements.size();
     std::vector<T> tmp;
     tmp.reserve(size);
     for (size_t i = 0; i < size; ++i) {
       tmp.push_back(_elements.top());
       _elements.pop();
     }
+    std::reverse(std::begin(tmp), std::end(tmp));
     return tmp;
   }
 
@@ -50,7 +48,7 @@ public:
   // Clears and returns through reducer function in reversed order
   T popAsOne(std::function<T(T inner, T outer)> composer) {
     auto tmp = popAll();
-    // std::reverse(std::begin(tmp), std::end(tmp));
+    std::reverse(std::begin(tmp), std::end(tmp));
     return std::accumulate(std::begin(tmp), std::end(tmp),
                            static_cast<T>(nullptr), [=](T inner, T outer) {
                              if (inner == nullptr) {
@@ -63,7 +61,7 @@ public:
   // Returns the size of the elements
   size_t size() { return _elements.size(); }
 
-protected:
+private:
   std::stack<T> _elements;
 };
 

package/cpp/rnskia/dom/base/JsiDomDrawingNode.h

@@ -30,7 +30,9 @@ protected:
 #endif
     // Save paint if the paint property is set
     if (_paintProp->isSet()) {
-      draw(_paintProp->getUnsafeDerivedValue().get());
+      auto localCtx = _paintProp->getUnsafeDerivedValue().get();
+      localCtx->setCanvas(context->getCanvas());
+      draw(localCtx);
     } else {
       // Call abstract draw method
       draw(context);

package/cpp/rnskia/dom/nodes/JsiBlurMaskNode.h

@@ -10,6 +10,7 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
+#include "SkBlurTypes.h"
 #include "SkMaskFilter.h"
 
 #pragma clang diagnostic pop

package/cpp/rnskia/dom/nodes/JsiPathNode.h

@@ -108,8 +108,8 @@ protected:
           // _path is const so we can't mutate it directly, let's replace the
           // path like this:
           auto p = std::make_shared<SkPath>(*_path.get());
-          if (!strokePaint.getFillPath(*_path.get(), p.get(), nullptr,
-                                       precision)) {
+          if (!skpathutils::FillPathWithPaint(*_path.get(), strokePaint,
+                                              p.get(), nullptr, precision)) {
             _path = nullptr;
           } else {
             _path = std::const_pointer_cast<const SkPath>(p);

package/cpp/rnskia/dom/props/BoxShadowProps.h

@@ -5,6 +5,8 @@
 #include <memory>
 #include <utility>
 
+#include "SkBlurTypes.h"
+
 namespace RNSkia {
 
 class BoxShadowProps : public DerivedProp<SkPaint> {

package/cpp/skia/include/android/SkAndroidFrameworkUtils.h

@@ -27,7 +27,7 @@ class SkShader;
 class SkAndroidFrameworkUtils {
 public:
 
-#if SK_SUPPORT_GPU
+#if defined(SK_GANESH)
     /**
      *  clipWithStencil draws the current clip into a stencil buffer with reference value and mask
      *  set to 0x1. This function works only on a GPU canvas.
@@ -37,7 +37,7 @@ public:
      *  @return true on success or false if clip is empty or not a GPU canvas.
      */
     static bool clipWithStencil(SkCanvas* canvas);
-#endif //SK_SUPPORT_GPU
+#endif //defined(SK_GANESH)
 
     static void SafetyNetLog(const char*);
 
@@ -58,12 +58,6 @@ public:
      */
     static SkCanvas* getBaseWrappedCanvas(SkCanvas* canvas);
 
-    /**
-     * Skia will change the order in which local matrices concatenate. In order to not break Android
-     * apps targeting older API levels we offer this function to use the legacy concatenation order.
-     */
-    static void UseLegacyLocalMatrixConcatenation();
-
     /**
      *  If the shader represents a linear gradient ShaderAsALinearGradient
      *  returns true and if info is not null, ShaderAsALinearGradient populates

package/cpp/skia/include/android/SkImageAndroid.h

@@ -0,0 +1,101 @@
+/*
+ * 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 SkImageAndroid_DEFINED
+#define SkImageAndroid_DEFINED
+
+#include "include/core/SkImage.h"
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrTypes.h"
+
+class SkColorSpace;
+class GrDirectContext;
+class SkPixmap;
+struct AHardwareBuffer;
+
+namespace SkImages {
+
+/** (See Skia bug 7447)
+    Creates SkImage from Android hardware buffer.
+    Returned SkImage takes a reference on the buffer.
+    Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param colorSpace      range of colors; may be nullptr
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> DeferredFromAHardwareBuffer(AHardwareBuffer* hardwareBuffer,
+                                                  SkAlphaType alphaType = kPremul_SkAlphaType);
+SK_API sk_sp<SkImage> DeferredFromAHardwareBuffer(
+        AHardwareBuffer* hardwareBuffer,
+        SkAlphaType alphaType,
+        sk_sp<SkColorSpace> colorSpace,
+        GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
+
+/** Creates SkImage from Android hardware buffer and uploads the data from the SkPixmap to it.
+    Returned SkImage takes a reference on the buffer.
+    Only available on Android, when __ANDROID_API__ is defined to be 26 or greater.
+    @param context         GPU context
+    @param pixmap          SkPixmap that contains data to be uploaded to the AHardwareBuffer
+    @param hardwareBuffer  AHardwareBuffer Android hardware buffer
+    @param surfaceOrigin   surface origin for resulting image
+    @return                created SkImage, or nullptr
+*/
+SK_API sk_sp<SkImage> TextureFromAHardwareBufferWithData(
+        GrDirectContext* context,
+        const SkPixmap& pixmap,
+        AHardwareBuffer* hardwareBuffer,
+        GrSurfaceOrigin surfaceOrigin = kTopLeft_GrSurfaceOrigin);
+
+/**
+ *  Like SkImagePriv::SkMakeImageFromRasterBitmap, except this can be pinned using
+ *  skgpu::ganesh::PinAsTexture and CopyPixelMode is never.
+ */
+SK_API sk_sp<SkImage> PinnableRasterFromBitmap(const SkBitmap&);
+
+}  // namespace SkImages
+
+// TODO(kjlubick) remove this after Android has been ported.
+namespace sk_image_factory {
+inline sk_sp<SkImage> MakePinnableFromRasterBitmap(const SkBitmap& b) {
+    return SkImages::PinnableRasterFromBitmap(b);
+}
+}  // namespace sk_image_factory
+
+namespace skgpu::ganesh {
+/**
+ *  Will attempt to upload and lock the contents of the image as a texture, so that subsequent
+ *  draws to a gpu-target will come from that texture (and not by looking at the original image
+ *  src). In particular this is intended to use the texture even if the image's original content
+ *  changes subsequent to this call (i.e. the src is mutable!).
+ *
+ *  Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.
+ *
+ *  All successful calls must be balanced by an equal number of calls to UnpinTexture().
+ *
+ *  Once in this "pinned" state, the image has all of the same thread restrictions that exist
+ *  for a natively created gpu image (e.g. SkImage::MakeFromTexture)
+ *  - all drawing, pinning, unpinning must happen in the same thread as the GrContext.
+ *
+ *  @return true if the image was successfully uploaded and locked into a texture
+ */
+bool PinAsTexture(GrRecordingContext*, SkImage*);
+
+/**
+ *  The balancing call to a successful invocation of PinAsTexture. When a balanced
+ *  number of calls have been made, then the "pinned" texture is free to be purged, etc. This
+ *  also means that a subsequent "pin" call will look at the original content again, and if
+ *  its uniqueID/generationID has changed, then a newer texture will be uploaded/pinned.
+ *
+ *  Only compatible with SkImages created from SkImages::PinnableRasterFromBitmap.
+ *
+ *  The context passed to unpin must match the one passed to pin.
+ */
+void UnpinTexture(GrRecordingContext*, SkImage*);
+
+} // namespace skgpu::ganesh
+
+#endif

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

@@ -9,24 +9,27 @@
 #define SkAndroidCodec_DEFINED
 
 #include "include/codec/SkCodec.h"
-#include "include/core/SkAlphaType.h"
 #include "include/core/SkColorSpace.h"
-#include "include/core/SkColorType.h"
-#include "include/core/SkEncodedImageFormat.h"
 #include "include/core/SkImageInfo.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkEncodedInfo.h"
-#include "include/private/SkNoncopyable.h"
+#include "include/private/base/SkNoncopyable.h"
 #include "modules/skcms/skcms.h"
 
+// TODO(kjlubick, bungeman) Replace these includes with forward declares
+#include "include/codec/SkEncodedImageFormat.h" // IWYU pragma: keep
+#include "include/core/SkAlphaType.h" // IWYU pragma: keep
+#include "include/core/SkColorType.h" // IWYU pragma: keep
+
 #include <cstddef>
 #include <memory>
 
 class SkData;
 class SkPngChunkReader;
 class SkStream;
+struct SkGainmapInfo;
 struct SkIRect;
 
 /**
@@ -118,10 +121,8 @@ public:
     /**
      *  @param outputColorType Color type that the client will decode to.
      *  @param prefColorSpace  Preferred color space to decode to.
-     *                         This may not return |prefColorSpace| for a couple reasons.
-     *                         (1) Android Principles: 565 must be sRGB, F16 must be
-     *                             linear sRGB, transfer function must be parametric.
-     *                         (2) Codec Limitations: F16 requires a linear color space.
+     *                         This may not return |prefColorSpace| for
+     *                         specific color types.
      *
      *  Returns the appropriate color space to decode to.
      */
@@ -262,6 +263,23 @@ public:
 
     SkCodec* codec() const { return fCodec.get(); }
 
+    /**
+     *  Retrieve the gainmap for an image.
+     *
+     *  @param outInfo                On success, this is populated with the parameters for
+     *                                rendering this gainmap. This parameter must be non-nullptr.
+     *
+     *  @param outGainmapImageStream  On success, this is populated with a stream from which the
+     *                                gainmap image may be decoded. This parameter is optional, and
+     *                                may be set to nullptr.
+     *
+     *  @return                       If this has a gainmap image and that gainmap image was
+     *                                successfully extracted then return true. Otherwise return
+     *                                false.
+     */
+    bool getAndroidGainmap(SkGainmapInfo* outInfo,
+                           std::unique_ptr<SkStream>* outGainmapImageStream);
+
 protected:
     SkAndroidCodec(SkCodec*);