Makes Panel related classes use ash/wm/common types

ash/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/toplevel_window_event_handler.h"
 
 #include "ash/shell.h"
 #include "ash/wm/aura/wm_window_aura.h"
 #include "ash/wm/common/wm_event.h"
+#include "ash/wm/common/wm_window_observer.h"
 #include "ash/wm/resize_shadow_controller.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_state_aura.h"
 #include "ash/wm/window_state_observer.h"
 #include "ash/wm/window_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
@@ skipping 62 matching lines @@
 }
 
 }  // namespace
 
 // ScopedWindowResizer ---------------------------------------------------------
 
 // Wraps a WindowResizer and installs an observer on its target window.  When
 // the window is destroyed ResizerWindowDestroyed() is invoked back on the
 // ToplevelWindowEventHandler to clean up.
 class ToplevelWindowEventHandler::ScopedWindowResizer
-    : public aura::WindowObserver,
+    : public wm::WmWindowObserver,
       public wm::WindowStateObserver {
  public:
   ScopedWindowResizer(ToplevelWindowEventHandler* handler,
                       WindowResizer* resizer);
   ~ScopedWindowResizer() override;
 
   // Returns true if the drag moves the window and does not resize.
   bool IsMove() const;
 
   WindowResizer* resizer() { return resizer_.get(); }
 
   // WindowObserver overrides:
-  void OnWindowDestroying(aura::Window* window) override;
+  void OnWindowDestroying(wm::WmWindow* window) override;
 
   // WindowStateObserver overrides:
   void OnPreWindowStateTypeChange(wm::WindowState* window_state,
                                   wm::WindowStateType type) override;
 
  private:
   ToplevelWindowEventHandler* handler_;
   std::unique_ptr<WindowResizer> resizer_;
 
   // Whether ScopedWindowResizer grabbed capture.
   bool grabbed_capture_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedWindowResizer);
 };
 
 ToplevelWindowEventHandler::ScopedWindowResizer::ScopedWindowResizer(
     ToplevelWindowEventHandler* handler,
     WindowResizer* resizer)
     : handler_(handler),
       resizer_(resizer),
       grabbed_capture_(false) {
-  aura::Window* target = resizer_->GetAuraTarget();
+  wm::WmWindow* target = resizer_->GetTarget();
   target->AddObserver(this);
-  wm::GetWindowState(target)->AddObserver(this);
+  target->GetWindowState()->AddObserver(this);
 
   if (!target->HasCapture()) {
     grabbed_capture_ = true;
     target->SetCapture();
   }
 }
 
 ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
-  aura::Window* target = resizer_->GetAuraTarget();
+  wm::WmWindow* target = resizer_->GetTarget();
   target->RemoveObserver(this);
-  wm::GetWindowState(target)->RemoveObserver(this);
+  target->GetWindowState()->RemoveObserver(this);
   if (grabbed_capture_)
     target->ReleaseCapture();
 }
 
 bool ToplevelWindowEventHandler::ScopedWindowResizer::IsMove() const {
   return resizer_->details().bounds_change ==
       WindowResizer::kBoundsChange_Repositions;
 }
 
 void
 ToplevelWindowEventHandler::ScopedWindowResizer::OnPreWindowStateTypeChange(
     wm::WindowState* window_state,
     wm::WindowStateType old) {
   handler_->CompleteDrag(DRAG_COMPLETE);
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowDestroying(
-    aura::Window* window) {
-  DCHECK_EQ(resizer_->GetAuraTarget(), window);
+    wm::WmWindow* window) {
+  DCHECK_EQ(resizer_->GetTarget(), window);
   handler_->ResizerWindowDestroyed();
 }
 
 // ToplevelWindowEventHandler --------------------------------------------------
 
 ToplevelWindowEventHandler::ToplevelWindowEventHandler()
     : first_finger_hittest_(HTNOWHERE),
       in_move_loop_(false),
       in_gesture_drag_(false),
       drag_reverted_(false),
@@ skipping 58 matching lines @@
   if (event->handled())
     return;
   aura::Window* target = static_cast<aura::Window*>(event->target());
   if (!target->delegate())
     return;
 
   if (window_resizer_.get() && !in_gesture_drag_)
     return;
 
   if (window_resizer_.get() &&
-      window_resizer_->resizer()->GetAuraTarget() != target) {
+      wm::WmWindowAura::GetAuraWindow(
+          window_resizer_->resizer()->GetTarget()) != target) {
     return;
   }
 
   if (event->details().touch_points() > 2) {
     if (CompleteDrag(DRAG_COMPLETE))
       event->StopPropagation();
     return;
   }
 
   switch (event->type()) {
@@ skipping 383 matching lines @@
     default:
       NOTREACHED();
   }
 }
 
 void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
   CompleteDrag(DRAG_RESIZER_WINDOW_DESTROYED);
 }
 
 }  // namespace ash