Replace WmWindowObserver with aura::WindowObserver.

ash/common/wm/system_modal_container_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/system_modal_container_layout_manager.h"
 
 #include <cmath>
 
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/wm/window_dimmer.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 "base/memory/ptr_util.h"
 #include "base/stl_util.h"
+#include "ui/aura/client/aura_constants.h"
+#include "ui/aura/window.h"
 #include "ui/keyboard/keyboard_controller.h"
 
 namespace ash {
 namespace {
 
 // The center point of the window can diverge this much from the center point
 // of the container to be kept centered upon resizing operations.
 const int kCenterPixelDelta = 32;
 
 ui::ModalType GetModalType(WmWindow* window) {
@@ skipping 53 matching lines @@
     DCHECK(container_->GetShellWindowId() !=
                kShellWindowId_LockSystemModalContainer ||
            WmShell::Get()->GetSessionStateDelegate()->IsUserSessionBlocked());
   }
   // Since this is for SystemModal, there is no good reason to add windows
   // other than MODAL_TYPE_NONE or MODAL_TYPE_SYSTEM. DCHECK to avoid simple
   // mistake.
   DCHECK_NE(GetModalType(child), ui::MODAL_TYPE_CHILD);
   DCHECK_NE(GetModalType(child), ui::MODAL_TYPE_WINDOW);
 
-  child->AddObserver(this);
+  child->aura_window()->AddObserver(this);
   if (GetModalType(child) == ui::MODAL_TYPE_SYSTEM && child->IsVisible())
     AddModalWindow(child);
 }
 
 void SystemModalContainerLayoutManager::OnWillRemoveWindowFromLayout(
     WmWindow* child) {
-  child->RemoveObserver(this);
+  child->aura_window()->RemoveObserver(this);
   windows_to_center_.erase(child);
   if (GetModalType(child) == ui::MODAL_TYPE_SYSTEM)
     RemoveModalWindow(child);
 }
 
 void SystemModalContainerLayoutManager::SetChildBounds(
     WmWindow* child,
     const gfx::Rect& requested_bounds) {
   WmSnapToPixelLayoutManager::SetChildBounds(child, requested_bounds);
   if (IsBoundsCentered(requested_bounds))
     windows_to_center_.insert(child);
   else
     windows_to_center_.erase(child);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// SystemModalContainerLayoutManager, WmWindowObserver implementation:
+// SystemModalContainerLayoutManager, aura::WindowObserver implementation:
 
 void SystemModalContainerLayoutManager::OnWindowPropertyChanged(
-    WmWindow* window,
-    WmWindowProperty property) {
-  if (property != WmWindowProperty::MODAL_TYPE || !window->IsVisible())
+    aura::Window* window,
+    const void* key,
+    intptr_t old) {
+  if (key != aura::client::kModalKey || !window->IsVisible())
     return;
 
-  if (GetModalType(window) == ui::MODAL_TYPE_SYSTEM) {
-    if (base::ContainsValue(modal_windows_, window))
+  WmWindow* wm_window = WmWindow::Get(window);
+  if (window->GetProperty(aura::client::kModalKey) == ui::MODAL_TYPE_SYSTEM) {
+    if (base::ContainsValue(modal_windows_, wm_window))
       return;
-    AddModalWindow(window);
+    AddModalWindow(wm_window);
   } else {
-    if (RemoveModalWindow(window))
-      WmShell::Get()->OnModalWindowRemoved(window);
+    if (RemoveModalWindow(wm_window))
+      WmShell::Get()->OnModalWindowRemoved(wm_window);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // SystemModalContainerLayoutManager, Keyboard::KeybaordControllerObserver
 // implementation:
 
 void SystemModalContainerLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& new_bounds) {
   PositionDialogsAfterWorkAreaResize();
@@ skipping 129 matching lines @@
 bool SystemModalContainerLayoutManager::IsBoundsCentered(
     const gfx::Rect& bounds) const {
   gfx::Point window_center = bounds.CenterPoint();
   gfx::Point container_center = GetUsableDialogArea().CenterPoint();
   return std::abs(window_center.x() - container_center.x()) <
              kCenterPixelDelta &&
          std::abs(window_center.y() - container_center.y()) < kCenterPixelDelta;
 }
 
 }  // namespace ash