Replace WmWindowObserver with aura::WindowObserver.

ash/common/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 2013 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/dock/docked_window_layout_manager.h"
 
 #include "ash/animation/animation_change_type.h"
 #include "ash/common/shelf/shelf_background_animator.h"
 #include "ash/common/shelf/shelf_background_animator_observer.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shelf/wm_shelf_observer.h"
 #include "ash/common/wm/overview/window_selector_controller.h"
 #include "ash/common/wm/window_animation_types.h"
 #include "ash/common/wm/window_parenting_utils.h"
 #include "ash/common/wm/window_resizer.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm_lookup.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
+#include "ash/screen_util.h"
+#include "ash/wm/window_state_aura.h"
 #include "base/auto_reset.h"
 #include "base/metrics/histogram_macros.h"
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/views/background.h"
+#include "ui/wm/core/window_animations.h"
 
 namespace ash {
 
 // Minimum, maximum width of the dock area and a width of the gap
 // static
 const int DockedWindowLayoutManager::kMaxDockWidth = 360;
 // static
 const int DockedWindowLayoutManager::kMinDockWidth = 200;
 // static
 const int DockedWindowLayoutManager::kMinDockGap = 2;
@@ skipping 257 matching lines @@
   }
 
  private:
   WmWindow* dragged_window_;
   WmWindow* docked_container_;
   float delta_;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // A class that observes shelf for bounds changes.
-class DockedWindowLayoutManager::ShelfWindowObserver : public WmWindowObserver {
+class DockedWindowLayoutManager::ShelfWindowObserver
+    : public aura::WindowObserver {
  public:
   explicit ShelfWindowObserver(DockedWindowLayoutManager* docked_layout_manager)
       : docked_layout_manager_(docked_layout_manager) {
     DCHECK(docked_layout_manager_->shelf()->GetWindow());
-    docked_layout_manager_->shelf()->GetWindow()->AddObserver(this);
+    docked_layout_manager_->shelf()->GetWindow()->aura_window()->AddObserver(
+        this);
   }
 
   ~ShelfWindowObserver() override {
     if (docked_layout_manager_->shelf() &&
         docked_layout_manager_->shelf()->GetWindow()) {
-      docked_layout_manager_->shelf()->GetWindow()->RemoveObserver(this);
+      docked_layout_manager_->shelf()
+          ->GetWindow()
+          ->aura_window()
+          ->RemoveObserver(this);
     }
   }
 
-  // WmWindowObserver:
-  void OnWindowBoundsChanged(WmWindow* window,
+  // aura::WindowObserver:
+  void OnWindowBoundsChanged(aura::Window* window,
                              const gfx::Rect& old_bounds,
                              const gfx::Rect& new_bounds) override {
     shelf_bounds_in_screen_ =
-        window->GetParent()->ConvertRectToScreen(new_bounds);
+        ScreenUtil::ConvertRectToScreen(window->parent(), new_bounds);
 
     // When the shelf is auto-hidden, it has an invisible height of 3px used
     // as a hit region which is specific to Chrome OS MD (for non-MD, the 3
     // pixels are visible). In computing the work area we should consider a
     // hidden shelf as having a height of 0 (for non-MD, shelf height is 3).
     if (docked_layout_manager_->shelf()->GetAutoHideState() ==
         ShelfAutoHideState::SHELF_AUTO_HIDE_HIDDEN) {
       shelf_bounds_in_screen_.set_height(
           GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE));
     }
@@ skipping 50 matching lines @@
   return static_cast<DockedWindowLayoutManager*>(
       root->GetChildByShellWindowId(kShellWindowId_DockedContainer)
           ->GetLayoutManager());
 }
 
 void DockedWindowLayoutManager::Shutdown() {
   background_widget_.reset();
   shelf_observer_.reset();
   shelf_ = nullptr;
   for (WmWindow* child : dock_container_->GetChildren()) {
-    child->RemoveObserver(this);
+    child->aura_window()->RemoveObserver(this);
     child->GetWindowState()->RemoveObserver(this);
   }
   dock_container_->GetShell()->RemoveActivationObserver(this);
   dock_container_->GetShell()->RemoveShellObserver(this);
   display::Screen::GetScreen()->RemoveObserver(this);
 }
 
 void DockedWindowLayoutManager::AddObserver(
     DockedWindowLayoutManagerObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void DockedWindowLayoutManager::RemoveObserver(
     DockedWindowLayoutManagerObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void DockedWindowLayoutManager::StartDragging(WmWindow* window) {
   DCHECK(!dragged_window_);
   dragged_window_ = window;
   DCHECK(!IsPopupOrTransient(window));
   // Start observing a window unless it is docked container's child in which
   // case it is already observed.
   wm::WindowState* dragged_state = dragged_window_->GetWindowState();
   if (dragged_window_->GetParent() != dock_container_) {
-    dragged_window_->AddObserver(this);
+    dragged_window_->aura_window()->AddObserver(this);
     dragged_state->AddObserver(this);
   } else if (!IsAnyWindowDocked() && dragged_state->drag_details() &&
              !(dragged_state->drag_details()->bounds_change &
                WindowResizer::kBoundsChange_Resizes)) {
     // If there are no other docked windows clear alignment when a docked window
     // is moved (but not when it is resized or the window could get undocked
     // when resized away from the edge while docked).
     alignment_ = DOCKED_ALIGNMENT_NONE;
   }
   is_dragged_from_dock_ = window->GetParent() == dock_container_;
@@ skipping 32 matching lines @@
 void DockedWindowLayoutManager::FinishDragging(DockedAction action,
                                                DockedActionSource source) {
   DCHECK(dragged_window_);
   DCHECK(!IsPopupOrTransient(dragged_window_));
   if (is_dragged_window_docked_)
     OnDraggedWindowUndocked();
   DCHECK(!is_dragged_window_docked_);
   // Stop observing a window unless it is docked container's child in which
   // case it needs to keep being observed after the drag completes.
   if (dragged_window_->GetParent() != dock_container_) {
-    dragged_window_->RemoveObserver(this);
+    dragged_window_->aura_window()->RemoveObserver(this);
     dragged_window_->GetWindowState()->RemoveObserver(this);
     if (last_active_window_ == dragged_window_)
       last_active_window_ = nullptr;
   } else {
     // If this is the first window that got docked by a move update alignment.
     if (alignment_ == DOCKED_ALIGNMENT_NONE)
       alignment_ = GetEdgeNearestWindow(dragged_window_);
     // A window is no longer dragged and is a child.
     // When a window becomes a child at drag start this is
     // the only opportunity we will have to enforce a window
@@ skipping 148 matching lines @@
   // If this is the first window getting docked - update alignment.
   // A window can be added without proper bounds when window is moved to another
   // display via API or due to display configuration change, so the alignment
   // is set based on which edge is closer in the new display.
   if (alignment_ == DOCKED_ALIGNMENT_NONE) {
     alignment_ = preferred_alignment_ != DOCKED_ALIGNMENT_NONE
                      ? preferred_alignment_
                      : GetEdgeNearestWindow(child);
   }
   MaybeMinimizeChildrenExcept(child);
-  child->AddObserver(this);
+  child->aura_window()->AddObserver(this);
   child->GetWindowState()->AddObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 
   // Only keyboard-initiated actions are recorded here. Dragging cases
   // are handled in FinishDragging.
   if (event_source_ != DOCKED_ACTION_SOURCE_UNKNOWN)
     RecordUmaAction(DOCKED_ACTION_DOCK, event_source_);
 }
 
 void DockedWindowLayoutManager::OnWindowRemovedFromLayout(WmWindow* child) {
   if (IsPopupOrTransient(child))
     return;
   // Dragged windows are stopped being observed by FinishDragging and do not
   // change alignment during the drag. They also cannot be set to be the
   // |last_active_window_|.
   if (child == dragged_window_)
     return;
   // If this is the last window, set alignment and maximize the workspace.
   if (!IsAnyWindowDocked()) {
     alignment_ = DOCKED_ALIGNMENT_NONE;
     UpdateDockedWidth(0);
   }
   if (last_active_window_ == child)
     last_active_window_ = nullptr;
-  child->RemoveObserver(this);
+  child->aura_window()->RemoveObserver(this);
   child->GetWindowState()->RemoveObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::OnChildWindowVisibilityChanged(WmWindow* child,
                                                                bool visible) {
   if (IsPopupOrTransient(child))
     return;
 
@@ skipping 67 matching lines @@
     RestoreDockedWindow(window_state);
   } else if (old_type == wm::WINDOW_STATE_TYPE_MINIMIZED) {
     NOTREACHED() << "Minimized window in docked layout manager";
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, WindowObserver implementation:
 
 void DockedWindowLayoutManager::OnWindowBoundsChanged(
-    WmWindow* window,
+    aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   // Only relayout if the dragged window would get docked.
-  if (window == dragged_window_ && is_dragged_window_docked_)
+  if (WmWindow::Get(window) == dragged_window_ && is_dragged_window_docked_)
     Relayout();
 }
 
-void DockedWindowLayoutManager::OnWindowVisibilityChanging(WmWindow* window,
+void DockedWindowLayoutManager::OnWindowVisibilityChanging(aura::Window* window,
                                                            bool visible) {
-  if (IsPopupOrTransient(window))
+  if (IsPopupOrTransient(WmWindow::Get(window)))
     return;
   int animation_type = ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_DEFAULT;
   if (visible) {
     animation_type = ::wm::WINDOW_VISIBILITY_ANIMATION_TYPE_DROP;
-    window->SetVisibilityAnimationDuration(
-        base::TimeDelta::FromMilliseconds(kFadeDurationMs));
-  } else if (window->GetWindowState()->IsMinimized()) {
+    ::wm::SetWindowVisibilityAnimationDuration(
+        window, base::TimeDelta::FromMilliseconds(kFadeDurationMs));
+  } else if (wm::GetWindowState(window)->IsMinimized()) {
     animation_type = wm::WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE;
   }
-  window->SetVisibilityAnimationType(animation_type);
+  ::wm::SetWindowVisibilityAnimationType(window, animation_type);
 }
 
-void DockedWindowLayoutManager::OnWindowDestroying(WmWindow* window) {
-  if (dragged_window_ == window) {
+void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
+  if (dragged_window_ == WmWindow::Get(window)) {
     FinishDragging(DOCKED_ACTION_NONE, DOCKED_ACTION_SOURCE_UNKNOWN);
     DCHECK(!dragged_window_);
     DCHECK(!is_dragged_window_docked_);
   }
-  if (window == last_active_window_)
+  if (WmWindow::Get(window) == last_active_window_)
     last_active_window_ = nullptr;
   RecordUmaAction(DOCKED_ACTION_CLOSE, event_source_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockedWindowLayoutManager, WmActivationObserver implementation:
 
 void DockedWindowLayoutManager::OnWindowActivated(WmWindow* gained_active,
                                                   WmWindow* lost_active) {
   if (gained_active && IsPopupOrTransient(gained_active))
@@ skipping 517 matching lines @@
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 void DockedWindowLayoutManager::OnKeyboardClosed() {}
 
 }  // namespace ash