Replace WmWindowObserver with aura::WindowObserver.

ash/common/wm/workspace/workspace_layout_manager.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/workspace/workspace_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/wm/always_on_top_controller.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/window_positioner.h"
 #include "ash/common/wm/window_state.h"
 #include "ash/common/wm/wm_event.h"
 #include "ash/common/wm/wm_screen_util.h"
 #include "ash/common/wm/workspace/workspace_layout_manager_backdrop_delegate.h"
 #include "ash/common/wm_shell.h"
 #include "ash/common/wm_window.h"
 #include "ash/common/wm_window_property.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
+#include "ash/wm/window_state_aura.h"
 #include "base/command_line.h"
+#include "ui/aura/client/aura_constants.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/keyboard/keyboard_controller.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 
 namespace ash {
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(WmWindow* window)
     : window_(window),
       root_window_(window->GetRootWindow()),
       root_window_controller_(root_window_->GetRootWindowController()),
       shell_(window_->GetShell()),
       work_area_in_parent_(wm::GetDisplayWorkAreaBounds(window_)),
       is_fullscreen_(wm::GetWindowForFullscreenMode(window) != nullptr) {
   shell_->AddShellObserver(this);
   shell_->AddActivationObserver(this);
-  root_window_->AddObserver(this);
+  root_window_->aura_window()->AddObserver(this);
   display::Screen::GetScreen()->AddObserver(this);
   DCHECK(window->GetBoolProperty(
       WmWindowProperty::SNAP_CHILDREN_TO_PIXEL_BOUNDARY));
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
   if (root_window_)
-    root_window_->RemoveObserver(this);
+    root_window_->aura_window()->RemoveObserver(this);
   for (WmWindow* window : windows_) {
     wm::WindowState* window_state = window->GetWindowState();
     window_state->RemoveObserver(this);
-    window->RemoveObserver(this);
+    window->aura_window()->RemoveObserver(this);
   }
   display::Screen::GetScreen()->RemoveObserver(this);
   shell_->RemoveActivationObserver(this);
   shell_->RemoveShellObserver(this);
 }
 
 void WorkspaceLayoutManager::SetMaximizeBackdropDelegate(
     std::unique_ptr<WorkspaceLayoutManagerBackdropDelegate> delegate) {
   backdrop_delegate_ = std::move(delegate);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::LayoutManager implementation:
 
 void WorkspaceLayoutManager::OnWindowResized() {}
 
 void WorkspaceLayoutManager::OnWindowAddedToLayout(WmWindow* child) {
   wm::WindowState* window_state = child->GetWindowState();
   wm::WMEvent event(wm::WM_EVENT_ADDED_TO_WORKSPACE);
   window_state->OnWMEvent(&event);
   windows_.insert(child);
-  child->AddObserver(this);
+  child->aura_window()->AddObserver(this);
   window_state->AddObserver(this);
   UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
     backdrop_delegate_->OnWindowAddedToLayout(child);
   WindowPositioner::RearrangeVisibleWindowOnShow(child);
   if (WmShell::Get()->IsPinned())
     child->GetWindowState()->DisableAlwaysOnTop(nullptr);
 }
 
 void WorkspaceLayoutManager::OnWillRemoveWindowFromLayout(WmWindow* child) {
   windows_.erase(child);
-  child->RemoveObserver(this);
+  child->aura_window()->RemoveObserver(this);
   child->GetWindowState()->RemoveObserver(this);
 
   if (child->GetTargetVisibility())
     WindowPositioner::RearrangeVisibleWindowOnHideOrRemove(child);
 }
 
 void WorkspaceLayoutManager::OnWindowRemovedFromLayout(WmWindow* child) {
   UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
@@ skipping 73 matching lines @@
     // override user intent.
     window_state->SetAndClearRestoreBounds();
   }
 }
 
 void WorkspaceLayoutManager::OnKeyboardClosed() {}
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager, aura::WindowObserver implementation:
 
-void WorkspaceLayoutManager::OnWindowTreeChanged(
-    WmWindow* window,
-    const WmWindowObserver::TreeChangeParams& params) {
-  if (!params.target->GetWindowState()->IsActive())
+void WorkspaceLayoutManager::OnWindowHierarchyChanged(
+    const HierarchyChangeParams& params) {
+  if (!wm::GetWindowState(params.target)->IsActive())
     return;
   // If the window is already tracked by the workspace this update would be
   // redundant as the fullscreen and shelf state would have been handled in
   // OnWindowAddedToLayout.
-  if (windows_.find(params.target) != windows_.end())
+  if (windows_.find(WmWindow::Get(params.target)) != windows_.end())
     return;
 
   // If the active window has moved to this root window then update the
   // fullscreen state.
   // TODO(flackr): Track the active window leaving this root window and update
   // the fullscreen state accordingly.
-  if (params.new_parent && params.new_parent->GetRootWindow() == root_window_) {
+  if (params.new_parent &&
+      WmWindow::Get(params.new_parent->GetRootWindow()) == root_window_) {
     UpdateFullscreenState();
     UpdateShelfVisibility();
   }
 }
 
-void WorkspaceLayoutManager::OnWindowPropertyChanged(
-    WmWindow* window,
-    WmWindowProperty property) {
-  if (property == WmWindowProperty::ALWAYS_ON_TOP &&
-      window->GetBoolProperty(WmWindowProperty::ALWAYS_ON_TOP)) {
+void WorkspaceLayoutManager::OnWindowPropertyChanged(aura::Window* window,
+                                                     const void* key,
+                                                     intptr_t old) {
+  if (key == aura::client::kAlwaysOnTopKey &&
+      window->GetProperty(aura::client::kAlwaysOnTopKey)) {
     WmWindow* container =
         root_window_controller_->always_on_top_controller()->GetContainer(
-            window);
-    if (window->GetParent() != container)
-      container->AddChild(window);
+            WmWindow::Get(window));
+    if (WmWindow::Get(window->parent()) != container)
+      container->AddChild(WmWindow::Get(window));
   }
 }
 
-void WorkspaceLayoutManager::OnWindowStackingChanged(WmWindow* window) {
+void WorkspaceLayoutManager::OnWindowStackingChanged(aura::Window* window) {
   UpdateShelfVisibility();
   UpdateFullscreenState();
   if (backdrop_delegate_)
-    backdrop_delegate_->OnWindowStackingChanged(window);
+    backdrop_delegate_->OnWindowStackingChanged(WmWindow::Get(window));
 }
 
-void WorkspaceLayoutManager::OnWindowDestroying(WmWindow* window) {
-  if (root_window_ == window) {
-    root_window_->RemoveObserver(this);
+void WorkspaceLayoutManager::OnWindowDestroying(aura::Window* window) {
+  if (root_window_ == WmWindow::Get(window)) {
+    root_window_->aura_window()->RemoveObserver(this);
     root_window_ = nullptr;
   }
 }
 
 void WorkspaceLayoutManager::OnWindowBoundsChanged(
-    WmWindow* window,
+    aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
-  if (root_window_ == window) {
+  if (root_window_ == WmWindow::Get(window)) {
     const wm::WMEvent wm_event(wm::WM_EVENT_DISPLAY_BOUNDS_CHANGED);
     AdjustAllWindowsBoundsForWorkAreaChange(&wm_event);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // WorkspaceLayoutManager,
 // aura::client::ActivationChangeObserver implementation:
 
 void WorkspaceLayoutManager::OnWindowActivated(WmWindow* gained_active,
@@ skipping 131 matching lines @@
   for (auto* window : windows) {
     wm::WindowState* window_state = window->GetWindowState();
     if (window_on_top)
       window_state->DisableAlwaysOnTop(window_on_top);
     else
       window_state->RestoreAlwaysOnTop();
   }
 }
 
 }  // namespace ash