Replace WmWindowObserver with aura::WindowObserver.

ash/common/wm/overview/window_selector.cc

 // Copyright 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/overview/window_selector.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <utility>
@@ skipping 221 matching lines @@
 
 WindowSelector::~WindowSelector() {
   RemoveAllObservers();
 }
 
 // NOTE: The work done in Init() is not done in the constructor because it may
 // cause other, unrelated classes, (ie PanelLayoutManager) to make indirect
 // calls to restoring_minimized_windows() on a partially constructed object.
 void WindowSelector::Init(const WindowList& windows) {
   if (restore_focus_window_)
-    restore_focus_window_->AddObserver(this);
+    restore_focus_window_->aura_window()->AddObserver(this);
 
   WmShell* shell = WmShell::Get();
 
   std::vector<WmWindow*> root_windows = shell->GetAllRootWindows();
   std::sort(root_windows.begin(), root_windows.end(),
             [](const WmWindow* a, const WmWindow* b) {
               // Since we don't know if windows are vertically or horizontally
               // oriented we use both x and y position. This may be confusing
               // if you have 3 or more monitors which are not strictly
               // horizontal or vertical but that case is not yet supported.
               return (a->GetBoundsInScreen().x() + a->GetBoundsInScreen().y()) <
                      (b->GetBoundsInScreen().x() + b->GetBoundsInScreen().y());
             });
 
   for (WmWindow* root : root_windows) {
     // Observed switchable containers for newly created windows on all root
     // windows.
     for (size_t i = 0; i < wm::kSwitchableWindowContainerIdsLength; ++i) {
       WmWindow* container =
           root->GetChildByShellWindowId(wm::kSwitchableWindowContainerIds[i]);
-      container->AddObserver(this);
+      container->aura_window()->AddObserver(this);
       observed_windows_.insert(container);
     }
 
     // Hide the callout widgets for panels. It is safe to call this for
     // root windows that don't contain any panel windows.
     PanelLayoutManager::Get(root)->SetShowCalloutWidgets(false);
 
     std::unique_ptr<WindowGrid> grid(new WindowGrid(root, windows, this));
     if (grid->empty())
       continue;
@@ skipping 91 matching lines @@
                              remaining_items);
   }
 
   // Clearing the window list resets the ignored_by_shelf flag on the windows.
   grid_list_.clear();
   UpdateShelfVisibility();
 }
 
 void WindowSelector::RemoveAllObservers() {
   for (WmWindow* window : observed_windows_)
-    window->RemoveObserver(this);
+    window->aura_window()->RemoveObserver(this);
 
   WmShell::Get()->RemoveActivationObserver(this);
   display::Screen::GetScreen()->RemoveObserver(this);
   if (restore_focus_window_)
-    restore_focus_window_->RemoveObserver(this);
+    restore_focus_window_->aura_window()->RemoveObserver(this);
 }
 
 void WindowSelector::CancelSelection() {
   delegate_->OnSelectionEnded();
 }
 
 void WindowSelector::OnGridEmpty(WindowGrid* grid) {
   size_t index = 0;
   for (auto iter = grid_list_.begin(); iter != grid_list_.end(); ++iter) {
     if (grid == (*iter).get()) {
@@ skipping 117 matching lines @@
   // TODO(flackr): Keep window selection active on remaining displays.
   CancelSelection();
 }
 
 void WindowSelector::OnDisplayMetricsChanged(const display::Display& display,
                                              uint32_t metrics) {
   PositionWindows(/* animate */ false);
   RepositionTextFilterOnDisplayMetricsChange();
 }
 
-void WindowSelector::OnWindowTreeChanged(WmWindow* window,
-                                         const TreeChangeParams& params) {
+void WindowSelector::OnWindowHierarchyChanged(
+    const HierarchyChangeParams& params) {
   // Only care about newly added children of |observed_windows_|.
-  if (!observed_windows_.count(window) ||
-      !observed_windows_.count(params.new_parent)) {
+  if (!observed_windows_.count(WmWindow::Get(params.receiver)) ||
+      !observed_windows_.count(WmWindow::Get(params.new_parent))) {
     return;
   }
 
-  WmWindow* new_window = params.target;
+  WmWindow* new_window = WmWindow::Get(params.target);
   if (!IsSelectable(new_window))
     return;
 
   for (size_t i = 0; i < wm::kSwitchableWindowContainerIdsLength; ++i) {
     if (new_window->GetParent()->GetShellWindowId() ==
             wm::kSwitchableWindowContainerIds[i] &&
         !new_window->GetTransientParent()) {
       // The new window is in one of the switchable containers, abort overview.
       CancelSelection();
       return;
     }
   }
 }
 
-void WindowSelector::OnWindowDestroying(WmWindow* window) {
+void WindowSelector::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
-  observed_windows_.erase(window);
-  if (window == restore_focus_window_)
+  observed_windows_.erase(WmWindow::Get(window));
+  if (WmWindow::Get(window) == restore_focus_window_)
     restore_focus_window_ = nullptr;
 }
 
 void WindowSelector::OnWindowActivated(WmWindow* gained_active,
                                        WmWindow* lost_active) {
   if (ignore_activations_ || !gained_active ||
       gained_active == GetTextFilterWidgetWindow()) {
     return;
   }
 
@@ skipping 94 matching lines @@
   if (!restore_focus_window_)
     return;
   if (focus) {
     base::AutoReset<bool> restoring_focus(&ignore_activations_, true);
     restore_focus_window_->Activate();
   }
   // If the window is in the observed_windows_ list it needs to continue to be
   // observed.
   if (observed_windows_.find(restore_focus_window_) ==
       observed_windows_.end()) {
-    restore_focus_window_->RemoveObserver(this);
+    restore_focus_window_->aura_window()->RemoveObserver(this);
   }
   restore_focus_window_ = nullptr;
 }
 
 void WindowSelector::Move(Direction direction, bool animate) {
   // Direction to move if moving past the end of a display.
   int display_direction = (direction == RIGHT || direction == DOWN) ? 1 : -1;
 
   // If this is the first move and it's going backwards, start on the last
   // display.
   if (display_direction == -1 && !grid_list_.empty() &&
       !grid_list_[selected_grid_index_]->is_selecting()) {
     selected_grid_index_ = grid_list_.size() - 1;
   }
 
   // Keep calling Move() on the grids until one of them reports no overflow or
   // we made a full cycle on all the grids.
   for (size_t i = 0; i <= grid_list_.size() &&
                      grid_list_[selected_grid_index_]->Move(direction, animate);
        i++) {
     selected_grid_index_ =
         (selected_grid_index_ + display_direction + grid_list_.size()) %
         grid_list_.size();
   }
 }
 
 }  // namespace ash