SkCanvas.h

Go to the documentation of this file.

/*
 * Copyright 2006 The Android Open Source Project
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef SkCanvas_DEFINED
#define SkCanvas_DEFINED
 
#include "include/core/SkBlendMode.h"
#include "include/core/SkClipOp.h"
#include "include/core/SkColor.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkImageFilter.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkM44.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRasterHandleAllocator.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkSamplingOptions.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkSurfaceProps.h"
#include "include/core/SkTypes.h"
#include "include/private/base/SkCPUTypes.h"
#include "include/private/base/SkDeque.h"
 
#include <cstdint>
#include <cstring>
#include <memory>
#include <optional>
 
#ifndef SK_SUPPORT_LEGACY_GETTOTALMATRIX
#define SK_SUPPORT_LEGACY_GETTOTALMATRIX
#endif
 
namespace sktext {
class GlyphRunBuilder;
class GlyphRunList;
}
 
class AutoLayerForImageFilter;
class GrRecordingContext;
 
class SkBitmap;
class SkBlender;
class SkData;
class SkDevice;
class SkDrawable;
class SkFont;
class SkImage;
class SkMesh;
class SkPaintFilterCanvas;
class SkPath;
class SkPicture;
class SkPixmap;
class SkRRect;
class SkRegion;
class SkShader;
class SkSpecialImage;
class SkSurface;
class SkSurface_Base;
class SkTextBlob;
class SkVertices;
struct SkDrawShadowRec;
struct SkRSXform;
 
namespace skgpu::graphite { class Recorder; }
namespace sktext::gpu { class Slug; }
namespace SkRecords { class Draw; }
 
class SK_API SkCanvas {
public:
 
    static std::unique_ptr<SkCanvas> MakeRasterDirect(const SkImageInfo& info, void* pixels,
                                                      size_t rowBytes,
                                                      const SkSurfaceProps* props = nullptr);
 
    static std::unique_ptr<SkCanvas> MakeRasterDirectN32(int width, int height, SkPMColor* pixels,
                                                         size_t rowBytes) {
        return MakeRasterDirect(SkImageInfo::MakeN32Premul(width, height), pixels, rowBytes);
    }
 
    SkCanvas();
 
    SkCanvas(int width, int height, const SkSurfaceProps* props = nullptr);
 
    explicit SkCanvas(sk_sp<SkDevice> device);
 
    explicit SkCanvas(const SkBitmap& bitmap);
 
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
    enum class ColorBehavior {
        kLegacy, 
    };
 
    SkCanvas(const SkBitmap& bitmap, ColorBehavior behavior);
#endif
 
    SkCanvas(const SkBitmap& bitmap, const SkSurfaceProps& props);
 
    virtual ~SkCanvas();
 
    SkImageInfo imageInfo() const;
 
    bool getProps(SkSurfaceProps* props) const;
 
    SkSurfaceProps getBaseProps() const;
 
    SkSurfaceProps getTopProps() const;
 
    virtual SkISize getBaseLayerSize() const;
 
    sk_sp<SkSurface> makeSurface(const SkImageInfo& info, const SkSurfaceProps* props = nullptr);
 
    virtual GrRecordingContext* recordingContext() const;
 
 
    virtual skgpu::graphite::Recorder* recorder() const;
 
    SkSurface* getSurface() const;
 
    void* accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin = nullptr);
 
    SkRasterHandleAllocator::Handle accessTopRasterHandle() const;
 
    bool peekPixels(SkPixmap* pixmap);
 
    bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                    int srcX, int srcY);
 
    bool readPixels(const SkPixmap& pixmap, int srcX, int srcY);
 
    bool readPixels(const SkBitmap& bitmap, int srcX, int srcY);
 
    bool writePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes, int x, int y);
 
    bool writePixels(const SkBitmap& bitmap, int x, int y);
 
    int save();
 
    int saveLayer(const SkRect* bounds, const SkPaint* paint);
 
    int saveLayer(const SkRect& bounds, const SkPaint* paint) {
        return this->saveLayer(&bounds, paint);
    }
 
    int saveLayerAlphaf(const SkRect* bounds, float alpha);
    // Helper that accepts an int between 0 and 255, and divides it by 255.0
    int saveLayerAlpha(const SkRect* bounds, U8CPU alpha) {
        return this->saveLayerAlphaf(bounds, alpha * (1.0f / 255));
    }
 
    enum SaveLayerFlagsSet {
        kPreserveLCDText_SaveLayerFlag  = 1 << 1,
        kInitWithPrevious_SaveLayerFlag = 1 << 2, 
        // instead of matching previous layer's colortype, use F16
        kF16ColorType                   = 1 << 4,
    };
 
    typedef uint32_t SaveLayerFlags;
 
    struct SaveLayerRec {
        SaveLayerRec() {}
 
        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, SaveLayerFlags saveLayerFlags = 0)
            : SaveLayerRec(bounds, paint, nullptr, 1.f, saveLayerFlags) {}
 
        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                     SaveLayerFlags saveLayerFlags)
            : SaveLayerRec(bounds, paint, backdrop, 1.f, saveLayerFlags) {}
 
        const SkRect*        fBounds         = nullptr;
 
        const SkPaint*       fPaint          = nullptr;
 
        const SkImageFilter* fBackdrop       = nullptr;
 
        SaveLayerFlags       fSaveLayerFlags = 0;
 
    private:
        friend class SkCanvas;
        friend class SkCanvasPriv;
 
        SaveLayerRec(const SkRect* bounds, const SkPaint* paint, const SkImageFilter* backdrop,
                     SkScalar backdropScale, SaveLayerFlags saveLayerFlags)
            : fBounds(bounds)
            , fPaint(paint)
            , fBackdrop(backdrop)
            , fSaveLayerFlags(saveLayerFlags)
            , fExperimentalBackdropScale(backdropScale) {}
 
        // Relative scale factor that the image content used to initialize the layer when the
        // kInitFromPrevious flag or a backdrop filter is used.
        SkScalar             fExperimentalBackdropScale = 1.f;
    };
 
    int saveLayer(const SaveLayerRec& layerRec);
 
    void restore();
 
    int getSaveCount() const;
 
    void restoreToCount(int saveCount);
 
    void translate(SkScalar dx, SkScalar dy);
 
    void scale(SkScalar sx, SkScalar sy);
 
    void rotate(SkScalar degrees);
 
    void rotate(SkScalar degrees, SkScalar px, SkScalar py);
 
    void skew(SkScalar sx, SkScalar sy);
 
    void concat(const SkMatrix& matrix);
    void concat(const SkM44&);
 
    void setMatrix(const SkM44& matrix);
 
    // DEPRECATED -- use SkM44 version
    void setMatrix(const SkMatrix& matrix);
 
    void resetMatrix();
 
    void clipRect(const SkRect& rect, SkClipOp op, bool doAntiAlias);
 
    void clipRect(const SkRect& rect, SkClipOp op) {
        this->clipRect(rect, op, false);
    }
 
    void clipRect(const SkRect& rect, bool doAntiAlias = false) {
        this->clipRect(rect, SkClipOp::kIntersect, doAntiAlias);
    }
 
    void clipIRect(const SkIRect& irect, SkClipOp op = SkClipOp::kIntersect) {
        this->clipRect(SkRect::Make(irect), op, false);
    }
 
    void androidFramework_setDeviceClipRestriction(const SkIRect& rect);
 
    void clipRRect(const SkRRect& rrect, SkClipOp op, bool doAntiAlias);
 
    void clipRRect(const SkRRect& rrect, SkClipOp op) {
        this->clipRRect(rrect, op, false);
    }
 
    void clipRRect(const SkRRect& rrect, bool doAntiAlias = false) {
        this->clipRRect(rrect, SkClipOp::kIntersect, doAntiAlias);
    }
 
    void clipPath(const SkPath& path, SkClipOp op, bool doAntiAlias);
 
    void clipPath(const SkPath& path, SkClipOp op) {
        this->clipPath(path, op, false);
    }
 
    void clipPath(const SkPath& path, bool doAntiAlias = false) {
        this->clipPath(path, SkClipOp::kIntersect, doAntiAlias);
    }
 
    void clipShader(sk_sp<SkShader>, SkClipOp = SkClipOp::kIntersect);
 
    void clipRegion(const SkRegion& deviceRgn, SkClipOp op = SkClipOp::kIntersect);
 
    bool quickReject(const SkRect& rect) const;
 
    bool quickReject(const SkPath& path) const;
 
    SkRect getLocalClipBounds() const;
 
    bool getLocalClipBounds(SkRect* bounds) const {
        *bounds = this->getLocalClipBounds();
        return !bounds->isEmpty();
    }
 
    SkIRect getDeviceClipBounds() const;
 
    bool getDeviceClipBounds(SkIRect* bounds) const {
        *bounds = this->getDeviceClipBounds();
        return !bounds->isEmpty();
    }
 
    void drawColor(SkColor color, SkBlendMode mode = SkBlendMode::kSrcOver) {
        this->drawColor(SkColor4f::FromColor(color), mode);
    }
 
    void drawColor(const SkColor4f& color, SkBlendMode mode = SkBlendMode::kSrcOver);
 
    void clear(SkColor color) {
        this->clear(SkColor4f::FromColor(color));
    }
 
    void clear(const SkColor4f& color) {
        this->drawColor(color, SkBlendMode::kSrc);
    }
 
    void discard() { this->onDiscard(); }
 
    void drawPaint(const SkPaint& paint);
 
    enum PointMode {
        kPoints_PointMode,  
        kLines_PointMode,   
        kPolygon_PointMode, 
    };
 
    void drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint);
 
    void drawPoint(SkScalar x, SkScalar y, const SkPaint& paint);
 
    void drawPoint(SkPoint p, const SkPaint& paint) {
        this->drawPoint(p.x(), p.y(), paint);
    }
 
    void drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint);
 
    void drawLine(SkPoint p0, SkPoint p1, const SkPaint& paint) {
        this->drawLine(p0.x(), p0.y(), p1.x(), p1.y(), paint);
    }
 
    void drawRect(const SkRect& rect, const SkPaint& paint);
 
    void drawIRect(const SkIRect& rect, const SkPaint& paint) {
        SkRect r;
        r.set(rect);    // promotes the ints to scalars
        this->drawRect(r, paint);
    }
 
    void drawRegion(const SkRegion& region, const SkPaint& paint);
 
    void drawOval(const SkRect& oval, const SkPaint& paint);
 
    void drawRRect(const SkRRect& rrect, const SkPaint& paint);
 
    void drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint);
 
    void drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint);
 
    void drawCircle(SkPoint center, SkScalar radius, const SkPaint& paint) {
        this->drawCircle(center.x(), center.y(), radius, paint);
    }
 
    void drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle,
                 bool useCenter, const SkPaint& paint);
 
    void drawRoundRect(const SkRect& rect, SkScalar rx, SkScalar ry, const SkPaint& paint);
 
    void drawPath(const SkPath& path, const SkPaint& paint);
 
    void drawImage(const SkImage* image, SkScalar left, SkScalar top) {
        this->drawImage(image, left, top, SkSamplingOptions(), nullptr);
    }
    void drawImage(const sk_sp<SkImage>& image, SkScalar left, SkScalar top) {
        this->drawImage(image.get(), left, top, SkSamplingOptions(), nullptr);
    }
 
    enum SrcRectConstraint {
        kStrict_SrcRectConstraint, 
        kFast_SrcRectConstraint,   
    };
 
    void drawImage(const SkImage*, SkScalar x, SkScalar y, const SkSamplingOptions&,
                   const SkPaint* = nullptr);
    void drawImage(const sk_sp<SkImage>& image, SkScalar x, SkScalar y,
                   const SkSamplingOptions& sampling, const SkPaint* paint = nullptr) {
        this->drawImage(image.get(), x, y, sampling, paint);
    }
    void drawImageRect(const SkImage*, const SkRect& src, const SkRect& dst,
                       const SkSamplingOptions&, const SkPaint*, SrcRectConstraint);
    void drawImageRect(const SkImage*, const SkRect& dst, const SkSamplingOptions&,
                       const SkPaint* = nullptr);
    void drawImageRect(const sk_sp<SkImage>& image, const SkRect& src, const SkRect& dst,
                       const SkSamplingOptions& sampling, const SkPaint* paint,
                       SrcRectConstraint constraint) {
        this->drawImageRect(image.get(), src, dst, sampling, paint, constraint);
    }
    void drawImageRect(const sk_sp<SkImage>& image, const SkRect& dst,
                       const SkSamplingOptions& sampling, const SkPaint* paint = nullptr) {
        this->drawImageRect(image.get(), dst, sampling, paint);
    }
 
    void drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst,
                       SkFilterMode filter, const SkPaint* paint = nullptr);
 
    struct Lattice {
 
        enum RectType : uint8_t {
            kDefault     = 0, 
            kTransparent,     
            kFixedColor,      
        };
 
        const int*      fXDivs;     
        const int*      fYDivs;     
        const RectType* fRectTypes; 
        int             fXCount;    
        int             fYCount;    
        const SkIRect*  fBounds;    
        const SkColor*  fColors;    
    };
 
    void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst,
                          SkFilterMode filter, const SkPaint* paint = nullptr);
    void drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst) {
        this->drawImageLattice(image, lattice, dst, SkFilterMode::kNearest, nullptr);
    }
 
    enum QuadAAFlags : unsigned {
        kLeft_QuadAAFlag    = 0b0001,
        kTop_QuadAAFlag     = 0b0010,
        kRight_QuadAAFlag   = 0b0100,
        kBottom_QuadAAFlag  = 0b1000,
 
        kNone_QuadAAFlags   = 0b0000,
        kAll_QuadAAFlags    = 0b1111,
    };
 
    struct SK_API ImageSetEntry {
        ImageSetEntry(sk_sp<const SkImage> image, const SkRect& srcRect, const SkRect& dstRect,
                      int matrixIndex, float alpha, unsigned aaFlags, bool hasClip);
 
        ImageSetEntry(sk_sp<const SkImage> image, const SkRect& srcRect, const SkRect& dstRect,
                      float alpha, unsigned aaFlags);
 
        ImageSetEntry();
        ~ImageSetEntry();
        ImageSetEntry(const ImageSetEntry&);
        ImageSetEntry& operator=(const ImageSetEntry&);
 
        sk_sp<const SkImage> fImage;
        SkRect fSrcRect;
        SkRect fDstRect;
        int fMatrixIndex = -1; // Index into the preViewMatrices arg, or < 0
        float fAlpha = 1.f;
        unsigned fAAFlags = kNone_QuadAAFlags; // QuadAAFlags
        bool fHasClip = false; // True to use next 4 points in dstClip arg as quad
    };
 
    void experimental_DrawEdgeAAQuad(const SkRect& rect, const SkPoint clip[4], QuadAAFlags aaFlags,
                                     const SkColor4f& color, SkBlendMode mode);
    void experimental_DrawEdgeAAQuad(const SkRect& rect, const SkPoint clip[4], QuadAAFlags aaFlags,
                                     SkColor color, SkBlendMode mode) {
        this->experimental_DrawEdgeAAQuad(rect, clip, aaFlags, SkColor4f::FromColor(color), mode);
    }
 
    void experimental_DrawEdgeAAImageSet(const ImageSetEntry imageSet[], int cnt,
                                         const SkPoint dstClips[], const SkMatrix preViewMatrices[],
                                         const SkSamplingOptions&, const SkPaint* paint = nullptr,
                                         SrcRectConstraint constraint = kStrict_SrcRectConstraint);
 
    void drawSimpleText(const void* text, size_t byteLength, SkTextEncoding encoding,
                        SkScalar x, SkScalar y, const SkFont& font, const SkPaint& paint);
 
    void drawString(const char str[], SkScalar x, SkScalar y, const SkFont& font,
                    const SkPaint& paint) {
        this->drawSimpleText(str, strlen(str), SkTextEncoding::kUTF8, x, y, font, paint);
    }
 
    void drawString(const SkString& str, SkScalar x, SkScalar y, const SkFont& font,
                    const SkPaint& paint) {
        this->drawSimpleText(str.c_str(), str.size(), SkTextEncoding::kUTF8, x, y, font, paint);
    }
 
    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
                    const uint32_t clusters[], int textByteCount, const char utf8text[],
                    SkPoint origin, const SkFont& font, const SkPaint& paint);
 
    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[],
                    SkPoint origin, const SkFont& font, const SkPaint& paint);
 
    void drawGlyphs(int count, const SkGlyphID glyphs[], const SkRSXform xforms[],
                    SkPoint origin, const SkFont& font, const SkPaint& paint);
 
    void drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint);
 
    void drawTextBlob(const sk_sp<SkTextBlob>& blob, SkScalar x, SkScalar y, const SkPaint& paint) {
        this->drawTextBlob(blob.get(), x, y, paint);
    }
 
    void drawPicture(const SkPicture* picture) {
        this->drawPicture(picture, nullptr, nullptr);
    }
 
    void drawPicture(const sk_sp<SkPicture>& picture) {
        this->drawPicture(picture.get());
    }
 
    void drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint);
 
    void drawPicture(const sk_sp<SkPicture>& picture, const SkMatrix* matrix,
                     const SkPaint* paint) {
        this->drawPicture(picture.get(), matrix, paint);
    }
 
    void drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint);
 
    void drawVertices(const sk_sp<SkVertices>& vertices, SkBlendMode mode, const SkPaint& paint);
 
    void drawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint);
 
    void drawPatch(const SkPoint cubics[12], const SkColor colors[4],
                   const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint);
 
    void drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[],
                   const SkColor colors[], int count, SkBlendMode mode,
                   const SkSamplingOptions& sampling, const SkRect* cullRect, const SkPaint* paint);
 
    void drawDrawable(SkDrawable* drawable, const SkMatrix* matrix = nullptr);
 
    void drawDrawable(SkDrawable* drawable, SkScalar x, SkScalar y);
 
    void drawAnnotation(const SkRect& rect, const char key[], SkData* value);
 
    void drawAnnotation(const SkRect& rect, const char key[], const sk_sp<SkData>& value) {
        this->drawAnnotation(rect, key, value.get());
    }
 
    virtual bool isClipEmpty() const;
 
    virtual bool isClipRect() const;
 
    SkM44 getLocalToDevice() const;
 
    SkMatrix getLocalToDeviceAs3x3() const {
        return this->getLocalToDevice().asM33();
    }
 
#ifdef SK_SUPPORT_LEGACY_GETTOTALMATRIX
    SkMatrix getTotalMatrix() const;
#endif
 
 
    void temporary_internal_getRgnClip(SkRegion* region);
 
    void private_draw_shadow_rec(const SkPath&, const SkDrawShadowRec&);
 
 
protected:
    // default impl defers to getDevice()->newSurface(info)
    virtual sk_sp<SkSurface> onNewSurface(const SkImageInfo& info, const SkSurfaceProps& props);
 
    // default impl defers to its device
    virtual bool onPeekPixels(SkPixmap* pixmap);
    virtual bool onAccessTopLayerPixels(SkPixmap* pixmap);
    virtual SkImageInfo onImageInfo() const;
    virtual bool onGetProps(SkSurfaceProps* props, bool top) const;
 
    // Subclass save/restore notifiers.
    // Overriders should call the corresponding INHERITED method up the inheritance chain.
    // getSaveLayerStrategy()'s return value may suppress full layer allocation.
    enum SaveLayerStrategy {
        kFullLayer_SaveLayerStrategy,
        kNoLayer_SaveLayerStrategy,
    };
 
    virtual void willSave() {}
    // Overriders should call the corresponding INHERITED method up the inheritance chain.
    virtual SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec& ) {
        return kFullLayer_SaveLayerStrategy;
    }
 
    // returns true if we should actually perform the saveBehind, or false if we should just save.
    virtual bool onDoSaveBehind(const SkRect*) { return true; }
    virtual void willRestore() {}
    virtual void didRestore() {}
 
    virtual void didConcat44(const SkM44&) {}
    virtual void didSetM44(const SkM44&) {}
    virtual void didTranslate(SkScalar, SkScalar) {}
    virtual void didScale(SkScalar, SkScalar) {}
 
    // NOTE: If you are adding a new onDraw virtual to SkCanvas, PLEASE add an override to
    // SkCanvasVirtualEnforcer (in SkCanvasVirtualEnforcer.h). This ensures that subclasses using
    // that mechanism  will be required to implement the new function.
    virtual void onDrawPaint(const SkPaint& paint);
    virtual void onDrawBehind(const SkPaint& paint);
    virtual void onDrawRect(const SkRect& rect, const SkPaint& paint);
    virtual void onDrawRRect(const SkRRect& rrect, const SkPaint& paint);
    virtual void onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint);
    virtual void onDrawOval(const SkRect& rect, const SkPaint& paint);
    virtual void onDrawArc(const SkRect& rect, SkScalar startAngle, SkScalar sweepAngle,
                           bool useCenter, const SkPaint& paint);
    virtual void onDrawPath(const SkPath& path, const SkPaint& paint);
    virtual void onDrawRegion(const SkRegion& region, const SkPaint& paint);
 
    virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                                const SkPaint& paint);
 
    virtual void onDrawGlyphRunList(const sktext::GlyphRunList& glyphRunList, const SkPaint& paint);
 
    virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                           const SkPoint texCoords[4], SkBlendMode mode, const SkPaint& paint);
    virtual void onDrawPoints(PointMode mode, size_t count, const SkPoint pts[],
                              const SkPaint& paint);
 
    virtual void onDrawImage2(const SkImage*, SkScalar dx, SkScalar dy, const SkSamplingOptions&,
                              const SkPaint*);
    virtual void onDrawImageRect2(const SkImage*, const SkRect& src, const SkRect& dst,
                                  const SkSamplingOptions&, const SkPaint*, SrcRectConstraint);
    virtual void onDrawImageLattice2(const SkImage*, const Lattice&, const SkRect& dst,
                                     SkFilterMode, const SkPaint*);
    virtual void onDrawAtlas2(const SkImage*, const SkRSXform[], const SkRect src[],
                              const SkColor[], int count, SkBlendMode, const SkSamplingOptions&,
                              const SkRect* cull, const SkPaint*);
    virtual void onDrawEdgeAAImageSet2(const ImageSetEntry imageSet[], int count,
                                       const SkPoint dstClips[], const SkMatrix preViewMatrices[],
                                       const SkSamplingOptions&, const SkPaint*,
                                       SrcRectConstraint);
 
    virtual void onDrawVerticesObject(const SkVertices* vertices, SkBlendMode mode,
                                      const SkPaint& paint);
    virtual void onDrawMesh(const SkMesh&, sk_sp<SkBlender>, const SkPaint&);
    virtual void onDrawAnnotation(const SkRect& rect, const char key[], SkData* value);
    virtual void onDrawShadowRec(const SkPath&, const SkDrawShadowRec&);
 
    virtual void onDrawDrawable(SkDrawable* drawable, const SkMatrix* matrix);
    virtual void onDrawPicture(const SkPicture* picture, const SkMatrix* matrix,
                               const SkPaint* paint);
 
    virtual void onDrawEdgeAAQuad(const SkRect& rect, const SkPoint clip[4], QuadAAFlags aaFlags,
                                  const SkColor4f& color, SkBlendMode mode);
 
    enum ClipEdgeStyle {
        kHard_ClipEdgeStyle,
        kSoft_ClipEdgeStyle
    };
 
    virtual void onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle);
    virtual void onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle);
    virtual void onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle);
    virtual void onClipShader(sk_sp<SkShader>, SkClipOp);
    virtual void onClipRegion(const SkRegion& deviceRgn, SkClipOp op);
    virtual void onResetClip();
 
    virtual void onDiscard();
 
    virtual sk_sp<sktext::gpu::Slug> onConvertGlyphRunListToSlug(
            const sktext::GlyphRunList& glyphRunList, const SkPaint& paint);
 
    virtual void onDrawSlug(const sktext::gpu::Slug* slug);
 
private:
 
    enum ShaderOverrideOpacity {
        kNone_ShaderOverrideOpacity,        
        kOpaque_ShaderOverrideOpacity,      
        kNotOpaque_ShaderOverrideOpacity,   
    };
 
    // notify our surface (if we have one) that we are about to draw, so it
    // can perform copy-on-write or invalidate any cached images
    // returns false if the copy failed
    [[nodiscard]] bool predrawNotify(bool willOverwritesEntireSurface = false);
    [[nodiscard]] bool predrawNotify(const SkRect*, const SkPaint*, ShaderOverrideOpacity);
 
    enum class CheckForOverwrite : bool {
        kNo = false,
        kYes = true
    };
    // call the appropriate predrawNotify and create a layer if needed.
    std::optional<AutoLayerForImageFilter> aboutToDraw(
        SkCanvas* canvas,
        const SkPaint& paint,
        const SkRect* rawBounds = nullptr,
        CheckForOverwrite = CheckForOverwrite::kNo,
        ShaderOverrideOpacity = kNone_ShaderOverrideOpacity);
 
    // The bottom-most device in the stack, only changed by init(). Image properties and the final
    // canvas pixels are determined by this device.
    SkDevice* rootDevice() const {
        SkASSERT(fRootDevice);
        return fRootDevice.get();
    }
 
    // The top-most device in the stack, will change within saveLayer()'s. All drawing and clipping
    // operations should route to this device.
    SkDevice* topDevice() const;
 
    // Canvases maintain a sparse stack of layers, where the top-most layer receives the drawing,
    // clip, and matrix commands. There is a layer per call to saveLayer() using the
    // kFullLayer_SaveLayerStrategy.
    struct Layer {
        sk_sp<SkDevice>      fDevice;
        sk_sp<SkImageFilter> fImageFilter; // applied to layer *before* being drawn by paint
        SkPaint              fPaint;
        bool                 fIsCoverage;
        bool                 fDiscard;
 
        Layer(sk_sp<SkDevice> device,
              sk_sp<SkImageFilter> imageFilter,
              const SkPaint& paint,
              bool isCoverage);
    };
 
    // Encapsulate state needed to restore from saveBehind()
    struct BackImage {
        // Out of line to avoid including SkSpecialImage.h
        BackImage(sk_sp<SkSpecialImage>, SkIPoint);
        BackImage(const BackImage&);
        BackImage(BackImage&&);
        BackImage& operator=(const BackImage&);
        ~BackImage();
 
        sk_sp<SkSpecialImage> fImage;
        SkIPoint              fLoc;
    };
 
    class MCRec {
    public:
        // If not null, this MCRec corresponds with the saveLayer() record that made the layer.
        // The base "layer" is not stored here, since it is stored inline in SkCanvas and has no
        // restoration behavior.
        std::unique_ptr<Layer> fLayer;
 
        // This points to the device of the top-most layer (which may be lower in the stack), or
        // to the canvas's fRootDevice. The MCRec does not own the device.
        SkDevice* fDevice;
 
        std::unique_ptr<BackImage> fBackImage;
        SkM44 fMatrix;
        int fDeferredSaveCount = 0;
 
        MCRec(SkDevice* device);
        MCRec(const MCRec* prev);
        ~MCRec();
 
        void newLayer(sk_sp<SkDevice> layerDevice,
                      sk_sp<SkImageFilter> filter,
                      const SkPaint& restorePaint,
                      bool layerIsCoverage);
 
        void reset(SkDevice* device);
    };
 
    // the first N recs that can fit here mean we won't call malloc
    static constexpr int kMCRecSize      = 96; // most recent measurement
    static constexpr int kMCRecCount     = 32; // common depth for save/restores
 
    intptr_t fMCRecStorage[kMCRecSize * kMCRecCount / sizeof(intptr_t)];
 
    SkDeque     fMCStack;
    // points to top of stack
    MCRec*      fMCRec;
 
    // Installed via init()
    sk_sp<SkDevice> fRootDevice;
    const SkSurfaceProps fProps;
 
    int         fSaveCount;         // value returned by getSaveCount()
 
    std::unique_ptr<SkRasterHandleAllocator> fAllocator;
 
    SkSurface_Base*  fSurfaceBase;
    SkSurface_Base* getSurfaceBase() const { return fSurfaceBase; }
    void setSurfaceBase(SkSurface_Base* sb) {
        fSurfaceBase = sb;
    }
    friend class SkSurface_Base;
    friend class SkSurface_Ganesh;
 
    SkIRect fClipRestrictionRect = SkIRect::MakeEmpty();
    int fClipRestrictionSaveCount = -1;
 
    void doSave();
    void checkForDeferredSave();
    void internalSetMatrix(const SkM44&);
 
    friend class SkAndroidFrameworkUtils;
    friend class SkCanvasPriv;      // needs to expose android functions for testing outside android
    friend class AutoLayerForImageFilter;
    friend class SkSurface_Raster;  // needs getDevice()
    friend class SkNoDrawCanvas;    // needs resetForNextPicture()
    friend class SkNWayCanvas;
    friend class SkPictureRecord;   // predrawNotify (why does it need it? <reed>)
    friend class SkOverdrawCanvas;
    friend class SkRasterHandleAllocator;
    friend class SkRecords::Draw;
    template <typename Key>
    friend class SkTestCanvas;
 
protected:
    // For use by SkNoDrawCanvas (via SkCanvasVirtualEnforcer, which can't be a friend)
    SkCanvas(const SkIRect& bounds);
private:
    SkCanvas(const SkBitmap&, std::unique_ptr<SkRasterHandleAllocator>,
             SkRasterHandleAllocator::Handle, const SkSurfaceProps* props);
 
    SkCanvas(SkCanvas&&) = delete;
    SkCanvas(const SkCanvas&) = delete;
    SkCanvas& operator=(SkCanvas&&) = delete;
    SkCanvas& operator=(const SkCanvas&) = delete;
 
    friend class sktext::gpu::Slug;
    friend class SkPicturePlayback;
    sk_sp<sktext::gpu::Slug> convertBlobToSlug(const SkTextBlob& blob, SkPoint origin,
                                               const SkPaint& paint);
 
    void drawSlug(const sktext::gpu::Slug* slug);
 
    int only_axis_aligned_saveBehind(const SkRect* subset);
 
    void drawClippedToSaveBehind(const SkPaint&);
 
    void resetForNextPicture(const SkIRect& bounds);
 
    // needs gettotalclip()
    friend class SkCanvasStateUtils;
 
    void init(sk_sp<SkDevice>);
 
    // All base onDrawX() functions should call this and skip drawing if it returns true.
    // If 'matrix' is non-null, it maps the paint's fast bounds before checking for quick rejection
    bool internalQuickReject(const SkRect& bounds, const SkPaint& paint,
                             const SkMatrix* matrix = nullptr);
 
    void internalDrawPaint(const SkPaint& paint);
    void internalSaveLayer(const SaveLayerRec&, SaveLayerStrategy, bool coverageOnly=false);
    void internalSaveBehind(const SkRect*);
 
    void internalConcat44(const SkM44&);
 
    // shared by save() and saveLayer()
    void internalSave();
    void internalRestore();
 
    enum class DeviceCompatibleWithFilter : bool {
        // Check the src device's local-to-device matrix for compatibility with the filter, and if
        // it is not compatible, introduce an intermediate image and transformation that allows the
        // filter to be evaluated on the modified src content.
        kUnknown = false,
        // Assume that the src device's local-to-device matrix is compatible with the filter.
        kYes     = true
    };
    void internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst,
                                      const SkImageFilter* filter, const SkPaint& paint,
                                      DeviceCompatibleWithFilter compat,
                                      SkScalar scaleFactor = 1.f,
                                      bool srcIsCoverageLayer = false);
 
    /*
     *  Returns true if drawing the specified rect (or all if it is null) with the specified
     *  paint (or default if null) would overwrite the entire root device of the canvas
     *  (i.e. the canvas' surface if it had one).
     */
    bool wouldOverwriteEntireSurface(const SkRect*, const SkPaint*, ShaderOverrideOpacity) const;
 
    bool canDrawBitmapAsSprite(SkScalar x, SkScalar y, int w, int h, const SkSamplingOptions&,
                               const SkPaint&);
 
    bool androidFramework_isClipAA() const;
 
    void internal_private_resetClip();
 
    virtual SkPaintFilterCanvas* internal_private_asPaintFilterCanvas() const { return nullptr; }
 
    // Keep track of the device clip bounds in the canvas' global space to reject draws before
    // invoking the top-level device.
    SkRect fQuickRejectBounds;
 
    // Compute the clip's bounds based on all clipped SkDevice's reported device bounds transformed
    // into the canvas' global space.
    SkRect computeDeviceClipBounds(bool outsetForAA=true) const;
 
    class AutoUpdateQRBounds;
    void validateClip() const;
 
    std::unique_ptr<sktext::GlyphRunBuilder> fScratchGlyphRunBuilder;
};
 
class SkAutoCanvasRestore {
public:
 
    SkAutoCanvasRestore(SkCanvas* canvas, bool doSave) : fCanvas(canvas), fSaveCount(0) {
        if (fCanvas) {
            fSaveCount = canvas->getSaveCount();
            if (doSave) {
                canvas->save();
            }
        }
    }
 
    ~SkAutoCanvasRestore() {
        if (fCanvas) {
            fCanvas->restoreToCount(fSaveCount);
        }
    }
 
    void restore() {
        if (fCanvas) {
            fCanvas->restoreToCount(fSaveCount);
            fCanvas = nullptr;
        }
    }
 
private:
    SkCanvas*   fCanvas;
    int         fSaveCount;
 
    SkAutoCanvasRestore(SkAutoCanvasRestore&&) = delete;
    SkAutoCanvasRestore(const SkAutoCanvasRestore&) = delete;
    SkAutoCanvasRestore& operator=(SkAutoCanvasRestore&&) = delete;
    SkAutoCanvasRestore& operator=(const SkAutoCanvasRestore&) = delete;
};
 
#endif