[Refactor] Move the logic to update bounds for show type from WorkspaceLayoutManager to DefaultState

ash/wm/default_state.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ash/wm/default_state.h"
 
+#include "ash/display/display_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
+#include "ash/wm/window_animations.h"
 #include "ash/wm/window_state.h"
+#include "ash/wm/window_state_delegate.h"
+#include "ash/wm/window_util.h"
+#include "ash/wm/workspace/workspace_window_resizer.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/rect.h"
 
 namespace ash {
 namespace wm {
+namespace {
+
+gfx::Rect BoundsWithScreenEdgeVisible(
+    aura::Window* window,
+    const gfx::Rect& restore_bounds) {
+  gfx::Rect max_bounds =
+      ash::ScreenUtil::GetMaximizedWindowBoundsInParent(window);
+  // If the restore_bounds are more than 1 grid step away from the size the
+  // window would be when maximized, inset it.
+  max_bounds.Inset(ash::internal::WorkspaceWindowResizer::kScreenEdgeInset,
+                   ash::internal::WorkspaceWindowResizer::kScreenEdgeInset);
+  if (restore_bounds.Contains(max_bounds))
+    return max_bounds;
+  return restore_bounds;
+}
+
+void MoveToDisplayForRestore(wm::WindowState* window_state) {
+  if (!window_state->HasRestoreBounds())
+    return;
+  const gfx::Rect& restore_bounds = window_state->GetRestoreBoundsInScreen();
+
+  // Move only if the restore bounds is outside of
+  // the display. There is no information about in which
+  // display it should be restored, so this is best guess.
+  // TODO(oshima): Restore information should contain the
+  // work area information like WindowResizer does for the
+  // last window location.
+  gfx::Rect display_area = Shell::GetScreen()->GetDisplayNearestWindow(
+      window_state->window()).bounds();
+
+  if (!display_area.Intersects(restore_bounds)) {
+    const gfx::Display& display =
+        Shell::GetScreen()->GetDisplayMatching(restore_bounds);
+    DisplayController* display_controller =
+        Shell::GetInstance()->display_controller();
+    aura::Window* new_root =
+        display_controller->GetRootWindowForDisplayId(display.id());
+    if (new_root != window_state->window()->GetRootWindow()) {
+      aura::Window* new_container =
+          Shell::GetContainer(new_root, window_state->window()->parent()->id());
+      new_container->AddChild(window_state->window());
+    }
+  }
+}
+
+}  // namespace;
 
 DefaultState::DefaultState() {}
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state,
                              WMEvent event) {
+  if (ProcessCompoundEvents(window_state, event))
+    return;
+
+  WindowShowType next_show_type = SHOW_TYPE_NORMAL;
+  switch (event) {
+    case NORMAL:
+      next_show_type = SHOW_TYPE_NORMAL;
+      break;
+    case MAXIMIZE:
+      next_show_type = SHOW_TYPE_MAXIMIZED;
+      break;
+    case MINIMIZE:
+      next_show_type = SHOW_TYPE_MINIMIZED;
+      break;
+    case FULLSCREEN:
+      next_show_type = SHOW_TYPE_FULLSCREEN;
+      break;
+    case SNAP_LEFT:
+      next_show_type = SHOW_TYPE_LEFT_SNAPPED;
+      break;
+    case SNAP_RIGHT:
+      next_show_type = SHOW_TYPE_RIGHT_SNAPPED;
+      break;
+    case TOGGLE_MAXIMIZE_CAPTION:
+    case TOGGLE_MAXIMIZE:
+    case TOGGLE_VERTICAL_MAXIMIZE:
+    case TOGGLE_HORIZONTAL_MAXIMIZE:
+    case TOGGLE_FULLSCREEN:
+      NOTREACHED() << "Compound event should not reach here:" << event;
+      return;
+  }
+
+  WindowShowType current = window_state->window_show_type();
+  if (current != next_show_type) {
+    window_state->UpdateWindowShowType(next_show_type);
+    window_state->NotifyPreShowTypeChange(current);
+    // TODO(oshima): Make docked window a state.

[pkotwicz, 2014/02/12 18:20:18]

Is there a plan to make panel windows and docked windows use more of
UpdateBoundsFromShowType()?

[oshima, 2014/02/12 19:56:16]

The plan is to replace DefaultState with state machine.

There will be a class for each state, and implement the behavior for WM events.
The goal is to eliminate IsSnapped, IsFullscreen (and other ifs) and makes it
clear what should happen in which state.

+    if (!window_state->IsDocked() && !window_state->IsPanel())
+      UpdateBoundsFromShowType(window_state, current);
+    window_state->NotifyPostShowTypeChange(current);
+  }
+};
+
+// static
+bool DefaultState::ProcessCompoundEvents(WindowState* window_state,
+                                         WMEvent event) {
   aura::Window* window = window_state->window();
 
   switch (event) {
     case TOGGLE_MAXIMIZE_CAPTION:
       if (window_state->IsFullscreen()) {
         window_state->ToggleFullscreen();
       } else if (window_state->IsMaximized()) {
         window_state->Restore();
       } else if (window_state->IsNormalShowType() ||
                  window_state->IsSnapped()) {
         if (window_state->CanMaximize())
           window_state->Maximize();
       }
-      break;
-
+      return true;
     case TOGGLE_MAXIMIZE:
       if (window_state->IsFullscreen())
         window_state->ToggleFullscreen();
       else if (window_state->IsMaximized())
         window_state->Restore();
       else if (window_state->CanMaximize())
         window_state->Maximize();
-      break;
-
+      return true;
     case TOGGLE_VERTICAL_MAXIMIZE: {
       gfx::Rect work_area =
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
 
       // Maximize vertically if:
       // - The window does not have a max height defined.
       // - The window has the normal show type. Snapped windows are excluded
       //   because they are already maximized vertically and reverting to the
       //   restored bounds looks weird.
       if (window->delegate()->GetMaximumSize().height() != 0 ||
           !window_state->IsNormalShowType()) {
-        return;
+        return true;
       }
       if (window_state->HasRestoreBounds() &&
           (window->bounds().height() == work_area.height() &&
            window->bounds().y() == work_area.y())) {
         window_state->SetAndClearRestoreBounds();
       } else {
         window_state->SaveCurrentBoundsForRestore();
         window->SetBounds(gfx::Rect(window->bounds().x(),
                                     work_area.y(),
                                     window->bounds().width(),
                                     work_area.height()));
       }
-      break;
+      return true;
     }
     case TOGGLE_HORIZONTAL_MAXIMIZE: {
       // Maximize horizontally if:
       // - The window does not have a max width defined.
       // - The window is snapped or has the normal show type.
       if (window->delegate()->GetMaximumSize().width() != 0)
-        return;
+        return true;
       if (!window_state->IsNormalShowType() && !window_state->IsSnapped())
-        return;
-
+        return true;
       gfx::Rect work_area =
           ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
-
       if (window_state->IsNormalShowType() &&
           window_state->HasRestoreBounds() &&
           (window->bounds().width() == work_area.width() &&
            window->bounds().x() == work_area.x())) {
         window_state->SetAndClearRestoreBounds();
       } else {
         gfx::Rect new_bounds(work_area.x(),
                              window->bounds().y(),
                              work_area.width(),
                              window->bounds().height());
 
         gfx::Rect restore_bounds = window->bounds();
         if (window_state->IsSnapped()) {
           window_state->SetRestoreBoundsInParent(new_bounds);
           window_state->Restore();
 
           // The restore logic prevents a window from being restored to bounds
           // which match the workspace bounds exactly so it is necessary to set
           // the bounds again below.
         }
 
         window_state->SetRestoreBoundsInParent(restore_bounds);
         window->SetBounds(new_bounds);
       }
+      return true;
+    }
+    case TOGGLE_FULLSCREEN: {
+      // Window which cannot be maximized should not be fullscreened.
+      // It can, however, be restored if it was fullscreened.
+      bool is_fullscreen = window_state->IsFullscreen();
+      if (!is_fullscreen && !window_state->CanMaximize())
+        return true;
+      if (window_state->delegate() &&
+          window_state->delegate()->ToggleFullscreen(window_state)) {
+        return true;
+      }
+      if (is_fullscreen) {
+        window_state->Restore();
+      } else {
+        //
+        window_state->window()->SetProperty(aura::client::kShowStateKey,
+                                            ui::SHOW_STATE_FULLSCREEN);
+      }
+      return true;
+    }
+    case NORMAL:
+    case MAXIMIZE:
+    case MINIMIZE:
+    case FULLSCREEN:
+    case SNAP_LEFT:
+    case SNAP_RIGHT:
+      break;
+  }
+  return false;
+}
+
+// static
+void DefaultState::UpdateBoundsFromShowType(wm::WindowState* window_state,
+                                            wm::WindowShowType old_show_type) {
+  aura::Window* window = window_state->window();
+  // Do nothing If this is not yet added to the container.
+  if (!window->parent())
+    return;
+
+  if (old_show_type != wm::SHOW_TYPE_MINIMIZED &&
+      !window_state->HasRestoreBounds() &&
+      window_state->IsMaximizedOrFullscreen() &&
+      !wm::IsMaximizedOrFullscreenWindowShowType(old_show_type)) {
+    window_state->SaveCurrentBoundsForRestore();
+  }
+
+  // When restoring from a minimized state, we want to restore to the previous
+  // bounds. However, we want to maintain the restore bounds. (The restore
+  // bounds are set if a user maximized the window in one axis by double
+  // clicking the window border for example).
+  gfx::Rect restore;
+  if (old_show_type == wm::SHOW_TYPE_MINIMIZED &&
+      window_state->IsNormalShowState() &&
+      window_state->HasRestoreBounds() &&
+      !window_state->unminimize_to_restore_bounds()) {
+    restore = window_state->GetRestoreBoundsInScreen();
+    window_state->SaveCurrentBoundsForRestore();
+  }
+
+  if (window_state->IsMaximizedOrFullscreen())
+    MoveToDisplayForRestore(window_state);
+
+  wm::WindowShowType show_type = window_state->window_show_type();
+  gfx::Rect bounds_in_parent;
+  switch (show_type) {
+    case wm::SHOW_TYPE_DEFAULT:
+    case wm::SHOW_TYPE_NORMAL:
+    case wm::SHOW_TYPE_LEFT_SNAPPED:
+    case wm::SHOW_TYPE_RIGHT_SNAPPED: {
+      gfx::Rect work_area_in_parent =
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
+
+      if (window_state->HasRestoreBounds())
+        bounds_in_parent = window_state->GetRestoreBoundsInParent();
+      else
+        bounds_in_parent = window->bounds();
+      // Make sure that part of the window is always visible.
+      wm::AdjustBoundsToEnsureMinimumWindowVisibility(
+          work_area_in_parent, &bounds_in_parent);
+
+      if (show_type == wm::SHOW_TYPE_LEFT_SNAPPED ||
+          show_type == wm::SHOW_TYPE_RIGHT_SNAPPED) {
+        window_state->AdjustSnappedBounds(&bounds_in_parent);
+      } else {
+        bounds_in_parent = BoundsWithScreenEdgeVisible(
+            window,
+            bounds_in_parent);
+      }
+      break;
+    }
+    case wm::SHOW_TYPE_MAXIMIZED:
+      bounds_in_parent = ScreenUtil::GetMaximizedWindowBoundsInParent(window);
+      break;
+
+    case wm::SHOW_TYPE_FULLSCREEN:
+      bounds_in_parent = ScreenUtil::GetDisplayBoundsInParent(window);
+      break;
+
+    case wm::SHOW_TYPE_MINIMIZED:
+      break;
+    case wm::SHOW_TYPE_INACTIVE:
+    case wm::SHOW_TYPE_DETACHED:
+    case wm::SHOW_TYPE_END:
+    case wm::SHOW_TYPE_AUTO_POSITIONED:
+      return;
+  }
+
+  if (show_type != wm::SHOW_TYPE_MINIMIZED) {
+    if (old_show_type == wm::SHOW_TYPE_MINIMIZED ||
+        (window_state->IsFullscreen() &&
+         !window_state->animate_to_fullscreen())) {
+      window_state->SetBoundsDirect(bounds_in_parent);
+    } else if (window_state->IsMaximizedOrFullscreen() ||
+               IsMaximizedOrFullscreenWindowShowType(old_show_type)) {
+      CrossFadeToBounds(window, bounds_in_parent);
+    } else {
+      window_state->SetBoundsDirectAnimated(bounds_in_parent);
     }
   }
-};
+
+  if (window_state->IsMinimized()) {
+    if (old_show_type == wm::SHOW_TYPE_MINIMIZED)
+      return;
+
+    // Save the previous show state so that we can correctly restore it.
+    window_state->window()->SetProperty(aura::client::kRestoreShowStateKey,
+                                        wm::ToWindowShowState(old_show_type));
+    views::corewm::SetWindowVisibilityAnimationType(
+        window_state->window(), WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
+
+    // Hide the window.
+    window_state->window()->Hide();
+    // Activate another window.
+    if (window_state->IsActive())
+      window_state->Deactivate();
+  } else if ((window_state->window()->TargetVisibility() ||
+              old_show_type == wm::SHOW_TYPE_MINIMIZED) &&
+             !window_state->window()->layer()->visible()) {
+    // The layer may be hidden if the window was previously minimized. Make
+    // sure it's visible.
+    window_state->window()->Show();
+    if (old_show_type == wm::SHOW_TYPE_MINIMIZED &&
+        !window_state->IsMaximizedOrFullscreen()) {
+      window_state->set_unminimize_to_restore_bounds(false);
+    }
+  }
+
+  if (window_state->IsNormalShowState())
+    window_state->ClearRestoreBounds();
+
+  // Set the restore rectangle to the previously set restore rectangle.
+  if (!restore.IsEmpty())
+    window_state->SetRestoreBoundsInScreen(restore);
+}
 
 }  // namespace wm
 }  // namespace ash