From 6837519a9181891c55ad286dd24aa211a536842d Mon Sep 17 00:00:00 2001
From: Robert Carr <racarr@google.com>
Date: Tue, 13 Jun 2017 12:41:53 -0700
Subject: [PATCH] Correct errant entry in to DRAG_RESIZE_FREEFORM state.

Observing the logic in computeDragResizing(), we see that whenever an
AppWindowToken has frozen bounds we will enter the drag resizing
state. Furthermore, in setDragResizing() we see that if the docked
divider is not resizing, then we set ourselves as freeform
resizing. Also observe that AppWindowToken#startRelaunching
unconditionally freezes the bounds for tasks not in the freeform
stack. This means we are almost always entering the freeform resize
state while relaunching. Within computeDragResizing, the StackId check
and the MATCH_PARENT check have prevented this from being an issue in
too many places, espescially in pinned.

Once we are in this state, calculateSurfaceBounds() will force us to
0,0 as it thinks we are using the big surface approach.

There's no need to freeze the bounds if we weren't drag resizing at
the time that the app is relaunched, and this CL enforces that.

Bug: 62430780
Test: Manual repro from bug. To verify no regressions, create app with long delay in onResume (>1s) verify no flickers when releasing the docked divider and triggering a resize.
      go/wm-smoke

Change-Id: I1d9bdfbe815ff48c884f933acd65612429d633ef
---
 .../com/android/server/wm/AppWindowToken.java | 40 +++++++++++--------
 1 file changed, 23 insertions(+), 17 deletions(-)

diff --git a/services/core/java/com/android/server/wm/AppWindowToken.java b/services/core/java/com/android/server/wm/AppWindowToken.java
index 71ecaf61da485..350a333cc8931 100644
--- a/services/core/java/com/android/server/wm/AppWindowToken.java
+++ b/services/core/java/com/android/server/wm/AppWindowToken.java
@@ -891,8 +891,24 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree
         return mPendingRelaunchCount > 0;
     }
 
+    boolean shouldFreezeBounds() {
+        final Task task = getTask();
+
+        // For freeform windows, we can't freeze the bounds at the moment because this would make
+        // the resizing unresponsive.
+        if (task == null || task.inFreeformWorkspace()) {
+            return false;
+        }
+
+        // We freeze the bounds while drag resizing to deal with the time between
+        // the divider/drag handle being released, and the handling it's new
+        // configuration. If we are relaunched outside of the drag resizing state,
+        // we need to be careful not to do this.
+        return getTask().isDragResizing();
+    }
+
     void startRelaunching() {
-        if (canFreezeBounds()) {
+        if (shouldFreezeBounds()) {
             freezeBounds();
         }
 
@@ -909,9 +925,8 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree
     }
 
     void finishRelaunching() {
-        if (canFreezeBounds()) {
-            unfreezeBounds();
-        }
+        unfreezeBounds();
+
         if (mPendingRelaunchCount > 0) {
             mPendingRelaunchCount--;
         } else {
@@ -926,9 +941,7 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree
         if (mPendingRelaunchCount == 0) {
             return;
         }
-        if (canFreezeBounds()) {
-            unfreezeBounds();
-        }
+        unfreezeBounds();
         mPendingRelaunchCount = 0;
     }
 
@@ -1032,14 +1045,6 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree
         }
     }
 
-    private boolean canFreezeBounds() {
-        final Task task = getTask();
-
-        // For freeform windows, we can't freeze the bounds at the moment because this would make
-        // the resizing unresponsive.
-        return task != null && !task.inFreeformWorkspace();
-    }
-
     /**
      * Freezes the task bounds. The size of this task reported the app will be fixed to the bounds
      * freezed by {@link Task#prepareFreezingBounds} until {@link #unfreezeBounds} gets called, even
@@ -1064,9 +1069,10 @@ class AppWindowToken extends WindowToken implements WindowManagerService.AppFree
      * Unfreezes the previously frozen bounds. See {@link #freezeBounds}.
      */
     private void unfreezeBounds() {
-        if (!mFrozenBounds.isEmpty()) {
-            mFrozenBounds.remove();
+        if (mFrozenBounds.isEmpty()) {
+            return;
         }
+        mFrozenBounds.remove();
         if (!mFrozenMergedConfig.isEmpty()) {
             mFrozenMergedConfig.remove();
         }