chromeos: converts WindowState to aura::Window

ash/wm/panels/panel_layout_manager.cc

 // Copyright (c) 2012 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/panels/panel_layout_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <utility>
 
@@ skipping 15 matching lines @@
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/window_parenting_client.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/vector2d.h"
 #include "ui/views/background.h"
 #include "ui/views/widget/widget.h"
+#include "ui/wm/core/window_util.h"
 #include "ui/wm/public/activation_client.h"
 
 using aura::Window;
 
 namespace ash {
 namespace {
 
 const int kPanelIdealSpacing = 4;
 
 const float kMaxHeightFactor = .80f;
@@ skipping 435 matching lines @@
 // PanelLayoutManager, WindowStateObserver implementation:
 
 void PanelLayoutManager::OnPostWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old_type) {
   // If the shelf is currently hidden then windows will not actually be shown
   // but the set to restore when the shelf becomes visible is updated.
   if (restore_windows_on_shelf_visible_) {
     if (window_state->IsMinimized()) {
       MinimizePanel(window_state->window());
-      restore_windows_on_shelf_visible_->Remove(
-          window_state->window()->aura_window());
+      restore_windows_on_shelf_visible_->Remove(window_state->window());
     } else {
-      restore_windows_on_shelf_visible_->Add(
-          window_state->window()->aura_window());
+      restore_windows_on_shelf_visible_->Add(window_state->window());
     }
     return;
   }
 
   if (window_state->IsMinimized())
     MinimizePanel(window_state->window());
   else
     RestorePanel(window_state->window());
 }
 
@@ skipping 27 matching lines @@
     ShelfVisibilityState new_state) {
   // On entering / leaving full screen mode the shelf visibility state is
   // changed to / from SHELF_HIDDEN. In this state, panel windows should hide
   // to allow the full-screen application to use the full screen.
   bool shelf_hidden = new_state == ash::SHELF_HIDDEN;
   if (!shelf_hidden) {
     if (restore_windows_on_shelf_visible_) {
       std::unique_ptr<aura::WindowTracker> restore_windows(
           std::move(restore_windows_on_shelf_visible_));
       for (aura::Window* window : restore_windows->windows())
-        RestorePanel(WmWindow::Get(window));
+        RestorePanel(window);
     }
     return;
   }
 
   if (restore_windows_on_shelf_visible_)
     return;
   std::unique_ptr<aura::WindowTracker> minimized_windows(
       new aura::WindowTracker);
   for (PanelList::iterator iter = panel_windows_.begin();
        iter != panel_windows_.end();) {
@@ skipping 12 matching lines @@
 void PanelLayoutManager::OnShelfIconPositionsChanged() {
   // TODO: As this is called for every animation step now. Relayout needs to be
   // updated to use current icon position instead of use the ideal bounds so
   // that the panels slide with their icons instead of jumping.
   Relayout();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // PanelLayoutManager private implementation:
 
-void PanelLayoutManager::MinimizePanel(WmWindow* panel) {
+void PanelLayoutManager::MinimizePanel(aura::Window* panel) {
   // Clusterfuzz can trigger panel accelerators before the shelf is created.
   // TODO(jamescook): Revert this after http://crbug.com/648964 is fixed.
   if (!shelf_)
     return;
 
-  panel->SetVisibilityAnimationType(
-      wm::WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
-  ui::Layer* layer = panel->GetLayer();
+  ::wm::SetWindowVisibilityAnimationType(
+      panel, wm::WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
+  ui::Layer* layer = panel->layer();
   ui::ScopedLayerAnimationSettings panel_slide_settings(layer->GetAnimator());
   panel_slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   panel_slide_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
-  gfx::Rect bounds(panel->GetBounds());
+  gfx::Rect bounds(panel->bounds());
   bounds.Offset(GetSlideInAnimationOffset(shelf_->GetAlignment()));
-  panel->SetBoundsDirect(bounds);
+  SetChildBoundsDirect(panel, bounds);
   panel->Hide();
   layer->SetOpacity(0);
-  if (panel->IsActive())
-    panel->Deactivate();
+  if (::wm::IsActiveWindow(panel))
+    ::wm::DeactivateWindow(panel);
   Relayout();
 }
 
-void PanelLayoutManager::RestorePanel(WmWindow* panel) {
-  PanelList::iterator found =
-      std::find(panel_windows_.begin(), panel_windows_.end(), panel);
+void PanelLayoutManager::RestorePanel(aura::Window* panel) {
+  PanelList::iterator found = std::find(
+      panel_windows_.begin(), panel_windows_.end(), WmWindow::Get(panel));
   DCHECK(found != panel_windows_.end());
   found->slide_in = true;
   Relayout();
 }
 
 void PanelLayoutManager::Relayout() {
   if (!shelf_ || !shelf_->GetWindow())
     return;
 
   // Suppress layouts during overview mode because changing window bounds
@@ skipping 116 matching lines @@
       bounds.set_y(visible_panels[i].major_pos -
                    visible_panels[i].major_length / 2);
     }
 
     ui::Layer* layer = visible_panels[i].window->GetLayer();
     if (slide_in) {
       // New windows shift up from the shelf into position and fade in.
       layer->SetOpacity(0);
       gfx::Rect initial_bounds(bounds);
       initial_bounds.Offset(GetSlideInAnimationOffset(shelf_->alignment()));
-      visible_panels[i].window->SetBoundsDirect(initial_bounds);
+      SetChildBoundsDirect(visible_panels[i].window->aura_window(),
+                           initial_bounds);
       // Set on shelf so that the panel animates into its target position.
       on_shelf = true;
     }
 
     if (on_shelf) {
       ui::ScopedLayerAnimationSettings panel_slide_settings(
           layer->GetAnimator());
       panel_slide_settings.SetPreemptionStrategy(
           ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
       panel_slide_settings.SetTransitionDuration(
           base::TimeDelta::FromMilliseconds(kPanelSlideDurationMilliseconds));
-      visible_panels[i].window->SetBoundsDirect(bounds);
+      SetChildBoundsDirect(visible_panels[i].window->aura_window(), bounds);
       if (slide_in) {
         layer->SetOpacity(1);
         visible_panels[i].window->Show();
       }
     } else {
       // If the shelf moved don't animate, move immediately to the new
       // target location.
-      visible_panels[i].window->SetBoundsDirect(bounds);
+      SetChildBoundsDirect(visible_panels[i].window->aura_window(), bounds);
     }
   }
 
   UpdateStacking(active_panel);
   UpdateCallouts();
 }
 
 void PanelLayoutManager::UpdateStacking(WmWindow* active_panel) {
   // Clusterfuzz can trigger panel accelerators before the shelf is created.
   // TODO(jamescook): Revert this after http://crbug.com/648964 is fixed.
@@ skipping 94 matching lines @@
     }
     if (shelf_->GetAlignment() == SHELF_ALIGNMENT_LEFT)
       callout_bounds.set_x(bounds.x() - callout_bounds.width());
     else if (shelf_->GetAlignment() == SHELF_ALIGNMENT_RIGHT)
       callout_bounds.set_x(bounds.right());
     else
       callout_bounds.set_y(bounds.bottom());
     callout_bounds = callout_widget_window->GetParent()->ConvertRectFromScreen(
         callout_bounds);
 
-    callout_widget_window->SetBoundsDirect(callout_bounds);
+    SetChildBoundsDirect(callout_widget_window->aura_window(), callout_bounds);
     DCHECK_EQ(panel_container_, callout_widget_window->GetParent());
     DCHECK_EQ(panel_container_, panel->GetParent());
     panel_container_->StackChildAbove(callout_widget_window, panel);
 
     ui::Layer* layer = callout_widget_window->GetLayer();
     // If the panel is not over the callout position or has just become visible
     // then fade in the callout.
     if ((distance_until_over_panel > 0 || layer->GetTargetOpacity() < 1)) {
       if (distance_until_over_panel > 0 &&
           slide_distance >= distance_until_over_panel) {
@@ skipping 36 matching lines @@
       // Save existing bounds, so that we can restore them when the keyboard
       // hides.
       panel_state->SaveCurrentBoundsForRestore();
 
       gfx::Rect panel_bounds =
           panel->GetParent()->ConvertRectToScreen(panel->GetTargetBounds());
       int delta = panel_bounds.height() - available_space;
       // Ensure panels are not pushed above the parent boundaries, shrink any
       // panels that violate this constraint.
       if (delta > 0) {
-        panel->SetBoundsDirect(
+        SetChildBoundsDirect(
+            panel->aura_window(),
             gfx::Rect(panel_bounds.x(), panel_bounds.y() + delta,
                       panel_bounds.width(), panel_bounds.height() - delta));
       }
     } else if (panel_state->HasRestoreBounds()) {
       // Keyboard hidden, restore original bounds if they exist.
-      panel->SetBoundsDirect(panel_state->GetRestoreBoundsInScreen());
+      SetChildBoundsDirect(panel->aura_window(),
+                           panel_state->GetRestoreBoundsInScreen());
     }
   }
   // This bounds change will have caused a change to the Shelf which does not
   // propogate automatically to this class, so manually recalculate bounds.
   OnWindowResized();
 }
 
 void PanelLayoutManager::OnKeyboardClosed() {
   keyboard_observer_.RemoveAll();
 }
 
 }  // namespace ash