/* * Copyright 2008 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. */ #include "include/core/SkCanvas.h" #include "include/core/SkAlphaType.h" #include "include/core/SkBitmap.h" #include "include/core/SkBlendMode.h" #include "include/core/SkBlender.h" #include "include/core/SkBlurTypes.h" #include "include/core/SkColorFilter.h" #include "include/core/SkColorSpace.h" #include "include/core/SkColorType.h" #include "include/core/SkImage.h" #include "include/core/SkImageFilter.h" #include "include/core/SkMaskFilter.h" #include "include/core/SkPath.h" #include "include/core/SkPathEffect.h" #include "include/core/SkPicture.h" #include "include/core/SkPixmap.h" #include "include/core/SkRRect.h" #include "include/core/SkRSXform.h" #include "include/core/SkRasterHandleAllocator.h" #include "include/core/SkRefCnt.h" #include "include/core/SkRegion.h" #include "include/core/SkShader.h" #include "include/core/SkStrokeRec.h" #include "include/core/SkSurface.h" #include "include/core/SkTextBlob.h" #include "include/core/SkTileMode.h" #include "include/core/SkTypes.h" #include "include/core/SkVertices.h" #include "include/private/base/SkDebug.h" #include "include/private/base/SkFloatingPoint.h" #include "include/private/base/SkSafe32.h" #include "include/private/base/SkTPin.h" #include "include/private/base/SkTemplates.h" #include "include/private/base/SkTo.h" #include "include/private/chromium/Slug.h" #include "include/utils/SkNoDrawCanvas.h" #include "src/base/SkEnumBitMask.h" #include "src/base/SkMSAN.h" #include "src/core/SkBlenderBase.h" #include "src/core/SkBlurMaskFilterImpl.h" #include "src/core/SkCanvasPriv.h" #include "src/core/SkDevice.h" #include "src/core/SkImageFilterTypes.h" #include "src/core/SkImageFilter_Base.h" #include "src/core/SkImagePriv.h" #include "src/core/SkLatticeIter.h" #include "src/core/SkMaskFilterBase.h" #include "src/core/SkMatrixPriv.h" #include "src/core/SkPaintPriv.h" #include "src/core/SkSpecialImage.h" #include "src/core/SkSurfacePriv.h" #include "src/core/SkTraceEvent.h" #include "src/core/SkVerticesPriv.h" #include "src/effects/colorfilters/SkColorFilterBase.h" #include "src/image/SkSurface_Base.h" #include "src/text/GlyphRun.h" #include "src/utils/SkPatchUtils.h" #include <algorithm> #include <memory> #include <new> #include <optional> #include <tuple> #include <utility> #define RETURN_ON_NULL(ptr) … #define RETURN_ON_FALSE(pred) … // This is a test: static_assert with no message is a c++17 feature, // and std::max() is constexpr only since the c++14 stdlib. static_assert …; Slug; /////////////////////////////////////////////////////////////////////////////////////////////////// SK_MAKE_BITMASK_OPS(…) /* * Return true if the drawing this rect would hit every pixels in the canvas. * * Returns false if * - rect does not contain the canvas' bounds * - paint is not fill * - paint would blur or otherwise change the coverage of the rect */ bool SkCanvas::wouldOverwriteEntireSurface(const SkRect* rect, const SkPaint* paint, SkEnumBitMask<PredrawFlags> flags) const { … } /////////////////////////////////////////////////////////////////////////////////////////////////// bool SkCanvas::predrawNotify(bool willOverwritesEntireSurface) { … } bool SkCanvas::predrawNotify(const SkRect* rect, const SkPaint* paint, SkEnumBitMask<PredrawFlags> flags) { … } /////////////////////////////////////////////////////////////////////////////// SkCanvas::Layer::Layer(sk_sp<SkDevice> device, FilterSpan imageFilters, const SkPaint& paint, bool isCoverage, bool includesPadding) : … { … } SkCanvas::BackImage::BackImage(sk_sp<SkSpecialImage> img, SkIPoint loc) : … { … } SkCanvas::BackImage::BackImage(const BackImage&) = default; SkCanvas::BackImage::BackImage(BackImage&&) = default; SkCanvas::BackImage& SkCanvas::BackImage::operator=(const BackImage&) = default; SkCanvas::BackImage::~BackImage() = default; SkCanvas::MCRec::MCRec(SkDevice* device) : … { … } SkCanvas::MCRec::MCRec(const MCRec* prev) : … { … } SkCanvas::MCRec::~MCRec() { … } void SkCanvas::MCRec::newLayer(sk_sp<SkDevice> layerDevice, FilterSpan filters, const SkPaint& restorePaint, bool layerIsCoverage, bool includesPadding) { … } void SkCanvas::MCRec::reset(SkDevice* device) { … } class SkCanvas::AutoUpdateQRBounds { … }; ///////////////////////////////////////////////////////////////////////////// std::optional<AutoLayerForImageFilter> SkCanvas::aboutToDraw( const SkPaint& paint, const SkRect* rawBounds, SkEnumBitMask<PredrawFlags> flags) { … } std::optional<AutoLayerForImageFilter> SkCanvas::aboutToDraw( const SkPaint& paint, const SkRect* rawBounds) { … } //////////////////////////////////////////////////////////////////////////// void SkCanvas::resetForNextPicture(const SkIRect& bounds) { … } void SkCanvas::init(sk_sp<SkDevice> device) { … } SkCanvas::SkCanvas() : … { … } SkCanvas::SkCanvas(int width, int height, const SkSurfaceProps* props) : … { … } SkCanvas::SkCanvas(const SkIRect& bounds) : … { … } SkCanvas::SkCanvas(sk_sp<SkDevice> device) : … { … } SkCanvas::~SkCanvas() { … } SkSurface* SkCanvas::getSurface() const { … } SkISize SkCanvas::getBaseLayerSize() const { … } SkDevice* SkCanvas::topDevice() const { … } bool SkCanvas::readPixels(const SkPixmap& pm, int x, int y) { … } bool SkCanvas::readPixels(const SkImageInfo& dstInfo, void* dstP, size_t rowBytes, int x, int y) { … } bool SkCanvas::readPixels(const SkBitmap& bm, int x, int y) { … } bool SkCanvas::writePixels(const SkBitmap& bitmap, int x, int y) { … } bool SkCanvas::writePixels(const SkImageInfo& srcInfo, const void* pixels, size_t rowBytes, int x, int y) { … } ////////////////////////////////////////////////////////////////////////////// void SkCanvas::checkForDeferredSave() { … } int SkCanvas::getSaveCount() const { … } int SkCanvas::save() { … } void SkCanvas::doSave() { … } void SkCanvas::restore() { … } void SkCanvas::restoreToCount(int count) { … } void SkCanvas::internalSave() { … } int SkCanvas::saveLayer(const SkRect* bounds, const SkPaint* paint) { … } int SkCanvas::saveLayer(const SaveLayerRec& rec) { … } int SkCanvas::only_axis_aligned_saveBehind(const SkRect* bounds) { … } // Helper function to compute the center reference point used for scale decomposition under // non-linear transformations. static skif::ParameterSpace<SkPoint> compute_decomposition_center( const SkMatrix& dstToLocal, std::optional<skif::ParameterSpace<SkRect>> contentBounds, const skif::DeviceSpace<SkIRect>& targetOutput) { … } // Helper when we need to upgrade a single filter to a FilterSpan struct FilterToSpan { … }; // Compute suitable transformations and layer bounds for a new layer that will be used as the source // input into 'filter' before being drawn into 'dst' via the returned skif::Mapping. // Null filters are permitted and act as the identity. The returned mapping will be compatible with // the image filter. // // An empty optional is returned if the layer mapping and bounds couldn't be determined, in which // case the layer should be skipped. An instantiated optional can have an empty layer bounds rect // if the image filter doesn't require an input image to produce a valid output. static std::optional<std::pair<skif::Mapping, skif::LayerSpace<SkIRect>>> get_layer_mapping_and_bounds( SkCanvas::FilterSpan filters, const SkMatrix& localToDst, const skif::DeviceSpace<SkIRect>& targetOutput, std::optional<skif::ParameterSpace<SkRect>> contentBounds = { … } // Ideally image filters operate in the dst color type, but if there is insufficient alpha bits // we move some bits from color channels into the alpha channel since that can greatly improve // the quality of blurs and other filters. static SkColorType image_filter_color_type(const SkColorInfo& dstInfo) { … } static skif::FilterResult apply_alpha_and_colorfilter(const skif::Context& ctx, const skif::FilterResult& image, const SkPaint& paint) { … } void SkCanvas::internalDrawDeviceWithFilter(SkDevice* src, SkDevice* dst, FilterSpan filters, const SkPaint& paint, DeviceCompatibleWithFilter compat, const SkColorInfo& filterColorInfo, SkScalar scaleFactor, bool srcIsCoverageLayer) { … } void SkCanvas::internalSaveLayer(const SaveLayerRec& rec, SaveLayerStrategy strategy, bool coverageOnly) { … } int SkCanvas::saveLayerAlphaf(const SkRect* bounds, float alpha) { … } void SkCanvas::internalSaveBehind(const SkRect* localBounds) { … } void SkCanvas::internalRestore() { … } sk_sp<SkSurface> SkCanvas::makeSurface(const SkImageInfo& info, const SkSurfaceProps* props) { … } sk_sp<SkSurface> SkCanvas::onNewSurface(const SkImageInfo& info, const SkSurfaceProps& props) { … } SkImageInfo SkCanvas::imageInfo() const { … } SkImageInfo SkCanvas::onImageInfo() const { … } bool SkCanvas::getProps(SkSurfaceProps* props) const { … } SkSurfaceProps SkCanvas::getBaseProps() const { … } SkSurfaceProps SkCanvas::getTopProps() const { … } bool SkCanvas::onGetProps(SkSurfaceProps* props, bool top) const { … } bool SkCanvas::peekPixels(SkPixmap* pmap) { … } bool SkCanvas::onPeekPixels(SkPixmap* pmap) { … } void* SkCanvas::accessTopLayerPixels(SkImageInfo* info, size_t* rowBytes, SkIPoint* origin) { … } bool SkCanvas::onAccessTopLayerPixels(SkPixmap* pmap) { … } ///////////////////////////////////////////////////////////////////////////// void SkCanvas::translate(SkScalar dx, SkScalar dy) { … } void SkCanvas::scale(SkScalar sx, SkScalar sy) { … } void SkCanvas::rotate(SkScalar degrees) { … } void SkCanvas::rotate(SkScalar degrees, SkScalar px, SkScalar py) { … } void SkCanvas::skew(SkScalar sx, SkScalar sy) { … } void SkCanvas::concat(const SkMatrix& matrix) { … } void SkCanvas::internalConcat44(const SkM44& m) { … } void SkCanvas::concat(const SkM44& m) { … } void SkCanvas::internalSetMatrix(const SkM44& m) { … } void SkCanvas::setMatrix(const SkMatrix& matrix) { … } void SkCanvas::setMatrix(const SkM44& m) { … } void SkCanvas::resetMatrix() { … } ////////////////////////////////////////////////////////////////////////////// void SkCanvas::clipRect(const SkRect& rect, SkClipOp op, bool doAA) { … } void SkCanvas::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle edgeStyle) { … } void SkCanvas::androidFramework_setDeviceClipRestriction(const SkIRect& rect) { … } void SkCanvas::internal_private_resetClip() { … } void SkCanvas::onResetClip() { … } void SkCanvas::clipRRect(const SkRRect& rrect, SkClipOp op, bool doAA) { … } void SkCanvas::onClipRRect(const SkRRect& rrect, SkClipOp op, ClipEdgeStyle edgeStyle) { … } void SkCanvas::clipPath(const SkPath& path, SkClipOp op, bool doAA) { … } void SkCanvas::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle edgeStyle) { … } void SkCanvas::clipShader(sk_sp<SkShader> sh, SkClipOp op) { … } void SkCanvas::onClipShader(sk_sp<SkShader> sh, SkClipOp op) { … } void SkCanvas::clipRegion(const SkRegion& rgn, SkClipOp op) { … } void SkCanvas::onClipRegion(const SkRegion& rgn, SkClipOp op) { … } void SkCanvas::validateClip() const { … } bool SkCanvas::androidFramework_isClipAA() const { … } void SkCanvas::temporary_internal_getRgnClip(SkRegion* rgn) { … } /////////////////////////////////////////////////////////////////////////////// bool SkCanvas::isClipEmpty() const { … } bool SkCanvas::isClipRect() const { … } bool SkCanvas::quickReject(const SkRect& src) const { … } bool SkCanvas::quickReject(const SkPath& path) const { … } bool SkCanvas::internalQuickReject(const SkRect& bounds, const SkPaint& paint, const SkMatrix* matrix) { … } SkRect SkCanvas::getLocalClipBounds() const { … } SkIRect SkCanvas::getDeviceClipBounds() const { … } SkRect SkCanvas::computeDeviceClipBounds(bool outsetForAA) const { … } /////////////////////////////////////////////////////////////////////// SkMatrix SkCanvas::getTotalMatrix() const { … } SkM44 SkCanvas::getLocalToDevice() const { … } GrRecordingContext* SkCanvas::recordingContext() const { … } skgpu::graphite::Recorder* SkCanvas::recorder() const { … } void SkCanvas::drawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) { … } void SkCanvas::drawPaint(const SkPaint& paint) { … } void SkCanvas::drawRect(const SkRect& r, const SkPaint& paint) { … } void SkCanvas::drawClippedToSaveBehind(const SkPaint& paint) { … } void SkCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) { … } void SkCanvas::drawOval(const SkRect& r, const SkPaint& paint) { … } void SkCanvas::drawRRect(const SkRRect& rrect, const SkPaint& paint) { … } void SkCanvas::drawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) { … } void SkCanvas::drawVertices(const sk_sp<SkVertices>& vertices, SkBlendMode mode, const SkPaint& paint) { … } void SkCanvas::drawVertices(const SkVertices* vertices, SkBlendMode mode, const SkPaint& paint) { … } void SkCanvas::drawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint) { … } void SkCanvas::drawPath(const SkPath& path, const SkPaint& paint) { … } // Returns true if the rect can be "filled" : non-empty and finite static bool fillable(const SkRect& r) { … } static SkPaint clean_paint_for_lattice(const SkPaint* paint) { … } void SkCanvas::drawImageNine(const SkImage* image, const SkIRect& center, const SkRect& dst, SkFilterMode filter, const SkPaint* paint) { … } void SkCanvas::drawImageLattice(const SkImage* image, const Lattice& lattice, const SkRect& dst, SkFilterMode filter, const SkPaint* paint) { … } void SkCanvas::drawAtlas(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode mode, const SkSamplingOptions& sampling, const SkRect* cull, const SkPaint* paint) { … } void SkCanvas::drawAnnotation(const SkRect& rect, const char key[], SkData* value) { … } void SkCanvas::private_draw_shadow_rec(const SkPath& path, const SkDrawShadowRec& rec) { … } void SkCanvas::onDrawShadowRec(const SkPath& path, const SkDrawShadowRec& rec) { … } void SkCanvas::experimental_DrawEdgeAAQuad(const SkRect& rect, const SkPoint clip[4], QuadAAFlags aaFlags, const SkColor4f& color, SkBlendMode mode) { … } void SkCanvas::experimental_DrawEdgeAAImageSet(const ImageSetEntry imageSet[], int cnt, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions& sampling, const SkPaint* paint, SrcRectConstraint constraint) { … } ////////////////////////////////////////////////////////////////////////////// // These are the virtual drawing methods ////////////////////////////////////////////////////////////////////////////// void SkCanvas::onDiscard() { … } void SkCanvas::onDrawPaint(const SkPaint& paint) { … } void SkCanvas::internalDrawPaint(const SkPaint& paint) { … } void SkCanvas::onDrawPoints(PointMode mode, size_t count, const SkPoint pts[], const SkPaint& paint) { … } static const SkBlurMaskFilterImpl* can_attempt_blurred_rrect_draw(const SkPaint& paint) { … } std::optional<AutoLayerForImageFilter> SkCanvas::attemptBlurredRRectDraw( const SkRRect& rrect, const SkPaint& paint, SkEnumBitMask<PredrawFlags> flags) { … } void SkCanvas::onDrawRect(const SkRect& r, const SkPaint& paint) { … } void SkCanvas::onDrawRegion(const SkRegion& region, const SkPaint& paint) { … } void SkCanvas::onDrawBehind(const SkPaint& paint) { … } void SkCanvas::onDrawOval(const SkRect& oval, const SkPaint& paint) { … } void SkCanvas::onDrawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint) { … } void SkCanvas::onDrawRRect(const SkRRect& rrect, const SkPaint& paint) { … } void SkCanvas::onDrawDRRect(const SkRRect& outer, const SkRRect& inner, const SkPaint& paint) { … } void SkCanvas::onDrawPath(const SkPath& path, const SkPaint& paint) { … } // Clean-up the paint to match the drawing semantics for drawImage et al. (skbug.com/7804). static SkPaint clean_paint_for_drawImage(const SkPaint* paint) { … } // drawVertices fills triangles and ignores mask filter and path effect, // so canonicalize the paint before checking quick reject. static SkPaint clean_paint_for_drawVertices(SkPaint paint) { … } // TODO: Delete this since it is no longer used void SkCanvas::onDrawImage2(const SkImage* image, SkScalar x, SkScalar y, const SkSamplingOptions& sampling, const SkPaint* paint) { … } static SkSamplingOptions clean_sampling_for_constraint( const SkSamplingOptions& sampling, SkCanvas::SrcRectConstraint constraint) { … } void SkCanvas::onDrawImageRect2(const SkImage* image, const SkRect& src, const SkRect& dst, const SkSamplingOptions& sampling, const SkPaint* paint, SrcRectConstraint constraint) { … } void SkCanvas::onDrawImageLattice2(const SkImage* image, const Lattice& lattice, const SkRect& dst, SkFilterMode filter, const SkPaint* paint) { … } void SkCanvas::drawImage(const SkImage* image, SkScalar x, SkScalar y, const SkSamplingOptions& sampling, const SkPaint* paint) { … } void SkCanvas::drawImageRect(const SkImage* image, const SkRect& src, const SkRect& dst, const SkSamplingOptions& sampling, const SkPaint* paint, SrcRectConstraint constraint) { … } void SkCanvas::drawImageRect(const SkImage* image, const SkRect& dst, const SkSamplingOptions& sampling, const SkPaint* paint) { … } void SkCanvas::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint) { … } void SkCanvas::onDrawGlyphRunList(const sktext::GlyphRunList& glyphRunList, const SkPaint& paint) { … } sk_sp<Slug> SkCanvas::convertBlobToSlug( const SkTextBlob& blob, SkPoint origin, const SkPaint& paint) { … } sk_sp<Slug> SkCanvas::onConvertGlyphRunListToSlug(const sktext::GlyphRunList& glyphRunList, const SkPaint& paint) { … } void SkCanvas::drawSlug(const Slug* slug, const SkPaint& paint) { … } void SkCanvas::onDrawSlug(const Slug* slug, const SkPaint& paint) { … } // These call the (virtual) onDraw... method void SkCanvas::drawSimpleText(const void* text, size_t byteLength, SkTextEncoding encoding, SkScalar x, SkScalar y, const SkFont& font, const SkPaint& paint) { … } void SkCanvas::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 SkCanvas::drawGlyphs(int count, const SkGlyphID glyphs[], const SkPoint positions[], SkPoint origin, const SkFont& font, const SkPaint& paint) { … } void SkCanvas::drawGlyphs(int count, const SkGlyphID glyphs[], const SkRSXform xforms[], SkPoint origin, const SkFont& font, const SkPaint& paint) { … } void SkCanvas::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y, const SkPaint& paint) { … } void SkCanvas::onDrawVerticesObject(const SkVertices* vertices, SkBlendMode bmode, const SkPaint& paint) { … } void SkCanvas::onDrawMesh(const SkMesh& mesh, sk_sp<SkBlender> blender, const SkPaint& paint) { … } void SkCanvas::drawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode bmode, const SkPaint& paint) { … } void SkCanvas::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4], const SkPoint texCoords[4], SkBlendMode bmode, const SkPaint& paint) { … } void SkCanvas::drawDrawable(SkDrawable* dr, SkScalar x, SkScalar y) { … } void SkCanvas::drawDrawable(SkDrawable* dr, const SkMatrix* matrix) { … } void SkCanvas::onDrawDrawable(SkDrawable* dr, const SkMatrix* matrix) { … } void SkCanvas::onDrawAtlas2(const SkImage* atlas, const SkRSXform xform[], const SkRect tex[], const SkColor colors[], int count, SkBlendMode bmode, const SkSamplingOptions& sampling, const SkRect* cull, const SkPaint* paint) { … } void SkCanvas::onDrawAnnotation(const SkRect& rect, const char key[], SkData* value) { … } void SkCanvas::onDrawEdgeAAQuad(const SkRect& r, const SkPoint clip[4], QuadAAFlags edgeAA, const SkColor4f& color, SkBlendMode mode) { … } void SkCanvas::onDrawEdgeAAImageSet2(const ImageSetEntry imageSet[], int count, const SkPoint dstClips[], const SkMatrix preViewMatrices[], const SkSamplingOptions& sampling, const SkPaint* paint, SrcRectConstraint constraint) { … } ////////////////////////////////////////////////////////////////////////////// // These methods are NOT virtual, and therefore must call back into virtual // methods, rather than actually drawing themselves. ////////////////////////////////////////////////////////////////////////////// void SkCanvas::drawColor(const SkColor4f& c, SkBlendMode mode) { … } void SkCanvas::drawPoint(SkScalar x, SkScalar y, const SkPaint& paint) { … } void SkCanvas::drawLine(SkScalar x0, SkScalar y0, SkScalar x1, SkScalar y1, const SkPaint& paint) { … } void SkCanvas::drawCircle(SkScalar cx, SkScalar cy, SkScalar radius, const SkPaint& paint) { … } void SkCanvas::drawRoundRect(const SkRect& r, SkScalar rx, SkScalar ry, const SkPaint& paint) { … } void SkCanvas::drawArc(const SkRect& oval, SkScalar startAngle, SkScalar sweepAngle, bool useCenter, const SkPaint& paint) { … } /////////////////////////////////////////////////////////////////////////////// #ifdef SK_DISABLE_SKPICTURE void SkCanvas::drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) {} void SkCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) {} #else void SkCanvas::drawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) { … } void SkCanvas::onDrawPicture(const SkPicture* picture, const SkMatrix* matrix, const SkPaint* paint) { … } #endif /////////////////////////////////////////////////////////////////////////////// SkCanvas::ImageSetEntry::ImageSetEntry() = default; SkCanvas::ImageSetEntry::~ImageSetEntry() = default; SkCanvas::ImageSetEntry::ImageSetEntry(const ImageSetEntry&) = default; SkCanvas::ImageSetEntry& SkCanvas::ImageSetEntry::operator=(const ImageSetEntry&) = default; SkCanvas::ImageSetEntry::ImageSetEntry(sk_sp<const SkImage> image, const SkRect& srcRect, const SkRect& dstRect, int matrixIndex, float alpha, unsigned aaFlags, bool hasClip) : … { … } SkCanvas::ImageSetEntry::ImageSetEntry(sk_sp<const SkImage> image, const SkRect& srcRect, const SkRect& dstRect, float alpha, unsigned aaFlags) : … { … } /////////////////////////////////////////////////////////////////////////////// std::unique_ptr<SkCanvas> SkCanvas::MakeRasterDirect(const SkImageInfo& info, void* pixels, size_t rowBytes, const SkSurfaceProps* props) { … } /////////////////////////////////////////////////////////////////////////////// SkNoDrawCanvas::SkNoDrawCanvas(int width, int height) : … { … } SkNoDrawCanvas::SkNoDrawCanvas(const SkIRect& bounds) : … { … } SkCanvas::SaveLayerStrategy SkNoDrawCanvas::getSaveLayerStrategy(const SaveLayerRec& rec) { … } bool SkNoDrawCanvas::onDoSaveBehind(const SkRect*) { … } /////////////////////////////////////////////////////////////////////////////// static_assert …; static_assert …; /////////////////////////////////////////////////////////////////////////////////////////////////// SkRasterHandleAllocator::Handle SkCanvas::accessTopRasterHandle() const { … } static bool install(SkBitmap* bm, const SkImageInfo& info, const SkRasterHandleAllocator::Rec& rec) { … } SkRasterHandleAllocator::Handle SkRasterHandleAllocator::allocBitmap(const SkImageInfo& info, SkBitmap* bm) { … } std::unique_ptr<SkCanvas> SkRasterHandleAllocator::MakeCanvas(std::unique_ptr<SkRasterHandleAllocator> alloc, const SkImageInfo& info, const Rec* rec, const SkSurfaceProps* props) { … }
Codebase Browser
chromium