Remove SkiaCanvasProxy (aee140c8) · Commits · e / os / android_frameworks_base

libs/hwui/Android.bp

+0 −1

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

libs/hwui/SkiaCanvasProxy.cpp

deleted100644 → 0

+0 −486

Original line number	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	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	Diff line number	Diff line
		@@ -74,7 +74,6 @@ typedef uint32_t Flags;
		} // namespace SaveFlags

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

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

		}; // namespace android