Merge "Remove Bitmap#getSkBitmap" into mnc-dev (05dc201f) · Commits · e / os / android_frameworks_base

core/java/android/view/DisplayListCanvas.java

+3 −3

core/jni/android/graphics/NinePatch.cpp

+24 −21

Original line number	Original line	Diff line number	Diff line
	@@ -64,7 +64,7 @@ public:
	return JNI_FALSE;		return JNI_FALSE;
	}		}

	static jlong validateNinePatchChunk(JNIEnv* env, jobject, jlong, jbyteArray obj) {		static jlong validateNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj) {
	size_t chunkSize = env->GetArrayLength(obj);		size_t chunkSize = env->GetArrayLength(obj);
	if (chunkSize < (int) (sizeof(Res_png_9patch))) {		if (chunkSize < (int) (sizeof(Res_png_9patch))) {
	jniThrowRuntimeException(env, "Array too small for chunk.");		jniThrowRuntimeException(env, "Array too small for chunk.");
	@@ -88,13 +88,13 @@ public:
	}		}
	}		}

	static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds, const SkBitmap* bitmap,		static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds, const SkBitmap& bitmap,
	Res_png_9patch* chunk, const SkPaint* paint, jint destDensity, jint srcDensity) {		Res_png_9patch* chunk, const SkPaint* paint, jint destDensity, jint srcDensity) {
	if (destDensity == srcDensity \|\| destDensity == 0 \|\| srcDensity == 0) {		if (destDensity == srcDensity \|\| destDensity == 0 \|\| srcDensity == 0) {
	ALOGV("Drawing unscaled 9-patch: (%g,%g)-(%g,%g)",		ALOGV("Drawing unscaled 9-patch: (%g,%g)-(%g,%g)",
	SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),		SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),
	SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom));		SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom));
	NinePatch_Draw(canvas, bounds, bitmap, chunk, paint, NULL);		NinePatch_Draw(canvas, bounds, bitmap, *chunk, paint, NULL);
	} else {		} else {
	canvas->save();		canvas->save();

	@@ -111,25 +111,25 @@ public:
	SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom),		SkScalarToFloat(bounds.fRight), SkScalarToFloat(bounds.fBottom),
	srcDensity, destDensity);		srcDensity, destDensity);

	NinePatch_Draw(canvas, bounds, bitmap, chunk, paint, NULL);		NinePatch_Draw(canvas, bounds, bitmap, *chunk, paint, NULL);

	canvas->restore();		canvas->restore();
	}		}
	}		}

	static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF,		static void drawF(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRectF,
	jlong bitmapHandle, jlong chunkHandle, jlong paintHandle,		jobject jbitmap, jlong chunkHandle, jlong paintHandle,
	jint destDensity, jint srcDensity) {		jint destDensity, jint srcDensity) {
	SkCanvas* canvas = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();		SkCanvas* canvas = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();
	const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
	Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);		Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
	const Paint* paint = reinterpret_cast<Paint*>(paintHandle);		const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
	SkASSERT(canvas);		SkASSERT(canvas);
	SkASSERT(boundsRectF);		SkASSERT(boundsRectF);
	SkASSERT(bitmap);
	SkASSERT(chunk);		SkASSERT(chunk);
	// paint is optional		// paint is optional

			SkBitmap bitmap;
			GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
	SkRect bounds;		SkRect bounds;
	GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds);		GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds);

	@@ -137,36 +137,36 @@ public:
	}		}

	static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect,		static void drawI(JNIEnv* env, jobject, jlong canvasHandle, jobject boundsRect,
	jlong bitmapHandle, jlong chunkHandle, jlong paintHandle,		jobject jbitmap, jlong chunkHandle, jlong paintHandle,
	jint destDensity, jint srcDensity) {		jint destDensity, jint srcDensity) {
	SkCanvas* canvas = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();		SkCanvas* canvas = reinterpret_cast<Canvas*>(canvasHandle)->asSkCanvas();
	const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
	Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);		Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
	const Paint* paint = reinterpret_cast<Paint*>(paintHandle);		const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
	SkASSERT(canvas);		SkASSERT(canvas);
	SkASSERT(boundsRect);		SkASSERT(boundsRect);
	SkASSERT(bitmap);
	SkASSERT(chunk);		SkASSERT(chunk);
	// paint is optional		// paint is optional

			SkBitmap bitmap;
			GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
	SkRect bounds;		SkRect bounds;
	GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);		GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);
	draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);		draw(env, canvas, bounds, bitmap, chunk, paint, destDensity, srcDensity);
	}		}

	static jlong getTransparentRegion(JNIEnv* env, jobject, jlong bitmapHandle,		static jlong getTransparentRegion(JNIEnv* env, jobject, jobject jbitmap,
	jlong chunkHandle, jobject boundsRect) {		jlong chunkHandle, jobject boundsRect) {
	const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
	Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);		Res_png_9patch* chunk = reinterpret_cast<Res_png_9patch*>(chunkHandle);
	SkASSERT(bitmap);
	SkASSERT(chunk);		SkASSERT(chunk);
	SkASSERT(boundsRect);		SkASSERT(boundsRect);

			SkBitmap bitmap;
			GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
	SkRect bounds;		SkRect bounds;
	GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);		GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds);

	SkRegion* region = NULL;		SkRegion* region = NULL;
	NinePatch_Draw(NULL, bounds, bitmap, chunk, NULL, &region);		NinePatch_Draw(NULL, bounds, bitmap, *chunk, NULL, &region);

	return reinterpret_cast<jlong>(region);		return reinterpret_cast<jlong>(region);
	}		}
	@@ -177,11 +177,14 @@ public:

	static JNINativeMethod gNinePatchMethods[] = {		static JNINativeMethod gNinePatchMethods[] = {
	{ "isNinePatchChunk", "([B)Z", (void*) SkNinePatchGlue::isNinePatchChunk },		{ "isNinePatchChunk", "([B)Z", (void*) SkNinePatchGlue::isNinePatchChunk },
	{ "validateNinePatchChunk", "(J[B)J", (void*) SkNinePatchGlue::validateNinePatchChunk },		{ "validateNinePatchChunk", "([B)J",
			(void*) SkNinePatchGlue::validateNinePatchChunk },
	{ "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize },		{ "nativeFinalize", "(J)V", (void*) SkNinePatchGlue::finalize },
	{ "nativeDraw", "(JLandroid/graphics/RectF;JJJII)V", (void*) SkNinePatchGlue::drawF },		{ "nativeDraw", "(JLandroid/graphics/RectF;Landroid/graphics/Bitmap;JJII)V",
	{ "nativeDraw", "(JLandroid/graphics/Rect;JJJII)V", (void*) SkNinePatchGlue::drawI },		(void*) SkNinePatchGlue::drawF },
	{ "nativeGetTransparentRegion", "(JJLandroid/graphics/Rect;)J",		{ "nativeDraw", "(JLandroid/graphics/Rect;Landroid/graphics/Bitmap;JJII)V",
			(void*) SkNinePatchGlue::drawI },
			{ "nativeGetTransparentRegion", "(Landroid/graphics/Bitmap;JLandroid/graphics/Rect;)J",
	(void*) SkNinePatchGlue::getTransparentRegion }		(void*) SkNinePatchGlue::getTransparentRegion }
	};		};

core/jni/android_graphics_Canvas.cpp

+23 −19

core/jni/android_view_DisplayListCanvas.cpp

+4 −4

graphics/java/android/graphics/Bitmap.java

+0 −5

Original line number	Original line	Diff line number	Diff line
	@@ -1568,11 +1568,6 @@ public final class Bitmap implements Parcelable {
	nativePrepareToDraw(mSkBitmapPtr);		nativePrepareToDraw(mSkBitmapPtr);
	}		}

	/** @hide */
	public final long getSkBitmap() {
	return mSkBitmapPtr;
	}

	/**		/**
	* Refs the underlying SkPixelRef and returns a pointer to it.		* Refs the underlying SkPixelRef and returns a pointer to it.
	*		*

Original line number	Original line	Diff line number	Diff line
	@@ -271,7 +271,7 @@ public class DisplayListCanvas extends Canvas {
	Bitmap bitmap = patch.getBitmap();		Bitmap bitmap = patch.getBitmap();
	throwIfCannotDraw(bitmap);		throwIfCannotDraw(bitmap);
	final long nativePaint = paint == null ? 0 : paint.getNativeInstance();		final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
	nDrawPatch(mNativeCanvasWrapper, bitmap.getSkBitmap(), patch.mNativeChunk,		nDrawPatch(mNativeCanvasWrapper, bitmap, patch.mNativeChunk,
	dst.left, dst.top, dst.right, dst.bottom, nativePaint);		dst.left, dst.top, dst.right, dst.bottom, nativePaint);
	}		}

	@@ -281,11 +281,11 @@ public class DisplayListCanvas extends Canvas {
	Bitmap bitmap = patch.getBitmap();		Bitmap bitmap = patch.getBitmap();
	throwIfCannotDraw(bitmap);		throwIfCannotDraw(bitmap);
	final long nativePaint = paint == null ? 0 : paint.getNativeInstance();		final long nativePaint = paint == null ? 0 : paint.getNativeInstance();
	nDrawPatch(mNativeCanvasWrapper, bitmap.getSkBitmap(), patch.mNativeChunk,		nDrawPatch(mNativeCanvasWrapper, bitmap, patch.mNativeChunk,
	dst.left, dst.top, dst.right, dst.bottom, nativePaint);		dst.left, dst.top, dst.right, dst.bottom, nativePaint);
	}		}

	private static native void nDrawPatch(long renderer, long bitmap, long chunk,		private static native void nDrawPatch(long renderer, Bitmap bitmap, long chunk,
	float left, float top, float right, float bottom, long paint);		float left, float top, float right, float bottom, long paint);

	public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,		public void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,

Original line number	Original line	Diff line number	Diff line
	@@ -318,11 +318,12 @@ static void drawVertices(JNIEnv* env, jobject, jlong canvasHandle,
	indices, indexCount, *paint);		indices, indexCount, *paint);
	}		}

	static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong bitmapHandle,		static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jobject jbitmap,
	jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,		jfloat left, jfloat top, jlong paintHandle, jint canvasDensity,
	jint screenDensity, jint bitmapDensity) {		jint screenDensity, jint bitmapDensity) {
	Canvas* canvas = get_canvas(canvasHandle);		Canvas* canvas = get_canvas(canvasHandle);
	const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);		SkBitmap bitmap;
			GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
	const Paint* paint = reinterpret_cast<Paint*>(paintHandle);		const Paint* paint = reinterpret_cast<Paint*>(paintHandle);

	if (canvasDensity == bitmapDensity \|\| canvasDensity == 0 \|\| bitmapDensity == 0) {		if (canvasDensity == bitmapDensity \|\| canvasDensity == 0 \|\| bitmapDensity == 0) {
	@@ -332,9 +333,9 @@ static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong b
	filteredPaint = *paint;		filteredPaint = *paint;
	}		}
	filteredPaint.setFilterQuality(kLow_SkFilterQuality);		filteredPaint.setFilterQuality(kLow_SkFilterQuality);
	canvas->drawBitmap(*bitmap, left, top, &filteredPaint);		canvas->drawBitmap(bitmap, left, top, &filteredPaint);
	} else {		} else {
	canvas->drawBitmap(*bitmap, left, top, paint);		canvas->drawBitmap(bitmap, left, top, paint);
	}		}
	} else {		} else {
	canvas->save(SkCanvas::kMatrixClip_SaveFlag);		canvas->save(SkCanvas::kMatrixClip_SaveFlag);
	@@ -348,37 +349,39 @@ static void drawBitmap(JNIEnv* env, jobject jcanvas, jlong canvasHandle, jlong b
	}		}
	filteredPaint.setFilterQuality(kLow_SkFilterQuality);		filteredPaint.setFilterQuality(kLow_SkFilterQuality);

	canvas->drawBitmap(*bitmap, 0, 0, &filteredPaint);		canvas->drawBitmap(bitmap, 0, 0, &filteredPaint);
	canvas->restore();		canvas->restore();
	}		}
	}		}

	static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jlong bitmapHandle,		static void drawBitmapMatrix(JNIEnv* env, jobject, jlong canvasHandle, jobject jbitmap,
	jlong matrixHandle, jlong paintHandle) {		jlong matrixHandle, jlong paintHandle) {
	const SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapHandle);
	const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);		const SkMatrix* matrix = reinterpret_cast<SkMatrix*>(matrixHandle);
	const Paint* paint = reinterpret_cast<Paint*>(paintHandle);		const Paint* paint = reinterpret_cast<Paint*>(paintHandle);
	get_canvas(canvasHandle)->drawBitmap(bitmap, matrix, paint);		SkBitmap bitmap;
			GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
			get_canvas(canvasHandle)->drawBitmap(bitmap, *matrix, paint);

Original line number	Original line	Diff line number	Diff line
	@@ -132,10 +132,10 @@ static jint android_view_DisplayListCanvas_getMaxTextureHeight(JNIEnv* env, jobj
	// ----------------------------------------------------------------------------		// ----------------------------------------------------------------------------

	static void android_view_DisplayListCanvas_drawPatch(JNIEnv* env, jobject clazz,		static void android_view_DisplayListCanvas_drawPatch(JNIEnv* env, jobject clazz,
	jlong rendererPtr, jlong bitmapPtr, jlong patchPtr,		jlong rendererPtr, jobject jbitmap, jlong patchPtr,
	float left, float top, float right, float bottom, jlong paintPtr) {		float left, float top, float right, float bottom, jlong paintPtr) {
	SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);		SkBitmap bitmap;
			GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
	DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);		DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);
	Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(patchPtr);		Res_png_9patch* patch = reinterpret_cast<Res_png_9patch*>(patchPtr);
	Paint* paint = reinterpret_cast<Paint*>(paintPtr);		Paint* paint = reinterpret_cast<Paint*>(paintPtr);
	@@ -273,7 +273,7 @@ static JNINativeMethod gMethods[] = {

	{ "nCallDrawGLFunction", "(JJ)V", (void*) android_view_DisplayListCanvas_callDrawGLFunction },		{ "nCallDrawGLFunction", "(JJ)V", (void*) android_view_DisplayListCanvas_callDrawGLFunction },

	{ "nDrawPatch", "(JJJFFFFJ)V", (void*) android_view_DisplayListCanvas_drawPatch },		{ "nDrawPatch", "(JLandroid/graphics/Bitmap;JFFFFJ)V", (void*) android_view_DisplayListCanvas_drawPatch },

	{ "nDrawRects", "(JJJ)V", (void*) android_view_DisplayListCanvas_drawRegionAsRects },		{ "nDrawRects", "(JJJ)V", (void*) android_view_DisplayListCanvas_drawRegionAsRects },
	{ "nDrawRoundRect", "(JJJJJJJJ)V", (void*) android_view_DisplayListCanvas_drawRoundRectProps },		{ "nDrawRoundRect", "(JJJJJJJJ)V", (void*) android_view_DisplayListCanvas_drawRoundRectProps },