chromeos: converts WindowResizer to aura::Window

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/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/wm/screen_pinning_controller.h"
 #include "ash/wm/window_animation_types.h"
 #include "ash/wm/window_parenting_utils.h"
 #include "ash/wm/window_positioning_utils.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_delegate.h"
 #include "ash/wm/window_state_util.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm_window.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 
 namespace ash {
 namespace wm {
 namespace {
 
 // This specifies how much percent (30%) of a window rect
 // must be visible when the window is added to the workspace.
@@ skipping 131 matching lines @@
       NOTREACHED() << "Compound event should not reach here:" << event;
       return;
     case WM_EVENT_ADDED_TO_WORKSPACE:
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED:
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED:
       NOTREACHED() << "Workspace event should not reach here:" << event;
       return;
   }
 
   if (next_state_type == current_state_type && window_state->IsSnapped()) {
+    aura::Window* window = window_state->window()->aura_window();
     gfx::Rect snapped_bounds =
         event->type() == WM_EVENT_SNAP_LEFT
-            ? GetDefaultLeftSnappedWindowBoundsInParent(window_state->window())
-            : GetDefaultRightSnappedWindowBoundsInParent(
-                  window_state->window());
+            ? GetDefaultLeftSnappedWindowBoundsInParent(window)
+            : GetDefaultRightSnappedWindowBoundsInParent(window);
     window_state->SetBoundsDirectAnimated(snapped_bounds);
     return;
   }
 
   if (event->type() == WM_EVENT_SNAP_LEFT ||
       event->type() == WM_EVENT_SNAP_RIGHT) {
     window_state->set_bounds_changed_by_user(true);
   }
 
   EnterToNextState(window_state, next_state_type);
@@ skipping 390 matching lines @@
   if (!stored_restore_bounds_.IsEmpty())
     window_state->SetRestoreBoundsInParent(stored_restore_bounds_);
   else
     window_state->ClearRestoreBounds();
 
   window_state->NotifyPostStateTypeChange(previous_state_type);
 }
 
 void DefaultState::UpdateBoundsFromState(WindowState* window_state,
                                          WindowStateType previous_state_type) {
-  WmWindow* window = window_state->window();
+  aura::Window* window = window_state->window()->aura_window();
   gfx::Rect bounds_in_parent;
   switch (state_type_) {
     case WINDOW_STATE_TYPE_LEFT_SNAPPED:
     case WINDOW_STATE_TYPE_RIGHT_SNAPPED:
       bounds_in_parent =
           state_type_ == WINDOW_STATE_TYPE_LEFT_SNAPPED
               ? GetDefaultLeftSnappedWindowBoundsInParent(window)
               : GetDefaultRightSnappedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_DEFAULT:
     case WINDOW_STATE_TYPE_NORMAL: {
       gfx::Rect work_area_in_parent =
-          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window());
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
       if (window_state->HasRestoreBounds()) {
         bounds_in_parent = window_state->GetRestoreBoundsInParent();
         // Check if the |window|'s restored size is bigger than the working area
         // This may happen if a window was resized to maximized bounds or if the
         // display resolution changed while the window was maximized.
         if (previous_state_type == WINDOW_STATE_TYPE_MAXIMIZED &&
             bounds_in_parent.width() >= work_area_in_parent.width() &&
             bounds_in_parent.height() >= work_area_in_parent.height()) {
           bounds_in_parent = work_area_in_parent;
           bounds_in_parent.Inset(kMaximizedWindowInset, kMaximizedWindowInset,
                                  kMaximizedWindowInset, kMaximizedWindowInset);
         }
       } else {
-        bounds_in_parent = window->GetBounds();
+        bounds_in_parent = window->bounds();
       }
       // Make sure that part of the window is always visible.
       if (!window_state->is_dragged()) {
         // Avoid doing this while the window is being dragged as its root
         // window hasn't been updated yet in the case of dragging to another
         // display. crbug.com/666836.
         wm::AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent,
                                                         &bounds_in_parent);
       }
       break;
     }
     case WINDOW_STATE_TYPE_MAXIMIZED:
-      bounds_in_parent =
-          ScreenUtil::GetMaximizedWindowBoundsInParent(window->aura_window());
+      bounds_in_parent = ScreenUtil::GetMaximizedWindowBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_FULLSCREEN:
     case WINDOW_STATE_TYPE_PINNED:
     case WINDOW_STATE_TYPE_TRUSTED_PINNED:
-      bounds_in_parent =
-          ScreenUtil::GetDisplayBoundsInParent(window->aura_window());
+      bounds_in_parent = ScreenUtil::GetDisplayBoundsInParent(window);
       break;
 
     case WINDOW_STATE_TYPE_MINIMIZED:
       break;
     case WINDOW_STATE_TYPE_INACTIVE:
     case WINDOW_STATE_TYPE_END:
     case WINDOW_STATE_TYPE_AUTO_POSITIONED:
       return;
   }
 
@@ skipping 10 matching lines @@
       // TODO(oshima): Consider fixing it and reenable the animation.
       window_state->SetBoundsDirect(bounds_in_parent);
     } else {
       window_state->SetBoundsDirectAnimated(bounds_in_parent);
     }
   }
 
   if (window_state->IsMinimized()) {
     // Save the previous show state so that we can correctly restore it after
     // exiting the minimized mode.
-    window->SetPreMinimizedShowState(ToWindowShowState(previous_state_type));

[msw, 2017/05/22 19:26:11]

optional nit: you can eliminate this WmWindow helper now, afaict.

[sky, 2017/05/22 19:50:58]

Done.

-    window->SetVisibilityAnimationType(
-        WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
+    window->SetProperty(aura::client::kPreMinimizedShowStateKey,
+                        ToWindowShowState(previous_state_type));
+    ::wm::SetWindowVisibilityAnimationType(
+        window, WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
 
-    // Hide the window.
     window->Hide();
-    // Activate another window.
     if (window_state->IsActive())
       window_state->Deactivate();
-  } else if ((window->GetTargetVisibility() ||
+  } else if ((window->layer()->GetTargetVisibility() ||
               IsMinimizedWindowState(previous_state_type)) &&
-             !window->GetLayerVisible()) {
+             !window->layer()->visible()) {
     // The layer may be hidden if the window was previously minimized. Make
     // sure it's visible.
     window->Show();
     if (IsMinimizedWindowState(previous_state_type) &&
         !window_state->IsMaximizedOrFullscreenOrPinned()) {
       window_state->set_unminimize_to_restore_bounds(false);
     }
   }
 }
 
@@ skipping 15 matching lines @@
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window->aura_window());
     center_in_parent.ClampToCenteredSize(window->GetBounds().size());
     window_state->SetBoundsDirectAnimated(center_in_parent);
   }
   // Centering window is treated as if a user moved and resized the window.
   window_state->set_bounds_changed_by_user(true);
 }
 
 }  // namespace wm
 }  // namespace ash