Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 956f340a authored by Chris Craik's avatar Chris Craik
Browse files

Remove unused flags and dirty rects 

bug:17209071

Also update DisplayList->RenderNode naming in Editor

Change-Id: I1d505640ba7388a0b0042d9c787f859e45a24da5
parent 340b198c

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
@@ -15509,7 +15509,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);

}