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

Commit 0a78e8fe authored by Jorge Gil's avatar Jorge Gil
Browse files

Remove outsets used to crop beyond the task bounds 

Having outsets around the task bounds was previously needed to
capture input events outside the task for resizing. With
I70cd2edf5720759e171298c1864854ab81b13b27, it's possible to register
regions beyond the surface for input events, so outsets are no
longer necessary.
This also fixes flickering around the corners/edges during drag
resizing.
Flickering before & after (bottom-right corner):
Before: http://recall/-/fY0xovcFXvWKac90hrLiAe/gxj4XfRMS5BMw6SJJnfOmd
After: http://recall/-/fY0xovcFXvWKac90hrLiAe/hLuUohiTSMNl4mgVkDZqqj

Bug: 270202228
Test: atest WindowDecorationTests
Test: manual: drag resize, verify there's less flickering around the
edge/corner of the task.

Change-Id: Ib9764cf17f23ef9b5688ead7ae93dabbc1155049
parent 5a162ba7

libs/WindowManager/Shell/src/com/android/wm/shell/windowdecor/CaptionWindowDecoration.java

+0 −8
Original line number Diff line number Diff line
@@ -110,19 +110,11 @@ public class CaptionWindowDecoration extends WindowDecoration<WindowDecorLinearL 
        final SurfaceControl oldDecorationSurface = mDecorationContainerSurface;

        final WindowContainerTransaction wct = new WindowContainerTransaction();



        final int outsetLeftId = R.dimen.freeform_resize_handle;

        final int outsetTopId = R.dimen.freeform_resize_handle;

        final int outsetRightId = R.dimen.freeform_resize_handle;

        final int outsetBottomId = R.dimen.freeform_resize_handle;



        mRelayoutParams.reset();

        mRelayoutParams.mRunningTaskInfo = taskInfo;

        mRelayoutParams.mLayoutResId = R.layout.caption_window_decor;

        mRelayoutParams.mCaptionHeightId = R.dimen.freeform_decor_caption_height;

        mRelayoutParams.mShadowRadiusId = shadowRadiusID;

        if (isDragResizeable) {

            mRelayoutParams.setOutsets(outsetLeftId, outsetTopId, outsetRightId, outsetBottomId);

        }



        relayout(mRelayoutParams, startT, finishT, wct, oldRootView, mResult);

        // After this line, mTaskInfo is up-to-date and should be used instead of taskInfo

libs/WindowManager/Shell/src/com/android/wm/shell/windowdecor/DesktopModeWindowDecoration.java

+10 −24
Original line number Diff line number Diff line
@@ -208,11 +208,6 @@ public class DesktopModeWindowDecoration extends WindowDecoration<WindowDecorLin 
        final SurfaceControl oldDecorationSurface = mDecorationContainerSurface;

        final WindowContainerTransaction wct = new WindowContainerTransaction();



        final int outsetLeftId = R.dimen.freeform_resize_handle;

        final int outsetTopId = R.dimen.freeform_resize_handle;

        final int outsetRightId = R.dimen.freeform_resize_handle;

        final int outsetBottomId = R.dimen.freeform_resize_handle;



        final int windowDecorLayoutId = getDesktopModeWindowDecorLayoutId(

                taskInfo.getWindowingMode());

        mRelayoutParams.reset();
@@ -220,9 +215,6 @@ public class DesktopModeWindowDecoration extends WindowDecoration<WindowDecorLin 
        mRelayoutParams.mLayoutResId = windowDecorLayoutId;

        mRelayoutParams.mCaptionHeightId = R.dimen.freeform_decor_caption_height;

        mRelayoutParams.mShadowRadiusId = shadowRadiusID;

        if (isDragResizeable) {

            mRelayoutParams.setOutsets(outsetLeftId, outsetTopId, outsetRightId, outsetBottomId);

        }



        relayout(mRelayoutParams, startT, finishT, wct, oldRootView, mResult);

        // After this line, mTaskInfo is up-to-date and should be used instead of taskInfo
@@ -424,13 +416,12 @@ public class DesktopModeWindowDecoration extends WindowDecoration<WindowDecorLin 
        if (mRelayoutParams.mLayoutResId

                == R.layout.desktop_mode_app_controls_window_decor) {

            // Align the handle menu to the left of the caption.

            menuX = mRelayoutParams.mCaptionX - mResult.mDecorContainerOffsetX + mMarginMenuStart;

            menuY = mRelayoutParams.mCaptionY - mResult.mDecorContainerOffsetY + mMarginMenuTop;

            menuX = mRelayoutParams.mCaptionX + mMarginMenuStart;

            menuY = mRelayoutParams.mCaptionY + mMarginMenuTop;

        } else {

            // Position the handle menu at the center of the caption.

            menuX = mRelayoutParams.mCaptionX + (captionWidth / 2) - (mMenuWidth / 2)

                    - mResult.mDecorContainerOffsetX;

            menuY = mRelayoutParams.mCaptionY - mResult.mDecorContainerOffsetY + mMarginMenuStart;

            menuX = mRelayoutParams.mCaptionX + (captionWidth / 2) - (mMenuWidth / 2);

            menuY = mRelayoutParams.mCaptionY + mMarginMenuStart;

        }



        // App Info pill setup.
@@ -497,23 +488,18 @@ public class DesktopModeWindowDecoration extends WindowDecoration<WindowDecorLin 


        final boolean pointInAppInfoPill = pointInView(

                mHandleMenuAppInfoPill.mWindowViewHost.getView(),

                inputPoint.x - mHandleMenuAppInfoPillPosition.x - mResult.mDecorContainerOffsetX,

                inputPoint.y - mHandleMenuAppInfoPillPosition.y

                        - mResult.mDecorContainerOffsetY);

                inputPoint.x - mHandleMenuAppInfoPillPosition.x,

                inputPoint.y - mHandleMenuAppInfoPillPosition.y);

        boolean pointInWindowingPill = false;

        if (mHandleMenuWindowingPill != null) {

            pointInWindowingPill = pointInView(mHandleMenuWindowingPill.mWindowViewHost.getView(),

                    inputPoint.x - mHandleMenuWindowingPillPosition.x

                            - mResult.mDecorContainerOffsetX,

                    inputPoint.y - mHandleMenuWindowingPillPosition.y

                            - mResult.mDecorContainerOffsetY);

                    inputPoint.x - mHandleMenuWindowingPillPosition.x,

                    inputPoint.y - mHandleMenuWindowingPillPosition.y);

        }

        final boolean pointInMoreActionsPill = pointInView(

                mHandleMenuMoreActionsPill.mWindowViewHost.getView(),

                inputPoint.x - mHandleMenuMoreActionsPillPosition.x

                        - mResult.mDecorContainerOffsetX,

                inputPoint.y - mHandleMenuMoreActionsPillPosition.y

                        - mResult.mDecorContainerOffsetY);

                inputPoint.x - mHandleMenuMoreActionsPillPosition.x,

                inputPoint.y - mHandleMenuMoreActionsPillPosition.y);

        if (!pointInAppInfoPill && !pointInWindowingPill

                && !pointInMoreActionsPill && !pointInOpenMenuButton) {

            closeHandleMenu();

libs/WindowManager/Shell/src/com/android/wm/shell/windowdecor/DragResizeInputListener.java

+47 −41
Original line number Diff line number Diff line
@@ -64,8 +64,8 @@ class DragResizeInputListener implements AutoCloseable { 
    private final TaskResizeInputEventReceiver mInputEventReceiver;

    private final DragPositioningCallback mCallback;



    private int mWidth;

    private int mHeight;

    private int mTaskWidth;

    private int mTaskHeight;

    private int mResizeHandleThickness;

    private int mCornerSize;
@@ -128,78 +128,84 @@ class DragResizeInputListener implements AutoCloseable { 
     * This is also used to update the touch regions of this handler every event dispatched here is

     * a potential resize request.

     *

     * @param width The width of the drag resize handler in pixels, including resize handle

     *              thickness. That is task width + 2 * resize handle thickness.

     * @param height The height of the drag resize handler in pixels, including resize handle

     *               thickness. That is task height + 2 * resize handle thickness.

     * @param taskWidth The width of the task.

     * @param taskHeight The height of the task.

     * @param resizeHandleThickness The thickness of the resize handle in pixels.

     * @param cornerSize The size of the resize handle centered in each corner.

     * @param touchSlop The distance in pixels user has to drag with touch for it to register as

     *                  a resize action.

     */

    void setGeometry(int width, int height, int resizeHandleThickness, int cornerSize,

    void setGeometry(int taskWidth, int taskHeight, int resizeHandleThickness, int cornerSize,

            int touchSlop) {

        if (mWidth == width && mHeight == height

        if (mTaskWidth == taskWidth && mTaskHeight == taskHeight

                && mResizeHandleThickness == resizeHandleThickness

                && mCornerSize == cornerSize) {

            return;

        }



        mWidth = width;

        mHeight = height;

        mTaskWidth = taskWidth;

        mTaskHeight = taskHeight;

        mResizeHandleThickness = resizeHandleThickness;

        mCornerSize = cornerSize;

        mDragDetector.setTouchSlop(touchSlop);



        Region touchRegion = new Region();

        final Rect topInputBounds = new Rect(0, 0, mWidth, mResizeHandleThickness);

        final Rect topInputBounds = new Rect(

                -mResizeHandleThickness,

                -mResizeHandleThickness,

                mTaskWidth + mResizeHandleThickness,

                0);

        touchRegion.union(topInputBounds);



        final Rect leftInputBounds = new Rect(0, mResizeHandleThickness,

                mResizeHandleThickness, mHeight - mResizeHandleThickness);

        final Rect leftInputBounds = new Rect(

                -mResizeHandleThickness,

                0,

                0,

                mTaskHeight);

        touchRegion.union(leftInputBounds);



        final Rect rightInputBounds = new Rect(

                mWidth - mResizeHandleThickness, mResizeHandleThickness,

                mWidth, mHeight - mResizeHandleThickness);

                mTaskWidth,

                0,

                mTaskWidth + mResizeHandleThickness,

                mTaskHeight);

        touchRegion.union(rightInputBounds);



        final Rect bottomInputBounds = new Rect(0, mHeight - mResizeHandleThickness,

                mWidth, mHeight);

        final Rect bottomInputBounds = new Rect(

                -mResizeHandleThickness,

                mTaskHeight,

                mTaskWidth + mResizeHandleThickness,

                mTaskHeight + mResizeHandleThickness);

        touchRegion.union(bottomInputBounds);



        // Set up touch areas in each corner.

        int cornerRadius = mCornerSize / 2;

        mLeftTopCornerBounds = new Rect(

                mResizeHandleThickness - cornerRadius,

                mResizeHandleThickness - cornerRadius,

                mResizeHandleThickness + cornerRadius,

                mResizeHandleThickness + cornerRadius

        );

                -cornerRadius,

                -cornerRadius,

                cornerRadius,

                cornerRadius);

        touchRegion.union(mLeftTopCornerBounds);



        mRightTopCornerBounds = new Rect(

                mWidth - mResizeHandleThickness - cornerRadius,

                mResizeHandleThickness - cornerRadius,

                mWidth - mResizeHandleThickness + cornerRadius,

                mResizeHandleThickness + cornerRadius

        );

                mTaskWidth - cornerRadius,

                -cornerRadius,

                mTaskWidth + cornerRadius,

                cornerRadius);

        touchRegion.union(mRightTopCornerBounds);



        mLeftBottomCornerBounds = new Rect(

                mResizeHandleThickness - cornerRadius,

                mHeight - mResizeHandleThickness - cornerRadius,

                mResizeHandleThickness + cornerRadius,

                mHeight - mResizeHandleThickness + cornerRadius

        );

                -cornerRadius,

                mTaskHeight - cornerRadius,

                cornerRadius,

                mTaskHeight + cornerRadius);

        touchRegion.union(mLeftBottomCornerBounds);



        mRightBottomCornerBounds = new Rect(

                mWidth - mResizeHandleThickness - cornerRadius,

                mHeight - mResizeHandleThickness - cornerRadius,

                mWidth - mResizeHandleThickness + cornerRadius,

                mHeight - mResizeHandleThickness + cornerRadius

        );

                mTaskWidth - cornerRadius,

                mTaskHeight - cornerRadius,

                mTaskWidth + cornerRadius,

                mTaskHeight + cornerRadius);

        touchRegion.union(mRightBottomCornerBounds);



        try {
@@ -358,16 +364,16 @@ class DragResizeInputListener implements AutoCloseable { 
        @TaskPositioner.CtrlType

        private int calculateResizeHandlesCtrlType(float x, float y) {

            int ctrlType = 0;

            if (x < mResizeHandleThickness) {

            if (x < 0) {

                ctrlType |= TaskPositioner.CTRL_TYPE_LEFT;

            }

            if (x > mWidth - mResizeHandleThickness) {

            if (x > mTaskWidth) {

                ctrlType |= TaskPositioner.CTRL_TYPE_RIGHT;

            }

            if (y < mResizeHandleThickness) {

            if (y < 0) {

                ctrlType |= TaskPositioner.CTRL_TYPE_TOP;

            }

            if (y > mHeight - mResizeHandleThickness) {

            if (y > mTaskHeight) {

                ctrlType |= TaskPositioner.CTRL_TYPE_BOTTOM;

            }

            return ctrlType;

libs/WindowManager/Shell/src/com/android/wm/shell/windowdecor/WindowDecoration.java

+9 −53
Original line number Diff line number Diff line
@@ -98,7 +98,6 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 


    private final Binder mOwner = new Binder();

    private final Rect mCaptionInsetsRect = new Rect();

    private final Rect mTaskSurfaceCrop = new Rect();

    private final float[] mTmpColor = new float[3];



    WindowDecoration(
@@ -218,21 +217,14 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 


        final Rect taskBounds = taskConfig.windowConfiguration.getBounds();

        final Resources resources = mDecorWindowContext.getResources();

        outResult.mDecorContainerOffsetX = -loadDimensionPixelSize(resources, params.mOutsetLeftId);

        outResult.mDecorContainerOffsetY = -loadDimensionPixelSize(resources, params.mOutsetTopId);

        outResult.mWidth = taskBounds.width()

                + loadDimensionPixelSize(resources, params.mOutsetRightId)

                - outResult.mDecorContainerOffsetX;

        outResult.mHeight = taskBounds.height()

                + loadDimensionPixelSize(resources, params.mOutsetBottomId)

                - outResult.mDecorContainerOffsetY;

        startT.setPosition(

                        mDecorationContainerSurface,

                        outResult.mDecorContainerOffsetX, outResult.mDecorContainerOffsetY)

                .setWindowCrop(mDecorationContainerSurface,

                        outResult.mWidth, outResult.mHeight)

        outResult.mWidth = taskBounds.width();

        outResult.mHeight = taskBounds.height();

        startT.setWindowCrop(mDecorationContainerSurface, outResult.mWidth, outResult.mHeight)

                .show(mDecorationContainerSurface);



        // TODO(b/270202228): This surface can be removed. Instead, use

        //  |mDecorationContainerSurface| to set the background now that it no longer has outsets

        //  and its crop is set to the task bounds.

        // TaskBackgroundSurface

        if (mTaskBackgroundSurface == null) {

            final SurfaceControl.Builder builder = mSurfaceControlBuilderSupplier.get();
@@ -250,8 +242,7 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 
        mTmpColor[0] = (float) Color.red(backgroundColorInt) / 255.f;

        mTmpColor[1] = (float) Color.green(backgroundColorInt) / 255.f;

        mTmpColor[2] = (float) Color.blue(backgroundColorInt) / 255.f;

        startT.setWindowCrop(mTaskBackgroundSurface, taskBounds.width(),

                        taskBounds.height())

        startT.setWindowCrop(mTaskBackgroundSurface, taskBounds.width(), taskBounds.height())

                .setShadowRadius(mTaskBackgroundSurface, shadowRadius)

                .setColor(mTaskBackgroundSurface, mTmpColor)

                .show(mTaskBackgroundSurface);
@@ -269,11 +260,7 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 
        final int captionHeight = loadDimensionPixelSize(resources, params.mCaptionHeightId);

        final int captionWidth = taskBounds.width();



        startT.setPosition(

                        mCaptionContainerSurface,

                        -outResult.mDecorContainerOffsetX + params.mCaptionX,

                        -outResult.mDecorContainerOffsetY + params.mCaptionY)

                .setWindowCrop(mCaptionContainerSurface, captionWidth, captionHeight)

        startT.setWindowCrop(mCaptionContainerSurface, captionWidth, captionHeight)

                .show(mCaptionContainerSurface);



        if (mCaptionWindowManager == null) {
@@ -314,14 +301,9 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 


        // Task surface itself

        Point taskPosition = mTaskInfo.positionInParent;

        mTaskSurfaceCrop.set(

                outResult.mDecorContainerOffsetX,

                outResult.mDecorContainerOffsetY,

                outResult.mWidth + outResult.mDecorContainerOffsetX,

                outResult.mHeight + outResult.mDecorContainerOffsetY);

        startT.show(mTaskSurface);

        finishT.setPosition(mTaskSurface, taskPosition.x, taskPosition.y)

                .setCrop(mTaskSurface, mTaskSurfaceCrop);

                .setWindowCrop(mTaskSurface, outResult.mWidth, outResult.mHeight);

    }



    /**
@@ -447,37 +429,15 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 
        int mCaptionWidthId;

        int mShadowRadiusId;



        int mOutsetTopId;

        int mOutsetBottomId;

        int mOutsetLeftId;

        int mOutsetRightId;



        int mCaptionX;

        int mCaptionY;



        void setOutsets(int leftId, int topId, int rightId, int bottomId) {

            mOutsetLeftId = leftId;

            mOutsetTopId = topId;

            mOutsetRightId = rightId;

            mOutsetBottomId = bottomId;

        }



        void setCaptionPosition(int left, int top) {

            mCaptionX = left;

            mCaptionY = top;

        }



        void reset() {

            mLayoutResId = Resources.ID_NULL;

            mCaptionHeightId = Resources.ID_NULL;

            mCaptionWidthId = Resources.ID_NULL;

            mShadowRadiusId = Resources.ID_NULL;



            mOutsetTopId = Resources.ID_NULL;

            mOutsetBottomId = Resources.ID_NULL;

            mOutsetLeftId = Resources.ID_NULL;

            mOutsetRightId = Resources.ID_NULL;



            mCaptionX = 0;

            mCaptionY = 0;

        }
@@ -487,14 +447,10 @@ public abstract class WindowDecoration<T extends View & TaskFocusStateConsumer> 
        int mWidth;

        int mHeight;

        T mRootView;

        int mDecorContainerOffsetX;

        int mDecorContainerOffsetY;



        void reset() {

            mWidth = 0;

            mHeight = 0;

            mDecorContainerOffsetX = 0;

            mDecorContainerOffsetY = 0;

            mRootView = null;

        }

    }

libs/WindowManager/Shell/tests/unittest/src/com/android/wm/shell/windowdecor/WindowDecorationTests.java

+9 −42
Original line number Diff line number Diff line
@@ -159,14 +159,8 @@ public class WindowDecorationTests extends ShellTestCase { 
                .setVisible(false)

                .build();

        taskInfo.isFocused = false;

        // Density is 2. Outsets are (20, 40, 60, 80) px. Shadow radius is 10px. Caption height is

        // 64px.

        // Density is 2. Shadow radius is 10px. Caption height is 64px.

        taskInfo.configuration.densityDpi = DisplayMetrics.DENSITY_DEFAULT * 2;

        mRelayoutParams.setOutsets(

                R.dimen.test_window_decor_left_outset,

                R.dimen.test_window_decor_top_outset,

                R.dimen.test_window_decor_right_outset,

                R.dimen.test_window_decor_bottom_outset);



        final SurfaceControl taskSurface = mock(SurfaceControl.class);

        final TestWindowDecoration windowDecor = createWindowDecoration(taskInfo, taskSurface);
@@ -213,14 +207,8 @@ public class WindowDecorationTests extends ShellTestCase { 
                .setVisible(true)

                .build();

        taskInfo.isFocused = true;

        // Density is 2. Outsets are (20, 40, 60, 80) px. Shadow radius is 10px. Caption height is

        // 64px.

        // Density is 2. Shadow radius is 10px. Caption height is 64px.

        taskInfo.configuration.densityDpi = DisplayMetrics.DENSITY_DEFAULT * 2;

        mRelayoutParams.setOutsets(

                R.dimen.test_window_decor_left_outset,

                R.dimen.test_window_decor_top_outset,

                R.dimen.test_window_decor_right_outset,

                R.dimen.test_window_decor_bottom_outset);

        final SurfaceControl taskSurface = mock(SurfaceControl.class);

        final TestWindowDecoration windowDecor = createWindowDecoration(taskInfo, taskSurface);
@@ -229,8 +217,7 @@ public class WindowDecorationTests extends ShellTestCase { 
        verify(decorContainerSurfaceBuilder).setParent(taskSurface);

        verify(decorContainerSurfaceBuilder).setContainerLayer();

        verify(mMockSurfaceControlStartT).setTrustedOverlay(decorContainerSurface, true);

        verify(mMockSurfaceControlStartT).setPosition(decorContainerSurface, -20, -40);

        verify(mMockSurfaceControlStartT).setWindowCrop(decorContainerSurface, 380, 220);

        verify(mMockSurfaceControlStartT).setWindowCrop(decorContainerSurface, 300, 100);



        verify(taskBackgroundSurfaceBuilder).setParent(taskSurface);

        verify(taskBackgroundSurfaceBuilder).setEffectLayer();
@@ -244,7 +231,6 @@ public class WindowDecorationTests extends ShellTestCase { 


        verify(captionContainerSurfaceBuilder).setParent(decorContainerSurface);

        verify(captionContainerSurfaceBuilder).setContainerLayer();

        verify(mMockSurfaceControlStartT).setPosition(captionContainerSurface, 20, 40);

        verify(mMockSurfaceControlStartT).setWindowCrop(captionContainerSurface, 300, 64);

        verify(mMockSurfaceControlStartT).show(captionContainerSurface);
@@ -268,12 +254,12 @@ public class WindowDecorationTests extends ShellTestCase { 
        verify(mMockSurfaceControlFinishT)

                .setPosition(taskSurface, TASK_POSITION_IN_PARENT.x, TASK_POSITION_IN_PARENT.y);

        verify(mMockSurfaceControlFinishT)

                .setCrop(taskSurface, new Rect(-20, -40, 360, 180));

                .setWindowCrop(taskSurface, 300, 100);

        verify(mMockSurfaceControlStartT)

                .show(taskSurface);



        assertEquals(380, mRelayoutResult.mWidth);

        assertEquals(220, mRelayoutResult.mHeight);

        assertEquals(300, mRelayoutResult.mWidth);

        assertEquals(100, mRelayoutResult.mHeight);

    }



    @Test
@@ -309,14 +295,8 @@ public class WindowDecorationTests extends ShellTestCase { 
                .setVisible(true)

                .build();

        taskInfo.isFocused = true;

        // Density is 2. Outsets are (20, 40, 60, 80) px. Shadow radius is 10px. Caption height is

        // 64px.

        // Density is 2. Shadow radius is 10px. Caption height is 64px.

        taskInfo.configuration.densityDpi = DisplayMetrics.DENSITY_DEFAULT * 2;

        mRelayoutParams.setOutsets(

                R.dimen.test_window_decor_left_outset,

                R.dimen.test_window_decor_top_outset,

                R.dimen.test_window_decor_right_outset,

                R.dimen.test_window_decor_bottom_outset);



        final SurfaceControl taskSurface = mock(SurfaceControl.class);

        final TestWindowDecoration windowDecor = createWindowDecoration(taskInfo, taskSurface);
@@ -419,11 +399,6 @@ public class WindowDecorationTests extends ShellTestCase { 
                .build();

        taskInfo.isFocused = true;

        taskInfo.configuration.densityDpi = DisplayMetrics.DENSITY_DEFAULT * 2;

        mRelayoutParams.setOutsets(

                R.dimen.test_window_decor_left_outset,

                R.dimen.test_window_decor_top_outset,

                R.dimen.test_window_decor_right_outset,

                R.dimen.test_window_decor_bottom_outset);

        final SurfaceControl taskSurface = mock(SurfaceControl.class);

        final TestWindowDecoration windowDecor = createWindowDecoration(taskInfo, taskSurface);

        windowDecor.relayout(taskInfo);
@@ -438,7 +413,7 @@ public class WindowDecorationTests extends ShellTestCase { 
        verify(additionalWindowSurfaceBuilder).setContainerLayer();

        verify(additionalWindowSurfaceBuilder).setParent(decorContainerSurface);

        verify(additionalWindowSurfaceBuilder).build();

        verify(mMockSurfaceControlAddWindowT).setPosition(additionalWindowSurface, 20, 40);

        verify(mMockSurfaceControlAddWindowT).setPosition(additionalWindowSurface, 0, 0);

        final int width = WindowDecoration.loadDimensionPixelSize(

                mContext.getResources(), mCaptionMenuWidthId);

        final int height = WindowDecoration.loadDimensionPixelSize(
@@ -496,11 +471,6 @@ public class WindowDecorationTests extends ShellTestCase { 
                .build();

        taskInfo.isFocused = true;

        taskInfo.configuration.densityDpi = DisplayMetrics.DENSITY_DEFAULT * 2;

        mRelayoutParams.setOutsets(

                R.dimen.test_window_decor_left_outset,

                R.dimen.test_window_decor_top_outset,

                R.dimen.test_window_decor_right_outset,

                R.dimen.test_window_decor_bottom_outset);

        final SurfaceControl taskSurface = mock(SurfaceControl.class);

        final TestWindowDecoration windowDecor = createWindowDecoration(taskInfo, taskSurface);
@@ -508,7 +478,6 @@ public class WindowDecorationTests extends ShellTestCase { 


        verify(captionContainerSurfaceBuilder).setParent(decorContainerSurface);

        verify(captionContainerSurfaceBuilder).setContainerLayer();

        verify(mMockSurfaceControlStartT).setPosition(captionContainerSurface, 20, 40);

        // Width of the captionContainerSurface should match the width of TASK_BOUNDS

        verify(mMockSurfaceControlStartT).setWindowCrop(captionContainerSurface, 300, 64);

        verify(mMockSurfaceControlStartT).show(captionContainerSurface);
@@ -584,9 +553,7 @@ public class WindowDecorationTests extends ShellTestCase { 
            String name = "Test Window";

            WindowDecoration.AdditionalWindow additionalWindow =

                    addWindow(R.layout.desktop_mode_window_decor_handle_menu_app_info_pill, name,

                            mMockSurfaceControlAddWindowT,

                            x - mRelayoutResult.mDecorContainerOffsetX,

                            y - mRelayoutResult.mDecorContainerOffsetY,

                            mMockSurfaceControlAddWindowT, x, y,

                            width, height, shadowRadius, cornerRadius);

            return additionalWindow;

        }