Merge "Remove unused flags and dirty rects" into mnc-dev (ff623a5a) · Commits · e / os / android_frameworks_base

core/java/android/view/DisplayListCanvas.java

+3 −15

Original line number	Diff line number	Diff line
		@@ -234,25 +234,13 @@ public class DisplayListCanvas extends Canvas {
		* Draws the specified display list onto this canvas. The display list can only
		* be drawn if {@link android.view.RenderNode#isValid()} returns true.
		*
		* @param renderNode The RenderNode to replay.
		* @param renderNode The RenderNode to draw.
		*/
		public void drawRenderNode(RenderNode renderNode) {
		drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);
		nDrawRenderNode(mNativeCanvasWrapper, renderNode.getNativeDisplayList());
		}

		/**
		* Draws the specified display list onto this canvas.
		*
		* @param renderNode The RenderNode to replay.
		* @param flags Optional flags about drawing, see {@link RenderNode} for
		* the possible flags.
		*/
		public void drawRenderNode(RenderNode renderNode, int flags) {
		nDrawRenderNode(mNativeCanvasWrapper, renderNode.getNativeDisplayList(), flags);
		}

		private static native void nDrawRenderNode(long renderer, long renderNode,
		int flags);
		private static native void nDrawRenderNode(long renderer, long renderNode);

		///////////////////////////////////////////////////////////////////////////
		// Hardware layer

core/java/android/view/View.java

+1 −1

Original line number	Diff line number	Diff line
		@@ -15540,7 +15540,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback,
		if (!drawingWithDrawingCache) {
		if (drawingWithRenderNode) {
		mPrivateFlags &= ~PFLAG_DIRTY_MASK;
		((DisplayListCanvas) canvas).drawRenderNode(renderNode, parentFlags);
		((DisplayListCanvas) canvas).drawRenderNode(renderNode);
		} else {
		// Fast path for layouts with no backgrounds
		if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {

core/java/android/widget/Editor.java

+28 −29

Original line number	Diff line number	Diff line
		@@ -145,16 +145,16 @@ public class Editor {
		InputContentType mInputContentType;
		InputMethodState mInputMethodState;

		private static class TextDisplayList {
		RenderNode displayList;
		private static class TextRenderNode {
		RenderNode renderNode;
		boolean isDirty;
		public TextDisplayList(String name) {
		public TextRenderNode(String name) {
		isDirty = true;
		displayList = RenderNode.create(name, null);
		renderNode = RenderNode.create(name, null);
		}
		boolean needsRecord() { return isDirty \|\| !displayList.isValid(); }
		boolean needsRecord() { return isDirty \|\| !renderNode.isValid(); }
		}
		TextDisplayList[] mTextDisplayLists;
		TextRenderNode[] mTextRenderNodes;

		boolean mFrozenWithFocus;
		boolean mSelectionMoved;
		@@ -360,10 +360,10 @@ public class Editor {
		}

		private void destroyDisplayListsData() {
		if (mTextDisplayLists != null) {
		for (int i = 0; i < mTextDisplayLists.length; i++) {
		RenderNode displayList = mTextDisplayLists[i] != null
		? mTextDisplayLists[i].displayList : null;
		if (mTextRenderNodes != null) {
		for (int i = 0; i < mTextRenderNodes.length; i++) {
		RenderNode displayList = mTextRenderNodes[i] != null
		? mTextRenderNodes[i].renderNode : null;
		if (displayList != null && displayList.isValid()) {
		displayList.destroyDisplayListData();
		}
		@@ -1467,8 +1467,8 @@ public class Editor {
		firstLine, lastLine);

		if (layout instanceof DynamicLayout) {
		if (mTextDisplayLists == null) {
		mTextDisplayLists = ArrayUtils.emptyArray(TextDisplayList.class);
		if (mTextRenderNodes == null) {
		mTextRenderNodes = ArrayUtils.emptyArray(TextRenderNode.class);
		}

		DynamicLayout dynamicLayout = (DynamicLayout) layout;
		@@ -1489,19 +1489,19 @@ public class Editor {
		searchStartIndex);
		// Note how dynamic layout's internal block indices get updated from Editor
		blockIndices[i] = blockIndex;
		if (mTextDisplayLists[blockIndex] != null) {
		mTextDisplayLists[blockIndex].isDirty = true;
		if (mTextRenderNodes[blockIndex] != null) {
		mTextRenderNodes[blockIndex].isDirty = true;
		}
		searchStartIndex = blockIndex + 1;
		}

		if (mTextDisplayLists[blockIndex] == null) {
		mTextDisplayLists[blockIndex] =
		new TextDisplayList("Text " + blockIndex);
		if (mTextRenderNodes[blockIndex] == null) {
		mTextRenderNodes[blockIndex] =
		new TextRenderNode("Text " + blockIndex);
		}

		final boolean blockDisplayListIsInvalid = mTextDisplayLists[blockIndex].needsRecord();
		RenderNode blockDisplayList = mTextDisplayLists[blockIndex].displayList;
		final boolean blockDisplayListIsInvalid = mTextRenderNodes[blockIndex].needsRecord();
		RenderNode blockDisplayList = mTextRenderNodes[blockIndex].renderNode;
		if (i >= indexFirstChangedBlock \|\| blockDisplayListIsInvalid) {
		final int blockBeginLine = endOfPreviousBlock + 1;
		final int top = layout.getLineTop(blockBeginLine);
		@@ -1528,7 +1528,7 @@ public class Editor {
		// brings this range of text back to the top left corner of the viewport
		displayListCanvas.translate(-left, -top);
		layout.drawText(displayListCanvas, blockBeginLine, blockEndLine);
		mTextDisplayLists[blockIndex].isDirty = false;
		mTextRenderNodes[blockIndex].isDirty = false;
		// No need to untranslate, previous context is popped after
		// drawDisplayList
		} finally {
		@@ -1543,8 +1543,7 @@ public class Editor {
		blockDisplayList.setLeftTopRightBottom(left, top, right, bottom);
		}

		((DisplayListCanvas) canvas).drawRenderNode(blockDisplayList,
		0 /* no child clipping, our TextView parent enforces it */);
		((DisplayListCanvas) canvas).drawRenderNode(blockDisplayList);

		endOfPreviousBlock = blockEndLine;
		}
		@@ -1558,7 +1557,7 @@ public class Editor {

		private int getAvailableDisplayListIndex(int[] blockIndices, int numberOfBlocks,
		int searchStartIndex) {
		int length = mTextDisplayLists.length;
		int length = mTextRenderNodes.length;
		for (int i = searchStartIndex; i < length; i++) {
		boolean blockIndexFound = false;
		for (int j = 0; j < numberOfBlocks; j++) {
		@@ -1572,7 +1571,7 @@ public class Editor {
		}

		// No available index found, the pool has to grow
		mTextDisplayLists = GrowingArrayUtils.append(mTextDisplayLists, length, null);
		mTextRenderNodes = GrowingArrayUtils.append(mTextRenderNodes, length, null);
		return length;
		}

		@@ -1589,7 +1588,7 @@ public class Editor {
		* Invalidates all the sub-display lists that overlap the specified character range
		*/
		void invalidateTextDisplayList(Layout layout, int start, int end) {
		if (mTextDisplayLists != null && layout instanceof DynamicLayout) {
		if (mTextRenderNodes != null && layout instanceof DynamicLayout) {
		final int firstLine = layout.getLineForOffset(start);
		final int lastLine = layout.getLineForOffset(end);

		@@ -1609,7 +1608,7 @@ public class Editor {
		while (i < numberOfBlocks) {
		final int blockIndex = blockIndices[i];
		if (blockIndex != DynamicLayout.INVALID_BLOCK_INDEX) {
		mTextDisplayLists[blockIndex].isDirty = true;
		mTextRenderNodes[blockIndex].isDirty = true;
		}
		if (blockEndLines[i] >= lastLine) break;
		i++;
		@@ -1618,9 +1617,9 @@ public class Editor {
		}

		void invalidateTextDisplayList() {
		if (mTextDisplayLists != null) {
		for (int i = 0; i < mTextDisplayLists.length; i++) {
		if (mTextDisplayLists[i] != null) mTextDisplayLists[i].isDirty = true;
		if (mTextRenderNodes != null) {
		for (int i = 0; i < mTextRenderNodes.length; i++) {
		if (mTextRenderNodes[i] != null) mTextRenderNodes[i].isDirty = true;
		}
		}
		}

core/jni/android_view_DisplayListCanvas.cpp

+4 −7

Original line number	Diff line number	Diff line
		@@ -112,8 +112,7 @@ static void android_view_DisplayListCanvas_callDrawGLFunction(JNIEnv* env, jobje
		jlong rendererPtr, jlong functorPtr) {
		DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);
		Functor* functor = reinterpret_cast<Functor*>(functorPtr);
		android::uirenderer::Rect dirty;
		renderer->callDrawGLFunction(functor, dirty);
		renderer->callDrawGLFunction(functor);
		}

		// ----------------------------------------------------------------------------
		@@ -212,12 +211,10 @@ static jlong android_view_DisplayListCanvas_createDisplayListCanvas(JNIEnv* env,
		}

		static void android_view_DisplayListCanvas_drawRenderNode(JNIEnv* env,
		jobject clazz, jlong rendererPtr, jlong renderNodePtr,
		jint flags) {
		jobject clazz, jlong rendererPtr, jlong renderNodePtr) {
		DisplayListCanvas* renderer = reinterpret_cast<DisplayListCanvas*>(rendererPtr);
		RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
		android::uirenderer::Rect bounds;
		renderer->drawRenderNode(renderNode, bounds, flags);
		renderer->drawRenderNode(renderNode);
		}

		// ----------------------------------------------------------------------------
		@@ -283,7 +280,7 @@ static JNINativeMethod gMethods[] = {
		{ "nDrawCircle", "(JJJJJ)V", (void*) android_view_DisplayListCanvas_drawCircleProps },

		{ "nFinishRecording", "(J)J", (void*) android_view_DisplayListCanvas_finishRecording },
		{ "nDrawRenderNode", "(JJI)V", (void*) android_view_DisplayListCanvas_drawRenderNode },
		{ "nDrawRenderNode", "(JJ)V", (void*) android_view_DisplayListCanvas_drawRenderNode },

		{ "nCreateDisplayListCanvas", "()J", (void*) android_view_DisplayListCanvas_createDisplayListCanvas },

libs/hwui/DisplayListCanvas.cpp

+3 −4

Original line number	Diff line number	Diff line
		@@ -88,8 +88,7 @@ void DisplayListCanvas::interrupt() {
		void DisplayListCanvas::resume() {
		}

		void DisplayListCanvas::callDrawGLFunction(Functor *functor, Rect& dirty) {
		// Ignore dirty during recording, it matters only when we replay
		void DisplayListCanvas::callDrawGLFunction(Functor *functor) {
		addDrawOp(new (alloc()) DrawFunctorOp(functor));
		mDisplayListData->functors.add(functor);
		}
		@@ -202,12 +201,12 @@ bool DisplayListCanvas::clipRegion(const SkRegion* region, SkRegion::Op op) {
		return mState.clipRegion(region, op);
		}

		void DisplayListCanvas::drawRenderNode(RenderNode* renderNode, Rect& dirty, int32_t flags) {
		void DisplayListCanvas::drawRenderNode(RenderNode* renderNode) {
		LOG_ALWAYS_FATAL_IF(!renderNode, "missing rendernode");

		// dirty is an out parameter and should not be recorded,
		// it matters only when replaying the display list
		DrawRenderNodeOp* op = new (alloc()) DrawRenderNodeOp(renderNode, flags, *mState.currentTransform());
		DrawRenderNodeOp* op = new (alloc()) DrawRenderNodeOp(renderNode, *mState.currentTransform());
		addRenderNodeOp(op);
		}