Replace WmWindowObserver with aura::WindowObserver.

ash/common/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/common/wm/wm_toplevel_window_event_handler.h"
 
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/window_state_observer.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
-#include "ash/common/wm_window_observer.h"
+#include "ui/aura/window.h"
+#include "ui/aura/window_observer.h"
 #include "ui/base/hit_test.h"
 #include "ui/events/event.h"
 
 namespace {
 const double kMinHorizVelocityForWindowSwipe = 1100;
 const double kMinVertVelocityForWindowMinimize = 1000;
 }
 
 namespace ash {
 namespace wm {
@@ skipping 35 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
 // WmToplevelWindowEventHandler to clean up.
 class WmToplevelWindowEventHandler::ScopedWindowResizer
-    : public WmWindowObserver,
+    : public aura::WindowObserver,
       public wm::WindowStateObserver {
  public:
   ScopedWindowResizer(WmToplevelWindowEventHandler* handler,
                       std::unique_ptr<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(WmWindow* window) override;
+  void OnWindowDestroying(aura::Window* window) override;
 
   // WindowStateObserver overrides:
   void OnPreWindowStateTypeChange(wm::WindowState* window_state,
                                   wm::WindowStateType type) override;
 
  private:
   WmToplevelWindowEventHandler* handler_;
   std::unique_ptr<WindowResizer> resizer_;
 
   // 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->AddObserver(this);
+  target->aura_window()->AddObserver(this);
   target->GetWindowState()->AddObserver(this);
 
   if (!target->HasCapture()) {
     grabbed_capture_ = true;
     target->SetCapture();
   }
 }
 
 WmToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
   WmWindow* target = resizer_->GetTarget();
-  target->RemoveObserver(this);
+  target->aura_window()->RemoveObserver(this);
   target->GetWindowState()->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(
-    WmWindow* window) {
-  DCHECK_EQ(resizer_->GetTarget(), window);
+    aura::Window* window) {
+  DCHECK_EQ(resizer_->GetTarget(), WmWindow::Get(window));
   handler_->ResizerWindowDestroyed();
 }
 
 // WmToplevelWindowEventHandler
 // --------------------------------------------------
 
 WmToplevelWindowEventHandler::WmToplevelWindowEventHandler(WmShell* shell)
     : shell_(shell), first_finger_hittest_(HTNOWHERE) {
   shell_->AddDisplayObserver(this);
 }
@@ skipping 396 matching lines @@
 void WmToplevelWindowEventHandler::ResizerWindowDestroyed() {
   CompleteDrag(DragResult::WINDOW_DESTROYED);
 }
 
 void WmToplevelWindowEventHandler::OnDisplayConfigurationChanging() {
   CompleteDrag(DragResult::REVERT);
 }
 
 }  // namespace wm
 }  // namespace ash