diff options
Diffstat (limited to '')
| -rw-r--r-- | gfx/2d/DrawTargetSkia.cpp | 2070 |
1 files changed, 2070 insertions, 0 deletions
diff --git a/gfx/2d/DrawTargetSkia.cpp b/gfx/2d/DrawTargetSkia.cpp new file mode 100644 index 0000000000..0ddf9fef52 --- /dev/null +++ b/gfx/2d/DrawTargetSkia.cpp @@ -0,0 +1,2070 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include "DrawTargetSkia.h" +#include "SourceSurfaceSkia.h" +#include "ScaledFontBase.h" +#include "FilterNodeSoftware.h" +#include "HelpersSkia.h" + +#include "mozilla/CheckedInt.h" +#include "mozilla/Vector.h" + +#include "skia/include/core/SkBitmap.h" +#include "skia/include/core/SkCanvas.h" +#include "skia/include/core/SkFont.h" +#include "skia/include/core/SkSurface.h" +#include "skia/include/core/SkTextBlob.h" +#include "skia/include/core/SkTypeface.h" +#include "skia/include/effects/SkGradientShader.h" +#include "skia/include/core/SkColorFilter.h" +#include "skia/include/core/SkRegion.h" +#include "skia/include/effects/SkImageFilters.h" +#include "skia/include/private/base/SkMalloc.h" +#include "Blur.h" +#include "Logging.h" +#include "Tools.h" +#include "PathHelpers.h" +#include "PathSkia.h" +#include "Swizzle.h" +#include <algorithm> +#include <cmath> + +#ifdef MOZ_WIDGET_COCOA +# include "BorrowedContext.h" +# include <ApplicationServices/ApplicationServices.h> +#endif + +#ifdef XP_WIN +# include "ScaledFontDWrite.h" +#endif + +namespace mozilla { + +void RefPtrTraits<SkSurface>::Release(SkSurface* aSurface) { + SkSafeUnref(aSurface); +} + +void RefPtrTraits<SkSurface>::AddRef(SkSurface* aSurface) { + SkSafeRef(aSurface); +} + +} // namespace mozilla + +namespace mozilla::gfx { + +class GradientStopsSkia : public GradientStops { + public: + MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GradientStopsSkia, override) + + GradientStopsSkia(const std::vector<GradientStop>& aStops, uint32_t aNumStops, + ExtendMode aExtendMode) + : mCount(aNumStops), mExtendMode(aExtendMode) { + if (mCount == 0) { + return; + } + + // Skia gradients always require a stop at 0.0 and 1.0, insert these if + // we don't have them. + uint32_t shift = 0; + if (aStops[0].offset != 0) { + mCount++; + shift = 1; + } + if (aStops[aNumStops - 1].offset != 1) { + mCount++; + } + mColors.resize(mCount); + mPositions.resize(mCount); + if (aStops[0].offset != 0) { + mColors[0] = ColorToSkColor(aStops[0].color, 1.0); + mPositions[0] = 0; + } + for (uint32_t i = 0; i < aNumStops; i++) { + mColors[i + shift] = ColorToSkColor(aStops[i].color, 1.0); + mPositions[i + shift] = SkFloatToScalar(aStops[i].offset); + } + if (aStops[aNumStops - 1].offset != 1) { + mColors[mCount - 1] = ColorToSkColor(aStops[aNumStops - 1].color, 1.0); + mPositions[mCount - 1] = SK_Scalar1; + } + } + + BackendType GetBackendType() const override { return BackendType::SKIA; } + + std::vector<SkColor> mColors; + std::vector<SkScalar> mPositions; + int mCount; + ExtendMode mExtendMode; +}; + +/** + * When constructing a temporary SkImage via GetSkImageForSurface, we may also + * have to construct a temporary DataSourceSurface, which must live as long as + * the SkImage. We attach this temporary surface to the image's pixelref, so + * that it can be released once the pixelref is freed. + */ +static void ReleaseTemporarySurface(const void* aPixels, void* aContext) { + DataSourceSurface* surf = static_cast<DataSourceSurface*>(aContext); + if (surf) { + surf->Release(); + } +} + +static void ReleaseTemporaryMappedSurface(const void* aPixels, void* aContext) { + DataSourceSurface* surf = static_cast<DataSourceSurface*>(aContext); + if (surf) { + surf->Unmap(); + surf->Release(); + } +} + +static void WriteRGBXFormat(uint8_t* aData, const IntSize& aSize, + const int32_t aStride, SurfaceFormat aFormat) { + if (aFormat != SurfaceFormat::B8G8R8X8 || aSize.IsEmpty()) { + return; + } + + SwizzleData(aData, aStride, SurfaceFormat::X8R8G8B8_UINT32, aData, aStride, + SurfaceFormat::A8R8G8B8_UINT32, aSize); +} + +#ifdef DEBUG +static IntRect CalculateSurfaceBounds(const IntSize& aSize, const Rect* aBounds, + const Matrix* aMatrix) { + IntRect surfaceBounds(IntPoint(0, 0), aSize); + if (!aBounds) { + return surfaceBounds; + } + + MOZ_ASSERT(aMatrix); + Matrix inverse(*aMatrix); + if (!inverse.Invert()) { + return surfaceBounds; + } + + IntRect bounds; + Rect sampledBounds = inverse.TransformBounds(*aBounds); + if (!sampledBounds.ToIntRect(&bounds)) { + return surfaceBounds; + } + + return surfaceBounds.Intersect(bounds); +} + +static const int kARGBAlphaOffset = + SurfaceFormat::A8R8G8B8_UINT32 == SurfaceFormat::B8G8R8A8 ? 3 : 0; + +static bool VerifyRGBXFormat(uint8_t* aData, const IntSize& aSize, + const int32_t aStride, SurfaceFormat aFormat) { + if (aFormat != SurfaceFormat::B8G8R8X8 || aSize.IsEmpty()) { + return true; + } + // We should've initialized the data to be opaque already + // On debug builds, verify that this is actually true. + int height = aSize.height; + int width = aSize.width * 4; + + for (int row = 0; row < height; ++row) { + for (int column = 0; column < width; column += 4) { + if (aData[column + kARGBAlphaOffset] != 0xFF) { + gfxCriticalError() << "RGBX pixel at (" << column << "," << row + << ") in " << width << "x" << height + << " surface is not opaque: " << int(aData[column]) + << "," << int(aData[column + 1]) << "," + << int(aData[column + 2]) << "," + << int(aData[column + 3]); + } + } + aData += aStride; + } + + return true; +} + +// Since checking every pixel is expensive, this only checks the four corners +// and center of a surface that their alpha value is 0xFF. +static bool VerifyRGBXCorners(uint8_t* aData, const IntSize& aSize, + const int32_t aStride, SurfaceFormat aFormat, + const Rect* aBounds = nullptr, + const Matrix* aMatrix = nullptr) { + if (aFormat != SurfaceFormat::B8G8R8X8 || aSize.IsEmpty()) { + return true; + } + + IntRect bounds = CalculateSurfaceBounds(aSize, aBounds, aMatrix); + if (bounds.IsEmpty()) { + return true; + } + + const int height = bounds.Height(); + const int width = bounds.Width(); + const int pixelSize = 4; + MOZ_ASSERT(aSize.width * pixelSize <= aStride); + + const int translation = bounds.Y() * aStride + bounds.X() * pixelSize; + const int topLeft = translation; + const int topRight = topLeft + (width - 1) * pixelSize; + const int bottomLeft = translation + (height - 1) * aStride; + const int bottomRight = bottomLeft + (width - 1) * pixelSize; + + // Lastly the center pixel + const int middleRowHeight = height / 2; + const int middleRowWidth = (width / 2) * pixelSize; + const int middle = translation + aStride * middleRowHeight + middleRowWidth; + + const int offsets[] = {topLeft, topRight, bottomRight, bottomLeft, middle}; + for (int offset : offsets) { + if (aData[offset + kARGBAlphaOffset] != 0xFF) { + int row = offset / aStride; + int column = (offset % aStride) / pixelSize; + gfxCriticalError() << "RGBX corner pixel at (" << column << "," << row + << ") in " << aSize.width << "x" << aSize.height + << " surface, bounded by " + << "(" << bounds.X() << "," << bounds.Y() << "," + << width << "," << height + << ") is not opaque: " << int(aData[offset]) << "," + << int(aData[offset + 1]) << "," + << int(aData[offset + 2]) << "," + << int(aData[offset + 3]); + } + } + + return true; +} +#endif + +static sk_sp<SkImage> GetSkImageForSurface(SourceSurface* aSurface, + Maybe<MutexAutoLock>* aLock, + const Rect* aBounds = nullptr, + const Matrix* aMatrix = nullptr) { + if (!aSurface) { + gfxDebug() << "Creating null Skia image from null SourceSurface"; + return nullptr; + } + + if (aSurface->GetType() == SurfaceType::SKIA) { + return static_cast<SourceSurfaceSkia*>(aSurface)->GetImage(aLock); + } + + RefPtr<DataSourceSurface> dataSurface = aSurface->GetDataSurface(); + if (!dataSurface) { + gfxWarning() << "Failed getting DataSourceSurface for Skia image"; + return nullptr; + } + + DataSourceSurface::MappedSurface map; + SkImage::RasterReleaseProc releaseProc; + if (dataSurface->GetType() == SurfaceType::DATA_SHARED_WRAPPER) { + // Technically all surfaces should be mapped and unmapped explicitly but it + // appears SourceSurfaceSkia and DataSourceSurfaceWrapper have issues with + // this. For now, we just map SourceSurfaceSharedDataWrapper to ensure we + // don't unmap the data during the transaction (for blob images). + if (!dataSurface->Map(DataSourceSurface::MapType::READ, &map)) { + gfxWarning() << "Failed mapping DataSourceSurface for Skia image"; + return nullptr; + } + releaseProc = ReleaseTemporaryMappedSurface; + } else { + map.mData = dataSurface->GetData(); + map.mStride = dataSurface->Stride(); + releaseProc = ReleaseTemporarySurface; + } + + DataSourceSurface* surf = dataSurface.forget().take(); + + // Skia doesn't support RGBX surfaces so ensure that the alpha value is opaque + // white. + MOZ_ASSERT(VerifyRGBXCorners(map.mData, surf->GetSize(), map.mStride, + surf->GetFormat(), aBounds, aMatrix)); + + SkPixmap pixmap(MakeSkiaImageInfo(surf->GetSize(), surf->GetFormat()), + map.mData, map.mStride); + sk_sp<SkImage> image = SkImage::MakeFromRaster(pixmap, releaseProc, surf); + if (!image) { + releaseProc(map.mData, surf); + gfxDebug() << "Failed making Skia raster image for temporary surface"; + } + + return image; +} + +DrawTargetSkia::DrawTargetSkia() + : mCanvas(nullptr), + mSnapshot(nullptr), + mSnapshotLock{"DrawTargetSkia::mSnapshotLock"} +#ifdef MOZ_WIDGET_COCOA + , + mCG(nullptr), + mColorSpace(nullptr), + mCanvasData(nullptr), + mCGSize(0, 0), + mNeedLayer(false) +#endif +{ +} + +DrawTargetSkia::~DrawTargetSkia() { + if (mSnapshot) { + MutexAutoLock lock(mSnapshotLock); + // We're going to go away, hand our SkSurface to the SourceSurface. + mSnapshot->GiveSurface(mSurface.forget().take()); + } + +#ifdef MOZ_WIDGET_COCOA + if (mCG) { + CGContextRelease(mCG); + mCG = nullptr; + } + + if (mColorSpace) { + CGColorSpaceRelease(mColorSpace); + mColorSpace = nullptr; + } +#endif +} + +already_AddRefed<SourceSurface> DrawTargetSkia::Snapshot( + SurfaceFormat aFormat) { + // Without this lock, this could cause us to get out a snapshot and race with + // Snapshot::~Snapshot() actually destroying itself. + MutexAutoLock lock(mSnapshotLock); + if (mSnapshot && aFormat != mSnapshot->GetFormat()) { + if (!mSnapshot->hasOneRef()) { + mSnapshot->DrawTargetWillChange(); + } + mSnapshot = nullptr; + } + RefPtr<SourceSurfaceSkia> snapshot = mSnapshot; + if (mSurface && !snapshot) { + snapshot = new SourceSurfaceSkia(); + sk_sp<SkImage> image; + // If the surface is raster, making a snapshot may trigger a pixel copy. + // Instead, try to directly make a raster image referencing the surface + // pixels. + SkPixmap pixmap; + if (mSurface->peekPixels(&pixmap)) { + image = SkImage::MakeFromRaster(pixmap, nullptr, nullptr); + } else { + image = mSurface->makeImageSnapshot(); + } + if (!snapshot->InitFromImage(image, aFormat, this)) { + return nullptr; + } + mSnapshot = snapshot; + } + + return snapshot.forget(); +} + +already_AddRefed<SourceSurface> DrawTargetSkia::GetBackingSurface() { + if (mBackingSurface) { + RefPtr<SourceSurface> snapshot = mBackingSurface; + return snapshot.forget(); + } + return Snapshot(); +} + +bool DrawTargetSkia::LockBits(uint8_t** aData, IntSize* aSize, int32_t* aStride, + SurfaceFormat* aFormat, IntPoint* aOrigin) { + SkImageInfo info; + size_t rowBytes; + SkIPoint origin; + void* pixels = mCanvas->accessTopLayerPixels(&info, &rowBytes, &origin); + if (!pixels || + // Ensure the layer is at the origin if required. + (!aOrigin && !origin.isZero())) { + return false; + } + + MarkChanged(); + + *aData = reinterpret_cast<uint8_t*>(pixels); + *aSize = IntSize(info.width(), info.height()); + *aStride = int32_t(rowBytes); + *aFormat = SkiaColorTypeToGfxFormat(info.colorType(), info.alphaType()); + if (aOrigin) { + *aOrigin = IntPoint(origin.x(), origin.y()); + } + return true; +} + +void DrawTargetSkia::ReleaseBits(uint8_t* aData) {} + +static void ReleaseImage(const void* aPixels, void* aContext) { + SkImage* image = static_cast<SkImage*>(aContext); + SkSafeUnref(image); +} + +static sk_sp<SkImage> ExtractSubset(sk_sp<SkImage> aImage, + const IntRect& aRect) { + SkIRect subsetRect = IntRectToSkIRect(aRect); + if (aImage->bounds() == subsetRect) { + return aImage; + } + // makeSubset is slow, so prefer to use SkPixmap::extractSubset where + // possible. + SkPixmap pixmap, subsetPixmap; + if (aImage->peekPixels(&pixmap) && + pixmap.extractSubset(&subsetPixmap, subsetRect)) { + // Release the original image reference so only the subset image keeps it + // alive. + return SkImage::MakeFromRaster(subsetPixmap, ReleaseImage, + aImage.release()); + } + return aImage->makeSubset(subsetRect); +} + +static void FreeAlphaPixels(void* aBuf, void*) { sk_free(aBuf); } + +static bool ExtractAlphaBitmap(const sk_sp<SkImage>& aImage, + SkBitmap* aResultBitmap, + bool aAllowReuse = false) { + SkPixmap pixmap; + if (aAllowReuse && aImage->isAlphaOnly() && aImage->peekPixels(&pixmap)) { + SkBitmap bitmap; + bitmap.installPixels(pixmap.info(), pixmap.writable_addr(), + pixmap.rowBytes()); + *aResultBitmap = bitmap; + return true; + } + SkImageInfo info = SkImageInfo::MakeA8(aImage->width(), aImage->height()); + // Skia does not fully allocate the last row according to stride. + // Since some of our algorithms (i.e. blur) depend on this, we must allocate + // the bitmap pixels manually. + size_t stride = GetAlignedStride<4>(info.width(), info.bytesPerPixel()); + if (stride) { + CheckedInt<size_t> size = stride; + size *= info.height(); + // We need to leave room for an additional 3 bytes for a potential overrun + // in our blurring code. + size += 3; + if (size.isValid()) { + void* buf = sk_malloc_flags(size.value(), 0); + if (buf) { + SkBitmap bitmap; + if (bitmap.installPixels(info, buf, stride, FreeAlphaPixels, nullptr) && + aImage->readPixels(bitmap.info(), bitmap.getPixels(), + bitmap.rowBytes(), 0, 0)) { + *aResultBitmap = bitmap; + return true; + } + } + } + } + + gfxWarning() << "Failed reading alpha pixels for Skia bitmap"; + return false; +} + +static void SetPaintPattern(SkPaint& aPaint, const Pattern& aPattern, + Maybe<MutexAutoLock>& aLock, Float aAlpha = 1.0, + const SkMatrix* aMatrix = nullptr, + const Rect* aBounds = nullptr) { + switch (aPattern.GetType()) { + case PatternType::COLOR: { + DeviceColor color = static_cast<const ColorPattern&>(aPattern).mColor; + aPaint.setColor(ColorToSkColor(color, aAlpha)); + break; + } + case PatternType::LINEAR_GRADIENT: { + const LinearGradientPattern& pat = + static_cast<const LinearGradientPattern&>(aPattern); + GradientStopsSkia* stops = + pat.mStops && pat.mStops->GetBackendType() == BackendType::SKIA + ? static_cast<GradientStopsSkia*>(pat.mStops.get()) + : nullptr; + if (!stops || stops->mCount < 2 || !pat.mBegin.IsFinite() || + !pat.mEnd.IsFinite() || pat.mBegin == pat.mEnd) { + aPaint.setColor(SK_ColorTRANSPARENT); + } else { + SkTileMode mode = ExtendModeToTileMode(stops->mExtendMode, Axis::BOTH); + SkPoint points[2]; + points[0] = SkPoint::Make(SkFloatToScalar(pat.mBegin.x), + SkFloatToScalar(pat.mBegin.y)); + points[1] = SkPoint::Make(SkFloatToScalar(pat.mEnd.x), + SkFloatToScalar(pat.mEnd.y)); + + SkMatrix mat; + GfxMatrixToSkiaMatrix(pat.mMatrix, mat); + if (aMatrix) { + mat.postConcat(*aMatrix); + } + sk_sp<SkShader> shader = SkGradientShader::MakeLinear( + points, &stops->mColors.front(), &stops->mPositions.front(), + stops->mCount, mode, 0, &mat); + if (shader) { + aPaint.setShader(shader); + } else { + aPaint.setColor(SK_ColorTRANSPARENT); + } + } + break; + } + case PatternType::RADIAL_GRADIENT: { + const RadialGradientPattern& pat = + static_cast<const RadialGradientPattern&>(aPattern); + GradientStopsSkia* stops = + pat.mStops && pat.mStops->GetBackendType() == BackendType::SKIA + ? static_cast<GradientStopsSkia*>(pat.mStops.get()) + : nullptr; + if (!stops || stops->mCount < 2 || !pat.mCenter1.IsFinite() || + !std::isfinite(pat.mRadius1) || !pat.mCenter2.IsFinite() || + !std::isfinite(pat.mRadius2) || + (pat.mCenter1 == pat.mCenter2 && pat.mRadius1 == pat.mRadius2)) { + aPaint.setColor(SK_ColorTRANSPARENT); + } else { + SkTileMode mode = ExtendModeToTileMode(stops->mExtendMode, Axis::BOTH); + SkPoint points[2]; + points[0] = SkPoint::Make(SkFloatToScalar(pat.mCenter1.x), + SkFloatToScalar(pat.mCenter1.y)); + points[1] = SkPoint::Make(SkFloatToScalar(pat.mCenter2.x), + SkFloatToScalar(pat.mCenter2.y)); + + SkMatrix mat; + GfxMatrixToSkiaMatrix(pat.mMatrix, mat); + if (aMatrix) { + mat.postConcat(*aMatrix); + } + sk_sp<SkShader> shader = SkGradientShader::MakeTwoPointConical( + points[0], SkFloatToScalar(pat.mRadius1), points[1], + SkFloatToScalar(pat.mRadius2), &stops->mColors.front(), + &stops->mPositions.front(), stops->mCount, mode, 0, &mat); + if (shader) { + aPaint.setShader(shader); + } else { + aPaint.setColor(SK_ColorTRANSPARENT); + } + } + break; + } + case PatternType::CONIC_GRADIENT: { + const ConicGradientPattern& pat = + static_cast<const ConicGradientPattern&>(aPattern); + GradientStopsSkia* stops = + pat.mStops && pat.mStops->GetBackendType() == BackendType::SKIA + ? static_cast<GradientStopsSkia*>(pat.mStops.get()) + : nullptr; + if (!stops || stops->mCount < 2 || !pat.mCenter.IsFinite() || + !std::isfinite(pat.mAngle)) { + aPaint.setColor(SK_ColorTRANSPARENT); + } else { + SkMatrix mat; + GfxMatrixToSkiaMatrix(pat.mMatrix, mat); + if (aMatrix) { + mat.postConcat(*aMatrix); + } + + SkScalar cx = SkFloatToScalar(pat.mCenter.x); + SkScalar cy = SkFloatToScalar(pat.mCenter.y); + + // Skia's sweep gradient angles are relative to the x-axis, not the + // y-axis. + Float angle = (pat.mAngle * 180.0 / M_PI) - 90.0; + if (angle != 0.0) { + mat.preRotate(angle, cx, cy); + } + + SkTileMode mode = ExtendModeToTileMode(stops->mExtendMode, Axis::BOTH); + sk_sp<SkShader> shader = SkGradientShader::MakeSweep( + cx, cy, &stops->mColors.front(), &stops->mPositions.front(), + stops->mCount, mode, 360 * pat.mStartOffset, 360 * pat.mEndOffset, + 0, &mat); + + if (shader) { + aPaint.setShader(shader); + } else { + aPaint.setColor(SK_ColorTRANSPARENT); + } + } + break; + } + case PatternType::SURFACE: { + const SurfacePattern& pat = static_cast<const SurfacePattern&>(aPattern); + sk_sp<SkImage> image = + GetSkImageForSurface(pat.mSurface, &aLock, aBounds, &pat.mMatrix); + if (!image) { + aPaint.setColor(SK_ColorTRANSPARENT); + break; + } + + SkMatrix mat; + GfxMatrixToSkiaMatrix(pat.mMatrix, mat); + if (aMatrix) { + mat.postConcat(*aMatrix); + } + + if (!pat.mSamplingRect.IsEmpty()) { + image = ExtractSubset(image, pat.mSamplingRect); + if (!image) { + aPaint.setColor(SK_ColorTRANSPARENT); + break; + } + mat.preTranslate(pat.mSamplingRect.X(), pat.mSamplingRect.Y()); + } + + SkTileMode xTile = ExtendModeToTileMode(pat.mExtendMode, Axis::X_AXIS); + SkTileMode yTile = ExtendModeToTileMode(pat.mExtendMode, Axis::Y_AXIS); + + SkFilterMode filterMode = pat.mSamplingFilter == SamplingFilter::POINT + ? SkFilterMode::kNearest + : SkFilterMode::kLinear; + + sk_sp<SkShader> shader = + image->makeShader(xTile, yTile, SkSamplingOptions(filterMode), mat); + if (shader) { + aPaint.setShader(shader); + } else { + gfxDebug() << "Failed creating Skia surface shader: x-tile=" + << (int)xTile << " y-tile=" << (int)yTile + << " matrix=" << (mat.isFinite() ? "finite" : "non-finite"); + aPaint.setColor(SK_ColorTRANSPARENT); + } + break; + } + } +} + +static inline Rect GetClipBounds(SkCanvas* aCanvas) { + // Use a manually transformed getClipDeviceBounds instead of + // getClipBounds because getClipBounds inflates the the bounds + // by a pixel in each direction to compensate for antialiasing. + SkIRect deviceBounds; + if (!aCanvas->getDeviceClipBounds(&deviceBounds)) { + return Rect(); + } + SkMatrix inverseCTM; + if (!aCanvas->getTotalMatrix().invert(&inverseCTM)) { + return Rect(); + } + SkRect localBounds; + inverseCTM.mapRect(&localBounds, SkRect::Make(deviceBounds)); + return SkRectToRect(localBounds); +} + +struct AutoPaintSetup { + AutoPaintSetup(SkCanvas* aCanvas, const DrawOptions& aOptions, + const Pattern& aPattern, const Rect* aMaskBounds = nullptr, + const SkMatrix* aMatrix = nullptr, + const Rect* aSourceBounds = nullptr) + : mNeedsRestore(false), mAlpha(1.0) { + Init(aCanvas, aOptions, aMaskBounds, false); + SetPaintPattern(mPaint, aPattern, mLock, mAlpha, aMatrix, aSourceBounds); + } + + AutoPaintSetup(SkCanvas* aCanvas, const DrawOptions& aOptions, + const Rect* aMaskBounds = nullptr, bool aForceGroup = false) + : mNeedsRestore(false), mAlpha(1.0) { + Init(aCanvas, aOptions, aMaskBounds, aForceGroup); + } + + ~AutoPaintSetup() { + if (mNeedsRestore) { + mCanvas->restore(); + } + } + + void Init(SkCanvas* aCanvas, const DrawOptions& aOptions, + const Rect* aMaskBounds, bool aForceGroup) { + mPaint.setBlendMode(GfxOpToSkiaOp(aOptions.mCompositionOp)); + mCanvas = aCanvas; + + // TODO: Can we set greyscale somehow? + if (aOptions.mAntialiasMode != AntialiasMode::NONE) { + mPaint.setAntiAlias(true); + } else { + mPaint.setAntiAlias(false); + } + + bool needsGroup = + aForceGroup || + (!IsOperatorBoundByMask(aOptions.mCompositionOp) && + (!aMaskBounds || !aMaskBounds->Contains(GetClipBounds(aCanvas)))); + + // TODO: We could skip the temporary for operator_source and just + // clear the clip rect. The other operators would be harder + // but could be worth it to skip pushing a group. + if (needsGroup) { + mPaint.setBlendMode(SkBlendMode::kSrcOver); + SkPaint temp; + temp.setBlendMode(GfxOpToSkiaOp(aOptions.mCompositionOp)); + temp.setAlpha(ColorFloatToByte(aOptions.mAlpha)); + // TODO: Get a rect here + SkCanvas::SaveLayerRec rec(nullptr, &temp, + SkCanvas::kPreserveLCDText_SaveLayerFlag); + mCanvas->saveLayer(rec); + mNeedsRestore = true; + } else { + mPaint.setAlpha(ColorFloatToByte(aOptions.mAlpha)); + mAlpha = aOptions.mAlpha; + } + } + + // TODO: Maybe add an operator overload to access this easier? + SkPaint mPaint; + bool mNeedsRestore; + SkCanvas* mCanvas; + Maybe<MutexAutoLock> mLock; + Float mAlpha; +}; + +void DrawTargetSkia::Flush() { mCanvas->flush(); } + +void DrawTargetSkia::DrawSurface(SourceSurface* aSurface, const Rect& aDest, + const Rect& aSource, + const DrawSurfaceOptions& aSurfOptions, + const DrawOptions& aOptions) { + if (aSource.IsEmpty()) { + return; + } + + MarkChanged(); + + Maybe<MutexAutoLock> lock; + sk_sp<SkImage> image = GetSkImageForSurface(aSurface, &lock); + if (!image) { + return; + } + + SkRect destRect = RectToSkRect(aDest); + SkRect sourceRect = RectToSkRect(aSource - aSurface->GetRect().TopLeft()); + bool forceGroup = + image->isAlphaOnly() && aOptions.mCompositionOp != CompositionOp::OP_OVER; + + AutoPaintSetup paint(mCanvas, aOptions, &aDest, forceGroup); + + SkFilterMode filterMode = + aSurfOptions.mSamplingFilter == SamplingFilter::POINT + ? SkFilterMode::kNearest + : SkFilterMode::kLinear; + + mCanvas->drawImageRect(image, sourceRect, destRect, + SkSamplingOptions(filterMode), &paint.mPaint, + SkCanvas::kStrict_SrcRectConstraint); +} + +DrawTargetType DrawTargetSkia::GetType() const { + return DrawTargetType::SOFTWARE_RASTER; +} + +void DrawTargetSkia::DrawFilter(FilterNode* aNode, const Rect& aSourceRect, + const Point& aDestPoint, + const DrawOptions& aOptions) { + if (!aNode || aNode->GetBackendType() != FILTER_BACKEND_SOFTWARE) { + return; + } + FilterNodeSoftware* filter = static_cast<FilterNodeSoftware*>(aNode); + filter->Draw(this, aSourceRect, aDestPoint, aOptions); +} + +void DrawTargetSkia::DrawSurfaceWithShadow(SourceSurface* aSurface, + const Point& aDest, + const ShadowOptions& aShadow, + CompositionOp aOperator) { + if (aSurface->GetSize().IsEmpty()) { + return; + } + + MarkChanged(); + + Maybe<MutexAutoLock> lock; + sk_sp<SkImage> image = GetSkImageForSurface(aSurface, &lock); + if (!image) { + return; + } + + mCanvas->save(); + mCanvas->resetMatrix(); + + SkPaint paint; + paint.setBlendMode(GfxOpToSkiaOp(aOperator)); + + // bug 1201272 + // We can't use the SkDropShadowImageFilter here because it applies the xfer + // mode first to render the bitmap to a temporary layer, and then implicitly + // uses src-over to composite the resulting shadow. + // The canvas spec, however, states that the composite op must be used to + // composite the resulting shadow, so we must instead use a SkBlurImageFilter + // to blur the image ourselves. + + SkPaint shadowPaint; + shadowPaint.setBlendMode(GfxOpToSkiaOp(aOperator)); + + auto shadowDest = IntPoint::Round(aDest + aShadow.mOffset); + + SkBitmap blurMask; + // Extract the alpha channel of the image into a bitmap. If the image is A8 + // format already, then we can directly reuse the bitmap rather than create a + // new one as the surface only needs to be drawn from once. + if (ExtractAlphaBitmap(image, &blurMask, true)) { + // Prefer using our own box blur instead of Skia's. It currently performs + // much better than SkBlurImageFilter or SkBlurMaskFilter on the CPU. + AlphaBoxBlur blur(Rect(0, 0, blurMask.width(), blurMask.height()), + int32_t(blurMask.rowBytes()), aShadow.mSigma, + aShadow.mSigma); + blur.Blur(reinterpret_cast<uint8_t*>(blurMask.getPixels())); + blurMask.notifyPixelsChanged(); + + shadowPaint.setColor(ColorToSkColor(aShadow.mColor, 1.0f)); + + mCanvas->drawImage(blurMask.asImage(), shadowDest.x, shadowDest.y, + SkSamplingOptions(SkFilterMode::kLinear), &shadowPaint); + } else { + sk_sp<SkImageFilter> blurFilter( + SkImageFilters::Blur(aShadow.mSigma, aShadow.mSigma, nullptr)); + sk_sp<SkColorFilter> colorFilter(SkColorFilters::Blend( + ColorToSkColor(aShadow.mColor, 1.0f), SkBlendMode::kSrcIn)); + + shadowPaint.setImageFilter(blurFilter); + shadowPaint.setColorFilter(colorFilter); + + mCanvas->drawImage(image, shadowDest.x, shadowDest.y, + SkSamplingOptions(SkFilterMode::kLinear), &shadowPaint); + } + + if (aSurface->GetFormat() != SurfaceFormat::A8) { + // Composite the original image after the shadow + auto dest = IntPoint::Round(aDest); + mCanvas->drawImage(image, dest.x, dest.y, + SkSamplingOptions(SkFilterMode::kLinear), &paint); + } + + mCanvas->restore(); +} + +void DrawTargetSkia::FillRect(const Rect& aRect, const Pattern& aPattern, + const DrawOptions& aOptions) { + // The sprite blitting path in Skia can be faster than the shader blitter for + // operators other than source (or source-over with opaque surface). So, when + // possible/beneficial, route to DrawSurface which will use the sprite + // blitter. + if (aPattern.GetType() == PatternType::SURFACE && + aOptions.mCompositionOp != CompositionOp::OP_SOURCE) { + const SurfacePattern& pat = static_cast<const SurfacePattern&>(aPattern); + // Verify there is a valid surface and a pattern matrix without skew. + if (pat.mSurface && + (aOptions.mCompositionOp != CompositionOp::OP_OVER || + GfxFormatToSkiaAlphaType(pat.mSurface->GetFormat()) != + kOpaque_SkAlphaType) && + !pat.mMatrix.HasNonAxisAlignedTransform()) { + // Bound the sampling to smaller of the bounds or the sampling rect. + IntRect srcRect(IntPoint(0, 0), pat.mSurface->GetSize()); + if (!pat.mSamplingRect.IsEmpty()) { + srcRect = srcRect.Intersect(pat.mSamplingRect); + } + // Transform the destination rectangle by the inverse of the pattern + // matrix so that it is in pattern space like the source rectangle. + Rect patRect = aRect - pat.mMatrix.GetTranslation(); + patRect.Scale(1.0f / pat.mMatrix._11, 1.0f / pat.mMatrix._22); + // Verify the pattern rectangle will not tile or clamp. + if (!patRect.IsEmpty() && srcRect.Contains(RoundedOut(patRect))) { + // The pattern is a surface with an axis-aligned source rectangle + // fitting entirely in its bounds, so just treat it as a DrawSurface. + DrawSurface(pat.mSurface, aRect, patRect, + DrawSurfaceOptions(pat.mSamplingFilter), aOptions); + return; + } + } + } + + MarkChanged(); + SkRect rect = RectToSkRect(aRect); + AutoPaintSetup paint(mCanvas, aOptions, aPattern, &aRect, nullptr, &aRect); + + mCanvas->drawRect(rect, paint.mPaint); +} + +void DrawTargetSkia::Stroke(const Path* aPath, const Pattern& aPattern, + const StrokeOptions& aStrokeOptions, + const DrawOptions& aOptions) { + MarkChanged(); + MOZ_ASSERT(aPath, "Null path"); + if (aPath->GetBackendType() != BackendType::SKIA) { + return; + } + + const PathSkia* skiaPath = static_cast<const PathSkia*>(aPath); + + AutoPaintSetup paint(mCanvas, aOptions, aPattern); + if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) { + return; + } + + if (!skiaPath->GetPath().isFinite()) { + return; + } + + mCanvas->drawPath(skiaPath->GetPath(), paint.mPaint); +} + +static Double DashPeriodLength(const StrokeOptions& aStrokeOptions) { + Double length = 0; + for (size_t i = 0; i < aStrokeOptions.mDashLength; i++) { + length += aStrokeOptions.mDashPattern[i]; + } + if (aStrokeOptions.mDashLength & 1) { + // "If an odd number of values is provided, then the list of values is + // repeated to yield an even number of values." + // Double the length. + length += length; + } + return length; +} + +static inline Double RoundDownToMultiple(Double aValue, Double aFactor) { + return floor(aValue / aFactor) * aFactor; +} + +static Rect UserSpaceStrokeClip(const IntRect& aDeviceClip, + const Matrix& aTransform, + const StrokeOptions& aStrokeOptions) { + Matrix inverse = aTransform; + if (!inverse.Invert()) { + return Rect(); + } + Rect deviceClip(aDeviceClip); + deviceClip.Inflate(MaxStrokeExtents(aStrokeOptions, aTransform)); + return inverse.TransformBounds(deviceClip); +} + +static Rect ShrinkClippedStrokedRect(const Rect& aStrokedRect, + const IntRect& aDeviceClip, + const Matrix& aTransform, + const StrokeOptions& aStrokeOptions) { + Rect userSpaceStrokeClip = + UserSpaceStrokeClip(aDeviceClip, aTransform, aStrokeOptions); + RectDouble strokedRectDouble(aStrokedRect.X(), aStrokedRect.Y(), + aStrokedRect.Width(), aStrokedRect.Height()); + RectDouble intersection = strokedRectDouble.Intersect( + RectDouble(userSpaceStrokeClip.X(), userSpaceStrokeClip.Y(), + userSpaceStrokeClip.Width(), userSpaceStrokeClip.Height())); + Double dashPeriodLength = DashPeriodLength(aStrokeOptions); + if (intersection.IsEmpty() || dashPeriodLength == 0.0f) { + return Rect(intersection.X(), intersection.Y(), intersection.Width(), + intersection.Height()); + } + + // Reduce the rectangle side lengths in multiples of the dash period length + // so that the visible dashes stay in the same place. + MarginDouble insetBy = strokedRectDouble - intersection; + insetBy.top = RoundDownToMultiple(insetBy.top, dashPeriodLength); + insetBy.right = RoundDownToMultiple(insetBy.right, dashPeriodLength); + insetBy.bottom = RoundDownToMultiple(insetBy.bottom, dashPeriodLength); + insetBy.left = RoundDownToMultiple(insetBy.left, dashPeriodLength); + + strokedRectDouble.Deflate(insetBy); + return Rect(strokedRectDouble.X(), strokedRectDouble.Y(), + strokedRectDouble.Width(), strokedRectDouble.Height()); +} + +void DrawTargetSkia::StrokeRect(const Rect& aRect, const Pattern& aPattern, + const StrokeOptions& aStrokeOptions, + const DrawOptions& aOptions) { + // Stroking large rectangles with dashes is expensive with Skia (fixed + // overhead based on the number of dashes, regardless of whether the dashes + // are visible), so we try to reduce the size of the stroked rectangle as + // much as possible before passing it on to Skia. + Rect rect = aRect; + if (aStrokeOptions.mDashLength > 0 && !rect.IsEmpty()) { + IntRect deviceClip(IntPoint(0, 0), mSize); + SkIRect clipBounds; + if (mCanvas->getDeviceClipBounds(&clipBounds)) { + deviceClip = SkIRectToIntRect(clipBounds); + } + rect = + ShrinkClippedStrokedRect(rect, deviceClip, mTransform, aStrokeOptions); + if (rect.IsEmpty()) { + return; + } + } + + MarkChanged(); + AutoPaintSetup paint(mCanvas, aOptions, aPattern); + if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) { + return; + } + + mCanvas->drawRect(RectToSkRect(rect), paint.mPaint); +} + +void DrawTargetSkia::StrokeLine(const Point& aStart, const Point& aEnd, + const Pattern& aPattern, + const StrokeOptions& aStrokeOptions, + const DrawOptions& aOptions) { + MarkChanged(); + AutoPaintSetup paint(mCanvas, aOptions, aPattern); + if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) { + return; + } + + mCanvas->drawLine(SkFloatToScalar(aStart.x), SkFloatToScalar(aStart.y), + SkFloatToScalar(aEnd.x), SkFloatToScalar(aEnd.y), + paint.mPaint); +} + +void DrawTargetSkia::Fill(const Path* aPath, const Pattern& aPattern, + const DrawOptions& aOptions) { + MarkChanged(); + if (!aPath || aPath->GetBackendType() != BackendType::SKIA) { + return; + } + + const PathSkia* skiaPath = static_cast<const PathSkia*>(aPath); + + AutoPaintSetup paint(mCanvas, aOptions, aPattern); + + if (!skiaPath->GetPath().isFinite()) { + return; + } + + mCanvas->drawPath(skiaPath->GetPath(), paint.mPaint); +} + +#ifdef MOZ_WIDGET_COCOA +static inline CGAffineTransform GfxMatrixToCGAffineTransform(const Matrix& m) { + CGAffineTransform t; + t.a = m._11; + t.b = m._12; + t.c = m._21; + t.d = m._22; + t.tx = m._31; + t.ty = m._32; + return t; +} + +/*** + * We have to do a lot of work to draw glyphs with CG because + * CG assumes that the origin of rects are in the bottom left + * while every other DrawTarget assumes the top left is the origin. + * This means we have to transform the CGContext to have rects + * actually be applied in top left fashion. We do this by: + * + * 1) Translating the context up by the height of the canvas + * 2) Flipping the context by the Y axis so it's upside down. + * + * These two transforms put the origin in the top left. + * Transforms are better understood thinking about them from right to left order + * (mathematically). + * + * Consider a point we want to draw at (0, 10) in normal cartesian planes with + * a box of (100, 100). in CG terms, this would be at (0, 10). + * Positive Y values point up. + * In our DrawTarget terms, positive Y values point down, so (0, 10) would be + * at (0, 90) in cartesian plane terms. That means our point at (0, 10) in + * DrawTarget terms should end up at (0, 90). How does this work with the + * current transforms? + * + * Going right to left with the transforms, a CGPoint of (0, 10) has cartesian + * coordinates of (0, 10). The first flip of the Y axis puts the point now at + * (0, -10); Next, we translate the context up by the size of the canvas + * (Positive Y values go up in CG coordinates but down in our draw target + * coordinates). Since our canvas size is (100, 100), the resulting coordinate + * becomes (0, 90), which is what we expect from our DrawTarget code. These two + * transforms put the CG context equal to what every other DrawTarget expects. + * + * Next, we need two more transforms for actual text. IF we left the transforms + * as is, the text would be drawn upside down, so we need another flip of the Y + * axis to draw the text right side up. However, with only the flip, the text + * would be drawn in the wrong place. Thus we also have to invert the Y position + * of the glyphs to get them in the right place. + * + * Thus we have the following transforms: + * 1) Translation of the context up + * 2) Flipping the context around the Y axis + * 3) Flipping the context around the Y axis + * 4) Inverting the Y position of each glyph + * + * We cannot cancel out (2) and (3) as we have to apply the clips and transforms + * of DrawTargetSkia between (2) and (3). + * + * Consider the example letter P, drawn at (0, 20) in CG coordinates in a + * (100, 100) rect. + * Again, going right to left of the transforms. We'd get: + * + * 1) The letter P drawn at (0, -20) due to the inversion of the Y axis + * 2) The letter P upside down (b) at (0, 20) due to the second flip + * 3) The letter P right side up at (0, -20) due to the first flip + * 4) The letter P right side up at (0, 80) due to the translation + * + * tl;dr - CGRects assume origin is bottom left, DrawTarget rects assume top + * left. + */ +static bool SetupCGContext(DrawTargetSkia* aDT, CGContextRef aCGContext, + SkCanvas* aCanvas, const IntPoint& aOrigin, + const IntSize& aSize, bool aClipped) { + // DrawTarget expects the origin to be at the top left, but CG + // expects it to be at the bottom left. Transform to set the origin to + // the top left. Have to set this before we do anything else. + // This is transform (1) up top + CGContextTranslateCTM(aCGContext, -aOrigin.x, aOrigin.y + aSize.height); + + // Transform (2) from the comments. + CGContextScaleCTM(aCGContext, 1, -1); + + // Want to apply clips BEFORE the transform since the transform + // will apply to the clips we apply. + if (aClipped) { + SkRegion clipRegion; + aCanvas->temporary_internal_getRgnClip(&clipRegion); + Vector<CGRect, 8> rects; + for (SkRegion::Iterator it(clipRegion); !it.done(); it.next()) { + const SkIRect& rect = it.rect(); + if (!rects.append( + CGRectMake(rect.x(), rect.y(), rect.width(), rect.height()))) { + break; + } + } + if (rects.length()) { + CGContextClipToRects(aCGContext, rects.begin(), rects.length()); + } + } + + CGContextConcatCTM(aCGContext, + GfxMatrixToCGAffineTransform(aDT->GetTransform())); + return true; +} +// End long comment about transforms. + +// The context returned from this method will have the origin +// in the top left and will have applied all the neccessary clips +// and transforms to the CGContext. See the comment above +// SetupCGContext. +CGContextRef DrawTargetSkia::BorrowCGContext(const DrawOptions& aOptions) { + // Since we can't replay Skia clips, we have to use a layer if we have a + // complex clip. After saving a layer, the SkCanvas queries for needing a + // layer change so save if we pushed a layer. + mNeedLayer = !mCanvas->isClipEmpty() && !mCanvas->isClipRect(); + if (mNeedLayer) { + SkPaint paint; + paint.setBlendMode(SkBlendMode::kSrc); + SkCanvas::SaveLayerRec rec(nullptr, &paint, + SkCanvas::kInitWithPrevious_SaveLayerFlag); + mCanvas->saveLayer(rec); + } + + uint8_t* data = nullptr; + int32_t stride; + SurfaceFormat format; + IntSize size; + IntPoint origin; + if (!LockBits(&data, &size, &stride, &format, &origin)) { + NS_WARNING("Could not lock skia bits to wrap CG around"); + return nullptr; + } + + if (!mNeedLayer && (data == mCanvasData) && mCG && (mCGSize == size)) { + // If our canvas data still points to the same data, + // we can reuse the CG Context + CGContextSetAlpha(mCG, aOptions.mAlpha); + CGContextSetShouldAntialias(mCG, + aOptions.mAntialiasMode != AntialiasMode::NONE); + CGContextSaveGState(mCG); + SetupCGContext(this, mCG, mCanvas, origin, size, true); + return mCG; + } + + if (!mColorSpace) { + mColorSpace = (format == SurfaceFormat::A8) ? CGColorSpaceCreateDeviceGray() + : CGColorSpaceCreateDeviceRGB(); + } + + if (mCG) { + // Release the old CG context since it's no longer valid. + CGContextRelease(mCG); + } + + mCanvasData = data; + mCGSize = size; + + uint32_t bitmapInfo = + (format == SurfaceFormat::A8) + ? kCGImageAlphaOnly + : kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host; + + mCG = CGBitmapContextCreateWithData( + mCanvasData, mCGSize.width, mCGSize.height, 8, /* bits per component */ + stride, mColorSpace, bitmapInfo, NULL, /* Callback when released */ + NULL); + if (!mCG) { + if (mNeedLayer) { + mCanvas->restore(); + } + ReleaseBits(mCanvasData); + NS_WARNING("Could not create bitmap around skia data\n"); + return nullptr; + } + + CGContextSetAlpha(mCG, aOptions.mAlpha); + CGContextSetShouldAntialias(mCG, + aOptions.mAntialiasMode != AntialiasMode::NONE); + CGContextSetShouldSmoothFonts(mCG, true); + CGContextSetTextDrawingMode(mCG, kCGTextFill); + CGContextSaveGState(mCG); + SetupCGContext(this, mCG, mCanvas, origin, size, !mNeedLayer); + return mCG; +} + +void DrawTargetSkia::ReturnCGContext(CGContextRef aCGContext) { + MOZ_ASSERT(aCGContext == mCG); + ReleaseBits(mCanvasData); + CGContextRestoreGState(aCGContext); + + if (mNeedLayer) { + // A layer was used for clipping and is about to be popped by the restore. + // Make sure the CG context referencing it is released first so the popped + // layer doesn't accidentally get used. + if (mCG) { + CGContextRelease(mCG); + mCG = nullptr; + } + mCanvas->restore(); + } +} + +CGContextRef BorrowedCGContext::BorrowCGContextFromDrawTarget(DrawTarget* aDT) { + DrawTargetSkia* skiaDT = static_cast<DrawTargetSkia*>(aDT); + return skiaDT->BorrowCGContext(DrawOptions()); +} + +void BorrowedCGContext::ReturnCGContextToDrawTarget(DrawTarget* aDT, + CGContextRef cg) { + DrawTargetSkia* skiaDT = static_cast<DrawTargetSkia*>(aDT); + skiaDT->ReturnCGContext(cg); +} +#endif + +static bool CanDrawFont(ScaledFont* aFont) { + switch (aFont->GetType()) { + case FontType::FREETYPE: + case FontType::FONTCONFIG: + case FontType::MAC: + case FontType::GDI: + case FontType::DWRITE: + return true; + default: + return false; + } +} + +void DrawTargetSkia::DrawGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer, + const Pattern& aPattern, + const StrokeOptions* aStrokeOptions, + const DrawOptions& aOptions) { + if (!CanDrawFont(aFont)) { + return; + } + + MarkChanged(); + + ScaledFontBase* skiaFont = static_cast<ScaledFontBase*>(aFont); + SkTypeface* typeface = skiaFont->GetSkTypeface(); + if (!typeface) { + return; + } + + AutoPaintSetup paint(mCanvas, aOptions, aPattern); + if (aStrokeOptions && !StrokeOptionsToPaint(paint.mPaint, *aStrokeOptions)) { + return; + } + + AntialiasMode aaMode = aFont->GetDefaultAAMode(); + if (aOptions.mAntialiasMode != AntialiasMode::DEFAULT) { + aaMode = aOptions.mAntialiasMode; + } + bool aaEnabled = aaMode != AntialiasMode::NONE; + paint.mPaint.setAntiAlias(aaEnabled); + + SkFont font(sk_ref_sp(typeface), SkFloatToScalar(skiaFont->mSize)); + + bool useSubpixelAA = + GetPermitSubpixelAA() && + (aaMode == AntialiasMode::DEFAULT || aaMode == AntialiasMode::SUBPIXEL); + font.setEdging(useSubpixelAA ? SkFont::Edging::kSubpixelAntiAlias + : (aaEnabled ? SkFont::Edging::kAntiAlias + : SkFont::Edging::kAlias)); + + skiaFont->SetupSkFontDrawOptions(font); + + // Limit the amount of internal batch allocations Skia does. + const uint32_t kMaxGlyphBatchSize = 8192; + + for (uint32_t offset = 0; offset < aBuffer.mNumGlyphs;) { + uint32_t batchSize = + std::min(aBuffer.mNumGlyphs - offset, kMaxGlyphBatchSize); + SkTextBlobBuilder builder; + auto runBuffer = builder.allocRunPos(font, batchSize); + for (uint32_t i = 0; i < batchSize; i++, offset++) { + runBuffer.glyphs[i] = aBuffer.mGlyphs[offset].mIndex; + runBuffer.points()[i] = PointToSkPoint(aBuffer.mGlyphs[offset].mPosition); + } + + sk_sp<SkTextBlob> text = builder.make(); + mCanvas->drawTextBlob(text, 0, 0, paint.mPaint); + } +} + +Maybe<Rect> DrawTargetSkia::GetGlyphLocalBounds( + ScaledFont* aFont, const GlyphBuffer& aBuffer, const Pattern& aPattern, + const StrokeOptions* aStrokeOptions, const DrawOptions& aOptions) { + if (!CanDrawFont(aFont)) { + return Nothing(); + } + + ScaledFontBase* skiaFont = static_cast<ScaledFontBase*>(aFont); + SkTypeface* typeface = skiaFont->GetSkTypeface(); + if (!typeface) { + return Nothing(); + } + + AutoPaintSetup paint(mCanvas, aOptions, aPattern); + if (aStrokeOptions && !StrokeOptionsToPaint(paint.mPaint, *aStrokeOptions)) { + return Nothing(); + } + + AntialiasMode aaMode = aFont->GetDefaultAAMode(); + if (aOptions.mAntialiasMode != AntialiasMode::DEFAULT) { + aaMode = aOptions.mAntialiasMode; + } + bool aaEnabled = aaMode != AntialiasMode::NONE; + paint.mPaint.setAntiAlias(aaEnabled); + + SkFont font(sk_ref_sp(typeface), SkFloatToScalar(skiaFont->mSize)); + + bool useSubpixelAA = + GetPermitSubpixelAA() && + (aaMode == AntialiasMode::DEFAULT || aaMode == AntialiasMode::SUBPIXEL); + font.setEdging(useSubpixelAA ? SkFont::Edging::kSubpixelAntiAlias + : (aaEnabled ? SkFont::Edging::kAntiAlias + : SkFont::Edging::kAlias)); + + skiaFont->SetupSkFontDrawOptions(font); + + // Limit the amount of internal batch allocations Skia does. + const uint32_t kMaxGlyphBatchSize = 8192; + + // Avoid using TextBlobBuilder for bounds computations as the conservative + // bounds can be wrong due to buggy font metrics. Instead, explicitly compute + // tight bounds directly with the SkFont. + Vector<SkGlyphID, 32> glyphs; + Vector<SkRect, 32> rects; + Rect bounds; + for (uint32_t offset = 0; offset < aBuffer.mNumGlyphs;) { + uint32_t batchSize = + std::min(aBuffer.mNumGlyphs - offset, kMaxGlyphBatchSize); + if (glyphs.resizeUninitialized(batchSize) && + rects.resizeUninitialized(batchSize)) { + for (uint32_t i = 0; i < batchSize; i++) { + glyphs[i] = aBuffer.mGlyphs[offset + i].mIndex; + } + font.getBounds(glyphs.begin(), batchSize, rects.begin(), nullptr); + for (uint32_t i = 0; i < batchSize; i++) { + bounds = bounds.Union(SkRectToRect(rects[i]) + + aBuffer.mGlyphs[offset + i].mPosition); + } + } + offset += batchSize; + } + + SkRect storage; + bounds = SkRectToRect( + paint.mPaint.computeFastBounds(RectToSkRect(bounds), &storage)); + + if (bounds.IsEmpty()) { + return Nothing(); + } + + return Some(bounds); +} + +void DrawTargetSkia::FillGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer, + const Pattern& aPattern, + const DrawOptions& aOptions) { + DrawGlyphs(aFont, aBuffer, aPattern, nullptr, aOptions); +} + +void DrawTargetSkia::StrokeGlyphs(ScaledFont* aFont, const GlyphBuffer& aBuffer, + const Pattern& aPattern, + const StrokeOptions& aStrokeOptions, + const DrawOptions& aOptions) { + DrawGlyphs(aFont, aBuffer, aPattern, &aStrokeOptions, aOptions); +} + +void DrawTargetSkia::Mask(const Pattern& aSource, const Pattern& aMask, + const DrawOptions& aOptions) { + Maybe<MutexAutoLock> lock; + SkPaint maskPaint; + SetPaintPattern(maskPaint, aMask, lock); + + sk_sp<SkShader> maskShader(maskPaint.getShader()); + if (!maskShader && maskPaint.getAlpha() != 0xFF) { + if (maskPaint.getAlpha() == 0) { + return; + } + maskShader = SkShaders::Color(maskPaint.getColor()); + if (!maskShader) { + gfxDebug() << "Failed creating Skia clip shader for Mask"; + return; + } + } + + MarkChanged(); + AutoPaintSetup paint(mCanvas, aOptions, aSource); + + mCanvas->save(); + if (maskShader) { + mCanvas->clipShader(maskShader); + } + + mCanvas->drawPaint(paint.mPaint); + + mCanvas->restore(); +} + +void DrawTargetSkia::MaskSurface(const Pattern& aSource, SourceSurface* aMask, + Point aOffset, const DrawOptions& aOptions) { + Maybe<MutexAutoLock> lock; + sk_sp<SkImage> maskImage = GetSkImageForSurface(aMask, &lock); + SkMatrix maskOffset = SkMatrix::Translate( + PointToSkPoint(aOffset + Point(aMask->GetRect().TopLeft()))); + sk_sp<SkShader> maskShader = maskImage->makeShader( + SkTileMode::kClamp, SkTileMode::kClamp, + SkSamplingOptions(SkFilterMode::kLinear), maskOffset); + if (!maskShader) { + gfxDebug() << "Failed creating Skia clip shader for MaskSurface"; + return; + } + + MarkChanged(); + AutoPaintSetup paint(mCanvas, aOptions, aSource); + + mCanvas->save(); + mCanvas->clipShader(maskShader); + + mCanvas->drawRect(RectToSkRect(Rect(aMask->GetRect()) + aOffset), + paint.mPaint); + + mCanvas->restore(); +} + +bool DrawTarget::Draw3DTransformedSurface(SourceSurface* aSurface, + const Matrix4x4& aMatrix) { + // Composite the 3D transform with the DT's transform. + Matrix4x4 fullMat = aMatrix * Matrix4x4::From2D(mTransform); + if (fullMat.IsSingular()) { + return false; + } + // Transform the surface bounds and clip to this DT. + IntRect xformBounds = RoundedOut(fullMat.TransformAndClipBounds( + Rect(Point(0, 0), Size(aSurface->GetSize())), + Rect(Point(0, 0), Size(GetSize())))); + if (xformBounds.IsEmpty()) { + return true; + } + // Offset the matrix by the transformed origin. + fullMat.PostTranslate(-xformBounds.X(), -xformBounds.Y(), 0); + + // Read in the source data. + Maybe<MutexAutoLock> lock; + sk_sp<SkImage> srcImage = GetSkImageForSurface(aSurface, &lock); + if (!srcImage) { + return true; + } + + // Set up an intermediate destination surface only the size of the transformed + // bounds. Try to pass through the source's format unmodified in both the BGRA + // and ARGB cases. + RefPtr<DataSourceSurface> dstSurf = Factory::CreateDataSourceSurface( + xformBounds.Size(), + !srcImage->isOpaque() ? aSurface->GetFormat() + : SurfaceFormat::A8R8G8B8_UINT32, + true); + if (!dstSurf) { + return false; + } + + DataSourceSurface::ScopedMap map(dstSurf, DataSourceSurface::READ_WRITE); + std::unique_ptr<SkCanvas> dstCanvas(SkCanvas::MakeRasterDirect( + SkImageInfo::Make(xformBounds.Width(), xformBounds.Height(), + GfxFormatToSkiaColorType(dstSurf->GetFormat()), + kPremul_SkAlphaType), + map.GetData(), map.GetStride())); + if (!dstCanvas) { + return false; + } + + // Do the transform. + SkPaint paint; + paint.setAntiAlias(true); + paint.setBlendMode(SkBlendMode::kSrc); + + SkMatrix xform; + GfxMatrixToSkiaMatrix(fullMat, xform); + dstCanvas->setMatrix(xform); + + dstCanvas->drawImage(srcImage, 0, 0, SkSamplingOptions(SkFilterMode::kLinear), + &paint); + dstCanvas->flush(); + + // Temporarily reset the DT's transform, since it has already been composed + // above. + Matrix origTransform = mTransform; + SetTransform(Matrix()); + + // Draw the transformed surface within the transformed bounds. + DrawSurface(dstSurf, Rect(xformBounds), + Rect(Point(0, 0), Size(xformBounds.Size()))); + + SetTransform(origTransform); + + return true; +} + +bool DrawTargetSkia::Draw3DTransformedSurface(SourceSurface* aSurface, + const Matrix4x4& aMatrix) { + if (aMatrix.IsSingular()) { + return false; + } + + MarkChanged(); + + Maybe<MutexAutoLock> lock; + sk_sp<SkImage> image = GetSkImageForSurface(aSurface, &lock); + if (!image) { + return true; + } + + mCanvas->save(); + + SkPaint paint; + paint.setAntiAlias(true); + + SkMatrix xform; + GfxMatrixToSkiaMatrix(aMatrix, xform); + mCanvas->concat(xform); + + mCanvas->drawImage(image, 0, 0, SkSamplingOptions(SkFilterMode::kLinear), + &paint); + + mCanvas->restore(); + + return true; +} + +already_AddRefed<SourceSurface> DrawTargetSkia::CreateSourceSurfaceFromData( + unsigned char* aData, const IntSize& aSize, int32_t aStride, + SurfaceFormat aFormat) const { + RefPtr<SourceSurfaceSkia> newSurf = new SourceSurfaceSkia(); + + if (!newSurf->InitFromData(aData, aSize, aStride, aFormat)) { + gfxDebug() << *this + << ": Failure to create source surface from data. Size: " + << aSize; + return nullptr; + } + + return newSurf.forget(); +} + +already_AddRefed<DrawTarget> DrawTargetSkia::CreateSimilarDrawTarget( + const IntSize& aSize, SurfaceFormat aFormat) const { + RefPtr<DrawTargetSkia> target = new DrawTargetSkia(); +#ifdef DEBUG + if (!IsBackedByPixels(mCanvas)) { + // If our canvas is backed by vector storage such as PDF then we want to + // create a new DrawTarget with similar storage to avoid losing fidelity + // (fidelity will be lost if the returned DT is Snapshot()'ed and drawn + // back onto us since a raster will be drawn instead of vector commands). + NS_WARNING("Not backed by pixels - we need to handle PDF backed SkCanvas"); + } +#endif + + if (!target->Init(aSize, aFormat)) { + return nullptr; + } + return target.forget(); +} + +bool DrawTargetSkia::CanCreateSimilarDrawTarget(const IntSize& aSize, + SurfaceFormat aFormat) const { + auto minmaxPair = std::minmax(aSize.width, aSize.height); + return minmaxPair.first > 0 && + size_t(minmaxPair.second) < GetMaxSurfaceSize(); +} + +RefPtr<DrawTarget> DrawTargetSkia::CreateClippedDrawTarget( + const Rect& aBounds, SurfaceFormat aFormat) { + SkIRect clipBounds; + + RefPtr<DrawTarget> result; + // Doing this save()/restore() dance is wasteful + mCanvas->save(); + if (!aBounds.IsEmpty()) { + mCanvas->clipRect(RectToSkRect(aBounds), SkClipOp::kIntersect, true); + } + if (mCanvas->getDeviceClipBounds(&clipBounds)) { + RefPtr<DrawTarget> dt = CreateSimilarDrawTarget( + IntSize(clipBounds.width(), clipBounds.height()), aFormat); + if (dt) { + result = gfx::Factory::CreateOffsetDrawTarget( + dt, IntPoint(clipBounds.x(), clipBounds.y())); + if (result) { + result->SetTransform(mTransform); + } + } + } else { + // Everything is clipped but we still want some kind of surface + result = CreateSimilarDrawTarget(IntSize(1, 1), aFormat); + } + mCanvas->restore(); + return result; +} + +already_AddRefed<SourceSurface> +DrawTargetSkia::OptimizeSourceSurfaceForUnknownAlpha( + SourceSurface* aSurface) const { + if (aSurface->GetType() == SurfaceType::SKIA) { + RefPtr<SourceSurface> surface(aSurface); + return surface.forget(); + } + + RefPtr<DataSourceSurface> dataSurface = aSurface->GetDataSurface(); + DataSourceSurface::ScopedMap map(dataSurface, DataSourceSurface::READ_WRITE); + + // For plugins, GDI can sometimes just write 0 to the alpha channel + // even for RGBX formats. In this case, we have to manually write + // the alpha channel to make Skia happy with RGBX and in case GDI + // writes some bad data. Luckily, this only happens on plugins. + WriteRGBXFormat(map.GetData(), dataSurface->GetSize(), map.GetStride(), + dataSurface->GetFormat()); + return dataSurface.forget(); +} + +already_AddRefed<SourceSurface> DrawTargetSkia::OptimizeSourceSurface( + SourceSurface* aSurface) const { + if (aSurface->GetType() == SurfaceType::SKIA) { + RefPtr<SourceSurface> surface(aSurface); + return surface.forget(); + } + + // If we're not using skia-gl then drawing doesn't require any + // uploading, so any data surface is fine. Call GetDataSurface + // to trigger any required readback so that it only happens + // once. + RefPtr<DataSourceSurface> dataSurface = aSurface->GetDataSurface(); +#ifdef DEBUG + DataSourceSurface::ScopedMap map(dataSurface, DataSourceSurface::READ); + MOZ_ASSERT(VerifyRGBXFormat(map.GetData(), dataSurface->GetSize(), + map.GetStride(), dataSurface->GetFormat())); +#endif + return dataSurface.forget(); +} + +already_AddRefed<SourceSurface> +DrawTargetSkia::CreateSourceSurfaceFromNativeSurface( + const NativeSurface& aSurface) const { + return nullptr; +} + +void DrawTargetSkia::CopySurface(SourceSurface* aSurface, + const IntRect& aSourceRect, + const IntPoint& aDestination) { + MarkChanged(); + + Maybe<MutexAutoLock> lock; + sk_sp<SkImage> image = GetSkImageForSurface(aSurface, &lock); + if (!image) { + return; + } + + SkPixmap srcPixmap; + if (!image->peekPixels(&srcPixmap)) { + return; + } + + // Ensure the source rect intersects the surface bounds. + IntRect srcRect = aSourceRect.Intersect(SkIRectToIntRect(srcPixmap.bounds())); + // Move the destination offset to match the altered source rect. + IntPoint dstOffset = + aDestination + (srcRect.TopLeft() - aSourceRect.TopLeft()); + // Then ensure the dest rect intersect the canvas bounds. + IntRect dstRect = IntRect(dstOffset, srcRect.Size()).Intersect(GetRect()); + // Move the source rect to match the altered dest rect. + srcRect += dstRect.TopLeft() - dstOffset; + srcRect.SizeTo(dstRect.Size()); + + if (!srcPixmap.extractSubset(&srcPixmap, IntRectToSkIRect(srcRect))) { + return; + } + + mCanvas->writePixels(srcPixmap.info(), srcPixmap.addr(), srcPixmap.rowBytes(), + dstRect.x, dstRect.y); +} + +static inline SkPixelGeometry GetSkPixelGeometry() { + return Factory::GetBGRSubpixelOrder() ? kBGR_H_SkPixelGeometry + : kRGB_H_SkPixelGeometry; +} + +template <typename T> +[[nodiscard]] static already_AddRefed<T> AsRefPtr(sk_sp<T>&& aSkPtr) { + return already_AddRefed<T>(aSkPtr.release()); +} + +bool DrawTargetSkia::Init(const IntSize& aSize, SurfaceFormat aFormat) { + if (size_t(std::max(aSize.width, aSize.height)) > GetMaxSurfaceSize()) { + return false; + } + + // we need to have surfaces that have a stride aligned to 4 for interop with + // cairo + SkImageInfo info = MakeSkiaImageInfo(aSize, aFormat); + size_t stride = GetAlignedStride<4>(info.width(), info.bytesPerPixel()); + if (!stride) { + return false; + } + SkSurfaceProps props(0, GetSkPixelGeometry()); + + if (aFormat == SurfaceFormat::A8) { + // Skia does not fully allocate the last row according to stride. + // Since some of our algorithms (i.e. blur) depend on this, we must allocate + // the bitmap pixels manually. + CheckedInt<size_t> size = stride; + size *= info.height(); + // We need to leave room for an additional 3 bytes for a potential overrun + // in our blurring code. + size += 3; + if (!size.isValid()) { + return false; + } + void* buf = sk_malloc_flags(size.value(), SK_MALLOC_ZERO_INITIALIZE); + if (!buf) { + return false; + } + mSurface = AsRefPtr(SkSurface::MakeRasterDirectReleaseProc( + info, buf, stride, FreeAlphaPixels, nullptr, &props)); + } else { + mSurface = AsRefPtr(SkSurface::MakeRaster(info, stride, &props)); + } + if (!mSurface) { + return false; + } + + mSize = aSize; + mFormat = aFormat; + mCanvas = mSurface->getCanvas(); + SetPermitSubpixelAA(IsOpaque(mFormat)); + + if (info.isOpaque()) { + mCanvas->clear(SK_ColorBLACK); + } + return true; +} + +bool DrawTargetSkia::Init(SkCanvas* aCanvas) { + mCanvas = aCanvas; + + SkImageInfo imageInfo = mCanvas->imageInfo(); + + // If the canvas is backed by pixels we clear it to be on the safe side. If + // it's not (for example, for PDF output) we don't. + if (IsBackedByPixels(mCanvas)) { + SkColor clearColor = + imageInfo.isOpaque() ? SK_ColorBLACK : SK_ColorTRANSPARENT; + mCanvas->clear(clearColor); + } + + SkISize size = mCanvas->getBaseLayerSize(); + mSize.width = size.width(); + mSize.height = size.height(); + mFormat = + SkiaColorTypeToGfxFormat(imageInfo.colorType(), imageInfo.alphaType()); + SetPermitSubpixelAA(IsOpaque(mFormat)); + return true; +} + +bool DrawTargetSkia::Init(unsigned char* aData, const IntSize& aSize, + int32_t aStride, SurfaceFormat aFormat, + bool aUninitialized) { + MOZ_ASSERT((aFormat != SurfaceFormat::B8G8R8X8) || aUninitialized || + VerifyRGBXFormat(aData, aSize, aStride, aFormat)); + + SkSurfaceProps props(0, GetSkPixelGeometry()); + mSurface = AsRefPtr(SkSurface::MakeRasterDirect( + MakeSkiaImageInfo(aSize, aFormat), aData, aStride, &props)); + if (!mSurface) { + return false; + } + + mSize = aSize; + mFormat = aFormat; + mCanvas = mSurface->getCanvas(); + SetPermitSubpixelAA(IsOpaque(mFormat)); + return true; +} + +bool DrawTargetSkia::Init(RefPtr<DataSourceSurface>&& aSurface) { + auto map = + new DataSourceSurface::ScopedMap(aSurface, DataSourceSurface::READ_WRITE); + if (!map->IsMapped()) { + delete map; + return false; + } + + SurfaceFormat format = aSurface->GetFormat(); + IntSize size = aSurface->GetSize(); + MOZ_ASSERT((format != SurfaceFormat::B8G8R8X8) || + VerifyRGBXFormat(map->GetData(), size, map->GetStride(), format)); + + SkSurfaceProps props(0, GetSkPixelGeometry()); + mSurface = AsRefPtr(SkSurface::MakeRasterDirectReleaseProc( + MakeSkiaImageInfo(size, format), map->GetData(), map->GetStride(), + DrawTargetSkia::ReleaseMappedSkSurface, map, &props)); + if (!mSurface) { + delete map; + return false; + } + + // map is now owned by mSurface + mBackingSurface = std::move(aSurface); + mSize = size; + mFormat = format; + mCanvas = mSurface->getCanvas(); + SetPermitSubpixelAA(IsOpaque(format)); + return true; +} + +/* static */ void DrawTargetSkia::ReleaseMappedSkSurface(void* aPixels, + void* aContext) { + auto map = reinterpret_cast<DataSourceSurface::ScopedMap*>(aContext); + delete map; +} + +void DrawTargetSkia::SetTransform(const Matrix& aTransform) { + SkMatrix mat; + GfxMatrixToSkiaMatrix(aTransform, mat); + mCanvas->setMatrix(mat); + mTransform = aTransform; +} + +void* DrawTargetSkia::GetNativeSurface(NativeSurfaceType aType) { + return nullptr; +} + +already_AddRefed<PathBuilder> DrawTargetSkia::CreatePathBuilder( + FillRule aFillRule) const { + return PathBuilderSkia::Create(aFillRule); +} + +void DrawTargetSkia::ClearRect(const Rect& aRect) { + MarkChanged(); + mCanvas->save(); + // Restrict clearing to the clip region if requested + mCanvas->clipRect(RectToSkRect(aRect), SkClipOp::kIntersect, true); + SkColor clearColor = (mFormat == SurfaceFormat::B8G8R8X8) + ? SK_ColorBLACK + : SK_ColorTRANSPARENT; + mCanvas->clear(clearColor); + mCanvas->restore(); +} + +void DrawTargetSkia::PushClip(const Path* aPath) { + if (aPath->GetBackendType() != BackendType::SKIA) { + return; + } + + const PathSkia* skiaPath = static_cast<const PathSkia*>(aPath); + mCanvas->save(); + mCanvas->clipPath(skiaPath->GetPath(), SkClipOp::kIntersect, true); +} + +void DrawTargetSkia::PushDeviceSpaceClipRects(const IntRect* aRects, + uint32_t aCount) { + // Build a region by unioning all the rects together. + SkRegion region; + for (uint32_t i = 0; i < aCount; i++) { + region.op(IntRectToSkIRect(aRects[i]), SkRegion::kUnion_Op); + } + + // Clip with the resulting region. clipRegion does not transform + // this region by the current transform, unlike the other SkCanvas + // clip methods, so it is just passed through in device-space. + mCanvas->save(); + mCanvas->clipRegion(region, SkClipOp::kIntersect); +} + +void DrawTargetSkia::PushClipRect(const Rect& aRect) { + SkRect rect = RectToSkRect(aRect); + + mCanvas->save(); + mCanvas->clipRect(rect, SkClipOp::kIntersect, true); +} + +void DrawTargetSkia::PopClip() { + mCanvas->restore(); + SetTransform(GetTransform()); +} + +bool DrawTargetSkia::RemoveAllClips() { + mCanvas->restoreToCount(1); + SetTransform(GetTransform()); + return true; +} + +// Get clip bounds in device space for the clipping region. By default, only +// bounds for simple (empty or rect) regions are reported. If explicitly +// allowed, the bounds will be reported for complex (all other) regions as well. +Maybe<IntRect> DrawTargetSkia::GetDeviceClipRect(bool aAllowComplex) const { + if (mCanvas->isClipEmpty()) { + return Some(IntRect()); + } + if (aAllowComplex || mCanvas->isClipRect()) { + SkIRect deviceBounds; + if (mCanvas->getDeviceClipBounds(&deviceBounds)) { + return Some(SkIRectToIntRect(deviceBounds)); + } + } + return Nothing(); +} + +void DrawTargetSkia::PushLayer(bool aOpaque, Float aOpacity, + SourceSurface* aMask, + const Matrix& aMaskTransform, + const IntRect& aBounds, bool aCopyBackground) { + PushLayerWithBlend(aOpaque, aOpacity, aMask, aMaskTransform, aBounds, + aCopyBackground, CompositionOp::OP_OVER); +} + +void DrawTargetSkia::PushLayerWithBlend(bool aOpaque, Float aOpacity, + SourceSurface* aMask, + const Matrix& aMaskTransform, + const IntRect& aBounds, + bool aCopyBackground, + CompositionOp aCompositionOp) { + SkPaint paint; + + paint.setAlpha(ColorFloatToByte(aOpacity)); + paint.setBlendMode(GfxOpToSkiaOp(aCompositionOp)); + + // aBounds is supplied in device space, but SaveLayerRec wants local space. + SkRect bounds = SkRect::MakeEmpty(); + if (!aBounds.IsEmpty()) { + Matrix inverseTransform = mTransform; + if (inverseTransform.Invert()) { + bounds = RectToSkRect(inverseTransform.TransformBounds(Rect(aBounds))); + } + } + + // We don't pass a lock object to GetSkImageForSurface here, to force a + // copy of the data if this is a copy-on-write snapshot. If we instead held + // the lock until the corresponding PopLayer, we'd risk deadlocking if someone + // tried to touch the originating DrawTarget while the layer was pushed. + sk_sp<SkImage> clipImage = GetSkImageForSurface(aMask, nullptr); + bool usedMask = false; + if (bool(clipImage)) { + Rect maskBounds(aMask->GetRect()); + sk_sp<SkShader> shader = clipImage->makeShader( + SkTileMode::kClamp, SkTileMode::kClamp, + SkSamplingOptions(SkFilterMode::kLinear), + SkMatrix::Translate(PointToSkPoint(maskBounds.TopLeft()))); + if (shader) { + usedMask = true; + mCanvas->save(); + + auto oldMatrix = mCanvas->getLocalToDevice(); + SkMatrix clipMatrix; + GfxMatrixToSkiaMatrix(aMaskTransform, clipMatrix); + mCanvas->concat(clipMatrix); + + mCanvas->clipRect(RectToSkRect(maskBounds)); + mCanvas->clipShader(shader); + + mCanvas->setMatrix(oldMatrix); + } else { + gfxDebug() << "Failed to create Skia clip shader for PushLayerWithBlend"; + } + } + + PushedLayer layer(GetPermitSubpixelAA(), usedMask ? aMask : nullptr); + mPushedLayers.push_back(layer); + + SkCanvas::SaveLayerRec saveRec( + aBounds.IsEmpty() ? nullptr : &bounds, &paint, nullptr, + SkCanvas::kPreserveLCDText_SaveLayerFlag | + (aCopyBackground ? SkCanvas::kInitWithPrevious_SaveLayerFlag : 0)); + + mCanvas->saveLayer(saveRec); + + SetPermitSubpixelAA(aOpaque); + +#ifdef MOZ_WIDGET_COCOA + CGContextRelease(mCG); + mCG = nullptr; +#endif +} + +void DrawTargetSkia::PopLayer() { + MOZ_RELEASE_ASSERT(!mPushedLayers.empty()); + + MarkChanged(); + + const PushedLayer& layer = mPushedLayers.back(); + + mCanvas->restore(); + + if (layer.mMask) { + mCanvas->restore(); + } + + SetTransform(GetTransform()); + SetPermitSubpixelAA(layer.mOldPermitSubpixelAA); + + mPushedLayers.pop_back(); + +#ifdef MOZ_WIDGET_COCOA + CGContextRelease(mCG); + mCG = nullptr; +#endif +} + +already_AddRefed<GradientStops> DrawTargetSkia::CreateGradientStops( + GradientStop* aStops, uint32_t aNumStops, ExtendMode aExtendMode) const { + std::vector<GradientStop> stops; + stops.resize(aNumStops); + for (uint32_t i = 0; i < aNumStops; i++) { + stops[i] = aStops[i]; + } + std::stable_sort(stops.begin(), stops.end()); + + return MakeAndAddRef<GradientStopsSkia>(stops, aNumStops, aExtendMode); +} + +already_AddRefed<FilterNode> DrawTargetSkia::CreateFilter(FilterType aType) { + return FilterNodeSoftware::Create(aType); +} + +void DrawTargetSkia::MarkChanged() { + // I'm not entirely certain whether this lock is needed, as multiple threads + // should never modify the DrawTarget at the same time anyway, but this seems + // like the safest. + MutexAutoLock lock(mSnapshotLock); + if (mSnapshot) { + if (mSnapshot->hasOneRef()) { + // No owners outside of this DrawTarget's own reference. Just dump it. + mSnapshot = nullptr; + return; + } + + mSnapshot->DrawTargetWillChange(); + mSnapshot = nullptr; + + // Handle copying of any image snapshots bound to the surface. + if (mSurface) { + mSurface->notifyContentWillChange(SkSurface::kRetain_ContentChangeMode); + } + } +} + +} // namespace mozilla::gfx |