Merge changes I9bf357f3,Ia83b74fc

            new TaskForResizePointSearchResult();

    private final ApplySurfaceChangesTransactionState mTmpApplySurfaceChangesTransactionState =

            new ApplySurfaceChangesTransactionState();

    private final ScreenshotApplicationState mScreenshotApplicationState =

            new ScreenshotApplicationState();

    private final Transaction mTmpTransaction = new Transaction();

    // True if this display is in the process of being removed. Used to determine if the removal of

    // the display's direct children should be allowed.

            mWallpaperController.updateWallpaperVisibility();

        }

        w.handleWindowMovedIfNeeded(mPendingTransaction);

        // Use mTmpTransaction instead of mPendingTransaction because we don't want to commit

        // other changes in mPendingTransaction at this point.

        w.handleWindowMovedIfNeeded(mTmpTransaction);

        SurfaceControl.mergeToGlobalTransaction(mTmpTransaction);

        final WindowStateAnimator winAnimator = w.mWinAnimator;

                    }

                }

            }

            final TaskStack stack = w.getStack();

            if (!winAnimator.isWaitingForOpening()

                    || (stack != null && stack.isAnimatingBounds())) {

                // Updates the shown frame before we set up the surface. This is needed

                // because the resizing could change the top-left position (in addition to

                // size) of the window. setSurfaceBoundariesLocked uses mShownPosition to

                // position the surface.

                //

                // If an animation is being started, we can't call this method because the

                // animation hasn't processed its initial transformation yet, but in general

                // we do want to update the position if the window is animating. We make an exception

                // for the bounds animating state, where an application may have been waiting

                // for an exit animation to start, but instead enters PiP. We need to ensure

                // we always recompute the top-left in this case.

                winAnimator.computeShownFrameLocked();

            }

            winAnimator.setSurfaceBoundariesLocked(mTmpRecoveringMemory /* recoveringMemory */);

            // Since setSurfaceBoundariesLocked applies the clipping, we need to apply the position

            // to the surface of the window container and also the position of the stack window

            // container as well. Use mTmpTransaction instead of mPendingTransaction to avoid

            // committing any existing changes in there.

            w.updateSurfacePosition(mTmpTransaction);

            if (stack != null) {

                stack.updateSurfaceBounds(mTmpTransaction);

            }

            SurfaceControl.mergeToGlobalTransaction(mTmpTransaction);

        }

        final AppWindowToken atoken = w.mAppToken;

        mTmpRecoveringMemory = recoveringMemory;

        forAllWindows(mApplySurfaceChangesTransaction, true /* traverseTopToBottom */);

        prepareSurfaces();

        mService.mDisplayManagerInternal.setDisplayProperties(mDisplayId,

                mTmpApplySurfaceChangesTransactionState.displayHasContent,

import android.annotation.CallSuper;

import android.content.res.Configuration;

import android.graphics.Point;

import android.graphics.Rect;

import android.graphics.Region;

import android.os.RemoteException;

     * For {@link #prepareSurfaces}.

     */

    final Rect mTmpDimBoundsRect = new Rect();

    private final Point mLastSurfaceSize = new Point();

    TaskStack(WindowManagerService service, int stackId, StackWindowController controller) {

        super(service);

        }

        final Rect stackBounds = getBounds();

        final int width = stackBounds.width();

        final int height = stackBounds.height();

        if (width == mLastSurfaceSize.x && height == mLastSurfaceSize.y) {

            return;

        }

        transaction.setSize(mSurfaceControl, width, height);

        mLastSurfaceSize.set(width, height);

        transaction.setSize(mSurfaceControl, stackBounds.width(), stackBounds.height());

    }

    @Override

    protected final WindowManagerService mService;

    private final Point mTmpPos = new Point();

    protected final Point mLastSurfacePosition = new Point();

    /** Total number of elements in this subtree, including our own hierarchy element. */

    private int mTreeWeight = 1;

        }

        getRelativePosition(mTmpPos);

        if (mTmpPos.equals(mLastSurfacePosition)) {

            return;

        }

        transaction.setPosition(mSurfaceControl, mTmpPos.x, mTmpPos.y);

        mLastSurfacePosition.set(mTmpPos.x, mTmpPos.y);

        for (int i = mChildren.size() - 1; i >= 0; i--) {

            mChildren.get(i).updateSurfacePosition(transaction);

        // Leash is now responsible for position, so set our position to 0.

        t.setPosition(mSurfaceControl, 0, 0);

        mLastSurfacePosition.set(0, 0);

    }

    @Override

        }

        transformFrameToSurfacePosition(mFrame.left, mFrame.top, mSurfacePosition);

        if (!mSurfaceAnimator.hasLeash() && !mLastSurfacePosition.equals(mSurfacePosition)) {

        if (!mSurfaceAnimator.hasLeash()) {

            t.setPosition(mSurfaceControl, mSurfacePosition.x, mSurfacePosition.y);

            mLastSurfacePosition.set(mSurfacePosition.x, mSurfacePosition.y);

        }

    }