Merge SkiaCanvas changes from master-skia to master branch. (f50806af) · Commits · e / os / android_frameworks_base

libs/hwui/SkiaCanvas.cpp

+230 −67

Original line number	Original line	Diff line number	Diff line
	@@ -31,11 +31,14 @@
	#include <SkRSXform.h>		#include <SkRSXform.h>
	#include <SkShader.h>		#include <SkShader.h>
	#include <SkTemplates.h>		#include <SkTemplates.h>
			#include <SkTextBlob.h>

	#include <memory>		#include <memory>

	namespace android {		namespace android {

			using uirenderer::PaintUtils;

	Canvas* Canvas::create_canvas(const SkBitmap& bitmap) {		Canvas* Canvas::create_canvas(const SkBitmap& bitmap) {
	return new SkiaCanvas(bitmap);		return new SkiaCanvas(bitmap);
	}		}
	@@ -44,6 +47,11 @@ Canvas* Canvas::create_canvas(SkCanvas* skiaCanvas) {
	return new SkiaCanvas(skiaCanvas);		return new SkiaCanvas(skiaCanvas);
	}		}

			SkiaCanvas::SkiaCanvas() {}

			SkiaCanvas::SkiaCanvas(SkCanvas* canvas)
			: mCanvas(SkRef(canvas)) {}

	SkiaCanvas::SkiaCanvas(const SkBitmap& bitmap) {		SkiaCanvas::SkiaCanvas(const SkBitmap& bitmap) {
	mCanvas.reset(new SkCanvas(bitmap));		mCanvas.reset(new SkCanvas(bitmap));
	}		}
	@@ -77,21 +85,21 @@ private:
	};		};

	void SkiaCanvas::setBitmap(const SkBitmap& bitmap) {		void SkiaCanvas::setBitmap(const SkBitmap& bitmap) {
	sk_sp<SkCanvas> newCanvas(new SkCanvas(bitmap));		SkCanvas* newCanvas = new SkCanvas(bitmap);

	if (!bitmap.isNull()) {		if (!bitmap.isNull()) {
	// Copy the canvas matrix & clip state.		// Copy the canvas matrix & clip state.
	newCanvas->setMatrix(mCanvas->getTotalMatrix());		newCanvas->setMatrix(mCanvas->getTotalMatrix());

	ClipCopier copier(newCanvas.get());		ClipCopier copier(newCanvas);
	mCanvas->replayClips(&copier);		mCanvas->replayClips(&copier);
	}		}

	// unrefs the existing canvas		// unrefs the existing canvas
	mCanvas = std::move(newCanvas);		mCanvas.reset(newCanvas);

	// clean up the old save stack		// clean up the old save stack
	mSaveStack.reset(NULL);		mSaveStack.reset(nullptr);
	}		}

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------
	@@ -129,13 +137,8 @@ int SkiaCanvas::save(SaveFlags::Flags flags) {
	// operation. It does this by explicitly saving off the clip & matrix state		// operation. It does this by explicitly saving off the clip & matrix state
	// when requested and playing it back after the SkCanvas::restore.		// when requested and playing it back after the SkCanvas::restore.
	void SkiaCanvas::restore() {		void SkiaCanvas::restore() {
	const SaveRec* rec = (NULL == mSaveStack.get())		const auto* rec = this->currentSaveRec();
	? NULL		if (!rec) {
	: static_cast<SaveRec*>(mSaveStack->back());
	int currentSaveCount = mCanvas->getSaveCount();
	SkASSERT(NULL == rec \|\| currentSaveCount >= rec->saveCount);

	if (NULL == rec \|\| rec->saveCount != currentSaveCount) {
	// Fast path - no record for this frame.		// Fast path - no record for this frame.
	mCanvas->restore();		mCanvas->restore();
	return;		return;
	@@ -149,27 +152,18 @@ void SkiaCanvas::restore() {
	savedMatrix = mCanvas->getTotalMatrix();		savedMatrix = mCanvas->getTotalMatrix();
	}		}

	SkTArray<SkClipStack::Element> savedClips;		const size_t clipIndex = rec->clipIndex;
	int topClipStackFrame = mCanvas->getClipStack()->getSaveCount();
	if (preserveClip) {
	saveClipsForFrame(savedClips, topClipStackFrame);
	}

	mCanvas->restore();		mCanvas->restore();
			mSaveStack->pop_back();

	if (preserveMatrix) {		if (preserveMatrix) {
	mCanvas->setMatrix(savedMatrix);		mCanvas->setMatrix(savedMatrix);
	}		}

	if (preserveClip && !savedClips.empty() &&		if (preserveClip) {
	topClipStackFrame != mCanvas->getClipStack()->getSaveCount()) {		this->applyPersistentClips(clipIndex);
	// Only reapply the saved clips if the top clip stack frame was actually
	// popped by restore(). If it wasn't, it means it doesn't belong to the
	// restored canvas frame (SkCanvas lazy save/restore kicked in).
	applyClips(savedClips);
	}		}

	mSaveStack->pop_back();
	}		}

	void SkiaCanvas::restoreToCount(int restoreCount) {		void SkiaCanvas::restoreToCount(int restoreCount) {
	@@ -213,6 +207,56 @@ int SkiaCanvas::saveLayerAlpha(float left, float top, float right, float bottom,
	return this->saveLayer(left, top, right, bottom, nullptr, flags);		return this->saveLayer(left, top, right, bottom, nullptr, flags);
	}		}

			class SkiaCanvas::Clip {
			public:
			Clip(const SkRect& rect, SkRegion::Op op, const SkMatrix& m)
			: mType(Type::Rect), mOp(op), mMatrix(m), mRRect(SkRRect::MakeRect(rect)) {}
			Clip(const SkRRect& rrect, SkRegion::Op op, const SkMatrix& m)
			: mType(Type::RRect), mOp(op), mMatrix(m), mRRect(rrect) {}
			Clip(const SkPath& path, SkRegion::Op op, const SkMatrix& m)
			: mType(Type::Path), mOp(op), mMatrix(m), mPath(&path) {}

			void apply(SkCanvas* canvas) const {
			canvas->setMatrix(mMatrix);
			switch (mType) {
			case Type::Rect:
			canvas->clipRect(mRRect.rect(), mOp);
			break;
			case Type::RRect:
			canvas->clipRRect(mRRect, mOp);
			break;
			case Type::Path:
			canvas->clipPath(*mPath.get(), mOp);
			break;
			}
			}

			private:
			enum class Type {
			Rect,
			RRect,
			Path,
			};

			Type mType;
			SkRegion::Op mOp;
			SkMatrix mMatrix;

			// These are logically a union (tracked separately due to non-POD path).
			SkTLazy<SkPath> mPath;
			SkRRect mRRect;
			};

			const SkiaCanvas::SaveRec* SkiaCanvas::currentSaveRec() const {
			const SaveRec* rec = mSaveStack
			? static_cast<const SaveRec*>(mSaveStack->back())
			: nullptr;
			int currentSaveCount = mCanvas->getSaveCount();
			SkASSERT(!rec \|\| currentSaveCount >= rec->saveCount);

			return (rec && rec->saveCount == currentSaveCount) ? rec : nullptr;
			}

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------
	// functions to emulate legacy SaveFlags (i.e. independent matrix/clip flags)		// functions to emulate legacy SaveFlags (i.e. independent matrix/clip flags)
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------
	@@ -229,45 +273,48 @@ void SkiaCanvas::recordPartialSave(SaveFlags::Flags flags) {
	return;		return;
	}		}

	if (NULL == mSaveStack.get()) {		if (!mSaveStack) {
	mSaveStack.reset(new SkDeque(sizeof(struct SaveRec), 8));		mSaveStack.reset(new SkDeque(sizeof(struct SaveRec), 8));
	}		}

	SaveRec* rec = static_cast<SaveRec*>(mSaveStack->push_back());		SaveRec* rec = static_cast<SaveRec*>(mSaveStack->push_back());
	rec->saveCount = mCanvas->getSaveCount();		rec->saveCount = mCanvas->getSaveCount();
	rec->saveFlags = flags;		rec->saveFlags = flags;
			rec->clipIndex = mClipStack.size();
	}		}

	void SkiaCanvas::saveClipsForFrame(SkTArray<SkClipStack::Element>& clips,		template <typename T>
	int saveCountToBackup) {		void SkiaCanvas::recordClip(const T& clip, SkRegion::Op op) {
	// Each SkClipStack::Element stores the index of the canvas save		// Only need tracking when in a partial save frame which
	// with which it is associated. Backup only those Elements that		// doesn't restore the clip.
	// are associated with 'saveCountToBackup'		const SaveRec* rec = this->currentSaveRec();
	SkClipStack::Iter clipIterator(*mCanvas->getClipStack(),		if (rec && !(rec->saveFlags & SaveFlags::Clip)) {
	SkClipStack::Iter::kTop_IterStart);		mClipStack.emplace_back(clip, op, mCanvas->getTotalMatrix());
	while (const SkClipStack::Element* elem = clipIterator.prev()) {
	if (elem->getSaveCount() < saveCountToBackup) {
	// done with the target save count.
	break;
	}
	SkASSERT(elem->getSaveCount() == saveCountToBackup);
	clips.push_back(*elem);
	}		}
	}		}

	void SkiaCanvas::applyClips(const SkTArray<SkClipStack::Element>& clips) {		// Applies and optionally removes all clips >= index.
	ClipCopier clipCopier(mCanvas.get());		void SkiaCanvas::applyPersistentClips(size_t clipStartIndex) {
			SkASSERT(clipStartIndex <= mClipStack.size());
			const auto begin = mClipStack.cbegin() + clipStartIndex;
			const auto end = mClipStack.cend();

	// The clip stack stores clips in device space.		// Clip application mutates the CTM.
	SkMatrix origMatrix = mCanvas->getTotalMatrix();		const SkMatrix saveMatrix = mCanvas->getTotalMatrix();
	mCanvas->resetMatrix();

	// We pushed the clips in reverse order.		for (auto clip = begin; clip != end; ++clip) {
	for (int i = clips.count() - 1; i >= 0; --i) {		clip->apply(mCanvas.get());
	clips[i].replay(&clipCopier);
	}		}

	mCanvas->setMatrix(origMatrix);		mCanvas->setMatrix(saveMatrix);

			// If the current/post-restore save rec is also persisting clips, we
			// leave them on the stack to be reapplied part of the next restore().
			// Otherwise we're done and just pop them.
			const auto* rec = this->currentSaveRec();
			if (!rec \|\| (rec->saveFlags & SaveFlags::Clip)) {
			mClipStack.erase(begin, end);
			}
	}		}

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------
	@@ -343,6 +390,7 @@ bool SkiaCanvas::quickRejectPath(const SkPath& path) const {

	bool SkiaCanvas::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {		bool SkiaCanvas::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
	SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);		SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
			this->recordClip(rect, op);
	mCanvas->clipRect(rect, op);		mCanvas->clipRect(rect, op);
	return !mCanvas->isClipEmpty();		return !mCanvas->isClipEmpty();
	}		}
	@@ -350,8 +398,10 @@ bool SkiaCanvas::clipRect(float left, float top, float right, float bottom, SkRe
	bool SkiaCanvas::clipPath(const SkPath* path, SkRegion::Op op) {		bool SkiaCanvas::clipPath(const SkPath* path, SkRegion::Op op) {
	SkRRect roundRect;		SkRRect roundRect;
	if (path->isRRect(&roundRect)) {		if (path->isRRect(&roundRect)) {
			this->recordClip(roundRect, op);
	mCanvas->clipRRect(roundRect, op);		mCanvas->clipRRect(roundRect, op);
	} else {		} else {
			this->recordClip(*path, op);
	mCanvas->clipPath(*path, op);		mCanvas->clipPath(*path, op);
	}		}
	return !mCanvas->isClipEmpty();		return !mCanvas->isClipEmpty();
	@@ -363,10 +413,13 @@ bool SkiaCanvas::clipRegion(const SkRegion* region, SkRegion::Op op) {
	// The region is specified in device space.		// The region is specified in device space.
	SkMatrix savedMatrix = mCanvas->getTotalMatrix();		SkMatrix savedMatrix = mCanvas->getTotalMatrix();
	mCanvas->resetMatrix();		mCanvas->resetMatrix();
			this->recordClip(rgnPath, op);
	mCanvas->clipPath(rgnPath, op);		mCanvas->clipPath(rgnPath, op);
	mCanvas->setMatrix(savedMatrix);		mCanvas->setMatrix(savedMatrix);
	} else {		} else {
	mCanvas->clipRect(SkRect::MakeEmpty(), op);		const auto emptyClip = SkRect::MakeEmpty();
			this->recordClip(emptyClip, op);
			mCanvas->clipRect(emptyClip, op);
	}		}
	return !mCanvas->isClipEmpty();		return !mCanvas->isClipEmpty();
	}		}
	@@ -401,6 +454,7 @@ void SkiaCanvas::drawPaint(const SkPaint& paint) {

	void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint,		void SkiaCanvas::drawPoints(const float* points, int count, const SkPaint& paint,
	SkCanvas::PointMode mode) {		SkCanvas::PointMode mode) {
			if (CC_UNLIKELY(count < 2 \|\| PaintUtils::paintWillNotDraw(paint))) return;
	// convert the floats into SkPoints		// convert the floats into SkPoints
	count >>= 1; // now it is the number of points		count >>= 1; // now it is the number of points
	std::unique_ptr<SkPoint[]> pts(new SkPoint[count]);		std::unique_ptr<SkPoint[]> pts(new SkPoint[count]);
	@@ -426,45 +480,49 @@ void SkiaCanvas::drawLine(float startX, float startY, float stopX, float stopY,
	}		}

	void SkiaCanvas::drawLines(const float* points, int count, const SkPaint& paint) {		void SkiaCanvas::drawLines(const float* points, int count, const SkPaint& paint) {
			if (CC_UNLIKELY(count < 4 \|\| PaintUtils::paintWillNotDraw(paint))) return;
	this->drawPoints(points, count, paint, SkCanvas::kLines_PointMode);		this->drawPoints(points, count, paint, SkCanvas::kLines_PointMode);
	}		}

	void SkiaCanvas::drawRect(float left, float top, float right, float bottom,		void SkiaCanvas::drawRect(float left, float top, float right, float bottom,
	const SkPaint& paint) {		const SkPaint& paint) {
			if (CC_UNLIKELY(PaintUtils::paintWillNotDraw(paint))) return;
	mCanvas->drawRectCoords(left, top, right, bottom, paint);		mCanvas->drawRectCoords(left, top, right, bottom, paint);

	}		}

	void SkiaCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {		void SkiaCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {
	SkRegion::Iterator it(region);		if (CC_UNLIKELY(PaintUtils::paintWillNotDraw(paint))) return;
	while (!it.done()) {		mCanvas->drawRegion(region, paint);
	mCanvas->drawRect(SkRect::Make(it.rect()), paint);
	it.next();
	}
	}		}

	void SkiaCanvas::drawRoundRect(float left, float top, float right, float bottom,		void SkiaCanvas::drawRoundRect(float left, float top, float right, float bottom,
	float rx, float ry, const SkPaint& paint) {		float rx, float ry, const SkPaint& paint) {
			if (CC_UNLIKELY(PaintUtils::paintWillNotDraw(paint))) return;
	SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);		SkRect rect = SkRect::MakeLTRB(left, top, right, bottom);
	mCanvas->drawRoundRect(rect, rx, ry, paint);		mCanvas->drawRoundRect(rect, rx, ry, paint);
	}		}

	void SkiaCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {		void SkiaCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
			if (CC_UNLIKELY(radius <= 0 \|\| PaintUtils::paintWillNotDraw(paint))) return;
	mCanvas->drawCircle(x, y, radius, paint);		mCanvas->drawCircle(x, y, radius, paint);
	}		}

	void SkiaCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {		void SkiaCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {
			if (CC_UNLIKELY(PaintUtils::paintWillNotDraw(paint))) return;
	SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);		SkRect oval = SkRect::MakeLTRB(left, top, right, bottom);
	mCanvas->drawOval(oval, paint);		mCanvas->drawOval(oval, paint);
	}		}

	void SkiaCanvas::drawArc(float left, float top, float right, float bottom,		void SkiaCanvas::drawArc(float left, float top, float right, float bottom,
	float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) {		float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) {
			if (CC_UNLIKELY(PaintUtils::paintWillNotDraw(paint))) return;
	SkRect arc = SkRect::MakeLTRB(left, top, right, bottom);		SkRect arc = SkRect::MakeLTRB(left, top, right, bottom);
	mCanvas->drawArc(arc, startAngle, sweepAngle, useCenter, paint);		mCanvas->drawArc(arc, startAngle, sweepAngle, useCenter, paint);
	}		}

	void SkiaCanvas::drawPath(const SkPath& path, const SkPaint& paint) {		void SkiaCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
			if (CC_UNLIKELY(PaintUtils::paintWillNotDraw(paint))) return;
	SkRect rect;		SkRect rect;
	SkRRect roundRect;		SkRRect roundRect;
	if (path.isOval(&rect)) {		if (path.isOval(&rect)) {
	@@ -603,25 +661,113 @@ void SkiaCanvas::drawBitmapMesh(Bitmap& hwuiBitmap, int meshWidth, int meshHeigh
	if (paint) {		if (paint) {
	tmpPaint = *paint;		tmpPaint = *paint;
	}		}
	sk_sp<SkShader> shader = SkMakeBitmapShader(bitmap,
	SkShader::kClamp_TileMode,		sk_sp<SkImage> image = SkMakeImageFromRasterBitmap(bitmap, kNever_SkCopyPixelsMode);
	SkShader::kClamp_TileMode,		tmpPaint.setShader(image->makeShader(SkShader::kClamp_TileMode, SkShader::kClamp_TileMode));
	nullptr,
	kNever_SkCopyPixelsMode,
	nullptr);
	tmpPaint.setShader(std::move(shader));

	mCanvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, (SkPoint*)vertices,		mCanvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, (SkPoint*)vertices,
	texs, (const SkColor*)colors, NULL, indices,		texs, (const SkColor*)colors, NULL, indices,
	indexCount, tmpPaint);		indexCount, tmpPaint);
	}		}

			static inline void set_lattice_divs(SkCanvas::Lattice* lattice, const Res_png_9patch& chunk,
			int width, int height) {
			lattice->fXCount = chunk.numXDivs;
			lattice->fYCount = chunk.numYDivs;
			lattice->fXDivs = chunk.getXDivs();
			lattice->fYDivs = chunk.getYDivs();

			// We'll often see ninepatches where the last div is equal to the width or height.
			// This doesn't provide any additional information and is not supported by Skia.
			if (lattice->fXCount > 0 && width == lattice->fXDivs[lattice->fXCount - 1]) {
			lattice->fXCount--;
			}
			if (lattice->fYCount > 0 && height == lattice->fYDivs[lattice->fYCount - 1]) {
			lattice->fYCount--;
			}
			}

			static inline int num_distinct_rects(const SkCanvas::Lattice& lattice) {
			int xRects;
			if (lattice.fXCount > 0) {
			xRects = (0 == lattice.fXDivs[0]) ? lattice.fXCount : lattice.fXCount + 1;
			} else {
			xRects = 1;
			}

			int yRects;
			if (lattice.fYCount > 0) {
			yRects = (0 == lattice.fYDivs[0]) ? lattice.fYCount : lattice.fYCount + 1;
			} else {
			yRects = 1;
			}
			return xRects * yRects;
			}

			static inline void set_lattice_flags(SkCanvas::Lattice* lattice, SkCanvas::Lattice::Flags* flags,
			int numFlags, const Res_png_9patch& chunk) {
			lattice->fFlags = flags;
			sk_bzero(flags, numFlags * sizeof(SkCanvas::Lattice::Flags));

			bool needPadRow = lattice->fYCount > 0 && 0 == lattice->fYDivs[0];
			bool needPadCol = lattice->fXCount > 0 && 0 == lattice->fXDivs[0];

			int yCount = lattice->fYCount;
			if (needPadRow) {
			// Skip flags for the degenerate first row of rects.
			flags += lattice->fXCount + 1;
			yCount--;
			}

			int i = 0;
			bool setFlags = false;
			for (int y = 0; y < yCount + 1; y++) {
			for (int x = 0; x < lattice->fXCount + 1; x++) {
			if (0 == x && needPadCol) {
			// First rect of each column is degenerate, skip the flag.
			flags++;
			continue;
			}

			if (0 == chunk.getColors()[i++]) {
			*flags = SkCanvas::Lattice::kTransparent_Flags;
			setFlags = true;
			}

			flags++;
			}
			}

			if (!setFlags) {
			lattice->fFlags = nullptr;
			}
			}

	void SkiaCanvas::drawNinePatch(Bitmap& hwuiBitmap, const Res_png_9patch& chunk,		void SkiaCanvas::drawNinePatch(Bitmap& hwuiBitmap, const Res_png_9patch& chunk,
	float dstLeft, float dstTop, float dstRight, float dstBottom, const SkPaint* paint) {		float dstLeft, float dstTop, float dstRight, float dstBottom, const SkPaint* paint) {

	SkBitmap bitmap;		SkBitmap bitmap;
	hwuiBitmap.getSkBitmap(&bitmap);		hwuiBitmap.getSkBitmap(&bitmap);
	SkRect bounds = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom);
	NinePatch::Draw(mCanvas.get(), bounds, bitmap, chunk, paint, nullptr);		SkCanvas::Lattice lattice;
			set_lattice_divs(&lattice, chunk, bitmap.width(), bitmap.height());

			lattice.fFlags = nullptr;
			int numFlags = 0;
			if (chunk.numColors > 0 && chunk.numColors == num_distinct_rects(lattice)) {
			// We can expect the framework to give us a color for every distinct rect.
			// Skia requires a flag for every rect.
			numFlags = (lattice.fXCount + 1) * (lattice.fYCount + 1);
			}

			SkAutoSTMalloc<25, SkCanvas::Lattice::Flags> flags(numFlags);
			if (numFlags > 0) {
			set_lattice_flags(&lattice, flags.get(), numFlags, chunk);
			}

			lattice.fBounds = nullptr;
			SkRect dst = SkRect::MakeLTRB(dstLeft, dstTop, dstRight, dstBottom);
			mCanvas->drawBitmapLattice(bitmap, lattice, dst, paint);
	}		}

	void SkiaCanvas::drawVectorDrawable(VectorDrawableRoot* vectorDrawable) {		void SkiaCanvas::drawVectorDrawable(VectorDrawableRoot* vectorDrawable) {
	@@ -636,9 +782,26 @@ void SkiaCanvas::drawGlyphs(const uint16_t* text, const float* positions, int co
	const SkPaint& paint, float x, float y,		const SkPaint& paint, float x, float y,
	float boundsLeft, float boundsTop, float boundsRight, float boundsBottom,		float boundsLeft, float boundsTop, float boundsRight, float boundsBottom,
	float totalAdvance) {		float totalAdvance) {
	static_assert(sizeof(SkPoint) == sizeof(float)*2, "SkPoint is no longer two floats");		if (!text \|\| !positions \|\| count <= 0 \|\| PaintUtils::paintWillNotDrawText(paint)) return;
	mCanvas->drawPosText(text, count << 1, reinterpret_cast<const SkPoint*>(positions), paint);		// Set align to left for drawing, as we don't want individual
	drawTextDecorations(x, y, totalAdvance, paint);		// glyphs centered or right-aligned; the offset above takes
			// care of all alignment.
			SkPaint paintCopy(paint);
			paintCopy.setTextAlign(SkPaint::kLeft_Align);

			SkRect bounds = SkRect::MakeLTRB(boundsLeft + x, boundsTop + y,
			boundsRight + x, boundsBottom + y);

			SkTextBlobBuilder builder;
			const SkTextBlobBuilder::RunBuffer& buffer = builder.allocRunPos(paintCopy, count, &bounds);
			// TODO: we could reduce the number of memcpy's if the this were exposed further up
			// in the architecture.
			memcpy(buffer.glyphs, text, count * sizeof(uint16_t));
			memcpy(buffer.pos, positions, (count << 1) * sizeof(float));

			sk_sp<SkTextBlob> textBlob(builder.make());
			mCanvas->drawTextBlob(textBlob, 0, 0, paintCopy);
			drawTextDecorations(x, y, totalAdvance, paintCopy);
	}		}

	void SkiaCanvas::drawLayoutOnPath(const minikin::Layout& layout, float hOffset, float vOffset,		void SkiaCanvas::drawLayoutOnPath(const minikin::Layout& layout, float hOffset, float vOffset,
	@@ -743,7 +906,7 @@ void SkiaCanvas::drawCircle(uirenderer::CanvasPropertyPrimitive* x, uirenderer::
	// Canvas draw operations: View System		// Canvas draw operations: View System
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	void SkiaCanvas::drawLayer(uirenderer::DeferredLayerUpdater* layer) {		void SkiaCanvas::drawLayer(uirenderer::DeferredLayerUpdater* layerUpdater) {
	LOG_ALWAYS_FATAL("SkiaCanvas can't directly draw Layers");		LOG_ALWAYS_FATAL("SkiaCanvas can't directly draw Layers");
	}		}

libs/hwui/SkiaCanvas.h

+13 −10

Original line number	Original line	Diff line number	Diff line
	@@ -22,8 +22,7 @@
	#include "VectorDrawable.h"		#include "VectorDrawable.h"

	#include <SkCanvas.h>		#include <SkCanvas.h>
	#include <SkClipStack.h>		#include <SkTLazy.h>
	#include <SkTArray.h>

	namespace android {		namespace android {

	@@ -39,10 +38,7 @@ public:
	* not be NULL. This constructor will ref() the SkCanvas, and unref()		* not be NULL. This constructor will ref() the SkCanvas, and unref()
	* it in its destructor.		* it in its destructor.
	*/		*/
	explicit SkiaCanvas(SkCanvas* canvas) : mCanvas(canvas) {		explicit SkiaCanvas(SkCanvas* canvas);
	SkASSERT(canvas);
	canvas->ref();
	}

	virtual SkCanvas* asSkCanvas() override {		virtual SkCanvas* asSkCanvas() override {
	return mCanvas.get();		return mCanvas.get();
	@@ -152,7 +148,7 @@ public:
	uirenderer::GlFunctorLifecycleListener* listener) override;		uirenderer::GlFunctorLifecycleListener* listener) override;

	protected:		protected:
	explicit SkiaCanvas() {}		SkiaCanvas();
	void reset(SkCanvas* skiaCanvas);		void reset(SkCanvas* skiaCanvas);
	void drawDrawable(SkDrawable* drawable) { mCanvas->drawDrawable(drawable); }		void drawDrawable(SkDrawable* drawable) { mCanvas->drawDrawable(drawable); }

	@@ -167,19 +163,26 @@ private:
	struct SaveRec {		struct SaveRec {
	int saveCount;		int saveCount;
	SaveFlags::Flags saveFlags;		SaveFlags::Flags saveFlags;
			size_t clipIndex;
	};		};

	bool mHighContrastText = false;		bool mHighContrastText = false;

			const SaveRec* currentSaveRec() const;
	void recordPartialSave(SaveFlags::Flags flags);		void recordPartialSave(SaveFlags::Flags flags);
	void saveClipsForFrame(SkTArray<SkClipStack::Element>& clips, int frameSaveCount);
	void applyClips(const SkTArray<SkClipStack::Element>& clips);		template<typename T>
			void recordClip(const T&, SkRegion::Op);
			void applyPersistentClips(size_t clipStartIndex);

	void drawPoints(const float* points, int count, const SkPaint& paint,		void drawPoints(const float* points, int count, const SkPaint& paint,
	SkCanvas::PointMode mode);		SkCanvas::PointMode mode);

			class Clip;

	sk_sp<SkCanvas> mCanvas;		sk_sp<SkCanvas> mCanvas;
	std::unique_ptr<SkDeque> mSaveStack; // lazily allocated, tracks partial saves.		std::unique_ptr<SkDeque> mSaveStack; // lazily allocated, tracks partial saves.
			std::vector<Clip> mClipStack; // tracks persistent clips.
	};		};

	} // namespace android		} // namespace android