Merge "Remove SkiaCanvasProxy" (64b600b5) · Commits · e / os / android_frameworks_base

libs/hwui/Android.bp

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -230,7 +230,6 @@ cc_defaults {
	"RenderProperties.cpp",		"RenderProperties.cpp",
	"ResourceCache.cpp",		"ResourceCache.cpp",
	"SkiaCanvas.cpp",		"SkiaCanvas.cpp",
	"SkiaCanvasProxy.cpp",
	"Snapshot.cpp",		"Snapshot.cpp",
	"Texture.cpp",		"Texture.cpp",
	"VectorDrawable.cpp",		"VectorDrawable.cpp",

libs/hwui/SkiaCanvasProxy.cpp

deleted100644 → 0

+0 −486

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "SkiaCanvasProxy.h"

	#include <memory>

	#include <log/log.h>

	#include <SkLatticeIter.h>
	#include <SkPaint.h>
	#include <SkPatchUtils.h>
	#include <SkPath.h>
	#include <SkPixelRef.h>
	#include <SkRRect.h>
	#include <SkRSXform.h>
	#include <SkRect.h>
	#include <SkSurface.h>
	#include <SkTextBlobRunIterator.h>
	#include <SkVertices.h>
	#include "hwui/Bitmap.h"

	namespace android {
	namespace uirenderer {

	SkiaCanvasProxy::SkiaCanvasProxy(Canvas* canvas, bool filterHwuiCalls)
	: INHERITED(canvas->width(), canvas->height())
	, mCanvas(canvas)
	, mFilterHwuiCalls(filterHwuiCalls) {}

	void SkiaCanvasProxy::onDrawPaint(const SkPaint& paint) {
	mCanvas->drawPaint(paint);
	}

	void SkiaCanvasProxy::onDrawPoints(PointMode pointMode, size_t count, const SkPoint pts[],
	const SkPaint& paint) {
	if (!pts \|\| count == 0) {
	return;
	}

	// convert the SkPoints into floats
	static_assert(sizeof(SkPoint) == sizeof(float) * 2, "SkPoint is no longer two floats");
	const size_t floatCount = count << 1;
	const float* floatArray = &pts[0].fX;

	switch (pointMode) {
	case kPoints_PointMode: {
	mCanvas->drawPoints(floatArray, floatCount, paint);
	break;
	}
	case kLines_PointMode: {
	mCanvas->drawLines(floatArray, floatCount, paint);
	break;
	}
	case kPolygon_PointMode: {
	SkPaint strokedPaint(paint);
	strokedPaint.setStyle(SkPaint::kStroke_Style);

	SkPath path;
	for (size_t i = 0; i < count - 1; i++) {
	path.moveTo(pts[i]);
	path.lineTo(pts[i + 1]);
	this->drawPath(path, strokedPaint);
	path.rewind();
	}
	break;
	}
	default:
	LOG_ALWAYS_FATAL("Unknown point type");
	}
	}

	void SkiaCanvasProxy::onDrawOval(const SkRect& rect, const SkPaint& paint) {
	mCanvas->drawOval(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, paint);
	}

	void SkiaCanvasProxy::onDrawRect(const SkRect& rect, const SkPaint& paint) {
	mCanvas->drawRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, paint);
	}

	void SkiaCanvasProxy::onDrawRRect(const SkRRect& roundRect, const SkPaint& paint) {
	if (!roundRect.isComplex()) {
	const SkRect& rect = roundRect.rect();
	SkVector radii = roundRect.getSimpleRadii();
	mCanvas->drawRoundRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, radii.fX, radii.fY,
	paint);
	} else {
	SkPath path;
	path.addRRect(roundRect);
	mCanvas->drawPath(path, paint);
	}
	}

	void SkiaCanvasProxy::onDrawArc(const SkRect& rect, SkScalar startAngle, SkScalar sweepAngle,
	bool useCenter, const SkPaint& paint) {
	mCanvas->drawArc(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, startAngle, sweepAngle,
	useCenter, paint);
	}

	void SkiaCanvasProxy::onDrawPath(const SkPath& path, const SkPaint& paint) {
	mCanvas->drawPath(path, paint);
	}

	void SkiaCanvasProxy::onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
	const SkPaint* paint) {
	sk_sp<Bitmap> hwuiBitmap = Bitmap::createFrom(bitmap.info(), *bitmap.pixelRef());
	// HWUI doesn't support extractSubset(), so convert any subsetted bitmap into
	// a drawBitmapRect(); pass through an un-subsetted bitmap.
	if (hwuiBitmap && bitmap.dimensions() != hwuiBitmap->info().dimensions()) {
	SkIPoint origin = bitmap.pixelRefOrigin();
	mCanvas->drawBitmap(
	*hwuiBitmap, origin.fX, origin.fY, origin.fX + bitmap.dimensions().width(),
	origin.fY + bitmap.dimensions().height(), left, top,
	left + bitmap.dimensions().width(), top + bitmap.dimensions().height(), paint);
	} else {
	mCanvas->drawBitmap(*hwuiBitmap, left, top, paint);
	}
	}

	void SkiaCanvasProxy::onDrawBitmapRect(const SkBitmap& skBitmap, const SkRect* srcPtr,
	const SkRect& dst, const SkPaint* paint, SrcRectConstraint) {
	SkRect src = (srcPtr) ? *srcPtr : SkRect::MakeWH(skBitmap.width(), skBitmap.height());
	// TODO: if bitmap is a subset, do we need to add pixelRefOrigin to src?
	Bitmap* bitmap = reinterpret_cast<Bitmap*>(skBitmap.pixelRef());
	mCanvas->drawBitmap(*bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom, dst.fLeft, dst.fTop,
	dst.fRight, dst.fBottom, paint);
	}

	void SkiaCanvasProxy::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
	const SkRect& dst, const SkPaint*) {
	// TODO make nine-patch drawing a method on Canvas.h
	SkDEBUGFAIL("SkiaCanvasProxy::onDrawBitmapNine is not yet supported");
	}

	void SkiaCanvasProxy::onDrawImage(const SkImage* image, SkScalar left, SkScalar top,
	const SkPaint* paint) {
	SkBitmap skiaBitmap;
	SkPixmap pixmap;
	if (image->peekPixels(&pixmap) && skiaBitmap.installPixels(pixmap)) {
	onDrawBitmap(skiaBitmap, left, top, paint);
	}
	}

	void SkiaCanvasProxy::onDrawImageRect(const SkImage* image, const SkRect* srcPtr, const SkRect& dst,
	const SkPaint* paint, SrcRectConstraint constraint) {
	SkBitmap skiaBitmap;
	SkPixmap pixmap;
	if (image->peekPixels(&pixmap) && skiaBitmap.installPixels(pixmap)) {
	sk_sp<Bitmap> bitmap = Bitmap::createFrom(skiaBitmap.info(), *skiaBitmap.pixelRef());
	SkRect src = (srcPtr) ? *srcPtr : SkRect::MakeWH(image->width(), image->height());
	mCanvas->drawBitmap(*bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom, dst.fLeft,
	dst.fTop, dst.fRight, dst.fBottom, paint);
	}
	}

	void SkiaCanvasProxy::onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
	const SkPaint*) {
	SkDEBUGFAIL("SkiaCanvasProxy::onDrawImageNine is not yet supported");
	}

	void SkiaCanvasProxy::onDrawImageLattice(const SkImage* image, const Lattice& lattice,
	const SkRect& dst, const SkPaint* paint) {
	SkLatticeIter iter(lattice, dst);
	SkRect srcR, dstR;
	while (iter.next(&srcR, &dstR)) {
	onDrawImageRect(image, &srcR, dstR, paint, SkCanvas::kFast_SrcRectConstraint);
	}
	}

	void SkiaCanvasProxy::onDrawVerticesObject(const SkVertices* vertices, SkBlendMode bmode,
	const SkPaint& paint) {
	if (mFilterHwuiCalls) {
	return;
	}
	mCanvas->drawVertices(vertices, bmode, paint);
	}

	sk_sp<SkSurface> SkiaCanvasProxy::onNewSurface(const SkImageInfo&, const SkSurfaceProps&) {
	SkDEBUGFAIL("SkiaCanvasProxy::onNewSurface is not supported");
	return NULL;
	}

	void SkiaCanvasProxy::willSave() {
	mCanvas->save(android::SaveFlags::MatrixClip);
	}

	static inline SaveFlags::Flags saveFlags(SkCanvas::SaveLayerFlags layerFlags) {
	SaveFlags::Flags saveFlags = 0;

	if (!(layerFlags & SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag)) {
	saveFlags \|= SaveFlags::ClipToLayer;
	}

	return saveFlags;
	}

	SkCanvas::SaveLayerStrategy SkiaCanvasProxy::getSaveLayerStrategy(
	const SaveLayerRec& saveLayerRec) {
	SkRect rect;
	if (saveLayerRec.fBounds) {
	rect = *saveLayerRec.fBounds;
	} else if (!mCanvas->getClipBounds(&rect)) {
	rect = SkRect::MakeEmpty();
	}
	mCanvas->saveLayer(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, saveLayerRec.fPaint,
	saveFlags(saveLayerRec.fSaveLayerFlags));
	return SkCanvas::kNoLayer_SaveLayerStrategy;
	}

	void SkiaCanvasProxy::willRestore() {
	mCanvas->restore();
	}

	void SkiaCanvasProxy::didConcat(const SkMatrix& matrix) {
	mCanvas->concat(matrix);
	}

	void SkiaCanvasProxy::didSetMatrix(const SkMatrix& matrix) {
	mCanvas->setMatrix(matrix);
	}

	void SkiaCanvasProxy::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
	const SkPaint& paint) {
	SkPath path;
	path.addRRect(outer);
	path.addRRect(inner);
	path.setFillType(SkPath::kEvenOdd_FillType);
	this->drawPath(path, paint);
	}

	/**
	* Utility class that converts the incoming text & paint from the given encoding
	* into glyphIDs.
	*/
	class GlyphIDConverter {
	public:
	GlyphIDConverter(const void* text, size_t byteLength, const SkPaint& origPaint) {
	paint = origPaint;
	if (paint.getTextEncoding() == SkPaint::kGlyphID_TextEncoding) {
	glyphIDs = (uint16_t*)text;
	count = byteLength >> 1;
	} else {
	// ensure space for one glyph per ID given UTF8 encoding.
	storage.reset(new uint16_t[byteLength]);
	glyphIDs = storage.get();
	count = paint.textToGlyphs(text, byteLength, storage.get());
	paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
	}
	}

	SkPaint paint;
	uint16_t* glyphIDs;
	int count;

	private:
	std::unique_ptr<uint16_t[]> storage;
	};

	void SkiaCanvasProxy::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
	const SkPaint& origPaint) {
	// convert to glyphIDs if necessary
	GlyphIDConverter glyphs(text, byteLength, origPaint);

	// compute the glyph positions
	std::unique_ptr<SkScalar[]> glyphWidths(new SkScalar[glyphs.count]);
	glyphs.paint.getTextWidths(glyphs.glyphIDs, glyphs.count << 1, glyphWidths.get());

	// compute conservative bounds
	// NOTE: We could call the faster paint.getFontBounds for a less accurate,
	// but even more conservative bounds if this is too slow.
	SkRect bounds;
	glyphs.paint.measureText(glyphs.glyphIDs, glyphs.count << 1, &bounds);

	// adjust for non-left alignment
	if (glyphs.paint.getTextAlign() != SkPaint::kLeft_Align) {
	SkScalar stop = 0;
	for (int i = 0; i < glyphs.count; i++) {
	stop += glyphWidths[i];
	}
	if (glyphs.paint.getTextAlign() == SkPaint::kCenter_Align) {
	stop = SkScalarHalf(stop);
	}
	if (glyphs.paint.isVerticalText()) {
	y -= stop;
	} else {
	x -= stop;
	}
	}

	// setup the first glyph position and adjust bounds if needed
	int xBaseline = 0;
	int yBaseline = 0;
	if (mCanvas->drawTextAbsolutePos()) {
	bounds.offset(x, y);
	xBaseline = x;
	yBaseline = y;
	}

	static_assert(sizeof(SkPoint) == sizeof(float) * 2, "SkPoint is no longer two floats");
	auto glyphFunc = [&](uint16_t* text, float* positions) {
	memcpy(text, glyphs.glyphIDs, glyphs.count * sizeof(uint16_t));
	size_t posIndex = 0;
	// setup the first glyph position
	positions[posIndex++] = xBaseline;
	positions[posIndex++] = yBaseline;
	// setup the remaining glyph positions
	if (glyphs.paint.isVerticalText()) {
	float yPosition = yBaseline;
	for (int i = 1; i < glyphs.count; i++) {
	positions[posIndex++] = xBaseline;
	yPosition += glyphWidths[i - 1];
	positions[posIndex++] = yPosition;
	}
	} else {
	float xPosition = xBaseline;
	for (int i = 1; i < glyphs.count; i++) {
	xPosition += glyphWidths[i - 1];
	positions[posIndex++] = xPosition;
	positions[posIndex++] = yBaseline;
	}
	}
	};
	mCanvas->drawGlyphs(glyphFunc, glyphs.count, glyphs.paint, x, y, bounds.fLeft, bounds.fTop,
	bounds.fRight, bounds.fBottom, 0);
	}

	void SkiaCanvasProxy::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
	const SkPaint& origPaint) {
	// convert to glyphIDs if necessary
	GlyphIDConverter glyphs(text, byteLength, origPaint);

	// convert to relative positions if necessary
	int x, y;
	if (mCanvas->drawTextAbsolutePos()) {
	x = 0;
	y = 0;
	} else {
	x = pos[0].fX;
	y = pos[0].fY;
	}

	// Compute conservative bounds. If the content has already been processed
	// by Minikin then it had already computed these bounds. Unfortunately,
	// there is no way to capture those bounds as part of the Skia drawPosText
	// API so we need to do that computation again here.
	SkRect bounds = SkRect::MakeEmpty();
	for (int i = 0; i < glyphs.count; i++) {
	SkRect glyphBounds = SkRect::MakeEmpty();
	glyphs.paint.measureText(&glyphs.glyphIDs[i], sizeof(uint16_t), &glyphBounds);
	glyphBounds.offset(pos[i].fX, pos[i].fY);
	bounds.join(glyphBounds);
	}

	static_assert(sizeof(SkPoint) == sizeof(float) * 2, "SkPoint is no longer two floats");
	auto glyphFunc = [&](uint16_t* text, float* positions) {
	memcpy(text, glyphs.glyphIDs, glyphs.count * sizeof(uint16_t));
	if (mCanvas->drawTextAbsolutePos()) {
	memcpy(positions, pos, 2 * glyphs.count * sizeof(float));
	} else {
	for (int i = 0, posIndex = 0; i < glyphs.count; i++) {
	positions[posIndex++] = pos[i].fX - x;
	positions[posIndex++] = pos[i].fY - y;
	}
	}
	};
	mCanvas->drawGlyphs(glyphFunc, glyphs.count, glyphs.paint, x, y, bounds.fLeft, bounds.fTop,
	bounds.fRight, bounds.fBottom, 0);
	}

	void SkiaCanvasProxy::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
	SkScalar constY, const SkPaint& paint) {
	const size_t pointCount = byteLength >> 1;
	std::unique_ptr<SkPoint[]> pts(new SkPoint[pointCount]);
	for (size_t i = 0; i < pointCount; i++) {
	pts[i].set(xpos[i], constY);
	}
	this->onDrawPosText(text, byteLength, pts.get(), paint);
	}

	void SkiaCanvasProxy::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
	const SkMatrix* matrix, const SkPaint& origPaint) {
	SkDEBUGFAIL("SkiaCanvasProxy::onDrawTextOnPath is not supported");
	}

	void SkiaCanvasProxy::onDrawTextRSXform(const void* text, size_t byteLength,
	const SkRSXform xform[], const SkRect* cullRect,
	const SkPaint& paint) {
	GlyphIDConverter glyphs(text, byteLength, paint); // Just get count
	SkMatrix localM, currM, origM;
	mCanvas->getMatrix(&currM);
	origM = currM;
	for (int i = 0; i < glyphs.count; i++) {
	localM.setRSXform(*xform++);
	currM.setConcat(origM, localM);
	mCanvas->setMatrix(currM);
	this->onDrawText((char)text + (byteLength / glyphs.count i), byteLength / glyphs.count,
	0, 0, paint);
	}
	mCanvas->setMatrix(origM);
	}

	void SkiaCanvasProxy::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
	const SkPaint& paint) {
	SkPaint runPaint = paint;

	SkTextBlobRunIterator it(blob);
	for (; !it.done(); it.next()) {
	size_t textLen = it.glyphCount() * sizeof(uint16_t);
	const SkPoint& offset = it.offset();
	// applyFontToPaint() always overwrites the exact same attributes,
	// so it is safe to not re-seed the paint for this reason.
	it.applyFontToPaint(&runPaint);

	switch (it.positioning()) {
	case SkTextBlob::kDefault_Positioning:
	this->drawText(it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint);
	break;
	case SkTextBlob::kHorizontal_Positioning: {
	std::unique_ptr<SkPoint[]> pts(new SkPoint[it.glyphCount()]);
	for (size_t i = 0; i < it.glyphCount(); i++) {
	pts[i].set(x + offset.x() + it.pos()[i], y + offset.y());
	}
	this->drawPosText(it.glyphs(), textLen, pts.get(), runPaint);
	break;
	}
	case SkTextBlob::kFull_Positioning: {
	std::unique_ptr<SkPoint[]> pts(new SkPoint[it.glyphCount()]);
	for (size_t i = 0; i < it.glyphCount(); i++) {
	const size_t xIndex = i * 2;
	const size_t yIndex = xIndex + 1;
	pts[i].set(x + offset.x() + it.pos()[xIndex],
	y + offset.y() + it.pos()[yIndex]);
	}
	this->drawPosText(it.glyphs(), textLen, pts.get(), runPaint);
	break;
	}
	default:
	SK_ABORT("unhandled positioning mode");
	}
	}
	}

	void SkiaCanvasProxy::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
	const SkPoint texCoords[4], SkBlendMode bmode,
	const SkPaint& paint) {
	if (mFilterHwuiCalls) {
	return;
	}
	SkMatrix matrix;
	mCanvas->getMatrix(&matrix);
	SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, &matrix);

	mCanvas->drawVertices(
	SkPatchUtils::MakeVertices(cubics, colors, texCoords, lod.width(), lod.height()).get(),
	bmode, paint);
	}

	void SkiaCanvasProxy::onClipRect(const SkRect& rect, SkClipOp op, ClipEdgeStyle) {
	mCanvas->clipRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, op);
	}

	void SkiaCanvasProxy::onClipRRect(const SkRRect& roundRect, SkClipOp op, ClipEdgeStyle) {
	SkPath path;
	path.addRRect(roundRect);
	mCanvas->clipPath(&path, op);
	}

	void SkiaCanvasProxy::onClipPath(const SkPath& path, SkClipOp op, ClipEdgeStyle) {
	mCanvas->clipPath(&path, op);
	}

	}; // namespace uirenderer
	}; // namespace android

libs/hwui/SkiaCanvasProxy.h

deleted100644 → 0

+0 −112

Original line number	Original line	Diff line number	Diff line
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#ifndef SkiaCanvasProxy_DEFINED
	#define SkiaCanvasProxy_DEFINED

	#include <SkCanvas.h>
	#include <cutils/compiler.h>

	#include "hwui/Canvas.h"

	namespace android {
	namespace uirenderer {

	/**
	* This class serves as a proxy between Skia's SkCanvas and Android Framework's
	* Canvas. The class does not maintain any draw-related state and will pass
	* through most requests directly to the Canvas provided in the constructor.
	*
	* Upon construction it is expected that the provided Canvas has already been
	* prepared for recording and will continue to be in the recording state while
	* this proxy class is being used.
	*
	* If filterHwuiCalls is true, the proxy silently ignores away draw calls that
	* aren't supported by HWUI.
	*/
	class ANDROID_API SkiaCanvasProxy : public SkCanvas {
	public:
	explicit SkiaCanvasProxy(Canvas* canvas, bool filterHwuiCalls = false);
	virtual ~SkiaCanvasProxy() {}

	protected:
	virtual sk_sp<SkSurface> onNewSurface(const SkImageInfo&, const SkSurfaceProps&) override;

	virtual void willSave() override;
	virtual SaveLayerStrategy getSaveLayerStrategy(const SaveLayerRec&) override;
	virtual void willRestore() override;

	virtual void didConcat(const SkMatrix&) override;
	virtual void didSetMatrix(const SkMatrix&) override;

	virtual void onDrawPaint(const SkPaint& paint) override;
	virtual void onDrawPoints(PointMode, size_t count, const SkPoint pts[],
	const SkPaint&) override;
	virtual void onDrawOval(const SkRect&, const SkPaint&) override;
	virtual void onDrawRect(const SkRect&, const SkPaint&) override;
	virtual void onDrawRRect(const SkRRect&, const SkPaint&) override;
	virtual void onDrawPath(const SkPath& path, const SkPaint&) override;
	virtual void onDrawArc(const SkRect&, SkScalar startAngle, SkScalar sweepAngle, bool useCenter,
	const SkPaint&) override;
	virtual void onDrawBitmap(const SkBitmap&, SkScalar left, SkScalar top,
	const SkPaint*) override;
	virtual void onDrawBitmapRect(const SkBitmap&, const SkRect* src, const SkRect& dst,
	const SkPaint* paint, SrcRectConstraint) override;
	virtual void onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center, const SkRect& dst,
	const SkPaint*) override;
	virtual void onDrawImage(const SkImage, SkScalar dx, SkScalar dy, const SkPaint);
	virtual void onDrawImageRect(const SkImage, const SkRect, const SkRect&, const SkPaint*,
	SrcRectConstraint);
	virtual void onDrawImageNine(const SkImage*, const SkIRect& center, const SkRect& dst,
	const SkPaint*);
	virtual void onDrawImageLattice(const SkImage*, const Lattice& lattice, const SkRect& dst,
	const SkPaint*);
	virtual void onDrawVerticesObject(const SkVertices*, SkBlendMode, const SkPaint&) override;

	virtual void onDrawDRRect(const SkRRect&, const SkRRect&, const SkPaint&) override;

	virtual void onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
	const SkPaint&) override;
	virtual void onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
	const SkPaint&) override;
	virtual void onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
	SkScalar constY, const SkPaint&) override;
	virtual void onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
	const SkMatrix* matrix, const SkPaint&) override;
	virtual void onDrawTextRSXform(const void* text, size_t byteLength, const SkRSXform[],
	const SkRect* cullRect, const SkPaint& paint);
	virtual void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
	const SkPaint& paint) override;

	virtual void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
	const SkPoint texCoords[4], SkBlendMode,
	const SkPaint& paint) override;

	virtual void onClipRect(const SkRect&, SkClipOp, ClipEdgeStyle) override;
	virtual void onClipRRect(const SkRRect&, SkClipOp, ClipEdgeStyle) override;
	virtual void onClipPath(const SkPath&, SkClipOp, ClipEdgeStyle) override;

	private:
	Canvas* mCanvas;
	bool mFilterHwuiCalls;

	typedef SkCanvas INHERITED;
	};

	}; // namespace uirenderer
	}; // namespace android

	#endif // SkiaCanvasProxy_DEFINED

libs/hwui/hwui/Canvas.h

+0 −2

Original line number	Original line	Diff line number	Diff line
	@@ -74,7 +74,6 @@ typedef uint32_t Flags;
	} // namespace SaveFlags		} // namespace SaveFlags

	namespace uirenderer {		namespace uirenderer {
	class SkiaCanvasProxy;
	namespace VectorDrawable {		namespace VectorDrawable {
	class Tree;		class Tree;
	};		};
	@@ -305,7 +304,6 @@ protected:

	friend class DrawTextFunctor;		friend class DrawTextFunctor;
	friend class DrawTextOnPathFunctor;		friend class DrawTextOnPathFunctor;
	friend class uirenderer::SkiaCanvasProxy;
	};		};

	}; // namespace android		}; // namespace android