Adds WmWindow and converts WindowState to use it

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/window_tree_host_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
@@ skipping 36 matching lines @@
   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 = gfx::Screen::GetScreen()
-                               ->GetDisplayNearestWindow(window_state->window())
-                               .bounds();
+  gfx::Rect display_area =
+      gfx::Screen::GetScreen()
+          ->GetDisplayNearestWindow(window_state->aura_window())
+          .bounds();
 
   if (!display_area.Intersects(restore_bounds)) {
     const gfx::Display& display =
         gfx::Screen::GetScreen()->GetDisplayMatching(restore_bounds);
     WindowTreeHostManager* window_tree_host_manager =
         Shell::GetInstance()->window_tree_host_manager();
     aura::Window* new_root =
         window_tree_host_manager->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());
+    if (new_root != window_state->aura_window()->GetRootWindow()) {
+      aura::Window* new_container = Shell::GetContainer(
+          new_root, window_state->aura_window()->parent()->id());
+      new_container->AddChild(window_state->aura_window());
     }
   }
 }
 
 DockedWindowLayoutManager* GetDockedWindowLayoutManager() {
   aura::Window* active_window = ash::wm::GetActiveWindow();
   if (active_window) {
     aura::Window* dock_container = Shell::GetContainer(
       active_window->GetRootWindow(), kShellWindowId_DockedContainer);
     DockedWindowLayoutManager* dock_layout =
@@ skipping 49 matching lines @@
       WM_EVENT_CYCLE_SNAP_DOCK_LEFT ?
       DOCKED_ALIGNMENT_LEFT : DOCKED_ALIGNMENT_RIGHT;
   DockedAlignment current_dock_alignment = dock_layout ?
       dock_layout->CalculateAlignment() : DOCKED_ALIGNMENT_NONE;
 
   if (!window_state->IsDocked() ||
       (current_dock_alignment != DOCKED_ALIGNMENT_NONE &&
        current_dock_alignment != desired_dock_alignment)) {
     if (window_state->CanSnap() &&
         window_state->GetStateType() != desired_snap_state &&
-        window_state->window()->type() != ui::wm::WINDOW_TYPE_PANEL) {
+        window_state->aura_window()->type() != ui::wm::WINDOW_TYPE_PANEL) {
       const wm::WMEvent event(desired_snap_state ==
                               wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ?
                               wm::WM_EVENT_SNAP_LEFT : wm::WM_EVENT_SNAP_RIGHT);
       window_state->OnWMEvent(&event);
       return;
     }
 
     if (dock_layout &&
-        dock_layout->CanDockWindow(window_state->window(),
+        dock_layout->CanDockWindow(window_state->aura_window(),
                                    desired_dock_alignment)) {
       if (window_state->IsDocked()) {
         dock_layout->MaybeSetDesiredDockedAlignment(desired_dock_alignment);
         return;
       }
 
       ScopedDockedLayoutEventSourceResetter event_source_resetter(dock_layout);
       ScopedPreferredAlignmentResetter alignmentResetter(desired_dock_alignment,
                                                          dock_layout);
       const wm::WMEvent event(wm::WM_EVENT_DOCK);
       window_state->OnWMEvent(&event);
       return;
     }
   }
 
   if (window_state->IsDocked() || window_state->IsSnapped()) {
     ScopedDockedLayoutEventSourceResetter event_source_resetter(dock_layout);
     window_state->Restore();
     return;
   }
-  ::wm::AnimateWindow(window_state->window(),
+  ::wm::AnimateWindow(window_state->aura_window(),
                       ::wm::WINDOW_ANIMATION_TYPE_BOUNCE);
 }
 
 }  // namespace
 
 DefaultState::DefaultState(WindowStateType initial_state_type)
     : state_type_(initial_state_type), stored_window_state_(nullptr) {}
 DefaultState::~DefaultState() {}
 
 void DefaultState::OnWMEvent(WindowState* window_state,
@@ skipping 73 matching lines @@
 void DefaultState::AttachState(
     WindowState* window_state,
     WindowState::State* state_in_previous_mode) {
   DCHECK_EQ(stored_window_state_, window_state);
 
   ReenterToCurrentState(window_state, state_in_previous_mode);
 
   // If the display has changed while in the another mode,
   // we need to let windows know the change.
   gfx::Display current_display =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(window_state->window());
+      gfx::Screen::GetScreen()->GetDisplayNearestWindow(
+          window_state->aura_window());
   if (stored_display_state_.bounds() != current_display.bounds()) {
     const WMEvent event(wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED);
     window_state->OnWMEvent(&event);
   } else if (stored_display_state_.work_area() != current_display.work_area()) {
     const WMEvent event(wm::WM_EVENT_WORKAREA_BOUNDS_CHANGED);
     window_state->OnWMEvent(&event);
   }
 }
 
 void DefaultState::DetachState(WindowState* window_state) {
   stored_window_state_ = window_state;
-  aura::Window* window = window_state->window();
+  aura::Window* window = window_state->aura_window();
   stored_bounds_ = window->bounds();
   stored_restore_bounds_ = window_state->HasRestoreBounds() ?
       window_state->GetRestoreBoundsInParent() : gfx::Rect();
   // Remember the display state so that in case of the display change
   // while in the other mode, we can perform necessary action to
   // restore the window state to the proper state for the current
   // display.
-  stored_display_state_ =
-      gfx::Screen::GetScreen()->GetDisplayNearestWindow(window_state->window());
+  stored_display_state_ = gfx::Screen::GetScreen()->GetDisplayNearestWindow(
+      window_state->aura_window());
 }
 
 // static
 bool DefaultState::ProcessCompoundEvents(WindowState* window_state,
                                          const WMEvent* event) {
-  aura::Window* window = window_state->window();
+  aura::Window* window = window_state->aura_window();
 
   switch (event->type()) {
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
       if (window_state->IsFullscreen()) {
         const wm::WMEvent event(wm::WM_EVENT_TOGGLE_FULLSCREEN);
         window_state->OnWMEvent(&event);
       } else if (window_state->IsMaximized()) {
         window_state->Restore();
       } else if (window_state->IsNormalOrSnapped()) {
         if (window_state->CanMaximize())
@@ skipping 108 matching lines @@
       // When a window is dragged and dropped onto a different
       // root window, the bounds will be updated after they are added
       // to the root window.
       // If a window is opened as maximized or fullscreen, its bounds may be
       // empty, so update the bounds now before checking empty.
       if (window_state->is_dragged() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
 
-      aura::Window* window = window_state->window();
+      aura::Window* window = window_state->aura_window();
       gfx::Rect bounds = window->bounds();
 
       // Don't adjust window bounds if the bounds are empty as this
       // happens when a new views::Widget is created.
       if (bounds.IsEmpty())
         return true;
 
       // Only windows of type WINDOW_TYPE_NORMAL or WINDOW_TYPE_PANEL need to be
       // adjusted to have minimum visibility, because they are positioned by the
       // user and user should always be able to interact with them. Other
@@ skipping 14 matching lines @@
       if (window->bounds() != bounds)
         window_state->SetBoundsConstrained(bounds);
       return true;
     }
     case WM_EVENT_DISPLAY_BOUNDS_CHANGED: {
       if (window_state->is_dragged() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
-          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
-      gfx::Rect bounds = window_state->window()->bounds();
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+              window_state->aura_window());
+      gfx::Rect bounds = window_state->aura_window()->bounds();
       // When display bounds has changed, make sure the entire window is fully
       // visible.
       bounds.AdjustToFit(work_area_in_parent);
       window_state->AdjustSnappedBounds(&bounds);
-      if (window_state->window()->bounds() != bounds)
+      if (window_state->aura_window()->bounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_WORKAREA_BOUNDS_CHANGED: {
       // Don't resize the maximized window when the desktop is covered
       // by fullscreen window. crbug.com/504299.
       bool in_fullscreen =
-          RootWindowController::ForWindow(window_state->window())
+          RootWindowController::ForWindow(window_state->aura_window())
               ->workspace_controller()
               ->GetWindowState() == WORKSPACE_WINDOW_STATE_FULL_SCREEN;
       if (in_fullscreen && window_state->IsMaximized())
         return true;
 
       if (window_state->is_dragged() ||
           SetMaximizedOrFullscreenBounds(window_state)) {
         return true;
       }
       gfx::Rect work_area_in_parent =
-          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
-      gfx::Rect bounds = window_state->window()->bounds();
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+              window_state->aura_window());
+      gfx::Rect bounds = window_state->aura_window()->bounds();
       AdjustBoundsToEnsureMinimumWindowVisibility(work_area_in_parent, &bounds);
       window_state->AdjustSnappedBounds(&bounds);
-      if (window_state->window()->bounds() != bounds)
+      if (window_state->aura_window()->bounds() != bounds)
         window_state->SetBoundsDirectAnimated(bounds);
       return true;
     }
     case WM_EVENT_TOGGLE_MAXIMIZE_CAPTION:
     case WM_EVENT_TOGGLE_MAXIMIZE:
     case WM_EVENT_TOGGLE_VERTICAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_HORIZONTAL_MAXIMIZE:
     case WM_EVENT_TOGGLE_FULLSCREEN:
     case WM_EVENT_CYCLE_SNAP_DOCK_LEFT:
     case WM_EVENT_CYCLE_SNAP_DOCK_RIGHT:
     case WM_EVENT_CENTER:
     case WM_EVENT_NORMAL:
     case WM_EVENT_MAXIMIZE:
     case WM_EVENT_MINIMIZE:
     case WM_EVENT_FULLSCREEN:
     case WM_EVENT_SNAP_LEFT:
     case WM_EVENT_SNAP_RIGHT:
     case WM_EVENT_SET_BOUNDS:
     case WM_EVENT_SHOW_INACTIVE:
     case WM_EVENT_DOCK:
       break;
   }
   return false;
 }
 
 // static
 bool DefaultState::SetMaximizedOrFullscreenBounds(WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
   if (window_state->IsMaximized()) {
-    window_state->SetBoundsDirect(
-        ScreenUtil::GetMaximizedWindowBoundsInParent(window_state->window()));
+    window_state->SetBoundsDirect(ScreenUtil::GetMaximizedWindowBoundsInParent(
+        window_state->aura_window()));
     return true;
   }
   if (window_state->IsFullscreen()) {
     window_state->SetBoundsDirect(
-        ScreenUtil::GetDisplayBoundsInParent(window_state->window()));
+        ScreenUtil::GetDisplayBoundsInParent(window_state->aura_window()));
     return true;
   }
   return false;
 }
 
 // static
 void DefaultState::SetBounds(WindowState* window_state,
                              const SetBoundsEvent* event) {
   if (window_state->is_dragged()) {
     // TODO(oshima|varkha): This may be no longer needed, as the dragging
     // happens in docked window container. crbug.com/485612.
     window_state->SetBoundsDirect(event->requested_bounds());
   } else if (window_state->IsSnapped()) {
     gfx::Rect work_area_in_parent =
-        ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
+        ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+            window_state->aura_window());
     gfx::Rect child_bounds(event->requested_bounds());
     AdjustBoundsSmallerThan(work_area_in_parent.size(), &child_bounds);
     window_state->AdjustSnappedBounds(&child_bounds);
     window_state->SetBoundsDirect(child_bounds);
   } else if (!SetMaximizedOrFullscreenBounds(window_state)) {
     window_state->SetBoundsConstrained(event->requested_bounds());
   }
 }
 
 void DefaultState::EnterToNextState(WindowState* window_state,
                                     WindowStateType next_state_type) {
   // Do nothing if  we're already in the same state.
   if (state_type_ == next_state_type)
     return;
 
   WindowStateType previous_state_type = state_type_;
   state_type_ = next_state_type;
 
   window_state->UpdateWindowShowStateFromStateType();
   window_state->NotifyPreStateTypeChange(previous_state_type);
 
-  if (window_state->window()->parent()) {
+  if (window_state->aura_window()->parent()) {
     if (!window_state->HasRestoreBounds() &&
         (previous_state_type == WINDOW_STATE_TYPE_DEFAULT ||
          previous_state_type == WINDOW_STATE_TYPE_NORMAL) &&
         !window_state->IsMinimized() &&
         !window_state->IsNormalStateType()) {
       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.
@@ skipping 53 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) {
-  aura::Window* window = window_state->window();
+  aura::Window* window = window_state->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_state->window()) :
           GetDefaultRightSnappedWindowBoundsInParent(window_state->window());
       break;
     case WINDOW_STATE_TYPE_DOCKED: {
       if (window->parent()->id() != kShellWindowId_DockedContainer) {
         aura::Window* docked_container = Shell::GetContainer(
             window->GetRootWindow(),
             kShellWindowId_DockedContainer);
         wm::ReparentChildWithTransientChildren(window,
             window->parent(),
             docked_container);
       }
       // Return early because we don't want to update the bounds of the
       // window below; as the bounds are managed by the dock layout.
       return;
     }
     case WINDOW_STATE_TYPE_DEFAULT:
     case WINDOW_STATE_TYPE_NORMAL: {
       gfx::Rect work_area_in_parent =
-          ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_state->window());
+          ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+              window_state->aura_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,
@@ skipping 35 matching lines @@
       // SetBoundsDirectAnimated does not work when the window gets reparented.
       // 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.
-    window_state->window()->SetProperty(aura::client::kRestoreShowStateKey,
-                                        ToWindowShowState(previous_state_type));
+    window_state->aura_window()->SetProperty(
+        aura::client::kRestoreShowStateKey,
+        ToWindowShowState(previous_state_type));
     ::wm::SetWindowVisibilityAnimationType(
-        window_state->window(), WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
+        window_state->aura_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() ||
-             IsMinimizedWindowState(previous_state_type)) &&
-             !window_state->window()->layer()->visible()) {
+  } else if ((window_state->window()->GetTargetVisibility() ||
+              IsMinimizedWindowState(previous_state_type)) &&
+             !window_state->aura_window()->layer()->visible()) {
     // The layer may be hidden if the window was previously minimized. Make
     // sure it's visible.
     window_state->window()->Show();
     if (IsMinimizedWindowState(previous_state_type) &&
         !window_state->IsMaximizedOrFullscreen()) {
       window_state->set_unminimize_to_restore_bounds(false);
     }
   }
 }
 
 // static
 void DefaultState::CenterWindow(WindowState* window_state) {
   if (!window_state->IsNormalOrSnapped())
     return;
-  aura::Window* window = window_state->window();
+  aura::Window* window = window_state->aura_window();
   if (window_state->IsSnapped()) {
     gfx::Rect center_in_screen =
         gfx::Screen::GetScreen()->GetDisplayNearestWindow(window).work_area();
     gfx::Size size = window_state->HasRestoreBounds() ?
         window_state->GetRestoreBoundsInScreen().size() :
         window->bounds().size();
     center_in_screen.ClampToCenteredSize(size);
     window_state->SetRestoreBoundsInScreen(center_in_screen);
     window_state->Restore();
   } else {
     gfx::Rect center_in_parent =
         ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     center_in_parent.ClampToCenteredSize(window->bounds().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