chromeos: converts WindowResizer to aura::Window

ash/wm/wm_toplevel_window_event_handler.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/wm_toplevel_window_event_handler.h"
 
 #include "ash/shell_port.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_observer.h"
@@ skipping 82 matching lines @@
   // Whether ScopedWindowResizer grabbed capture.
   bool grabbed_capture_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedWindowResizer);
 };
 
 WmToplevelWindowEventHandler::ScopedWindowResizer::ScopedWindowResizer(
     WmToplevelWindowEventHandler* handler,
     std::unique_ptr<WindowResizer> resizer)
     : handler_(handler), resizer_(std::move(resizer)), grabbed_capture_(false) {
-  WmWindow* target = resizer_->GetTarget();
-  target->aura_window()->AddObserver(this);
-  target->GetWindowState()->AddObserver(this);
+  aura::Window* target = resizer_->GetTarget();
+  target->AddObserver(this);
+  GetWindowState(target)->AddObserver(this);
 
   if (!target->HasCapture()) {
     grabbed_capture_ = true;
     target->SetCapture();
   }
 }
 
 WmToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
-  WmWindow* target = resizer_->GetTarget();
-  target->aura_window()->RemoveObserver(this);
-  target->GetWindowState()->RemoveObserver(this);
+  aura::Window* target = resizer_->GetTarget();
+  target->RemoveObserver(this);
+  GetWindowState(target)->RemoveObserver(this);
   if (grabbed_capture_)
     target->ReleaseCapture();
 }
 
 bool WmToplevelWindowEventHandler::ScopedWindowResizer::IsMove() const {
   return resizer_->details().bounds_change ==
          WindowResizer::kBoundsChange_Repositions;
 }
 
 void WmToplevelWindowEventHandler::ScopedWindowResizer::
     OnPreWindowStateTypeChange(wm::WindowState* window_state,
                                wm::WindowStateType old) {
   handler_->CompleteDrag(DragResult::SUCCESS);
 }
 
 void WmToplevelWindowEventHandler::ScopedWindowResizer::OnWindowDestroying(
     aura::Window* window) {
-  DCHECK_EQ(resizer_->GetTarget(), WmWindow::Get(window));
+  DCHECK_EQ(resizer_->GetTarget(), window);
   handler_->ResizerWindowDestroyed();
 }
 
 // WmToplevelWindowEventHandler
 // --------------------------------------------------
 
 WmToplevelWindowEventHandler::WmToplevelWindowEventHandler()
     : first_finger_hittest_(HTNOWHERE) {
   ShellPort::Get()->AddDisplayObserver(this);
 }
@@ skipping 52 matching lines @@
                                                   WmWindow* target) {
   if (event->handled())
     return;
   if (!target->HasNonClientArea())
     return;
 
   if (window_resizer_.get() && !in_gesture_drag_)
     return;
 
   if (window_resizer_.get() &&
-      window_resizer_->resizer()->GetTarget() != target) {
+      window_resizer_->resizer()->GetTarget() != target->aura_window()) {
     return;
   }
 
   if (event->details().touch_points() > 2) {
     if (CompleteDrag(DragResult::SUCCESS))
       event->StopPropagation();
     return;
   }
 
   switch (event->type()) {
@@ skipping 137 matching lines @@
 }
 
 bool WmToplevelWindowEventHandler::AttemptToStartDrag(
     WmWindow* window,
     const gfx::Point& point_in_parent,
     int window_component,
     aura::client::WindowMoveSource source,
     const EndClosure& end_closure) {
   if (window_resizer_.get())
     return false;
-  std::unique_ptr<WindowResizer> resizer(
-      CreateWindowResizer(window, point_in_parent, window_component, source));
+  std::unique_ptr<WindowResizer> resizer(CreateWindowResizer(
+      window->aura_window(), point_in_parent, window_component, source));
   if (!resizer)
     return false;
 
   end_closure_ = end_closure;
   window_resizer_.reset(new ScopedWindowResizer(this, std::move(resizer)));
 
   pre_drag_window_bounds_ = window->GetBounds();
   in_gesture_drag_ = (source == aura::client::WINDOW_MOVE_SOURCE_TOUCH);
   return true;
 }
@@ skipping 164 matching lines @@
 void WmToplevelWindowEventHandler::ResizerWindowDestroyed() {
   CompleteDrag(DragResult::WINDOW_DESTROYED);
 }
 
 void WmToplevelWindowEventHandler::OnDisplayConfigurationChanging() {
   CompleteDrag(DragResult::REVERT);
 }
 
 }  // namespace wm
 }  // namespace ash