@shopify/react-native-skia 0.1.129 → 0.1.130

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

@@ -8,23 +8,37 @@
 #ifndef GrSlug_DEFINED
 #define GrSlug_DEFINED
 
+#include "include/core/SkData.h"
 #include "include/core/SkRect.h"
 #include "include/core/SkRefCnt.h"
 
 class SkCanvas;
+class SkMatrix;
 class SkPaint;
 class SkTextBlob;
+class SkReadBuffer;
+class SkStrikeClient;
+class SkWriteBuffer;
 
 // You can use GrSlug to simulate drawTextBlob by defining the following at compile time.
 //    SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG
+// You can use GrSlug serialization to simulate drawTextBlob by defining the following:
+//    SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG_SERIALIZE
 // For Skia, add this to your args.gn file.
 //    extra_cflags = ["-D", "SK_EXPERIMENTAL_SIMULATE_DRAWGLYPHRUNLIST_WITH_SLUG"]
 
+// Internal infrastructure for using SubRuns.
+class SK_API GrTextReferenceFrame : public SkRefCnt {
+public:
+    ~GrTextReferenceFrame() override;
+    virtual const SkMatrix& initialPositionMatrix() const = 0;
+};
+
 // GrSlug encapsulates an SkTextBlob at a specific origin, using a specific paint. It can be
 // manipulated using matrix and clip changes to the canvas. If the canvas is transformed, then
 // the GrSlug will also transform with smaller glyphs using bi-linear interpolation to render. You
 // can think of a GrSlug as making a rubber stamp out of a SkTextBlob.
-class SK_API GrSlug : public SkRefCnt {
+class SK_API GrSlug : public GrTextReferenceFrame {
 public:
     ~GrSlug() override;
     // Return nullptr if the blob would not draw. This is not because of clipping, but because of
@@ -32,10 +46,33 @@ public:
     static sk_sp<GrSlug> ConvertBlob(
             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;
+
+    // Set the client parameter to the appropriate SkStrikeClient when typeface ID translation
+    // is needed.
+    static sk_sp<GrSlug> Deserialize(
+            const void* data, size_t size, const SkStrikeClient* client = nullptr);
+    static sk_sp<GrSlug> MakeFromBuffer(SkReadBuffer& buffer);
+
+
     // Draw the GrSlug obeying the canvas's mapping and clipping.
-    void draw(SkCanvas* canvas);
+    void draw(SkCanvas* canvas) const;
 
     virtual SkRect sourceBounds() const = 0;
-    virtual const SkPaint& paint() const = 0;
+
+    // The paint passed into ConvertBlob; this paint is used instead of the paint resulting from
+    // the call to aboutToDraw because when we call draw(), the initial paint is needed to call
+    // aboutToDraw again to get the layer right.
+    virtual const SkPaint& initialPaint() const = 0;
+
+    virtual void doFlatten(SkWriteBuffer&) const = 0;
+
+    uint32_t uniqueID() const { return fUniqueID; }
+
+private:
+    static uint32_t NextUniqueID();
+    const uint32_t  fUniqueID{NextUniqueID()};
 };
 #endif  // GrSlug_DEFINED

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

@@ -15,8 +15,9 @@
 #include "include/core/SkRefCnt.h"
 #include "include/utils/SkNoDrawCanvas.h"
 
-class SkAutoDescriptor;
+class GrSlug;
 struct SkPackedGlyphID;
+class SkAutoDescriptor;
 class SkStrikeCache;
 class SkStrikeClientImpl;
 class SkStrikeServer;
@@ -93,7 +94,8 @@ public:
         kGlyphMetricsFallback = 4,
         kGlyphPathFallback    = 5,
 
-        kLast = kGlyphPath
+        kGlyphDrawable = 6,
+        kLast = kGlyphDrawable
     };
 
     // An interface to delete handles that may be pinned by the remote server.
@@ -133,11 +135,15 @@ public:
     // Returns false if the data is invalid.
     SK_SPI bool readStrikeData(const volatile void* memory, size_t memorySize);
 
+    // Given a descriptor re-write the Rec mapping the typefaceID from the renderer to the
+    // corresponding typefaceID on the GPU.
+    SK_SPI bool translateTypefaceID(SkAutoDescriptor* descriptor) const;
+
+    // Given a buffer, unflatten into a slug making sure to do the typefaceID translation from
+    // renderer to GPU. Returns nullptr if there was a problem.
+    sk_sp<GrSlug> deserializeSlug(const void* data, size_t size) const;
+
 private:
     std::unique_ptr<SkStrikeClientImpl> fImpl;
 };
-
-// For exposure to fuzzing only.
-bool SkFuzzDeserializeSkDescriptor(sk_sp<SkData> bytes, SkAutoDescriptor* ad);
-
 #endif  // SkChromeRemoteGlyphCache_DEFINED

package/cpp/skia/include/private/{GrContext_Base.h → gpu/ganesh/GrContext_Base.h}

@@ -45,6 +45,13 @@ public:
 
     SK_API GrBackendFormat compressedBackendFormat(SkImage::CompressionType) const;
 
+    /**
+     * Gets the maximum supported sample count for a color type. 1 is returned if only non-MSAA
+     * rendering is supported for the color type. 0 is returned if rendering to this color type
+     * is not supported at all.
+     */
+    SK_API int maxSurfaceSampleCountForColorType(SkColorType colorType) const;
+
     // TODO: When the public version is gone, rename to refThreadSafeProxy and add raw ptr ver.
     sk_sp<GrContextThreadSafeProxy> threadSafeProxy();
 

package/cpp/skia/include/private/{GrGLTypesPriv.h → gpu/ganesh/GrGLTypesPriv.h}

@@ -38,6 +38,7 @@ public:
         GrGLenum fWrapT;
         GrGLfloat fMinLOD;
         GrGLfloat fMaxLOD;
+        GrGLfloat fMaxAniso;
         // We always want the border color to be transparent black, so no need to store 4 floats.
         // Just track if it's been invalidated and no longer the default
         bool fBorderColorInvalid;

package/cpp/skia/include/private/{GrImageContext.h → gpu/ganesh/GrImageContext.h}

@@ -8,8 +8,8 @@
 #ifndef GrImageContext_DEFINED
 #define GrImageContext_DEFINED
 
-#include "include/private/GrContext_Base.h"
-#include "include/private/GrSingleOwner.h"
+#include "include/private/SingleOwner.h"
+#include "include/private/gpu/ganesh/GrContext_Base.h"
 
 class GrImageContextPriv;
 
@@ -33,7 +33,7 @@ protected:
     SK_API virtual bool abandoned();
 
     /** This is only useful for debug purposes */
-    GrSingleOwner* singleOwner() const { return &fSingleOwner; }
+    skgpu::SingleOwner* singleOwner() const { return &fSingleOwner; }
 
     GrImageContext* asImageContext() override { return this; }
 
@@ -47,7 +47,7 @@ private:
     // This guard is passed to the GrDrawingManager and, from there to all the
     // GrSurfaceDrawContexts.  It is also passed to the GrResourceProvider and SkGpuDevice.
     // TODO: Move this down to GrRecordingContext.
-    mutable GrSingleOwner            fSingleOwner;
+    mutable skgpu::SingleOwner fSingleOwner;
 
     using INHERITED = GrContext_Base;
 };

package/cpp/skia/include/private/{GrTypesPriv.h → gpu/ganesh/GrTypesPriv.h}

@@ -45,10 +45,8 @@ enum class GrPrimitiveType : uint8_t {
     kPoints,
     kLines,          // 1 pix wide only
     kLineStrip,      // 1 pix wide only
-    kPatches,
-    kPath
 };
-static constexpr int kNumGrPrimitiveTypes = (int)GrPrimitiveType::kPath + 1;
+static constexpr int kNumGrPrimitiveTypes = (int)GrPrimitiveType::kLineStrip + 1;
 
 static constexpr bool GrIsPrimTypeLines(GrPrimitiveType type) {
     return GrPrimitiveType::kLines == type || GrPrimitiveType::kLineStrip == type;
@@ -74,33 +72,6 @@ enum class GrDDLProvider : bool {
     kYes = true
 };
 
-/**
- *  Formats for masks, used by the font cache. Important that these are 0-based.
- */
-enum GrMaskFormat {
-    kA8_GrMaskFormat,    //!< 1-byte per pixel
-    kA565_GrMaskFormat,  //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage
-    kARGB_GrMaskFormat,  //!< 4-bytes per pixel, color format
-
-    kLast_GrMaskFormat = kARGB_GrMaskFormat
-};
-static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
-
-/**
- *  Return the number of bytes-per-pixel for the specified mask format.
- */
-inline constexpr int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
-    SkASSERT(format < kMaskFormatCount);
-    // kA8   (0) -> 1
-    // kA565 (1) -> 2
-    // kARGB (2) -> 4
-    static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency");
-    static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency");
-    static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency");
-
-    return SkTo<int>(1u << format);
-}
-
 /** Ownership rules for external GPU resources imported into Skia. */
 enum GrWrapOwnership {
     /** Skia will assume the client will keep the resource alive and Skia will not free it. */
@@ -257,18 +228,13 @@ enum class GrClampType {
 /**
  * A number of rectangle/quadrilateral drawing APIs can control anti-aliasing on a per edge basis.
  * These masks specify which edges are AA'ed. The intent for this is to support tiling with seamless
- * boundaries, where the inner edges are non-AA and the outer edges are AA. Regular draws (where AA
- * is specified by GrAA) is almost equivalent to kNone or kAll, with the exception of how MSAA is
- * handled.
- *
- * When tiling and there is MSAA, mixed edge rectangles are processed with MSAA, so in order for the
- * tiled edges to remain seamless, inner tiles with kNone must also be processed with MSAA. In
- * regular drawing, however, kNone should disable MSAA (if it's supported) to match the expected
- * appearance.
+ * boundaries, where the inner edges are non-AA and the outer edges are AA. Regular rectangle draws
+ * simply use kAll or kNone depending on if they want anti-aliasing or not.
  *
- * Therefore, APIs that use per-edge AA flags also take a GrAA value so that they can differentiate
- * between the regular and tiling use case behaviors. Tiling operations should always pass
- * GrAA::kYes while regular options should pass GrAA based on the SkPaint's anti-alias state.
+ * In APIs that support per-edge AA, GrQuadAAFlags is the only AA-control parameter that is
+ * provided (compared to the typical GrAA parameter). kNone is equivalent to GrAA::kNo, and any
+ * other set of edge flags would require GrAA::kYes (with rendering output dependent on how that
+ * maps to GrAAType for a given SurfaceDrawContext).
  *
  * These values are identical to SkCanvas::QuadAAFlags.
  */
@@ -288,56 +254,6 @@ static inline GrQuadAAFlags SkToGrQuadAAFlags(unsigned flags) {
     return static_cast<GrQuadAAFlags>(flags);
 }
 
-/**
- * Types of shader-language-specific boxed variables we can create.
- */
-enum GrSLType {
-    kVoid_GrSLType,
-    kBool_GrSLType,
-    kBool2_GrSLType,
-    kBool3_GrSLType,
-    kBool4_GrSLType,
-    kShort_GrSLType,
-    kShort2_GrSLType,
-    kShort3_GrSLType,
-    kShort4_GrSLType,
-    kUShort_GrSLType,
-    kUShort2_GrSLType,
-    kUShort3_GrSLType,
-    kUShort4_GrSLType,
-    kFloat_GrSLType,
-    kFloat2_GrSLType,
-    kFloat3_GrSLType,
-    kFloat4_GrSLType,
-    kFloat2x2_GrSLType,
-    kFloat3x3_GrSLType,
-    kFloat4x4_GrSLType,
-    kHalf_GrSLType,
-    kHalf2_GrSLType,
-    kHalf3_GrSLType,
-    kHalf4_GrSLType,
-    kHalf2x2_GrSLType,
-    kHalf3x3_GrSLType,
-    kHalf4x4_GrSLType,
-    kInt_GrSLType,
-    kInt2_GrSLType,
-    kInt3_GrSLType,
-    kInt4_GrSLType,
-    kUInt_GrSLType,
-    kUInt2_GrSLType,
-    kUInt3_GrSLType,
-    kUInt4_GrSLType,
-    kTexture2DSampler_GrSLType,
-    kTextureExternalSampler_GrSLType,
-    kTexture2DRectSampler_GrSLType,
-    kTexture2D_GrSLType,
-    kSampler_GrSLType,
-    kInput_GrSLType,
-
-    kLast_GrSLType = kInput_GrSLType
-};
-static const int kGrSLTypeCount = kLast_GrSLType + 1;
-
 /**
  * The type of texture. Backends other than GL currently only use the 2D value but the type must
  * still be known at the API-neutral layer as it used to determine whether MIP maps, renderability,
@@ -362,192 +278,10 @@ static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1;
 enum GrShaderFlags {
     kNone_GrShaderFlags          = 0,
     kVertex_GrShaderFlag         = 1 << 0,
-    kTessControl_GrShaderFlag    = 1 << 1,
-    kTessEvaluation_GrShaderFlag = 1 << 2,
-    kFragment_GrShaderFlag       = 1 << 3
+    kFragment_GrShaderFlag       = 1 << 1
 };
 SK_MAKE_BITFIELD_OPS(GrShaderFlags)
 
-/** Is the shading language type float (including vectors/matrices)? */
-static constexpr bool GrSLTypeIsFloatType(GrSLType type) {
-    switch (type) {
-        case kFloat_GrSLType:
-        case kFloat2_GrSLType:
-        case kFloat3_GrSLType:
-        case kFloat4_GrSLType:
-        case kFloat2x2_GrSLType:
-        case kFloat3x3_GrSLType:
-        case kFloat4x4_GrSLType:
-        case kHalf_GrSLType:
-        case kHalf2_GrSLType:
-        case kHalf3_GrSLType:
-        case kHalf4_GrSLType:
-        case kHalf2x2_GrSLType:
-        case kHalf3x3_GrSLType:
-        case kHalf4x4_GrSLType:
-            return true;
-
-        case kVoid_GrSLType:
-        case kTexture2DSampler_GrSLType:
-        case kTextureExternalSampler_GrSLType:
-        case kTexture2DRectSampler_GrSLType:
-        case kBool_GrSLType:
-        case kBool2_GrSLType:
-        case kBool3_GrSLType:
-        case kBool4_GrSLType:
-        case kShort_GrSLType:
-        case kShort2_GrSLType:
-        case kShort3_GrSLType:
-        case kShort4_GrSLType:
-        case kUShort_GrSLType:
-        case kUShort2_GrSLType:
-        case kUShort3_GrSLType:
-        case kUShort4_GrSLType:
-        case kInt_GrSLType:
-        case kInt2_GrSLType:
-        case kInt3_GrSLType:
-        case kInt4_GrSLType:
-        case kUInt_GrSLType:
-        case kUInt2_GrSLType:
-        case kUInt3_GrSLType:
-        case kUInt4_GrSLType:
-        case kTexture2D_GrSLType:
-        case kSampler_GrSLType:
-        case kInput_GrSLType:
-            return false;
-    }
-    SkUNREACHABLE;
-}
-
-/** Is the shading language type integral (including vectors)? */
-static constexpr bool GrSLTypeIsIntegralType(GrSLType type) {
-    switch (type) {
-        case kShort_GrSLType:
-        case kShort2_GrSLType:
-        case kShort3_GrSLType:
-        case kShort4_GrSLType:
-        case kUShort_GrSLType:
-        case kUShort2_GrSLType:
-        case kUShort3_GrSLType:
-        case kUShort4_GrSLType:
-        case kInt_GrSLType:
-        case kInt2_GrSLType:
-        case kInt3_GrSLType:
-        case kInt4_GrSLType:
-        case kUInt_GrSLType:
-        case kUInt2_GrSLType:
-        case kUInt3_GrSLType:
-        case kUInt4_GrSLType:
-            return true;
-
-        case kFloat_GrSLType:
-        case kFloat2_GrSLType:
-        case kFloat3_GrSLType:
-        case kFloat4_GrSLType:
-        case kFloat2x2_GrSLType:
-        case kFloat3x3_GrSLType:
-        case kFloat4x4_GrSLType:
-        case kHalf_GrSLType:
-        case kHalf2_GrSLType:
-        case kHalf3_GrSLType:
-        case kHalf4_GrSLType:
-        case kHalf2x2_GrSLType:
-        case kHalf3x3_GrSLType:
-        case kHalf4x4_GrSLType:
-        case kVoid_GrSLType:
-        case kTexture2DSampler_GrSLType:
-        case kTextureExternalSampler_GrSLType:
-        case kTexture2DRectSampler_GrSLType:
-        case kBool_GrSLType:
-        case kBool2_GrSLType:
-        case kBool3_GrSLType:
-        case kBool4_GrSLType:
-        case kTexture2D_GrSLType:
-        case kSampler_GrSLType:
-        case kInput_GrSLType:
-            return false;
-    }
-    SkUNREACHABLE;
-}
-
-/**
- * Is the shading language type supported as a uniform (ie, does it have a corresponding set
- * function on GrGLSLProgramDataManager)?
- */
-static constexpr bool GrSLTypeCanBeUniformValue(GrSLType type) {
-    return GrSLTypeIsFloatType(type) || GrSLTypeIsIntegralType(type);
-}
-
-/** If the type represents a single value or vector return the vector length, else -1. */
-static constexpr int GrSLTypeVecLength(GrSLType type) {
-    switch (type) {
-        case kFloat_GrSLType:
-        case kHalf_GrSLType:
-        case kBool_GrSLType:
-        case kShort_GrSLType:
-        case kUShort_GrSLType:
-        case kInt_GrSLType:
-        case kUInt_GrSLType:
-            return 1;
-
-        case kFloat2_GrSLType:
-        case kHalf2_GrSLType:
-        case kBool2_GrSLType:
-        case kShort2_GrSLType:
-        case kUShort2_GrSLType:
-        case kInt2_GrSLType:
-        case kUInt2_GrSLType:
-            return 2;
-
-        case kFloat3_GrSLType:
-        case kHalf3_GrSLType:
-        case kBool3_GrSLType:
-        case kShort3_GrSLType:
-        case kUShort3_GrSLType:
-        case kInt3_GrSLType:
-        case kUInt3_GrSLType:
-            return 3;
-
-        case kFloat4_GrSLType:
-        case kHalf4_GrSLType:
-        case kBool4_GrSLType:
-        case kShort4_GrSLType:
-        case kUShort4_GrSLType:
-        case kInt4_GrSLType:
-        case kUInt4_GrSLType:
-            return 4;
-
-        case kFloat2x2_GrSLType:
-        case kFloat3x3_GrSLType:
-        case kFloat4x4_GrSLType:
-        case kHalf2x2_GrSLType:
-        case kHalf3x3_GrSLType:
-        case kHalf4x4_GrSLType:
-        case kVoid_GrSLType:
-        case kTexture2DSampler_GrSLType:
-        case kTextureExternalSampler_GrSLType:
-        case kTexture2DRectSampler_GrSLType:
-        case kTexture2D_GrSLType:
-        case kSampler_GrSLType:
-        case kInput_GrSLType:
-            return -1;
-    }
-    SkUNREACHABLE;
-}
-
-static inline GrSLType GrSLCombinedSamplerTypeForTextureType(GrTextureType type) {
-    switch (type) {
-        case GrTextureType::k2D:
-            return kTexture2DSampler_GrSLType;
-        case GrTextureType::kRectangle:
-            return kTexture2DRectSampler_GrSLType;
-        case GrTextureType::kExternal:
-            return kTextureExternalSampler_GrSLType;
-        default:
-            SK_ABORT("Unexpected texture type");
-    }
-}
-
 /** Rectangle and external textures only support the clamp wrap mode and do not support
  *  MIP maps.
  */
@@ -564,56 +298,6 @@ static inline bool GrTextureTypeHasRestrictedSampling(GrTextureType type) {
     }
 }
 
-static constexpr bool GrSLTypeIsCombinedSamplerType(GrSLType type) {
-    switch (type) {
-        case kTexture2DSampler_GrSLType:
-        case kTextureExternalSampler_GrSLType:
-        case kTexture2DRectSampler_GrSLType:
-            return true;
-
-        case kVoid_GrSLType:
-        case kFloat_GrSLType:
-        case kFloat2_GrSLType:
-        case kFloat3_GrSLType:
-        case kFloat4_GrSLType:
-        case kFloat2x2_GrSLType:
-        case kFloat3x3_GrSLType:
-        case kFloat4x4_GrSLType:
-        case kHalf_GrSLType:
-        case kHalf2_GrSLType:
-        case kHalf3_GrSLType:
-        case kHalf4_GrSLType:
-        case kHalf2x2_GrSLType:
-        case kHalf3x3_GrSLType:
-        case kHalf4x4_GrSLType:
-        case kInt_GrSLType:
-        case kInt2_GrSLType:
-        case kInt3_GrSLType:
-        case kInt4_GrSLType:
-        case kUInt_GrSLType:
-        case kUInt2_GrSLType:
-        case kUInt3_GrSLType:
-        case kUInt4_GrSLType:
-        case kBool_GrSLType:
-        case kBool2_GrSLType:
-        case kBool3_GrSLType:
-        case kBool4_GrSLType:
-        case kShort_GrSLType:
-        case kShort2_GrSLType:
-        case kShort3_GrSLType:
-        case kShort4_GrSLType:
-        case kUShort_GrSLType:
-        case kUShort2_GrSLType:
-        case kUShort3_GrSLType:
-        case kUShort4_GrSLType:
-        case kTexture2D_GrSLType:
-        case kSampler_GrSLType:
-        case kInput_GrSLType:
-            return false;
-    }
-    SkUNREACHABLE;
-}
-
 //////////////////////////////////////////////////////////////////////////////
 
 /**
@@ -883,6 +567,7 @@ enum class GrColorType {
     kAlpha_8xxx,
     kAlpha_F32xxx,
     kGray_8xxx,
+    kR_8xxx,
 
     // Types used to initialize backend textures.
     kRGB_888,
@@ -920,12 +605,13 @@ static constexpr SkColorType GrColorTypeToSkColorType(GrColorType ct) {
         case GrColorType::kAlpha_8xxx:       return kUnknown_SkColorType;
         case GrColorType::kAlpha_F32xxx:     return kUnknown_SkColorType;
         case GrColorType::kGray_8xxx:        return kUnknown_SkColorType;
+        case GrColorType::kR_8xxx:           return kUnknown_SkColorType;
         case GrColorType::kAlpha_16:         return kA16_unorm_SkColorType;
         case GrColorType::kRG_1616:          return kR16G16_unorm_SkColorType;
         case GrColorType::kRGBA_16161616:    return kR16G16B16A16_unorm_SkColorType;
         case GrColorType::kRG_F16:           return kR16G16_float_SkColorType;
         case GrColorType::kRGB_888:          return kUnknown_SkColorType;
-        case GrColorType::kR_8:              return kUnknown_SkColorType;
+        case GrColorType::kR_8:              return kR8_unorm_SkColorType;
         case GrColorType::kR_16:             return kUnknown_SkColorType;
         case GrColorType::kR_F16:            return kUnknown_SkColorType;
         case GrColorType::kGray_F16:         return kUnknown_SkColorType;
@@ -959,6 +645,7 @@ static constexpr GrColorType SkColorTypeToGrColorType(SkColorType ct) {
         case kA16_float_SkColorType:          return GrColorType::kAlpha_F16;
         case kR16G16_float_SkColorType:       return GrColorType::kRG_F16;
         case kR16G16B16A16_unorm_SkColorType: return GrColorType::kRGBA_16161616;
+        case kR8_unorm_SkColorType:           return GrColorType::kR_8;
     }
     SkUNREACHABLE;
 }
@@ -985,6 +672,7 @@ static constexpr uint32_t GrColorTypeChannelFlags(GrColorType ct) {
         case GrColorType::kAlpha_8xxx:       return kAlpha_SkColorChannelFlag;
         case GrColorType::kAlpha_F32xxx:     return kAlpha_SkColorChannelFlag;
         case GrColorType::kGray_8xxx:        return kGray_SkColorChannelFlag;
+        case GrColorType::kR_8xxx:           return kRed_SkColorChannelFlag;
         case GrColorType::kAlpha_16:         return kAlpha_SkColorChannelFlag;
         case GrColorType::kRG_1616:          return kRG_SkColorChannelFlags;
         case GrColorType::kRGBA_16161616:    return kRGBA_SkColorChannelFlags;
@@ -1135,6 +823,8 @@ static constexpr GrColorFormatDesc GrGetColorTypeDesc(GrColorType ct) {
             return GrColorFormatDesc::MakeAlpha(32, GrColorTypeEncoding::kFloat);
         case GrColorType::kGray_8xxx:
             return GrColorFormatDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
+        case GrColorType::kR_8xxx:
+            return GrColorFormatDesc::MakeR(8, GrColorTypeEncoding::kUnorm);
         case GrColorType::kAlpha_16:
             return GrColorFormatDesc::MakeAlpha(16, GrColorTypeEncoding::kUnorm);
         case GrColorType::kRG_1616:
@@ -1211,6 +901,7 @@ static constexpr size_t GrColorTypeBytesPerPixel(GrColorType ct) {
         case GrColorType::kAlpha_8xxx:       return 4;
         case GrColorType::kAlpha_F32xxx:     return 16;
         case GrColorType::kGray_8xxx:        return 4;
+        case GrColorType::kR_8xxx:           return 4;
         case GrColorType::kAlpha_16:         return 2;
         case GrColorType::kRG_1616:          return 4;
         case GrColorType::kRGBA_16161616:    return 8;
@@ -1239,48 +930,6 @@ static constexpr SkColorType GrCompressionTypeToSkColorType(SkImage::Compression
     SkUNREACHABLE;
 }
 
-static constexpr GrColorType GrMaskFormatToColorType(GrMaskFormat format) {
-    switch (format) {
-        case kA8_GrMaskFormat:
-            return GrColorType::kAlpha_8;
-        case kA565_GrMaskFormat:
-            return GrColorType::kBGR_565;
-        case kARGB_GrMaskFormat:
-            return GrColorType::kRGBA_8888;
-    }
-    SkUNREACHABLE;
-}
-
-/**
- * Ref-counted object that calls a callback from its destructor.
- */
-class GrRefCntedCallback : public SkNVRefCnt<GrRefCntedCallback> {
-public:
-    using Context = void*;
-    using Callback = void (*)(Context);
-
-    static sk_sp<GrRefCntedCallback> Make(Callback proc, Context ctx) {
-        if (!proc) {
-            return nullptr;
-        }
-        return sk_sp<GrRefCntedCallback>(new GrRefCntedCallback(proc, ctx));
-    }
-
-    ~GrRefCntedCallback() { fReleaseProc(fReleaseCtx); }
-
-    Context context() const { return fReleaseCtx; }
-
-private:
-    GrRefCntedCallback(Callback proc, Context ctx) : fReleaseProc(proc), fReleaseCtx(ctx) {}
-    GrRefCntedCallback(const GrRefCntedCallback&) = delete;
-    GrRefCntedCallback(GrRefCntedCallback&&) = delete;
-    GrRefCntedCallback& operator=(const GrRefCntedCallback&) = delete;
-    GrRefCntedCallback& operator=(GrRefCntedCallback&&) = delete;
-
-    Callback fReleaseProc;
-    Context fReleaseCtx;
-};
-
 enum class GrDstSampleFlags {
     kNone = 0,
     kRequiresTextureBarrier =   1 << 0,
@@ -1325,6 +974,7 @@ static constexpr const char* GrColorTypeToStr(GrColorType ct) {
         case GrColorType::kAlpha_8xxx:       return "kAlpha_8xxx";
         case GrColorType::kAlpha_F32xxx:     return "kAlpha_F32xxx";
         case GrColorType::kGray_8xxx:        return "kGray_8xxx";
+        case GrColorType::kR_8xxx:           return "kR_8xxx";
         case GrColorType::kAlpha_16:         return "kAlpha_16";
         case GrColorType::kRG_1616:          return "kRG_1616";
         case GrColorType::kRGBA_16161616:    return "kRGBA_16161616";
@@ -1349,6 +999,14 @@ static constexpr const char* GrCompressionTypeToStr(SkImage::CompressionType com
     }
     SkUNREACHABLE;
 }
+
+static constexpr const char* GrSurfaceOriginToStr(GrSurfaceOrigin origin) {
+    switch (origin) {
+        case kTopLeft_GrSurfaceOrigin:    return "kTopLeft";
+        case kBottomLeft_GrSurfaceOrigin: return "kBottomLeft";
+    }
+    SkUNREACHABLE;
+}
 #endif
 
 #endif