chromeos: converts WindowResizer to aura::Window

ash/wm/workspace/workspace_window_resizer.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/workspace/workspace_window_resizer.h"
 
 #include <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/metrics/user_metrics_action.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/default_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.h"
 #include "ash/wm/window_positioning_utils.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/wm_event.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/two_step_edge_cycler.h"
 #include "ash/wm_window.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/transform.h"
+#include "ui/wm/core/coordinate_conversion.h"
 #include "ui/wm/public/window_types.h"
 
 namespace ash {
 
 std::unique_ptr<WindowResizer> CreateWindowResizer(
-    WmWindow* window,
+    aura::Window* window,
     const gfx::Point& point_in_parent,
     int window_component,
     aura::client::WindowMoveSource source) {
   DCHECK(window);
-  wm::WindowState* window_state = window->GetWindowState();
+  wm::WindowState* window_state = wm::GetWindowState(window);
   // No need to return a resizer when the window cannot get resized or when a
   // resizer already exists for this window.
   if ((!window_state->CanResize() && window_component != HTCAPTION) ||
       window_state->drag_details()) {
     return nullptr;
   }
 
   if (window_component == HTCAPTION && !window_state->can_be_dragged())
     return nullptr;
 
@@ skipping 11 matching lines @@
   if (!window_state->IsNormalOrSnapped())
     return std::unique_ptr<WindowResizer>();
 
   int bounds_change =
       WindowResizer::GetBoundsChangeForWindowComponent(window_component);
   if (bounds_change == WindowResizer::kBoundsChangeDirection_None)
     return std::unique_ptr<WindowResizer>();
 
   window_state->CreateDragDetails(point_in_parent, window_component, source);
   const int parent_shell_window_id =
-      window->GetParent() ? window->GetParent()->aura_window()->id() : -1;
-  if (window->GetParent() &&
+      window->parent() ? window->parent()->id() : -1;
+  if (window->parent() &&
       (parent_shell_window_id == kShellWindowId_DefaultContainer ||
        parent_shell_window_id == kShellWindowId_PanelContainer)) {
-    window_resizer.reset(
-        WorkspaceWindowResizer::Create(window_state, std::vector<WmWindow*>()));
+    window_resizer.reset(WorkspaceWindowResizer::Create(
+        window_state, std::vector<aura::Window*>()));
   } else {
     window_resizer.reset(DefaultWindowResizer::Create(window_state));
   }
   window_resizer = ShellPort::Get()->CreateDragWindowResizer(
       std::move(window_resizer), window_state);
-  if (window->GetType() == ui::wm::WINDOW_TYPE_PANEL) {
+  if (window->type() == ui::wm::WINDOW_TYPE_PANEL) {
     window_resizer.reset(
         PanelWindowResizer::Create(window_resizer.release(), window_state));
   }
   return window_resizer;
 }
 
 namespace {
 
 // Snapping distance used instead of WorkspaceWindowResizer::kScreenEdgeInset
 // when resizing a window using touchscreen.
@@ skipping 210 matching lines @@
   if (did_lock_cursor_)
     ShellPort::Get()->UnlockCursor();
 
   if (instance == this)
     instance = NULL;
 }
 
 // static
 WorkspaceWindowResizer* WorkspaceWindowResizer::Create(
     wm::WindowState* window_state,
-    const std::vector<WmWindow*>& attached_windows) {
+    const std::vector<aura::Window*>& attached_windows) {
   return new WorkspaceWindowResizer(window_state, attached_windows);
 }
 
 void WorkspaceWindowResizer::Drag(const gfx::Point& location_in_parent,
                                   int event_flags) {
   last_mouse_location_ = location_in_parent;
 
   int sticky_size;
   if (event_flags & ui::EF_CONTROL_DOWN) {
     sticky_size = 0;
   } else if ((details().bounds_change & kBoundsChange_Resizes) &&
              details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchDrag;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |GetTarget()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(location_in_parent);
   AdjustBoundsForMainWindow(sticky_size, &bounds);
 
-  if (bounds != GetTarget()->GetBounds()) {
+  if (bounds != GetTarget()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details().restore_bounds.IsEmpty())
         window_state()->ClearRestoreBounds();
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
-  gfx::Point location_in_screen =
-      GetTarget()->GetParent()->ConvertPointToScreen(location_in_parent);
+  gfx::Point location_in_screen = location_in_parent;
+  ::wm::ConvertPointToScreen(GetTarget()->parent(), &location_in_screen);
 
-  WmWindow* root = nullptr;
+  aura::Window* root = nullptr;
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestPoint(location_in_screen);
   // Track the last screen that the pointer was on to keep the snap phantom
   // window there.
   if (display.bounds().Contains(location_in_screen)) {
-    root =
-        Shell::GetRootWindowControllerWithDisplayId(display.id())->GetWindow();
+    root = Shell::GetRootWindowControllerWithDisplayId(display.id())
+               ->GetRootWindow();
   }
   if (!attached_windows_.empty())
     LayoutAttachedWindows(&bounds);
-  if (bounds != GetTarget()->GetBounds()) {
+  if (bounds != GetTarget()->bounds()) {
     // SetBounds needs to be called to update the layout which affects where the
     // phantom window is drawn. Keep track if the window was destroyed during
     // the drag and quit early if so.
     base::WeakPtr<WorkspaceWindowResizer> resizer(
         weak_ptr_factory_.GetWeakPtr());
     GetTarget()->SetBounds(bounds);
     if (!resizer)
       return;
   }
   const bool in_original_root = !root || root == GetTarget()->GetRootWindow();
@@ skipping 16 matching lines @@
 
   // If the window's state type changed over the course of the drag do not snap
   // the window. This happens when the user minimizes or maximizes the window
   // using a keyboard shortcut while dragging it.
   if (window_state()->GetStateType() != details().initial_state_type)
     return;
 
   bool snapped = false;
   if (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT) {
     if (!window_state()->HasRestoreBounds()) {
-      gfx::Rect initial_bounds = GetTarget()->GetParent()->ConvertRectToScreen(
-          details().initial_bounds_in_parent);
+      gfx::Rect initial_bounds = details().initial_bounds_in_parent;
+      ::wm::ConvertRectToScreen(GetTarget()->parent(), &initial_bounds);
       window_state()->SetRestoreBoundsInScreen(
           details().restore_bounds.IsEmpty() ? initial_bounds
                                              : details().restore_bounds);
     }
     // TODO(oshima): Add event source type to WMEvent and move
     // metrics recording inside WindowState::OnWMEvent.
     const wm::WMEvent event(snap_type_ == SNAP_LEFT ? wm::WM_EVENT_SNAP_LEFT
                                                     : wm::WM_EVENT_SNAP_RIGHT);
     window_state()->OnWMEvent(&event);
     ShellPort::Get()->RecordUserMetricsAction(snap_type_ == SNAP_LEFT
                                                   ? UMA_DRAG_MAXIMIZE_LEFT
                                                   : UMA_DRAG_MAXIMIZE_RIGHT);
     snapped = true;
   }
 
   if (!snapped) {
     if (window_state()->IsSnapped()) {
       // Keep the window snapped if the user resizes the window such that the
       // window has valid bounds for a snapped window. Always unsnap the window
       // if the user dragged the window via the caption area because doing this
       // is slightly less confusing.
       if (details().window_component == HTCAPTION ||
           !AreBoundsValidSnappedBounds(window_state()->GetStateType(),
-                                       GetTarget()->GetBounds())) {
+                                       GetTarget()->bounds())) {
         // Set the window to WINDOW_STATE_TYPE_NORMAL but keep the
         // window at the bounds that the user has moved/resized the
         // window to.
         window_state()->SaveCurrentBoundsForRestore();
         window_state()->Restore();
       }
     } else {
       // The window was not snapped and is not snapped. This is a user
       // resize/drag and so the current bounds should be maintained, clearing
       // any prior restore bounds.
       window_state()->ClearRestoreBounds();
     }
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   window_state()->set_bounds_changed_by_user(initial_bounds_changed_by_user_);
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
   GetTarget()->SetBounds(details().initial_bounds_in_parent);
   if (!details().restore_bounds.IsEmpty())
     window_state()->SetRestoreBoundsInScreen(details().restore_bounds);
 
   if (details().window_component == HTRIGHT) {
     int last_x = details().initial_bounds_in_parent.right();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
-      gfx::Rect bounds(attached_windows_[i]->GetBounds());
+      gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_x(last_x);
       bounds.set_width(initial_size_[i]);
       attached_windows_[i]->SetBounds(bounds);
-      last_x = attached_windows_[i]->GetBounds().right();
+      last_x = attached_windows_[i]->bounds().right();
     }
   } else {
     int last_y = details().initial_bounds_in_parent.bottom();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
-      gfx::Rect bounds(attached_windows_[i]->GetBounds());
+      gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_y(last_y);
       bounds.set_height(initial_size_[i]);
       attached_windows_[i]->SetBounds(bounds);
-      last_y = attached_windows_[i]->GetBounds().bottom();
+      last_y = attached_windows_[i]->bounds().bottom();
     }
   }
 }
 
 WorkspaceWindowResizer::WorkspaceWindowResizer(
     wm::WindowState* window_state,
-    const std::vector<WmWindow*>& attached_windows)
+    const std::vector<aura::Window*>& attached_windows)
     : WindowResizer(window_state),
       attached_windows_(attached_windows),
       did_lock_cursor_(false),
       did_move_or_resize_(false),
       initial_bounds_changed_by_user_(window_state_->bounds_changed_by_user()),
       total_min_(0),
       total_initial_size_(0),
       snap_type_(SNAP_NONE),
       num_mouse_moves_since_bounds_change_(0),
       magnetism_window_(NULL),
       weak_ptr_factory_(this) {
   DCHECK(details().is_resizable);
 
   // A mousemove should still show the cursor even if the window is
   // being moved or resized with touch, so do not lock the cursor.
   if (details().source != aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     ShellPort::Get()->LockCursor();
     did_lock_cursor_ = true;
   }
 
   // Only support attaching to the right/bottom.
   DCHECK(attached_windows_.empty() || (details().window_component == HTRIGHT ||
                                        details().window_component == HTBOTTOM));
 
   // TODO: figure out how to deal with window going off the edge.
 
   // Calculate sizes so that we can maintain the ratios if we need to resize.
   int total_available = 0;
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
-    gfx::Size min(attached_windows_[i]->GetMinimumSize());
-    int initial_size =
-        PrimaryAxisSize(attached_windows_[i]->GetBounds().size());
+    gfx::Size min(attached_windows_[i]->delegate()
+                      ? attached_windows_[i]->delegate()->GetMinimumSize()
+                      : gfx::Size());
+    int initial_size = PrimaryAxisSize(attached_windows_[i]->bounds().size());
     initial_size_.push_back(initial_size);
     // If current size is smaller than the min, use the current size as the min.
     // This way we don't snap on resize.
     int min_size = std::min(initial_size,
                             std::max(PrimaryAxisSize(min), kMinOnscreenSize));
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
   instance = this;
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(gfx::Rect* bounds) {
   gfx::Rect work_area(
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()->aura_window()));
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()));
   int initial_size = PrimaryAxisSize(details().initial_bounds_in_parent.size());
   int current_size = PrimaryAxisSize(bounds->size());
   int start = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
   int end = PrimaryAxisCoordinate(work_area.right(), work_area.bottom());
 
   int delta = current_size - initial_size;
   int available_size = end - start;
   std::vector<int> sizes;
   int leftovers = CalculateAttachedSizes(delta, available_size, &sizes);
 
   // leftovers > 0 means that the attached windows can't grow to compensate for
   // the shrinkage of the main window. This line causes the attached windows to
   // be moved so they are still flush against the main window, rather than the
   // main window being prevented from shrinking.
   leftovers = std::min(0, leftovers);
   // Reallocate any leftover pixels back into the main window. This is
   // necessary when, for example, the main window shrinks, but none of the
   // attached windows can grow without exceeding their max size constraints.
   // Adding the pixels back to the main window effectively prevents the main
   // window from resizing too far.
   if (details().window_component == HTRIGHT)
     bounds->set_width(bounds->width() + leftovers);
   else
     bounds->set_height(bounds->height() + leftovers);
 
   DCHECK_EQ(attached_windows_.size(), sizes.size());
   int last = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
   for (size_t i = 0; i < attached_windows_.size(); ++i) {
-    gfx::Rect attached_bounds(attached_windows_[i]->GetBounds());
+    gfx::Rect attached_bounds(attached_windows_[i]->bounds());
     if (details().window_component == HTRIGHT) {
       attached_bounds.set_x(last);
       attached_bounds.set_width(sizes[i]);
     } else {
       attached_bounds.set_y(last);
       attached_bounds.set_height(sizes[i]);
     }
     attached_windows_[i]->SetBounds(attached_bounds);
     last += sizes[i];
   }
@@ skipping 78 matching lines @@
     total_value += sizes[i]->size();
 
   for (size_t i = 0; i < sizes.size(); ++i)
     out_ratios->push_back((static_cast<float>(sizes[i]->size())) / total_value);
 }
 
 void WorkspaceWindowResizer::CreateBucketsForAttached(
     std::vector<WindowSize>* sizes) const {
   for (size_t i = 0; i < attached_windows_.size(); i++) {
     int initial_size = initial_size_[i];
-    int min = PrimaryAxisSize(attached_windows_[i]->GetMinimumSize());
-    int max = PrimaryAxisSize(attached_windows_[i]->GetMaximumSize());
+    aura::WindowDelegate* window_delegate = attached_windows_[i]->delegate();
+    int min = PrimaryAxisSize(
+        window_delegate ? window_delegate->GetMinimumSize() : gfx::Size());
+    int max = PrimaryAxisSize(
+        window_delegate ? window_delegate->GetMaximumSize() : gfx::Size());
 
     sizes->push_back(WindowSize(initial_size, min, max));
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapToOtherWindows(gfx::Rect* bounds) {
   if (UpdateMagnetismWindow(*bounds, kAllMagnetismEdges)) {
+    gfx::Rect bounds_in_screen = *bounds;
+    ::wm::ConvertRectToScreen(GetTarget()->parent(), &bounds_in_screen);
     gfx::Point point = OriginForMagneticAttach(
-        GetTarget()->GetParent()->ConvertRectToScreen(*bounds),
-        magnetism_window_->GetBoundsInScreen(), magnetism_edge_);
-    point = GetTarget()->GetParent()->ConvertPointFromScreen(point);
+        bounds_in_screen, magnetism_window_->GetBoundsInScreen(),
+        magnetism_edge_);
+    ::wm::ConvertPointFromScreen(GetTarget()->parent(), &point);
     bounds->set_origin(point);
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
     gfx::Rect* bounds) {
   const uint32_t edges =
       WindowComponentToMagneticEdge(details().window_component);
   if (UpdateMagnetismWindow(*bounds, edges)) {
-    *bounds = GetTarget()->GetParent()->ConvertRectFromScreen(
-        BoundsForMagneticResizeAttach(
-            GetTarget()->GetParent()->ConvertRectToScreen(*bounds),
-            magnetism_window_->GetBoundsInScreen(), magnetism_edge_));
+    gfx::Rect bounds_in_screen = *bounds;
+    ::wm::ConvertRectToScreen(GetTarget()->parent(), &bounds_in_screen);
+    *bounds = BoundsForMagneticResizeAttach(
+        bounds_in_screen, magnetism_window_->GetBoundsInScreen(),
+        magnetism_edge_);
+    ::wm::ConvertRectFromScreen(GetTarget()->parent(), bounds);
   }
 }
 
 bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
                                                    uint32_t edges) {
   // |bounds| are in coordinates of original window's parent.
-  gfx::Rect bounds_in_screen =
-      GetTarget()->GetParent()->ConvertRectToScreen(bounds);
+  gfx::Rect bounds_in_screen = bounds;
+  ::wm::ConvertRectToScreen(GetTarget()->parent(), &bounds_in_screen);
   MagnetismMatcher matcher(bounds_in_screen, edges);
 
   // If we snapped to a window then check it first. That way we don't bounce
   // around when close to multiple edges.
   if (magnetism_window_) {
-    if (window_tracker_.Contains(magnetism_window_->aura_window()) &&
+    if (window_tracker_.Contains(magnetism_window_) &&
         matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
                              &magnetism_edge_)) {
       return true;
     }
-    window_tracker_.Remove(magnetism_window_->aura_window());
+    window_tracker_.Remove(magnetism_window_);
     magnetism_window_ = NULL;
   }
 
   // Avoid magnetically snapping windows that are not resizable.
   // TODO(oshima): change this to window.type() == TYPE_NORMAL.
   if (!window_state()->CanResize())
     return false;
 
-  for (WmWindow* root_window : ShellPort::Get()->GetAllRootWindows()) {
+  for (aura::Window* root_window : Shell::Get()->GetAllRootWindows()) {
     // Test all children from the desktop in each root window.
-    const std::vector<WmWindow*> children =
-        root_window->GetChildByShellWindowId(kShellWindowId_DefaultContainer)
-            ->GetChildren();
+    const std::vector<aura::Window*>& children =
+        root_window->GetChildById(kShellWindowId_DefaultContainer)->children();
     for (auto i = children.rbegin();
          i != children.rend() && !matcher.AreEdgesObscured(); ++i) {
-      wm::WindowState* other_state = (*i)->GetWindowState();
-      if (other_state->window() == GetTarget() ||
+      wm::WindowState* other_state = wm::GetWindowState(*i);
+      if (other_state->window()->aura_window() == GetTarget() ||
           !other_state->window()->IsVisible() ||
           !other_state->IsNormalOrSnapped() || !other_state->CanResize()) {
         continue;
       }
       if (matcher.ShouldAttach(other_state->window()->GetBoundsInScreen(),
                                &magnetism_edge_)) {
-        magnetism_window_ = other_state->window();
-        window_tracker_.Add(magnetism_window_->aura_window());
+        magnetism_window_ = other_state->window()->aura_window();
+        window_tracker_.Add(magnetism_window_);
         return true;
       }
     }
   }
   return false;
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(int sticky_size,
                                                        gfx::Rect* bounds) {
-  gfx::Point last_mouse_location_in_screen =
-      GetTarget()->GetParent()->ConvertPointToScreen(last_mouse_location_);
+  gfx::Point last_mouse_location_in_screen = last_mouse_location_;
+  ::wm::ConvertPointToScreen(GetTarget()->parent(),
+                             &last_mouse_location_in_screen);
   display::Display display =
       display::Screen::GetScreen()->GetDisplayNearestPoint(
           last_mouse_location_in_screen);
-  gfx::Rect work_area =
-      GetTarget()->GetParent()->ConvertRectFromScreen(display.work_area());
+  gfx::Rect work_area = display.work_area();
+  ::wm::ConvertRectFromScreen(GetTarget()->parent(), &work_area);
   if (details().window_component == HTCAPTION) {
     // Adjust the bounds to the work area where the mouse cursor is located.
     // Always keep kMinOnscreenHeight or the window height (whichever is less)
     // on the bottom.
     int max_y =
         work_area.bottom() - std::min(kMinOnscreenHeight, bounds->height());
     if (bounds->y() > max_y) {
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
       // Don't allow dragging above the top of the display until the mouse
@@ skipping 132 matching lines @@
     edge_cycler_->OnMove(location);
   }
 
   // Update phantom window with snapped guide bounds.
   const gfx::Rect phantom_bounds =
       (snap_type_ == SNAP_LEFT)
           ? wm::GetDefaultLeftSnappedWindowBoundsInParent(GetTarget())
           : wm::GetDefaultRightSnappedWindowBoundsInParent(GetTarget());
 
   if (!snap_phantom_window_controller_) {
-    snap_phantom_window_controller_.reset(
-        new PhantomWindowController(GetTarget()));
+    snap_phantom_window_controller_ =
+        base::MakeUnique<PhantomWindowController>(WmWindow::Get(GetTarget()));
   }
-  snap_phantom_window_controller_->Show(
-      GetTarget()->GetParent()->ConvertRectToScreen(phantom_bounds));
+  gfx::Rect phantom_bounds_in_screen(phantom_bounds);
+  ::wm::ConvertRectToScreen(GetTarget()->parent(), &phantom_bounds_in_screen);
+  snap_phantom_window_controller_->Show(phantom_bounds_in_screen);
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
-  using IndexToWindowMap = std::map<size_t, WmWindow*>;
+  using IndexToWindowMap = std::map<size_t, aura::Window*>;
   IndexToWindowMap map;
-  WmWindow* parent = GetTarget()->GetParent();
-  const std::vector<WmWindow*> windows(parent->GetChildren());
+  aura::Window* parent = GetTarget()->parent();
+  const std::vector<aura::Window*>& windows(parent->children());
   map[std::find(windows.begin(), windows.end(), GetTarget()) -
       windows.begin()] = GetTarget();
   for (auto i = attached_windows_.begin(); i != attached_windows_.end(); ++i) {
-    if ((*i)->GetParent() != parent)
+    if ((*i)->parent() != parent)
       return;
     size_t index =
         std::find(windows.begin(), windows.end(), *i) - windows.begin();
     map[index] = *i;
   }
 
   // Reorder the windows starting at the topmost.
   parent->StackChildAtTop(map.rbegin()->second);
   for (auto i = map.rbegin(); i != map.rend();) {
-    WmWindow* window = i->second;
+    aura::Window* window = i->second;
     ++i;
     if (i != map.rend())
       parent->StackChildBelow(i->second, window);
   }
 }
 
 WorkspaceWindowResizer::SnapType WorkspaceWindowResizer::GetSnapType(
     const gfx::Point& location) const {
   // TODO: this likely only wants total display area, not the area of a single
   // display.
-  gfx::Rect area(
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()->aura_window()));
+  gfx::Rect area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()));
   if (details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     // Increase tolerance for touch-snapping near the screen edges. This is only
     // necessary when the work area left or right edge is same as screen edge.
-    gfx::Rect display_bounds(
-        ScreenUtil::GetDisplayBoundsInParent(GetTarget()->aura_window()));
+    gfx::Rect display_bounds(ScreenUtil::GetDisplayBoundsInParent(GetTarget()));
     int inset_left = 0;
     if (area.x() == display_bounds.x())
       inset_left = kScreenEdgeInsetForTouchDrag;
     int inset_right = 0;
     if (area.right() == display_bounds.right())
       inset_right = kScreenEdgeInsetForTouchDrag;
     area.Inset(inset_left, 0, inset_right, 0);
   }
   if (location.x() <= area.x())
     return SNAP_LEFT;
   if (location.x() >= area.right() - 1)
     return SNAP_RIGHT;
   return SNAP_NONE;
 }
 
 bool WorkspaceWindowResizer::AreBoundsValidSnappedBounds(
     wm::WindowStateType snapped_type,
     const gfx::Rect& bounds_in_parent) const {
   DCHECK(snapped_type == wm::WINDOW_STATE_TYPE_LEFT_SNAPPED ||
          snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED);
   gfx::Rect snapped_bounds =
-      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()->aura_window());
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget());
   if (snapped_type == wm::WINDOW_STATE_TYPE_RIGHT_SNAPPED)
     snapped_bounds.set_x(snapped_bounds.right() - bounds_in_parent.width());
   snapped_bounds.set_width(bounds_in_parent.width());
   return bounds_in_parent == snapped_bounds;
 }
 
 }  // namespace ash