Set the dragged window as active window on window drag ended.

changes in this cl,
- Added overview exit type kWindowDragged for ending overview on window
  drag.
- Set the dragged window as active window on window drag ended, this will
  make sure the dragged window will not lost its activation on overview
  ended.
- Update the non-dragged windows' bounds at the end of animation. Since
  we want no animation if overview ends on window drag, including the
  update bounds animation. Set the animation type to ZERO for all the
  other windows except the dragged window. Then we can only see the update
  bounds animation of the dragged window. All the other windows' bounds
  will be updated at the end of the animation, which can not be seen by
  users.

Bug: 883579
Change-Id: I6a523e6be7caf32757299462cdf6197574768be2
Reviewed-on: https://chromium-review.googlesource.com/1232957
Commit-Queue: Min Chen <minch@chromium.org>
Reviewed-by: Xiaoqian Dai <xdai@chromium.org>
Reviewed-by: Xiyuan Xia <xiyuan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#593715}

ash/wm/overview/window_selector.h

@@ -78,7 +78,12 @@ class ASH_EXPORT WindowSelector : public display::DisplayObserver,
     // Overview can be closed by swiping up from the shelf. In this mode, the
     // call site will handle shifting the bounds of the windows, so overview
     // code does not need to handle any animations. This is an exit only type.
-    kSwipeFromShelf
+    kSwipeFromShelf,
+    // Overview can be opened by start dragging a window from top or be closed
+    // if the dragged window restores back to maximized/full-screened. Used as
+    // an exit type only currently to avoid the update bounds animation of the
+    // windows in overview grid on overview mode ended.
+    kWindowDragged
   };
 
   // Callback which fills out the passed settings object. Used by several

ash/wm/overview/window_selector_controller.cc

@@ -291,7 +291,8 @@ bool WindowSelectorController::ToggleOverview(
       return true;
 
     window_selector_->set_enter_exit_overview_type(new_type);
-    if (type != WindowSelector::EnterExitOverviewType::kNormal) {
+    if (type == WindowSelector::EnterExitOverviewType::kWindowsMinimized ||
+        type == WindowSelector::EnterExitOverviewType::kSwipeFromShelf) {
       // Minimize the windows without animations. When the home launcher button
       // is pressed, minimized widgets will get created in their place, and
       // those widgets will be slid out of overview. Otherwise,

ash/wm/splitview/split_view_controller.cc

@@ -126,6 +126,14 @@ bool IsSnapped(aura::Window* window) {
   return wm::GetWindowState(window)->IsSnapped();
 }
 
+// Returns the window selector if overview mode is active, otherwise returns
+// nullptr.
+WindowSelector* GetWindowSelector() {
+  return Shell::Get()->window_selector_controller()->IsSelecting()
+             ? Shell::Get()->window_selector_controller()->window_selector()
+             : nullptr;
+}
+
 }  // namespace
 
 // The window observer that observes the current tab-dragged window. When it's
@@ -724,8 +732,7 @@ void SplitViewController::OnOverviewModeStarting() {
 void SplitViewController::OnOverviewModeEnding() {
   DCHECK(IsSplitViewModeActive());
 
-  WindowSelector* window_selector =
-      Shell::Get()->window_selector_controller()->window_selector();
+  WindowSelector* window_selector = GetWindowSelector();
   // Early exit if overview is ended while swiping up on the shelf to avoid
   // snapping a window or showing a toast.
   if (window_selector->enter_exit_overview_type() ==
@@ -1401,8 +1408,7 @@ void SplitViewController::RemoveWindowFromOverviewIfApplicable(
   if (!Shell::Get()->window_selector_controller()->IsSelecting())
     return;
 
-  WindowSelector* window_selector =
-      Shell::Get()->window_selector_controller()->window_selector();
+  WindowSelector* window_selector = GetWindowSelector();
   WindowGrid* current_grid =
       window_selector->GetGridWithRootWindow(window->GetRootWindow());
   if (!current_grid)
@@ -1430,10 +1436,9 @@ void SplitViewController::UpdateSnappingWindowTransformedBounds(
 }
 
 void SplitViewController::InsertWindowToOverview(aura::Window* window) {
-  if (!window || !Shell::Get()->window_selector_controller()->IsSelecting())
+  if (!window || !GetWindowSelector())
     return;
-  Shell::Get()->window_selector_controller()->window_selector()->AddItem(
-      window, /*reposition=*/true, /*animate=*/true);
+  GetWindowSelector()->AddItem(window, /*reposition=*/true, /*animate=*/true);
 }
 
 void SplitViewController::StartOverview() {
@@ -1461,13 +1466,8 @@ void SplitViewController::EndWindowDragImpl(
     const gfx::Point& last_location_in_screen) {
   // If dragged window was in overview before or it has been added to overview
   // window by dropping on the new selector item, do nothing.
-  WindowSelectorController* window_selector_controller =
-      Shell::Get()->window_selector_controller();
-  if (window_selector_controller->IsSelecting() &&
-      window_selector_controller->window_selector()->IsWindowInOverview(
-          window)) {
+  if (GetWindowSelector() && GetWindowSelector()->IsWindowInOverview(window))
     return;
-  }
 
   const bool was_splitview_active = IsSplitViewModeActive();
   if (desired_snap_position == SplitViewController::NONE) {
@@ -1486,13 +1486,20 @@ void SplitViewController::EndWindowDragImpl(
       SetTransformWithAnimation(window, window->layer()->GetTargetTransform(),
                                 gfx::Transform());
 
-      if (window_selector_controller->IsSelecting()) {
-        window_selector_controller->window_selector()
-            ->SetWindowListNotAnimatedWhenExiting(window->GetRootWindow());
-        // End the overview mode if it's active at the moment. The dragged
-        // window will be restored back to its previous state before dragging.
-        EndOverview();
+      WindowSelector* window_selector = GetWindowSelector();
+      if (window_selector) {
+        window_selector->SetWindowListNotAnimatedWhenExiting(
+            window->GetRootWindow());
+        // Set the overview exit type to kWindowDragged to avoid update bounds
+        // animation of the windows in overview grid.
+        window_selector->set_enter_exit_overview_type(
+            WindowSelector::EnterExitOverviewType::kWindowDragged);
       }
+      // Activate the dragged window will end the overview at the same time.The
+      // dragged window will be restored back to its previous state before
+      // dragging.
+      wm::ActivateWindow(window);
+      DCHECK(!Shell::Get()->window_selector_controller()->IsSelecting());
     }
   } else {
     // Note SnapWindow() might put the previous window that was snapped at the

ash/wm/splitview/split_view_controller_unittest.cc

@@ -2839,6 +2839,51 @@ TEST_F(SplitViewTabDraggingTest, SourceWindowBackgroundTest) {
     EXPECT_TRUE(Shell::Get()->app_list_controller()->IsVisible());
 }
 
+// Tests that the dragged window should be the active and top window if overview
+// ended because of window drag.
+TEST_F(SplitViewTabDraggingTest, OverviewEndedOnWindowDrag) {
+  const gfx::Rect bounds(0, 0, 400, 400);
+  std::unique_ptr<aura::Window> window1(
+      CreateWindowWithType(bounds, AppType::BROWSER));
+  std::unique_ptr<aura::Window> window2(
+      CreateWindowWithType(bounds, AppType::BROWSER));
+  split_view_controller()->SnapWindow(window1.get(), SplitViewController::LEFT);
+  split_view_controller()->SnapWindow(window2.get(),
+                                      SplitViewController::RIGHT);
+
+  // Drags |window2| to overview.
+  std::unique_ptr<WindowResizer> resizer =
+      StartDrag(window2.get(), window2.get());
+  gfx::Rect new_selector_item_bounds =
+      GetNewSelectorItemBoundsDuringDrag(window1.get());
+  DragWindowTo(resizer.get(), new_selector_item_bounds.CenterPoint());
+  CompleteDrag(std::move(resizer));
+  WindowSelectorController* selector_controller =
+      Shell::Get()->window_selector_controller();
+  EXPECT_TRUE(selector_controller->IsSelecting());
+  EXPECT_TRUE(selector_controller->window_selector()->IsWindowInOverview(
+      window2.get()));
+  EXPECT_EQ(split_view_controller()->state(),
+            SplitViewController::LEFT_SNAPPED);
+
+  // Drags |window1| by a small distance. Both splitview and overview should be
+  // ended and |window1| is the active window and above |window2|.
+  resizer = StartDrag(window1.get(), window1.get());
+  DragWindowTo(resizer.get(), gfx::Point(10, 10));
+  CompleteDrag(std::move(resizer));
+  EXPECT_FALSE(selector_controller->IsSelecting());
+  EXPECT_FALSE(split_view_controller()->IsSplitViewModeActive());
+  EXPECT_TRUE(wm::GetWindowState(window1.get())->IsMaximized());
+  EXPECT_TRUE(wm::GetWindowState(window2.get())->IsMaximized());
+  EXPECT_TRUE(wm::GetWindowState(window1.get())->IsActive());
+  EXPECT_FALSE(wm::GetWindowState(window2.get())->IsActive());
+  // |window1| should above |window2|.
+  const aura::Window::Windows windows = window1->parent()->children();
+  auto window1_layer = std::find(windows.begin(), windows.end(), window1.get());
+  auto window2_layer = std::find(windows.begin(), windows.end(), window2.get());
+  EXPECT_TRUE(window1_layer > window2_layer);
+}
+
 class TestWindowDelegateWithWidget : public views::WidgetDelegate {
  public:
   TestWindowDelegateWithWidget(bool can_activate)

ash/wm/tablet_mode/tablet_mode_window_manager.cc

@@ -85,12 +85,36 @@ void TabletModeWindowManager::WindowStateDestroyed(aura::Window* window) {
 
 void TabletModeWindowManager::OnOverviewModeStarting() {
   for (auto& pair : window_state_map_)
-    SetDeferBoundsUpdates(pair.first, true);
+    SetDeferBoundsUpdates(pair.first, /*defer_bounds_updates=*/true);
+}
+
+void TabletModeWindowManager::OnOverviewModeEnding() {
+  WindowSelector* window_selector =
+      Shell::Get()->window_selector_controller()->window_selector();
+  exit_overview_by_window_drag_ =
+      window_selector->enter_exit_overview_type() ==
+      WindowSelector::EnterExitOverviewType::kWindowDragged;
 }
 
 void TabletModeWindowManager::OnOverviewModeEnded() {
-  for (auto& pair : window_state_map_)
-    SetDeferBoundsUpdates(pair.first, false);
+  for (auto& pair : window_state_map_) {
+    // We don't want any animation if overview exits because of dragging a
+    // window from top, including the window update bounds animation. Set the
+    // animation tween type to ZERO for all the other windows except the dragged
+    // window(active window). Then the dragged window can still be animated to
+    // its target bounds but all the other windows' bounds will be updated at
+    // the end of the animation.
+    pair.second->set_use_zero_animation_type(
+        exit_overview_by_window_drag_ &&
+        !wm::GetWindowState(pair.first)->IsActive());
+
+    SetDeferBoundsUpdates(pair.first, /*defer_bounds_updates=*/false);
+    // SetDeferBoundsUpdates is called with /*defer_bounds_updates=*/false
+    // hence the window bounds is updated with proper zero animation type
+    // flag. Reset the flag here so that it does not affect window bounds
+    // update later.
+    pair.second->set_use_zero_animation_type(false);
+  }
 }
 
 void TabletModeWindowManager::OnSplitViewModeEnded() {

ash/wm/tablet_mode/tablet_mode_window_manager.h

@@ -59,6 +59,7 @@ class ASH_EXPORT TabletModeWindowManager
 
   // ShellObserver:
   void OnOverviewModeStarting() override;
+  void OnOverviewModeEnding() override;
   void OnOverviewModeEnded() override;
   void OnSplitViewModeEnded() override;
 
@@ -146,6 +147,9 @@ class ASH_EXPORT TabletModeWindowManager
 
   std::unique_ptr<wm::TabletModeEventHandler> event_handler_;
 
+  // True if overview exit type is |kWindowDragged|.
+  bool exit_overview_by_window_drag_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(TabletModeWindowManager);
 };
 

ash/wm/tablet_mode/tablet_mode_window_state.cc

@@ -174,8 +174,7 @@ TabletModeWindowState::TabletModeWindowState(aura::Window* window,
                                              TabletModeWindowManager* creator)
     : window_(window),
       creator_(creator),
-      current_state_type_(wm::GetWindowState(window)->GetStateType()),
-      defer_bounds_updates_(false) {
+      current_state_type_(wm::GetWindowState(window)->GetStateType()) {
   old_state_.reset(wm::GetWindowState(window)
                        ->SetStateObject(std::unique_ptr<State>(this))
                        .release());
@@ -449,6 +448,11 @@ void TabletModeWindowState::UpdateBounds(wm::WindowState* window_state,
     if (!window_state->window()->IsVisible() || !animated) {
       window_state->SetBoundsDirect(bounds_in_parent);
     } else {
+      if (use_zero_animation_type_) {
+        window_state->SetBoundsDirectCrossFade(bounds_in_parent,
+                                               gfx::Tween::ZERO);
+        return;
+      }
       // If we animate (to) tablet mode, we want to use the cross fade to
       // avoid flashing.
       if (window_state->IsMaximized())

ash/wm/tablet_mode/tablet_mode_window_state.h

@@ -47,6 +47,10 @@ class TabletModeWindowState : public wm::WindowState::State {
                    wm::WindowState::State* previous_state) override;
   void DetachState(wm::WindowState* window_state) override;
 
+  void set_use_zero_animation_type(bool use_zero_animation_type) {
+    use_zero_animation_type_ = use_zero_animation_type;
+  }
+
  private:
   // Updates the window to |new_state_type| and resulting bounds:
   // Either full screen, maximized centered or minimized. If the state does not
@@ -87,7 +91,11 @@ class TabletModeWindowState : public wm::WindowState::State {
   mojom::WindowStateType current_state_type_;
 
   // If true, do not update bounds.
-  bool defer_bounds_updates_;
+  bool defer_bounds_updates_ = false;
+
+  // If true, the animation type will be set to ZERO, which means the bounds
+  // will be updated at the end of the animation.
+  bool use_zero_animation_type_ = false;
 
   // If true, the state will not process events.
   bool ignore_wm_events_ = false;

ash/wm/window_state.cc

@@ -629,7 +629,8 @@ void WindowState::SetBoundsDirectAnimated(const gfx::Rect& bounds) {
   SetBoundsDirect(bounds);
 }
 
-void WindowState::SetBoundsDirectCrossFade(const gfx::Rect& new_bounds) {
+void WindowState::SetBoundsDirectCrossFade(const gfx::Rect& new_bounds,
+                                           gfx::Tween::Type animation_type) {
   // Some test results in invoking CrossFadeToBounds when window is not visible.
   // No animation is necessary in that case, thus just change the bounds and
   // quit.
@@ -656,7 +657,7 @@ void WindowState::SetBoundsDirectCrossFade(const gfx::Rect& new_bounds) {
   // Resize the window to the new size, which will force a layout and paint.
   SetBoundsDirect(new_bounds);
 
-  CrossFadeAnimation(window_, std::move(old_layer_owner), gfx::Tween::EASE_OUT);
+  CrossFadeAnimation(window_, std::move(old_layer_owner), animation_type);
 }
 
 WindowState* GetActiveWindowState() {

ash/wm/window_state.h

@@ -17,6 +17,7 @@
 #include "base/optional.h"
 #include "ui/aura/window_observer.h"
 #include "ui/base/ui_base_types.h"
+#include "ui/gfx/animation/tween.h"
 
 namespace gfx {
 class Rect;
@@ -394,7 +395,9 @@ class ASH_EXPORT WindowState : public aura::WindowObserver {
 
   // Sets the window's |bounds| and transition to the new bounds with
   // a cross fade animation.
-  void SetBoundsDirectCrossFade(const gfx::Rect& bounds);
+  void SetBoundsDirectCrossFade(
+      const gfx::Rect& bounds,
+      gfx::Tween::Type animation_type = gfx::Tween::EASE_OUT);
 
   // aura::WindowObserver:
   void OnWindowPropertyChanged(aura::Window* window,