Merge "Removing SkiaColorFilter and inspecting the native object directly." (eef1be1d) · Commits · e / os / android_frameworks_base

core/java/android/view/GLES20Canvas.java

+22 −80

Original line number	Original line	Diff line number	Diff line
	@@ -46,7 +46,6 @@ class GLES20Canvas extends HardwareCanvas {
	private static final int MODIFIER_NONE = 0;		private static final int MODIFIER_NONE = 0;
	private static final int MODIFIER_SHADOW = 1;		private static final int MODIFIER_SHADOW = 1;
	private static final int MODIFIER_SHADER = 2;		private static final int MODIFIER_SHADER = 2;
	private static final int MODIFIER_COLOR_FILTER = 4;

	private final boolean mOpaque;		private final boolean mOpaque;
	private long mRenderer;		private long mRenderer;
	@@ -627,15 +626,8 @@ class GLES20Canvas extends HardwareCanvas {
	return saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, paint, saveFlags);		return saveLayer(bounds.left, bounds.top, bounds.right, bounds.bottom, paint, saveFlags);
	}		}

	int count;
	int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
	try {
	final long nativePaint = paint == null ? 0 : paint.mNativePaint;		final long nativePaint = paint == null ? 0 : paint.mNativePaint;
	count = nSaveLayer(mRenderer, nativePaint, saveFlags);		return nSaveLayer(mRenderer, nativePaint, saveFlags);
	} finally {
	if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
	}
	return count;
	}		}

	private static native int nSaveLayer(long renderer, long paint, int saveFlags);		private static native int nSaveLayer(long renderer, long paint, int saveFlags);
	@@ -644,15 +636,8 @@ class GLES20Canvas extends HardwareCanvas {
	public int saveLayer(float left, float top, float right, float bottom, Paint paint,		public int saveLayer(float left, float top, float right, float bottom, Paint paint,
	int saveFlags) {		int saveFlags) {
	if (left < right && top < bottom) {		if (left < right && top < bottom) {
	int count;
	int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
	try {
	final long nativePaint = paint == null ? 0 : paint.mNativePaint;		final long nativePaint = paint == null ? 0 : paint.mNativePaint;
	count = nSaveLayer(mRenderer, left, top, right, bottom, nativePaint, saveFlags);		return nSaveLayer(mRenderer, left, top, right, bottom, nativePaint, saveFlags);
	} finally {
	if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
	}
	return count;
	}		}
	return save(saveFlags);		return save(saveFlags);
	}		}
	@@ -734,7 +719,7 @@ class GLES20Canvas extends HardwareCanvas {
	@Override		@Override
	public void drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter,		public void drawArc(RectF oval, float startAngle, float sweepAngle, boolean useCenter,
	Paint paint) {		Paint paint) {
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawArc(mRenderer, oval.left, oval.top, oval.right, oval.bottom,		nDrawArc(mRenderer, oval.left, oval.top, oval.right, oval.bottom,
	startAngle, sweepAngle, useCenter, paint.mNativePaint);		startAngle, sweepAngle, useCenter, paint.mNativePaint);
	@@ -757,14 +742,9 @@ class GLES20Canvas extends HardwareCanvas {
	Bitmap bitmap = patch.getBitmap();		Bitmap bitmap = patch.getBitmap();
	throwIfCannotDraw(bitmap);		throwIfCannotDraw(bitmap);
	// Shaders are ignored when drawing patches		// Shaders are ignored when drawing patches
	int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
	try {
	final long nativePaint = paint == null ? 0 : paint.mNativePaint;		final long nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,		nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,
	dst.left, dst.top, dst.right, dst.bottom, nativePaint);		dst.left, dst.top, dst.right, dst.bottom, nativePaint);
	} finally {
	if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
	}
	}		}

	@Override		@Override
	@@ -772,14 +752,9 @@ class GLES20Canvas extends HardwareCanvas {
	Bitmap bitmap = patch.getBitmap();		Bitmap bitmap = patch.getBitmap();
	throwIfCannotDraw(bitmap);		throwIfCannotDraw(bitmap);
	// Shaders are ignored when drawing patches		// Shaders are ignored when drawing patches
	int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
	try {
	final long nativePaint = paint == null ? 0 : paint.mNativePaint;		final long nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,		nDrawPatch(mRenderer, bitmap.mNativeBitmap, bitmap.mBuffer, patch.mNativeChunk,
	dst.left, dst.top, dst.right, dst.bottom, nativePaint);		dst.left, dst.top, dst.right, dst.bottom, nativePaint);
	} finally {
	if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
	}
	}		}

	private static native void nDrawPatch(long renderer, long bitmap, byte[] buffer, long chunk,		private static native void nDrawPatch(long renderer, long bitmap, byte[] buffer, long chunk,
	@@ -900,14 +875,9 @@ class GLES20Canvas extends HardwareCanvas {
	}		}

	// Shaders are ignored when drawing bitmaps		// Shaders are ignored when drawing bitmaps
	int modifier = paint != null ? setupColorFilter(paint) : MODIFIER_NONE;
	try {
	final long nativePaint = paint == null ? 0 : paint.mNativePaint;		final long nativePaint = paint == null ? 0 : paint.mNativePaint;
	nDrawBitmap(mRenderer, colors, offset, stride, x, y,		nDrawBitmap(mRenderer, colors, offset, stride, x, y,
	width, height, hasAlpha, nativePaint);		width, height, hasAlpha, nativePaint);
	} finally {
	if (modifier != MODIFIER_NONE) nResetModifiers(mRenderer, modifier);
	}
	}		}

	private static native void nDrawBitmap(long renderer, int[] colors, int offset, int stride,		private static native void nDrawBitmap(long renderer, int[] colors, int offset, int stride,
	@@ -955,7 +925,7 @@ class GLES20Canvas extends HardwareCanvas {

	@Override		@Override
	public void drawCircle(float cx, float cy, float radius, Paint paint) {		public void drawCircle(float cx, float cy, float radius, Paint paint) {
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawCircle(mRenderer, cx, cy, radius, paint.mNativePaint);		nDrawCircle(mRenderer, cx, cy, radius, paint.mNativePaint);
	} finally {		} finally {
	@@ -995,7 +965,7 @@ class GLES20Canvas extends HardwareCanvas {
	if ((offset \| count) < 0 \|\| offset + count > pts.length) {		if ((offset \| count) < 0 \|\| offset + count > pts.length) {
	throw new IllegalArgumentException("The lines array must contain 4 elements per line.");		throw new IllegalArgumentException("The lines array must contain 4 elements per line.");
	}		}
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawLines(mRenderer, pts, offset, count, paint.mNativePaint);		nDrawLines(mRenderer, pts, offset, count, paint.mNativePaint);
	} finally {		} finally {
	@@ -1013,7 +983,7 @@ class GLES20Canvas extends HardwareCanvas {

	@Override		@Override
	public void drawOval(RectF oval, Paint paint) {		public void drawOval(RectF oval, Paint paint) {
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawOval(mRenderer, oval.left, oval.top, oval.right, oval.bottom, paint.mNativePaint);		nDrawOval(mRenderer, oval.left, oval.top, oval.right, oval.bottom, paint.mNativePaint);
	} finally {		} finally {
	@@ -1033,7 +1003,7 @@ class GLES20Canvas extends HardwareCanvas {

	@Override		@Override
	public void drawPath(Path path, Paint paint) {		public void drawPath(Path path, Paint paint) {
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	if (path.isSimplePath) {		if (path.isSimplePath) {
	if (path.rects != null) {		if (path.rects != null) {
	@@ -1051,7 +1021,7 @@ class GLES20Canvas extends HardwareCanvas {
	private static native void nDrawRects(long renderer, long region, long paint);		private static native void nDrawRects(long renderer, long region, long paint);

	void drawRects(float[] rects, int count, Paint paint) {		void drawRects(float[] rects, int count, Paint paint) {
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawRects(mRenderer, rects, count, paint.mNativePaint);		nDrawRects(mRenderer, rects, count, paint.mNativePaint);
	} finally {		} finally {
	@@ -1118,7 +1088,7 @@ class GLES20Canvas extends HardwareCanvas {
	public void drawPoints(float[] pts, int offset, int count, Paint paint) {		public void drawPoints(float[] pts, int offset, int count, Paint paint) {
	if (count < 2) return;		if (count < 2) return;

	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawPoints(mRenderer, pts, offset, count, paint.mNativePaint);		nDrawPoints(mRenderer, pts, offset, count, paint.mNativePaint);
	} finally {		} finally {
	@@ -1168,7 +1138,7 @@ class GLES20Canvas extends HardwareCanvas {
	@Override		@Override
	public void drawRect(float left, float top, float right, float bottom, Paint paint) {		public void drawRect(float left, float top, float right, float bottom, Paint paint) {
	if (left == right \|\| top == bottom) return;		if (left == right \|\| top == bottom) return;
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawRect(mRenderer, left, top, right, bottom, paint.mNativePaint);		nDrawRect(mRenderer, left, top, right, bottom, paint.mNativePaint);
	} finally {		} finally {
	@@ -1196,7 +1166,7 @@ class GLES20Canvas extends HardwareCanvas {

	@Override		@Override
	public void drawRoundRect(RectF rect, float rx, float ry, Paint paint) {		public void drawRoundRect(RectF rect, float rx, float ry, Paint paint) {
	int modifiers = setupModifiers(paint, MODIFIER_COLOR_FILTER \| MODIFIER_SHADER);		int modifiers = setupModifiers(paint, MODIFIER_SHADER);
	try {		try {
	nDrawRoundRect(mRenderer, rect.left, rect.top, rect.right, rect.bottom,		nDrawRoundRect(mRenderer, rect.left, rect.top, rect.right, rect.bottom,
	rx, ry, paint.mNativePaint);		rx, ry, paint.mNativePaint);
	@@ -1376,12 +1346,6 @@ class GLES20Canvas extends HardwareCanvas {

	private int setupModifiers(Bitmap b, Paint paint) {		private int setupModifiers(Bitmap b, Paint paint) {
	if (b.getConfig() != Bitmap.Config.ALPHA_8) {		if (b.getConfig() != Bitmap.Config.ALPHA_8) {
	final ColorFilter filter = paint.getColorFilter();
	if (filter != null) {
	nSetupColorFilter(mRenderer, filter.nativeColorFilter);
	return MODIFIER_COLOR_FILTER;
	}

	return MODIFIER_NONE;		return MODIFIER_NONE;
	} else {		} else {
	return setupModifiers(paint);		return setupModifiers(paint);
	@@ -1403,12 +1367,6 @@ class GLES20Canvas extends HardwareCanvas {
	modifiers \|= MODIFIER_SHADER;		modifiers \|= MODIFIER_SHADER;
	}		}

	final ColorFilter filter = paint.getColorFilter();
	if (filter != null) {
	nSetupColorFilter(mRenderer, filter.nativeColorFilter);
	modifiers \|= MODIFIER_COLOR_FILTER;
	}

	return modifiers;		return modifiers;
	}		}

	@@ -1427,26 +1385,10 @@ class GLES20Canvas extends HardwareCanvas {
	modifiers \|= MODIFIER_SHADER;		modifiers \|= MODIFIER_SHADER;
	}		}

	final ColorFilter filter = paint.getColorFilter();
	if (filter != null && (flags & MODIFIER_COLOR_FILTER) != 0) {
	nSetupColorFilter(mRenderer, filter.nativeColorFilter);
	modifiers \|= MODIFIER_COLOR_FILTER;
	}

	return modifiers;		return modifiers;
	}		}

	private int setupColorFilter(Paint paint) {
	final ColorFilter filter = paint.getColorFilter();
	if (filter != null) {
	nSetupColorFilter(mRenderer, filter.nativeColorFilter);
	return MODIFIER_COLOR_FILTER;
	}
	return MODIFIER_NONE;
	}

	private static native void nSetupShader(long renderer, long shader);		private static native void nSetupShader(long renderer, long shader);
	private static native void nSetupColorFilter(long renderer, long colorFilter);
	private static native void nSetupShadow(long renderer, float radius,		private static native void nSetupShadow(long renderer, float radius,
	float dx, float dy, int color);		float dx, float dy, int color);

core/java/android/view/GLES20Layer.java

+1 −1

Original line number	Original line	Diff line number	Diff line
	@@ -48,7 +48,7 @@ abstract class GLES20Layer extends HardwareLayer {
	if (paint != null) {		if (paint != null) {
	GLES20Canvas.nSetLayerPaint(mLayer, paint.mNativePaint);		GLES20Canvas.nSetLayerPaint(mLayer, paint.mNativePaint);
	GLES20Canvas.nSetLayerColorFilter(mLayer, paint.getColorFilter() != null ?		GLES20Canvas.nSetLayerColorFilter(mLayer, paint.getColorFilter() != null ?
	paint.getColorFilter().nativeColorFilter : 0);		paint.getColorFilter().native_instance : 0);
	}		}
	}		}

core/jni/android/graphics/ColorFilter.cpp

+4 −63

Original line number	Original line	Diff line number	Diff line
	@@ -23,7 +23,6 @@
	#include "SkColorMatrixFilter.h"		#include "SkColorMatrixFilter.h"
	#include "SkPorterDuff.h"		#include "SkPorterDuff.h"

	#include <SkiaColorFilter.h>
	#include <Caches.h>		#include <Caches.h>

	namespace android {		namespace android {
	@@ -32,64 +31,9 @@ using namespace uirenderer;

	class SkColorFilterGlue {		class SkColorFilterGlue {
	public:		public:
	static void finalizer(JNIEnv* env, jobject clazz, jlong objHandle, jlong fHandle) {		static void finalizer(JNIEnv* env, jobject clazz, jlong skFilterHandle) {
	SkColorFilter* obj = reinterpret_cast<SkColorFilter *>(objHandle);		SkColorFilter* filter = reinterpret_cast<SkColorFilter *>(skFilterHandle);
	SkiaColorFilter* f = reinterpret_cast<SkiaColorFilter *>(fHandle);		if (filter) SkSafeUnref(filter);
	if (obj) SkSafeUnref(obj);
	// f == NULL when not !USE_OPENGL_RENDERER, so no need to delete outside the ifdef
	#ifdef USE_OPENGL_RENDERER
	if (f && android::uirenderer::Caches::hasInstance()) {
	android::uirenderer::Caches::getInstance().resourceCache.destructor(f);
	} else {
	delete f;
	}
	#endif
	}

	static jlong glCreatePorterDuffFilter(JNIEnv* env, jobject, jlong skFilterHandle,
	jint srcColor, jint modeHandle) {
	SkColorFilter skFilter = reinterpret_cast<SkColorFilter >(skFilterHandle);
	SkPorterDuff::Mode mode = static_cast<SkPorterDuff::Mode>(modeHandle);
	#ifdef USE_OPENGL_RENDERER
	return reinterpret_cast<jlong>(new SkiaBlendFilter(skFilter, srcColor, SkPorterDuff::ToXfermodeMode(mode)));
	#else
	return NULL;
	#endif
	}

	static jlong glCreateLightingFilter(JNIEnv* env, jobject, jlong skFilterHandle,
	jint mul, jint add) {
	SkColorFilter skFilter = reinterpret_cast<SkColorFilter >(skFilterHandle);
	#ifdef USE_OPENGL_RENDERER
	return reinterpret_cast<jlong>(new SkiaLightingFilter(skFilter, mul, add));
	#else
	return NULL;
	#endif
	}

	static jlong glCreateColorMatrixFilter(JNIEnv* env, jobject, jlong skFilterHandle,
	jfloatArray jarray) {
	SkColorFilter skFilter = reinterpret_cast<SkColorFilter >(skFilterHandle);
	#ifdef USE_OPENGL_RENDERER
	AutoJavaFloatArray autoArray(env, jarray, 20);
	const float* src = autoArray.ptr();

	float* colorMatrix = new float[16];
	memcpy(colorMatrix, src, 4 * sizeof(float));
	memcpy(&colorMatrix[4], &src[5], 4 * sizeof(float));
	memcpy(&colorMatrix[8], &src[10], 4 * sizeof(float));
	memcpy(&colorMatrix[12], &src[15], 4 * sizeof(float));

	float* colorVector = new float[4];
	colorVector[0] = src[4];
	colorVector[1] = src[9];
	colorVector[2] = src[14];
	colorVector[3] = src[19];

	return reinterpret_cast<jlong>(new SkiaColorMatrixFilter(skFilter, colorMatrix, colorVector));
	#else
	return NULL;
	#endif
	}		}

	static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor,		static jlong CreatePorterDuffFilter(JNIEnv* env, jobject, jint srcColor,
	@@ -119,22 +63,19 @@ public:
	};		};

	static JNINativeMethod colorfilter_methods[] = {		static JNINativeMethod colorfilter_methods[] = {
	{"destroyFilter", "(JJ)V", (void*) SkColorFilterGlue::finalizer}		{"destroyFilter", "(J)V", (void*) SkColorFilterGlue::finalizer}
	};		};

	static JNINativeMethod porterduff_methods[] = {		static JNINativeMethod porterduff_methods[] = {
	{ "native_CreatePorterDuffFilter", "(II)J", (void*) SkColorFilterGlue::CreatePorterDuffFilter },		{ "native_CreatePorterDuffFilter", "(II)J", (void*) SkColorFilterGlue::CreatePorterDuffFilter },
	{ "nCreatePorterDuffFilter", "(JII)J", (void*) SkColorFilterGlue::glCreatePorterDuffFilter }
	};		};

	static JNINativeMethod lighting_methods[] = {		static JNINativeMethod lighting_methods[] = {
	{ "native_CreateLightingFilter", "(II)J", (void*) SkColorFilterGlue::CreateLightingFilter },		{ "native_CreateLightingFilter", "(II)J", (void*) SkColorFilterGlue::CreateLightingFilter },
	{ "nCreateLightingFilter", "(JII)J", (void*) SkColorFilterGlue::glCreateLightingFilter },
	};		};

	static JNINativeMethod colormatrix_methods[] = {		static JNINativeMethod colormatrix_methods[] = {
	{ "nativeColorMatrixFilter", "([F)J", (void*) SkColorFilterGlue::CreateColorMatrixFilter },		{ "nativeColorMatrixFilter", "([F)J", (void*) SkColorFilterGlue::CreateColorMatrixFilter },
	{ "nColorMatrixFilter", "(J[F)J", (void*) SkColorFilterGlue::glCreateColorMatrixFilter }
	};		};

	#define REG(env, name, array) \		#define REG(env, name, array) \

core/jni/android_view_GLES20Canvas.cpp

+1 −11

Original line number	Original line	Diff line number	Diff line
	@@ -47,7 +47,6 @@
	#include <LayerRenderer.h>		#include <LayerRenderer.h>
	#include <OpenGLRenderer.h>		#include <OpenGLRenderer.h>
	#include <SkiaShader.h>		#include <SkiaShader.h>
	#include <SkiaColorFilter.h>
	#include <Stencil.h>		#include <Stencil.h>
	#include <Rect.h>		#include <Rect.h>

	@@ -81,7 +80,6 @@ using namespace uirenderer;

	#define MODIFIER_SHADOW 1		#define MODIFIER_SHADOW 1
	#define MODIFIER_SHADER 2		#define MODIFIER_SHADER 2
	#define MODIFIER_COLOR_FILTER 4

	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	@@ -638,7 +636,6 @@ static void android_view_GLES20Canvas_resetModifiers(JNIEnv* env, jobject clazz,
	OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);		OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
	if (modifiers & MODIFIER_SHADOW) renderer->resetShadow();		if (modifiers & MODIFIER_SHADOW) renderer->resetShadow();
	if (modifiers & MODIFIER_SHADER) renderer->resetShader();		if (modifiers & MODIFIER_SHADER) renderer->resetShader();
	if (modifiers & MODIFIER_COLOR_FILTER) renderer->resetColorFilter();
	}		}

	static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,		static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,
	@@ -648,12 +645,6 @@ static void android_view_GLES20Canvas_setupShader(JNIEnv* env, jobject clazz,
	renderer->setupShader(shader);		renderer->setupShader(shader);
	}		}

	static void android_view_GLES20Canvas_setupColorFilter(JNIEnv* env, jobject clazz,
	jlong rendererPtr, jlong colorFilterPtr) {
	OpenGLRenderer* renderer = reinterpret_cast<OpenGLRenderer*>(rendererPtr);
	SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);
	renderer->setupColorFilter(colorFilter);
	}

	static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz,		static void android_view_GLES20Canvas_setupShadow(JNIEnv* env, jobject clazz,
	jlong rendererPtr, jfloat radius, jfloat dx, jfloat dy, jint color) {		jlong rendererPtr, jfloat radius, jfloat dx, jfloat dy, jint color) {
	@@ -987,7 +978,7 @@ static void android_view_GLES20Canvas_setLayerColorFilter(JNIEnv* env, jobject c
	jlong layerPtr, jlong colorFilterPtr) {		jlong layerPtr, jlong colorFilterPtr) {
	Layer* layer = reinterpret_cast<Layer*>(layerPtr);		Layer* layer = reinterpret_cast<Layer*>(layerPtr);
	if (layer) {		if (layer) {
	SkiaColorFilter* colorFilter = reinterpret_cast<SkiaColorFilter*>(colorFilterPtr);		SkColorFilter* colorFilter = reinterpret_cast<SkColorFilter*>(colorFilterPtr);
	layer->setColorFilter(colorFilter);		layer->setColorFilter(colorFilter);
	}		}
	}		}
	@@ -1222,7 +1213,6 @@ static JNINativeMethod gMethods[] = {

	{ "nResetModifiers", "(JI)V", (void*) android_view_GLES20Canvas_resetModifiers },		{ "nResetModifiers", "(JI)V", (void*) android_view_GLES20Canvas_resetModifiers },
	{ "nSetupShader", "(JJ)V", (void*) android_view_GLES20Canvas_setupShader },		{ "nSetupShader", "(JJ)V", (void*) android_view_GLES20Canvas_setupShader },
	{ "nSetupColorFilter", "(JJ)V", (void*) android_view_GLES20Canvas_setupColorFilter },
	{ "nSetupShadow", "(JFFFI)V", (void*) android_view_GLES20Canvas_setupShadow },		{ "nSetupShadow", "(JFFFI)V", (void*) android_view_GLES20Canvas_setupShadow },

	{ "nSetupPaintFilter", "(JII)V", (void*) android_view_GLES20Canvas_setupPaintFilter },		{ "nSetupPaintFilter", "(JII)V", (void*) android_view_GLES20Canvas_setupPaintFilter },

graphics/java/android/graphics/ColorFilter.java

+4 −7

Original line number	Original line	Diff line number	Diff line
	@@ -27,24 +27,21 @@ package android.graphics;
	* never be used directly.		* never be used directly.
	*/		*/
	public class ColorFilter {		public class ColorFilter {
	// Holds the pointer to the native SkColorFilter instance
	long native_instance;

	/**		/**
	* Holds the pointer to the native SkiaColorFilter instance, from libhwui.		* Holds the pointer to the native SkColorFilter instance.
	*		*
	* @hide		* @hide
	*/		*/
	public long nativeColorFilter;		public long native_instance;

	@Override		@Override
	protected void finalize() throws Throwable {		protected void finalize() throws Throwable {
	try {		try {
	super.finalize();		super.finalize();
	} finally {		} finally {
	destroyFilter(native_instance, nativeColorFilter);		destroyFilter(native_instance);
	}		}
	}		}

	static native void destroyFilter(long native_instance, long nativeColorFilter);		static native void destroyFilter(long native_instance);
	}		}