@shopify/react-native-skia 0.1.212 → 0.1.214

package/cpp/skia/include/private/chromium/SkImageChromium.h

@@ -9,17 +9,21 @@
 #define SkImageChromium_DEFINED
 
 #include "include/core/SkRefCnt.h"
-#include "include/gpu/GrTypes.h"
 #include "include/private/base/SkAPI.h"
 
 class GrBackendFormat;
 class GrContextThreadSafeProxy;
 class GrPromiseImageTexture;
+class GrDirectContext;
 class GrYUVABackendTextureInfo;
 class SkColorSpace;
 class SkImage;
 enum SkAlphaType : int;
 enum SkColorType : int;
+enum GrSurfaceOrigin : int;
+namespace skgpu {
+enum class Mipmapped : bool;
+}
 struct SkISize;
 
 /**
@@ -37,7 +41,7 @@ using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
     image pixel data. Moreover, the SkImage may be created on a thread as the creation of the
     image does not require access to the backend API or GrDirectContext. Instead of passing a
     GrBackendTexture the client supplies a description of the texture consisting of
-    GrBackendFormat, width, height, and GrMipmapped state. The resulting SkImage can be drawn
+    GrBackendFormat, width, height, and skgpu::Mipmapped state. The resulting SkImage can be drawn
     to a GrDeferredDisplayListRecorder or directly to a GPU-backed SkSurface.
     When the actual texture is required to perform a backend API draw, textureFulfillProc will
     be called to receive a GrBackendTexture. The properties of the GrBackendTexture must match
@@ -63,7 +67,7 @@ using PromiseImageTextureReleaseProc = void (*)(PromiseImageTextureContext);
 SK_API sk_sp<SkImage> PromiseTextureFrom(sk_sp<GrContextThreadSafeProxy> gpuContextProxy,
                                          const GrBackendFormat& backendFormat,
                                          SkISize dimensions,
-                                         GrMipmapped mipmapped,
+                                         skgpu::Mipmapped mipmapped,
                                          GrSurfaceOrigin origin,
                                          SkColorType colorType,
                                          SkAlphaType alphaType,
@@ -99,6 +103,15 @@ SK_API sk_sp<SkImage> PromiseTextureFromYUVA(sk_sp<GrContextThreadSafeProxy> gpu
                                              PromiseImageTextureReleaseProc textureReleaseProc,
                                              PromiseImageTextureContext textureContexts[]);
 
+/** Returns the GPU context associated with this image or nullptr if the image is not Ganesh-backed.
+    We expose this only to help transition certain API calls and do not intend for this to stick
+    around forever.
+*/
+SK_API GrDirectContext* GetContext(const SkImage* src);
+inline GrDirectContext* GetContext(sk_sp<const SkImage> src) {
+    return GetContext(src.get());
+}
+
 }  // namespace SkImages
 
 #endif

package/cpp/skia/include/private/chromium/Slug.h

@@ -10,6 +10,7 @@
 
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
+#include "include/core/SkSerialProcs.h"  // IWYU pragma: keep
 #include "include/private/base/SkAPI.h"
 
 #include <cstddef>
@@ -37,15 +38,19 @@ public:
             SkCanvas* canvas, const SkTextBlob& blob, SkPoint origin, const SkPaint& paint);
 
     // Serialize the slug.
-    sk_sp<SkData> serialize() const;
-    size_t serialize(void* buffer, size_t size) const;
+    sk_sp<SkData> serialize(const SkSerialProcs& procs = {}) const;
+    size_t serialize(void* buffer, size_t size, const SkSerialProcs& procs = {}) const;
 
     // Set the client parameter to the appropriate SkStrikeClient when typeface ID translation
     // is needed.
-    static sk_sp<Slug> Deserialize(
-            const void* data, size_t size, const SkStrikeClient* client = nullptr);
+    static sk_sp<Slug> Deserialize(const void* data,
+                                   size_t size,
+                                   const SkStrikeClient* client = nullptr,
+                                   const SkDeserialProcs& procs = {});
     static sk_sp<Slug> MakeFromBuffer(SkReadBuffer& buffer);
 
+    // Allows clients to deserialize SkPictures that contain slug data
+    static void AddDeserialProcs(SkDeserialProcs* procs, const SkStrikeClient* client = nullptr);
 
     // Draw the Slug obeying the canvas's mapping and clipping.
     void draw(SkCanvas* canvas) const;
@@ -66,6 +71,8 @@ private:
     static uint32_t NextUniqueID();
     const uint32_t  fUniqueID{NextUniqueID()};
 };
+
+
 }  // namespace sktext::gpu
 
 #endif  // sktext_gpu_Slug_DEFINED

package/cpp/skia/include/private/gpu/ganesh/GrD3DTypesMinimal.h

@@ -48,7 +48,7 @@ struct GrD3DBackendSurfaceInfo {
     GrD3DTextureResourceInfo snapTextureResourceInfo() const;
 
     bool isProtected() const;
-#if GR_TEST_UTILS
+#if defined(GR_TEST_UTILS)
     bool operator==(const GrD3DBackendSurfaceInfo& that) const;
 #endif
 

package/cpp/skia/include/private/gpu/ganesh/GrGLTypesPriv.h

@@ -11,6 +11,8 @@
 #ifndef GrGLTypesPriv_DEFINED
 #define GrGLTypesPriv_DEFINED
 
+// TODO(b/293490566) Move this to src/ after GrSurfaceInfo.h has been decoupled from GL
+
 static constexpr int kGrGLColorFormatCount = static_cast<int>(GrGLFormat::kLastColorFormat) + 1;
 
 class GrGLTextureParameters : public SkNVRefCnt<GrGLTextureParameters> {
@@ -76,22 +78,17 @@ private:
 
 class GrGLBackendTextureInfo {
 public:
-    GrGLBackendTextureInfo(const GrGLTextureInfo& info, GrGLTextureParameters* params)
+    GrGLBackendTextureInfo(const GrGLTextureInfo& info, sk_sp<GrGLTextureParameters> params)
             : fInfo(info), fParams(params) {}
-    GrGLBackendTextureInfo(const GrGLBackendTextureInfo&) = delete;
-    GrGLBackendTextureInfo& operator=(const GrGLBackendTextureInfo&) = delete;
     const GrGLTextureInfo& info() const { return fInfo; }
-    GrGLTextureParameters* parameters() const { return fParams; }
-    sk_sp<GrGLTextureParameters> refParameters() const { return sk_ref_sp(fParams); }
-
-    void cleanup();
-    void assign(const GrGLBackendTextureInfo&, bool thisIsValid);
+    GrGLTextureParameters* parameters() const { return fParams.get(); }
+    sk_sp<GrGLTextureParameters> refParameters() const { return fParams; }
 
     bool isProtected() const { return fInfo.isProtected(); }
 
 private:
     GrGLTextureInfo fInfo;
-    GrGLTextureParameters* fParams;
+    sk_sp<GrGLTextureParameters> fParams;  // not const because we might call invalidate() on it.
 };
 
 struct GrGLTextureSpec {

package/cpp/skia/include/private/gpu/ganesh/GrTypesPriv.h

@@ -9,20 +9,28 @@
 #define GrTypesPriv_DEFINED
 
 #include "include/core/SkColor.h"
-#include "include/core/SkImageInfo.h"
+#include "include/core/SkColorType.h"
+#include "include/core/SkData.h"
 #include "include/core/SkPath.h"
+#include "include/core/SkPathTypes.h"
 #include "include/core/SkRefCnt.h"
 #include "include/core/SkTextureCompressionType.h"
 #include "include/gpu/GrTypes.h"
+#include "include/private/base/SkAssert.h"
 #include "include/private/base/SkMacros.h"
 #include "include/private/base/SkTypeTraits.h"
 
+#include <cstddef>
+#include <cstdint>
 #include <functional>
+#include <type_traits>
 
-class GrBackendFormat;
-class GrCaps;
 class GrSurfaceProxy;
 
+namespace skgpu {
+enum class Mipmapped : bool;
+}
+
 /**
  *  divide, rounding up
  */
@@ -269,9 +277,9 @@ enum GrShaderType {
     kVertex_GrShaderType,
     kFragment_GrShaderType,
 
-    kLastkFragment_GrShaderType = kFragment_GrShaderType
+    kLast_GrShaderType = kFragment_GrShaderType
 };
-static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1;
+static const int kGrShaderTypeCount = kLast_GrShaderType + 1;
 
 enum GrShaderFlags {
     kNone_GrShaderFlags          = 0,
@@ -546,6 +554,7 @@ enum class GrColorType {
     kBGRA_8888,
     kRGBA_1010102,
     kBGRA_1010102,
+    kRGBA_10x6,
     kGray_8,
     kGrayAlpha_88,
     kAlpha_F16,
@@ -594,6 +603,7 @@ static constexpr SkColorType GrColorTypeToSkColorType(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return kBGRA_8888_SkColorType;
         case GrColorType::kRGBA_1010102:     return kRGBA_1010102_SkColorType;
         case GrColorType::kBGRA_1010102:     return kBGRA_1010102_SkColorType;
+        case GrColorType::kRGBA_10x6:        return kRGBA_10x6_SkColorType;
         case GrColorType::kGray_8:           return kGray_8_SkColorType;
         case GrColorType::kGrayAlpha_88:     return kUnknown_SkColorType;
         case GrColorType::kAlpha_F16:        return kA16_float_SkColorType;
@@ -637,6 +647,7 @@ static constexpr GrColorType SkColorTypeToGrColorType(SkColorType ct) {
         case kBGRA_1010102_SkColorType:       return GrColorType::kBGRA_1010102;
         case kBGR_101010x_SkColorType:        return GrColorType::kUnknown;
         case kBGR_101010x_XR_SkColorType:     return GrColorType::kUnknown;
+        case kRGBA_10x6_SkColorType:          return GrColorType::kRGBA_10x6;
         case kRGBA_F32_SkColorType:           return GrColorType::kRGBA_F32;
         case kR8G8_unorm_SkColorType:         return GrColorType::kRG_88;
         case kA16_unorm_SkColorType:          return GrColorType::kAlpha_16;
@@ -662,6 +673,7 @@ static constexpr uint32_t GrColorTypeChannelFlags(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return kRGBA_SkColorChannelFlags;
         case GrColorType::kRGBA_1010102:     return kRGBA_SkColorChannelFlags;
         case GrColorType::kBGRA_1010102:     return kRGBA_SkColorChannelFlags;
+        case GrColorType::kRGBA_10x6:        return kRGBA_SkColorChannelFlags;
         case GrColorType::kGray_8:           return kGray_SkColorChannelFlag;
         case GrColorType::kGrayAlpha_88:     return kGrayAlpha_SkColorChannelFlags;
         case GrColorType::kAlpha_F16:        return kAlpha_SkColorChannelFlag;
@@ -804,6 +816,8 @@ static constexpr GrColorFormatDesc GrGetColorTypeDesc(GrColorType ct) {
             return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
         case GrColorType::kBGRA_1010102:
             return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
+        case GrColorType::kRGBA_10x6:
+            return GrColorFormatDesc::MakeRGBA(10, GrColorTypeEncoding::kUnorm);
         case GrColorType::kGray_8:
             return GrColorFormatDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
         case GrColorType::kGrayAlpha_88:
@@ -891,6 +905,7 @@ static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return 4;
         case GrColorType::kRGBA_1010102:     return 4;
         case GrColorType::kBGRA_1010102:     return 4;
+        case GrColorType::kRGBA_10x6:        return 8;
         case GrColorType::kGray_8:           return 1;
         case GrColorType::kGrayAlpha_88:     return 2;
         case GrColorType::kAlpha_F16:        return 2;
@@ -936,17 +951,17 @@ enum class GrDstSampleFlags {
 };
 GR_MAKE_BITFIELD_CLASS_OPS(GrDstSampleFlags)
 
-using GrVisitProxyFunc = std::function<void(GrSurfaceProxy*, GrMipmapped)>;
+using GrVisitProxyFunc = std::function<void(GrSurfaceProxy*, skgpu::Mipmapped)>;
 
-#if defined(SK_DEBUG) || GR_TEST_UTILS || defined(SK_ENABLE_DUMP_GPU)
+#if defined(SK_DEBUG) || defined(GR_TEST_UTILS) || defined(SK_ENABLE_DUMP_GPU)
 static constexpr const char* GrBackendApiToStr(GrBackendApi api) {
     switch (api) {
-        case GrBackendApi::kOpenGL:   return "OpenGL";
-        case GrBackendApi::kVulkan:   return "Vulkan";
-        case GrBackendApi::kMetal:    return "Metal";
-        case GrBackendApi::kDirect3D: return "Direct3D";
-        case GrBackendApi::kDawn:     return "Dawn";
-        case GrBackendApi::kMock:     return "Mock";
+        case GrBackendApi::kOpenGL:      return "OpenGL";
+        case GrBackendApi::kVulkan:      return "Vulkan";
+        case GrBackendApi::kMetal:       return "Metal";
+        case GrBackendApi::kDirect3D:    return "Direct3D";
+        case GrBackendApi::kMock:        return "Mock";
+        case GrBackendApi::kUnsupported: return "Unsupported";
     }
     SkUNREACHABLE;
 }
@@ -964,6 +979,7 @@ static constexpr const char* GrColorTypeToStr(GrColorType ct) {
         case GrColorType::kBGRA_8888:        return "kBGRA_8888";
         case GrColorType::kRGBA_1010102:     return "kRGBA_1010102";
         case GrColorType::kBGRA_1010102:     return "kBGRA_1010102";
+        case GrColorType::kRGBA_10x6:        return "kBGRA_10x6";
         case GrColorType::kGray_8:           return "kGray_8";
         case GrColorType::kGrayAlpha_88:     return "kGrayAlpha_88";
         case GrColorType::kAlpha_F16:        return "kAlpha_F16";

package/cpp/skia/include/private/gpu/ganesh/GrVkTypesPriv.h

@@ -15,34 +15,8 @@ namespace skgpu {
 class MutableTextureStateRef;
 }
 
-
-// This struct is to used to store the the actual information about the vulkan backend image on the
-// GrBackendTexture and GrBackendRenderTarget. When a client calls getVkImageInfo on a
-// GrBackendTexture/RenderTarget, we use the GrVkBackendSurfaceInfo to create a snapshot
-// GrVkImgeInfo object. Internally, this uses a ref count GrVkImageLayout object to track the
-// current VkImageLayout which can be shared with an internal GrVkImage so that layout updates can
-// be seen by all users of the image.
-struct GrVkBackendSurfaceInfo {
-    GrVkBackendSurfaceInfo(GrVkImageInfo info) : fImageInfo(info) {}
-
-    void cleanup();
-
-    GrVkBackendSurfaceInfo& operator=(const GrVkBackendSurfaceInfo&) = delete;
-
-    // Assigns the passed in GrVkBackendSurfaceInfo to this object. if isValid is true we will also
-    // attempt to unref the old fLayout on this object.
-    void assign(const GrVkBackendSurfaceInfo&, bool isValid);
-
-    GrVkImageInfo snapImageInfo(const skgpu::MutableTextureStateRef*) const;
-
-    bool isProtected() const { return fImageInfo.fProtected == skgpu::Protected::kYes; }
-#if GR_TEST_UTILS
-    bool operator==(const GrVkBackendSurfaceInfo& that) const;
-#endif
-
-private:
-    GrVkImageInfo    fImageInfo;
-};
+GrVkImageInfo GrVkImageInfoWithMutableState(const GrVkImageInfo&,
+                                            const skgpu::MutableTextureStateRef*);
 
 struct GrVkImageSpec {
     GrVkImageSpec()

package/cpp/skia/include/private/gpu/graphite/ContextOptionsPriv.h

@@ -0,0 +1,34 @@
+/*
+ * 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 skgpu_graphite_ContextOptionsPriv_DEFINED
+#define skgpu_graphite_ContextOptionsPriv_DEFINED
+
+namespace skgpu::graphite {
+
+/**
+ * Private options that are only meant for testing within Skia's tools.
+ */
+struct ContextOptionsPriv {
+
+    int  fMaxTextureSizeOverride = SK_MaxS32;
+
+    /**
+     * Maximum width and height of internal texture atlases.
+     */
+    int  fMaxTextureAtlasSize = 2048;
+
+    /**
+     * If true, will store a pointer in Recorder that points back to the Context
+     * that created it. Used by readPixels() and other methods that normally require a Context.
+     */
+    bool fStoreContextRefInRecorder = false;
+};
+
+}  // namespace skgpu::graphite
+
+#endif  // skgpu_graphite_ContextOptionsPriv_DEFINED

package/cpp/skia/include/private/gpu/graphite/DawnTypesPriv.h

@@ -26,6 +26,12 @@ struct DawnTextureSpec {
                fFormat == that.fFormat;
     }
 
+    bool isCompatible(const DawnTextureSpec& that) const {
+        // The usages may match or the usage passed in may be a superset of the usage stored within.
+        return fFormat == that.fFormat &&
+               (fUsage & that.fUsage) == fUsage;
+    }
+
     SkString toString() const {
         return SkStringPrintf("format=0x%08X,usage=0x%08X",
                               static_cast<unsigned int>(fFormat),

package/cpp/skia/include/private/gpu/graphite/MtlGraphiteTypesPriv.h

@@ -64,6 +64,14 @@ struct MtlTextureSpec {
                fFramebufferOnly == that.fFramebufferOnly;
     }
 
+    bool isCompatible(const MtlTextureSpec& that) const {
+        // The usages may match or the usage passed in may be a superset of the usage stored within.
+        return fFormat == that.fFormat &&
+               fStorageMode == that.fStorageMode &&
+               fFramebufferOnly == that.fFramebufferOnly &&
+               (fUsage & that.fUsage) == fUsage;
+    }
+
     SkString toString() const {
         return SkStringPrintf("format=%u,usage=0x%04X,storageMode=%d,framebufferOnly=%d",
                               fFormat,

package/cpp/skia/include/private/gpu/graphite/VulkanGraphiteTypesPriv.h

@@ -38,6 +38,16 @@ struct VulkanTextureSpec {
                fAspectMask == that.fAspectMask;
     }
 
+    bool isCompatible(const VulkanTextureSpec& that) const {
+        // The usages may match or the usage passed in may be a superset of the usage stored within.
+        return fFlags == that.fFlags &&
+               fFormat == that.fFormat &&
+               fImageTiling == that.fImageTiling &&
+               fSharingMode == that.fSharingMode &&
+               fAspectMask == that.fAspectMask &&
+               (fImageUsageFlags & that.fImageUsageFlags) == fImageUsageFlags;
+    }
+
     SkString toString() const {
         return SkStringPrintf(
                 "flags=0x%08X,format=%d,imageTiling=%d,imageUsageFlags=0x%08X,sharingMode=%d,"

package/cpp/skia/include/utils/SkBase64.h

@@ -46,8 +46,8 @@ public:
 
        @param dstLength assigned the length dst is required to be. Must not be nullptr.
     */
-    static Error SK_WARN_UNUSED_RESULT Decode(const void* src, size_t  srcLength,
-                                                    void* dst, size_t* dstLength);
+    [[nodiscard]] static Error Decode(const void* src, size_t  srcLength,
+                                      void* dst, size_t* dstLength);
 };
 
 #endif // SkBase64_DEFINED

package/cpp/skia/include/utils/SkNWayCanvas.h

@@ -45,11 +45,7 @@ struct SkPoint;
 struct SkRSXform;
 struct SkRect;
 
-#if defined(SK_GANESH)
-namespace sktext::gpu {
-class Slug;
-}
-#endif
+namespace sktext::gpu { class Slug; }
 
 class SK_API SkNWayCanvas : public SkCanvasVirtualEnforcer<SkNoDrawCanvas> {
 public:
@@ -77,9 +73,7 @@ protected:
     void onDrawGlyphRunList(const sktext::GlyphRunList&, const SkPaint&) override;
     void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                         const SkPaint& paint) override;
-#if defined(SK_GANESH)
     void onDrawSlug(const sktext::gpu::Slug* slug) override;
-#endif
     void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                      const SkPoint texCoords[4], SkBlendMode, const SkPaint& paint) override;
 
@@ -120,11 +114,7 @@ protected:
                           SkBlendMode) override;
     void onDrawEdgeAAImageSet2(const ImageSetEntry[], int count, const SkPoint[], const SkMatrix[],
                                const SkSamplingOptions&,const SkPaint*, SrcRectConstraint) override;
-
-    void onFlush() override;
-
     class Iter;
-
 private:
     using INHERITED = SkCanvasVirtualEnforcer<SkNoDrawCanvas>;
 };

package/cpp/skia/include/utils/SkNoDrawCanvas.h

@@ -26,8 +26,6 @@ public:
     SkNoDrawCanvas(int width, int height);
     SkNoDrawCanvas(const SkIRect&);
 
-    explicit SkNoDrawCanvas(sk_sp<SkBaseDevice> device);
-
     // Optimization to reset state to be the same as after construction.
     void resetCanvas(int w, int h)        { this->resetForNextPicture(SkIRect::MakeWH(w, h)); }
     void resetCanvas(const SkIRect& rect) { this->resetForNextPicture(rect); }

package/cpp/skia/include/utils/SkPaintFilterCanvas.h

@@ -65,8 +65,7 @@ public:
 
     // Forwarded to the wrapped canvas.
     SkISize getBaseLayerSize() const override { return proxy()->getBaseLayerSize(); }
-    GrRecordingContext* recordingContext() override { return proxy()->recordingContext(); }
-
+    GrRecordingContext* recordingContext() const override { return proxy()->recordingContext(); }
 protected:
     /**
      *  Called with the paint that will be used to draw the specified type.

package/cpp/skia/include/utils/SkShadowUtils.h

@@ -11,7 +11,6 @@
 #include "include/core/SkColor.h"
 #include "include/core/SkScalar.h"
 #include "include/core/SkTypes.h"
-#include "include/private/SkShadowFlags.h"
 
 #include <cstdint>
 
@@ -21,6 +20,21 @@ class SkPath;
 struct SkPoint3;
 struct SkRect;
 
+enum SkShadowFlags {
+    kNone_ShadowFlag = 0x00,
+    /** The occluding object is not opaque. Knowing that the occluder is opaque allows
+    * us to cull shadow geometry behind it and improve performance. */
+    kTransparentOccluder_ShadowFlag = 0x01,
+    /** Don't try to use analytic shadows. */
+    kGeometricOnly_ShadowFlag = 0x02,
+    /** Light position represents a direction, light radius is blur radius at elevation 1 */
+    kDirectionalLight_ShadowFlag = 0x04,
+    /** Concave paths will only use blur to generate the shadow */
+    kConcaveBlurOnly_ShadowFlag = 0x08,
+    /** mask for all shadow flags */
+    kAll_ShadowFlag = 0x0F
+};
+
 class SK_API SkShadowUtils {
 public:
     /**

package/cpp/skia/include/utils/SkTextUtils.h

@@ -13,7 +13,7 @@
 #include "include/core/SkTypes.h"
 
 #include <cstddef>
-#include <string>
+#include <cstring>
 
 class SkCanvas;
 class SkFont;

package/cpp/skia/modules/skparagraph/include/Paragraph.h

@@ -2,6 +2,7 @@
 #ifndef Paragraph_DEFINED
 #define Paragraph_DEFINED
 
+#include "include/core/SkPath.h"
 #include "modules/skparagraph/include/FontCollection.h"
 #include "modules/skparagraph/include/Metrics.h"
 #include "modules/skparagraph/include/ParagraphStyle.h"
@@ -97,9 +98,72 @@ public:
     using Visitor = std::function<void(int lineNumber, const VisitorInfo*)>;
     virtual void visit(const Visitor&) = 0;
 
+    struct ExtendedVisitorInfo {
+        const SkFont&   font;
+        SkPoint         origin;
+        SkSize          advance;
+        int             count;
+        const uint16_t* glyphs;     // count values
+        SkPoint*        positions;  // count values
+        const SkRect*   bounds;     // count values
+        const uint32_t* utf8Starts; // count+1 values
+        unsigned        flags;
+    };
+    using ExtendedVisitor = std::function<void(int lineNumber, const ExtendedVisitorInfo*)>;
+    virtual void extendedVisit(const ExtendedVisitor&) = 0;
+
+    /* Returns path for a given line
+     *
+     * @param lineNumber  a line number
+     * @param dest        a resulting path
+     * @return            a number glyphs that could not be converted to path
+     */
+    virtual int getPath(int lineNumber, SkPath* dest) = 0;
+
+    /* Returns path for a text blob
+     *
+     * @param textBlob    a text blob
+     * @return            a path
+     */
+    static SkPath GetPath(SkTextBlob* textBlob);
+
+    /* Checks if a given text blob contains
+     * glyph with emoji
+     *
+     * @param textBlob    a text blob
+     * @return            true if there is such a glyph
+     */
+    virtual bool containsEmoji(SkTextBlob* textBlob) = 0;
+
+    /* Checks if a given text blob contains colored font or bitmap
+     *
+     * @param textBlob    a text blob
+     * @return            true if there is such a glyph
+     */
+    virtual bool containsColorFontOrBitmap(SkTextBlob* textBlob) = 0;
+
     // Editing API
+
+    /* Finds the line number of the line that contains the given UTF-8 index.
+    *
+    * @param index         a UTF-8 TextIndex into the paragraph
+    * @return              the line number the glyph that corresponds to the
+    *                      given codeUnitIndex is in, or -1 if the codeUnitIndex
+    *                      is out of bounds, or when the glyph is truncated or
+    *                      ellipsized away.
+    */
     virtual int getLineNumberAt(TextIndex codeUnitIndex) const = 0;
 
+    /* Finds the line number of the line that contains the given UTF-16 index.
+    *
+    * @param index         a UTF-16 offset into the paragraph
+    * @return              the line number the glyph that corresponds to the
+    *                      given codeUnitIndex is in, or -1 if the codeUnitIndex
+    *                      is out of bounds, or when the glyph is truncated or
+    *                      ellipsized away.
+    */
+    virtual int getLineNumberAtUTF16Offset(size_t codeUnitIndex) = 0;
+
     /* Returns line metrics info for the line
      *
      * @param lineNumber    a line number
@@ -135,12 +199,47 @@ public:
      * @param dx              x coordinate
      * @param dy              y coordinate
      * @param glyphInfo       a glyph cluster info filled if not null
-     * @return
+     * @return                true if glyph cluster was found; false if not
+     *                        (which usually means the paragraph is empty)
      */
     virtual bool getClosestGlyphClusterAt(SkScalar dx,
                                           SkScalar dy,
                                           GlyphClusterInfo* glyphInfo) = 0;
 
+    // The glyph and grapheme cluster information assoicated with a unicode
+    // codepoint in the paragraph.
+    struct GlyphInfo {
+        SkRect fGraphemeLayoutBounds;
+        TextRange fGraphemeClusterTextRange;
+        TextDirection fDirection;
+        bool fIsEllipsis;
+    };
+
+    /** Retrives the information associated with the glyph located at the given
+     *  codeUnitIndex.
+     *
+     * @param codeUnitIndex   a UTF-16 offset into the paragraph
+     * @param glyphInfo       an optional GlyphInfo struct to hold the
+     *                        information associated with the glyph found at the
+     *                        given index
+     * @return                false only if the offset is out of bounds
+     */
+    virtual bool getGlyphInfoAtUTF16Offset(size_t codeUnitIndex, GlyphInfo* glyphInfo) = 0;
+
+    /** Finds the information associated with the closest glyph to the given
+     *  paragraph coordinates.
+     *
+     * @param dx              x coordinate
+     * @param dy              y coordinate
+     * @param glyphInfo       an optional GlyphInfo struct to hold the
+     *                        information associated with the glyph found. The
+     *                        text indices and text ranges are described using
+     *                        UTF-16 offsets
+     * @return                true if a graphme cluster was found; false if not
+     *                        (which usually means the paragraph is empty)
+     */
+    virtual bool getClosestUTF16GlyphInfoAt(SkScalar dx, SkScalar dy, GlyphInfo* glyphInfo) = 0;
+
     struct FontInfo {
         FontInfo(const SkFont font, const TextRange textRange)
             : fFont(font), fTextRange(textRange) { }
@@ -157,6 +256,13 @@ public:
      */
     virtual SkFont getFontAt(TextIndex codeUnitIndex) const = 0;
 
+    /** Returns the font used to shape the text at the given UTF-16 offset.
+     *
+     * @param codeUnitIndex   a UTF-16 offset in the paragraph
+     * @return                font info or an empty font info if the text is not found
+     */
+    virtual SkFont getFontAtUTF16Offset(size_t codeUnitIndex) = 0;
+
     /** Returns the information about all the fonts used to shape the paragraph text
      *
      * @return                a list of fonts and text ranges

package/cpp/skia/modules/skparagraph/include/ParagraphBuilder.h

@@ -16,9 +16,10 @@ namespace skia {
 namespace textlayout {
 
 class ParagraphBuilder {
-public:
-    ParagraphBuilder(const ParagraphStyle&, sk_sp<FontCollection>) { }
+protected:
+    ParagraphBuilder() {}
 
+public:
     virtual ~ParagraphBuilder() = default;
 
     // Push a style to the stack. The corresponding text added with AddText will