Replace WmWindowObserver with aura::WindowObserver.

ash/common/wm/workspace/workspace_layout_manager_unittest.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 <string>
 #include <utility>
 
 #include "ash/common/session/session_state_delegate.h"
 #include "ash/common/shelf/shelf_constants.h"
 #include "ash/common/shelf/shelf_layout_manager.h"
 #include "ash/common/shelf/wm_shelf.h"
 #include "ash/common/shell_observer.h"
 #include "ash/common/test/ash_test.h"
 #include "ash/common/test/test_session_state_delegate.h"
 #include "ash/common/wm/fullscreen_window_finder.h"
 #include "ash/common/wm/maximize_mode/workspace_backdrop_delegate.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_window_resizer.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/wm/window_state_aura.h"
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "ui/aura/env.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/views/widget/widget.h"
@@ skipping 248 matching lines @@
   window_state->SetRestoreBoundsInScreen(gfx::Rect(295, 0, 30, 40));
   window->SetShowState(ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("300,0 400x500", window->GetBoundsInScreen().ToString());
 
   window_state->Restore();
   EXPECT_EQ(root_windows[1], window->GetRootWindow());
   EXPECT_EQ("295,0 30x40", window->GetBoundsInScreen().ToString());
 }
 
-// WmWindowObserver implementation used by
+// aura::WindowObserver implementation used by
 // DontClobberRestoreBoundsWindowObserver. This code mirrors what
 // BrowserFrameAsh does. In particular when this code sees the window was
 // maximized it changes the bounds of a secondary window. The secondary window
 // mirrors the status window.
-class DontClobberRestoreBoundsWindowObserver : public WmWindowObserver {
+class DontClobberRestoreBoundsWindowObserver : public aura::WindowObserver {
  public:
   DontClobberRestoreBoundsWindowObserver() : window_(nullptr) {}
 
   void set_window(WmWindow* window) { window_ = window; }
 
-  // WmWindowObserver:
-  void OnWindowPropertyChanged(WmWindow* window,
-                               WmWindowProperty property) override {
+  // aura::WindowObserver:
+  void OnWindowPropertyChanged(aura::Window* window,
+                               const void* key,
+                               intptr_t old) override {
     if (!window_)
       return;
 
-    if (window->GetWindowState()->IsMaximized()) {
+    if (wm::GetWindowState(window)->IsMaximized()) {
       WmWindow* w = window_;
       window_ = nullptr;
 
       gfx::Rect shelf_bounds(AshTest::GetPrimaryShelf()->GetIdealBounds());
       const gfx::Rect& window_bounds(w->GetBounds());
       w->SetBounds(gfx::Rect(window_bounds.x(), shelf_bounds.y() - 1,
                              window_bounds.width(), window_bounds.height()));
     }
   }
 
  private:
   WmWindow* window_;
 
   DISALLOW_COPY_AND_ASSIGN(DontClobberRestoreBoundsWindowObserver);
 };
 
 // Creates a window, maximized the window and from within the maximized
 // notification sets the bounds of a window to overlap the shelf. Verifies this
 // doesn't effect the restore bounds.
 TEST_F(WorkspaceLayoutManagerTest, DontClobberRestoreBounds) {
   DontClobberRestoreBoundsWindowObserver window_observer;
   WindowOwner window_owner(WmShell::Get()->NewWindow(ui::wm::WINDOW_TYPE_NORMAL,
                                                      ui::LAYER_TEXTURED));
   WmWindow* window = window_owner.window();
   window->SetBounds(gfx::Rect(10, 20, 30, 40));
   // NOTE: for this test to exercise the failure the observer needs to be added
   // before the parent set. This mimics what BrowserFrameAsh does.
-  window->AddObserver(&window_observer);
+  window->aura_window()->AddObserver(&window_observer);
   ParentWindowInPrimaryRootWindow(window);
   window->Show();
 
   wm::WindowState* window_state = window->GetWindowState();
   window_state->Activate();
 
   std::unique_ptr<WindowOwner> window2_owner(
       CreateTestWindow(gfx::Rect(12, 20, 30, 40)));
   WmWindow* window2 = window2_owner->window();
   AddTransientChild(window, window2);
   window2->Show();
 
   window_observer.set_window(window2);
   window_state->Maximize();
   EXPECT_EQ("10,20 30x40", window_state->GetRestoreBoundsInScreen().ToString());
-  window->RemoveObserver(&window_observer);
+  window->aura_window()->RemoveObserver(&window_observer);
 }
 
 // Verifies when a window is maximized all descendant windows have a size.
 TEST_F(WorkspaceLayoutManagerTest, ChildBoundsResetOnMaximize) {
   std::unique_ptr<WindowOwner> window_owner(
       CreateTestWindow(gfx::Rect(10, 20, 30, 40)));
   WmWindow* window = window_owner->window();
   window->Show();
   wm::WindowState* window_state = window->GetWindowState();
   window_state->Activate();
@@ skipping 244 matching lines @@
   std::unique_ptr<WindowOwner> window_owner(CreateTestWindow(bounds));
   WmWindow* window = window_owner->window();
   window->SetShowState(ui::SHOW_STATE_MINIMIZED);
   // Note: Currently minimize doesn't do anything except set the state.
   // See crbug.com/104571.
   EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString());
   window->SetShowState(ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(bounds.ToString(), window->GetBounds().ToString());
 }
 
-// A WmWindowObserver which sets the focus when the window becomes visible.
-class FocusDuringUnminimizeWindowObserver : public WmWindowObserver {
+// A aura::WindowObserver which sets the focus when the window becomes visible.
+class FocusDuringUnminimizeWindowObserver : public aura::WindowObserver {
  public:
   FocusDuringUnminimizeWindowObserver()
       : window_(nullptr), show_state_(ui::SHOW_STATE_END) {}
   ~FocusDuringUnminimizeWindowObserver() override { SetWindow(nullptr); }
 
   void SetWindow(WmWindow* window) {
     if (window_)
-      window_->RemoveObserver(this);
+      window_->aura_window()->RemoveObserver(this);
     window_ = window;
     if (window_)
-      window_->AddObserver(this);
+      window_->aura_window()->AddObserver(this);
   }
 
-  // WmWindowObserver:
-  void OnWindowVisibilityChanged(WmWindow* window, bool visible) override {
+  // aura::WindowObserver:
+  void OnWindowVisibilityChanged(aura::Window* window, bool visible) override {
     if (window_) {
       if (visible)
         window_->SetFocused();
       show_state_ = window_->GetShowState();
     }
   }
 
   ui::WindowShowState GetShowStateAndReset() {
     ui::WindowShowState ret = show_state_;
     show_state_ = ui::SHOW_STATE_END;
@@ skipping 608 matching lines @@
   window->SetBounds(keyboard_bounds());
   window->GetWindowState()->set_ignore_keyboard_bounds_change(true);
   window->Activate();
 
   EXPECT_EQ(keyboard_bounds(), window->GetBounds());
   ShowKeyboard();
   EXPECT_EQ(keyboard_bounds(), window->GetBounds());
 }
 
 }  // namespace ash