[Cleanup] Rename WindowSettings to WindowState

ash/wm/workspace_controller_unittest.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/wm/workspace_controller.h"
 
 #include <map>
 
 #include "ash/ash_switches.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/shell_test_api.h"
-#include "ash/wm/property_util.h"
-#include "ash/wm/window_settings.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
@@ skipping 65 matching lines @@
     window->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
     window->SetType(aura::client::WINDOW_TYPE_NORMAL);
     window->Init(ui::LAYER_TEXTURED);
     SetDefaultParentByPrimaryRootWindow(window);
     return window;
   }
 
   aura::Window* CreateBrowserLikeWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindow();
     window->SetBounds(bounds);
-    wm::WindowSettings* settings = wm::GetWindowSettings(window);
-    settings->SetTrackedByWorkspace(true);
-    settings->set_window_position_managed(true);
+    wm::WindowState* window_state = wm::GetWindowState(window);
+    window_state->SetTrackedByWorkspace(true);
+    window_state->set_window_position_managed(true);
     window->Show();
     return window;
   }
 
   aura::Window* CreatePopupLikeWindow(const gfx::Rect& bounds) {
     aura::Window* window = CreateTestWindowInShellWithBounds(bounds);
     window->Show();
     return window;
   }
 
@@ skipping 20 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WorkspaceControllerTest);
 };
 
 // Assertions around adding a normal window.
 TEST_F(WorkspaceControllerTest, AddNormalWindowWhenEmpty) {
   scoped_ptr<Window> w1(CreateTestWindow());
   w1->SetBounds(gfx::Rect(0, 0, 250, 251));
 
-  EXPECT_TRUE(GetRestoreBoundsInScreen(w1.get()) == NULL);
+  wm::WindowState* window_state = wm::GetWindowState(w1.get());
+
+  EXPECT_FALSE(window_state->HasRestoreBounds());
 
   w1->Show();
 
-  EXPECT_TRUE(GetRestoreBoundsInScreen(w1.get()) == NULL);
+  EXPECT_FALSE(window_state->HasRestoreBounds());
 
   ASSERT_TRUE(w1->layer() != NULL);
   EXPECT_TRUE(w1->layer()->visible());
 
   EXPECT_EQ("0,0 250x251", w1->bounds().ToString());
 
   EXPECT_EQ(w1.get(), GetDesktop()->children()[0]);
 }
 
 // Assertions around maximizing/unmaximizing.
@@ skipping 104 matching lines @@
 
   EXPECT_EQ(w1.get(), GetDesktop()->children()[0]);
   EXPECT_EQ(250, w1->bounds().width());
   EXPECT_EQ(251, w1->bounds().height());
 
   // Back to fullscreen.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   EXPECT_EQ(w1.get(), GetDesktop()->children()[0]);
   EXPECT_EQ(GetFullscreenBounds(w1.get()).width(), w1->bounds().width());
   EXPECT_EQ(GetFullscreenBounds(w1.get()).height(), w1->bounds().height());
-  ASSERT_TRUE(GetRestoreBoundsInScreen(w1.get()));
-  EXPECT_EQ("0,0 250x251", GetRestoreBoundsInScreen(w1.get())->ToString());
+  wm::WindowState* window_state = wm::GetWindowState(w1.get());
+
+  ASSERT_TRUE(window_state->HasRestoreBounds());
+  EXPECT_EQ("0,0 250x251", window_state->GetRestoreBoundsInScreen().ToString());
 }
 
 // Assertions around minimizing a single window.
 TEST_F(WorkspaceControllerTest, MinimizeSingleWindow) {
   scoped_ptr<Window> w1(CreateTestWindow());
 
   w1->Show();
 
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_FALSE(w1->layer()->IsDrawn());
 
   // Show the window.
   w1->Show();
-  EXPECT_TRUE(wm::IsWindowNormal(w1.get()));
+  EXPECT_TRUE(wm::GetWindowState(w1.get())->IsNormal());
   EXPECT_TRUE(w1->layer()->IsDrawn());
 }
 
 // Assertions around minimizing a fullscreen window.
 TEST_F(WorkspaceControllerTest, MinimizeFullscreenWindow) {
   // Two windows, w1 normal, w2 fullscreen.
   scoped_ptr<Window> w1(CreateTestWindow());
   scoped_ptr<Window> w2(CreateTestWindow());
   w1->Show();
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   w2->Show();
-  wm::ActivateWindow(w2.get());
+
+  wm::WindowState* w1_state = wm::GetWindowState(w1.get());
+  wm::WindowState* w2_state = wm::GetWindowState(w2.get());
+
+  w2_state->Activate();
 
   // Minimize w2.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_FALSE(w2->layer()->IsDrawn());
 
   // Show the window, which should trigger unminimizing.
   w2->Show();
-  wm::ActivateWindow(w2.get());
+  w2_state->Activate();
 
-  EXPECT_TRUE(wm::IsWindowFullscreen(w2.get()));
+  EXPECT_TRUE(w2_state->IsFullscreen());
   EXPECT_TRUE(w1->layer()->IsDrawn());
   EXPECT_TRUE(w2->layer()->IsDrawn());
 
   // Minimize the window, which should hide the window.
-  EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
-  w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
-  EXPECT_FALSE(wm::IsActiveWindow(w2.get()));
+  EXPECT_TRUE(w2_state->IsActive());
+  w2_state->Minimize();
+  EXPECT_FALSE(w2_state->IsActive());
   EXPECT_FALSE(w2->layer()->IsDrawn());
-  EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
+  EXPECT_TRUE(w1_state->IsActive());
 
   // Make the window normal.
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(w1.get(), GetDesktop()->children()[0]);
   EXPECT_EQ(w2.get(), GetDesktop()->children()[1]);
   EXPECT_TRUE(w2->layer()->IsDrawn());
 }
 
 // Verifies ShelfLayoutManager's visibility/auto-hide state is correctly
 // updated.
@@ skipping 10 matching lines @@
   shelf->SetAutoHideBehavior(ash::SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   const gfx::Rect touches_shelf_bounds(
       0, shelf->GetIdealBounds().y() - 10, 101, 102);
   // Move |w1| to overlap the shelf.
   w1->SetBounds(touches_shelf_bounds);
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
   // A visible ignored window should not trigger the overlap.
   scoped_ptr<Window> w_ignored(CreateTestWindow());
   w_ignored->SetBounds(touches_shelf_bounds);
-  wm::GetWindowSettings(&(*w_ignored))->set_ignored_by_shelf(true);
+  wm::GetWindowState(&(*w_ignored))->set_ignored_by_shelf(true);
   w_ignored->Show();
   EXPECT_FALSE(GetWindowOverlapsShelf());
 
   // Make it visible, since visible shelf overlaps should be true.
   w1->Show();
   EXPECT_TRUE(GetWindowOverlapsShelf());
 
   wm::ActivateWindow(w1.get());
   w1->SetBounds(w1_bounds);
   w1->Show();
@@ skipping 34 matching lines @@
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
   EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->auto_hide_state());
 
   // Minimize.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_MINIMIZED);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
 
   // Since the restore from minimize will restore to the pre-minimize
   // state (tested elsewhere), we abandon the current size and restore
   // rect and set them to the window.
-  gfx::Rect restore = *GetRestoreBoundsInScreen(w1.get());
+  wm::WindowState* controller = wm::GetWindowState(w1.get());
+
+  gfx::Rect restore = controller->GetRestoreBoundsInScreen();
   EXPECT_EQ("0,0 800x597", w1->bounds().ToString());
   EXPECT_EQ("0,1 101x102", restore.ToString());
-  ClearRestoreBounds(w1.get());
+  controller->ClearRestoreBounds();
   w1->SetBounds(restore);
 
   // Restore.
   w1->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_NORMAL);
   EXPECT_EQ(SHELF_AUTO_HIDE, shelf->visibility_state());
   EXPECT_EQ("0,1 101x102", w1->bounds().ToString());
 
   // Create another window, maximized.
   scoped_ptr<Window> w2(CreateTestWindow());
   w2->SetBounds(gfx::Rect(10, 11, 250, 251));
@@ skipping 209 matching lines @@
 TEST_F(WorkspaceControllerTest, DontCrashOnChangeAndActivate) {
   // Force the shelf
   ShelfLayoutManager* shelf = shelf_layout_manager();
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
 
   DontCrashOnChangeAndActivateDelegate delegate;
   scoped_ptr<Window> w1(CreateTestWindowInShellWithDelegate(
       &delegate, 1000, gfx::Rect(10, 11, 250, 251)));
 
   w1->Show();
-  wm::ActivateWindow(w1.get());
-  wm::MaximizeWindow(w1.get());
-  wm::MinimizeWindow(w1.get());
+  wm::WindowState* w1_state = wm::GetWindowState(w1.get());
+  w1_state->Activate();
+  w1_state->Maximize();
+  w1_state->Minimize();
 
   w1->parent()->RemoveChild(w1.get());
 
   // Do this so that when we Show() the window a resize occurs and we make the
   // window active.
   shelf->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
 
   SetDefaultParentByPrimaryRootWindow(w1.get());
   delegate.set_window(w1.get());
   w1->Show();
@@ skipping 31 matching lines @@
   EXPECT_TRUE(wm::IsActiveWindow(w1.get()));
   EXPECT_TRUE(w1->IsVisible());
 
   // Create a second fullscreen window and mark it not tracked by workspace
   // manager.
   scoped_ptr<Window> w2(CreateTestWindowUnparented());
   w2->SetBounds(gfx::Rect(1, 6, 25, 30));
   w2->SetProperty(aura::client::kShowStateKey, ui::SHOW_STATE_FULLSCREEN);
   SetDefaultParentByPrimaryRootWindow(w2.get());
   w2->Show();
-  wm::GetWindowSettings(w2.get())->SetTrackedByWorkspace(false);
+  wm::GetWindowState(w2.get())->SetTrackedByWorkspace(false);
   wm::ActivateWindow(w2.get());
 
   // Activating |w2| should force it to have the same parent as |w1|.
   EXPECT_EQ(w1->parent(), w2->parent());
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
 
   // Because |w2| isn't tracked we should be able to set the bounds of it.
   gfx::Rect bounds(w2->bounds());
   bounds.Offset(4, 5);
   w2->SetBounds(bounds);
   EXPECT_EQ(bounds.ToString(), w2->bounds().ToString());
 
   // Transition it to tracked by worskpace. It should end up in the desktop
   // workspace.
-  wm::GetWindowSettings(w2.get())->SetTrackedByWorkspace(true);
+  wm::GetWindowState(w2.get())->SetTrackedByWorkspace(true);
   EXPECT_TRUE(wm::IsActiveWindow(w2.get()));
   EXPECT_TRUE(w1->IsVisible());
   EXPECT_TRUE(w2->IsVisible());
   EXPECT_EQ(w1->parent(), w2->parent());
 }
 
 // Test the placement of newly created windows.
 TEST_F(WorkspaceControllerTest, BasicAutoPlacingOnCreate) {
   if (!SupportsHostWindowResize())
     return;
@@ skipping 66 matching lines @@
 
   // Check the initial position of the windows is unchanged.
   EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
   EXPECT_EQ("32,48 256x512", window2->bounds().ToString());
 
   // Remove the second window and make sure that the first window
   // does NOT get centered.
   window2.reset();
   EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
 
+  wm::WindowState* window1_state = wm::GetWindowState(window1.get());
   // Test 2: Set up two managed windows and check their auto positioning.
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
+  window1_state->set_window_position_managed(true);
 
   scoped_ptr<aura::Window> window3(CreateTestWindowInShellWithId(2));
-  wm::GetWindowSettings(window3.get())->set_window_position_managed(true);
+  wm::GetWindowState(window3.get())->set_window_position_managed(true);
   // To avoid any auto window manager changes due to SetBounds, the window
   // gets first hidden and then shown again.
   window3->Hide();
   window3->SetBounds(gfx::Rect(32, 48, 256, 512));
   window3->Show();
   // |window1| should be flush left and |window3| flush right.
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window3->bounds().width()) +
             ",48 256x512", window3->bounds().ToString());
@@ skipping 16 matching lines @@
   window1->Show();
   // |window1| should be centered and |window4| untouched.
   EXPECT_EQ(
       base::IntToString(
           (desktop_area.width() - window1->bounds().width()) / 2) +
       ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("32,48 256x512", window4->bounds().ToString());
 
   // Test4: A single manageable window should get centered.
   window4.reset();
-  wm::GetWindowSettings(window1.get())->set_bounds_changed_by_user(false);
+  window1_state->set_bounds_changed_by_user(false);
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
   // |window1| should be centered.
   EXPECT_EQ(
       base::IntToString(
           (desktop_area.width() - window1->bounds().width()) / 2) +
       ",32 640x320", window1->bounds().ToString());
 }
 
 // Test the proper usage of user window movement interaction.
 TEST_F(WorkspaceControllerTest, TestUserMovedWindowRepositioning) {
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
   window2->Hide();
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
-  EXPECT_FALSE(wm::GetWindowSettings(window1.get())->bounds_changed_by_user());
-  EXPECT_FALSE(wm::GetWindowSettings(window2.get())->bounds_changed_by_user());
+  wm::WindowState* window1_state = wm::GetWindowState(window1.get());
+  wm::WindowState* window2_state = wm::GetWindowState(window2.get());
+
+  window1_state->set_window_position_managed(true);
+  window2_state->set_window_position_managed(true);
+  EXPECT_FALSE(window1_state->bounds_changed_by_user());
+  EXPECT_FALSE(window2_state->bounds_changed_by_user());
 
   // Check that the current location gets preserved if the user has
   // positioned it previously.
-  wm::GetWindowSettings(window1.get())->set_bounds_changed_by_user(true);
+  window1_state->set_bounds_changed_by_user(true);
   window1->Show();
   EXPECT_EQ("16,32 640x320", window1->bounds().ToString());
   // Flag should be still set.
-  EXPECT_TRUE(wm::GetWindowSettings(window1.get())->bounds_changed_by_user());
-  EXPECT_FALSE(wm::GetWindowSettings(window2.get())->bounds_changed_by_user());
+  EXPECT_TRUE(window1_state->bounds_changed_by_user());
+  EXPECT_FALSE(window2_state->bounds_changed_by_user());
 
   // Turn on the second window and make sure that both windows are now
   // positionable again (user movement cleared).
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(desktop_area.width() - window2->bounds().width()) +
       ",48 256x512", window2->bounds().ToString());
   // FLag should now be reset.
-  EXPECT_FALSE(wm::GetWindowSettings(window1.get())->bounds_changed_by_user());
-  EXPECT_FALSE(wm::GetWindowSettings(window2.get())->bounds_changed_by_user());
+  EXPECT_FALSE(window1_state->bounds_changed_by_user());
+  EXPECT_FALSE(window2_state->bounds_changed_by_user());
 
   // Going back to one shown window should keep the state.
-  wm::GetWindowSettings(window1.get())->set_bounds_changed_by_user(true);
+  window1_state->set_bounds_changed_by_user(true);
   window2->Hide();
   EXPECT_EQ("0,32 640x320", window1->bounds().ToString());
-  EXPECT_TRUE(wm::GetWindowSettings(window1.get())->bounds_changed_by_user());
+  EXPECT_TRUE(window1_state->bounds_changed_by_user());
 }
 
 // Test if the single window will be restored at original position.
 TEST_F(WorkspaceControllerTest, TestSingleWindowsRestoredBounds) {
   scoped_ptr<aura::Window> window1(
       CreateTestWindowInShellWithBounds(gfx::Rect(100, 100, 100, 100)));
   scoped_ptr<aura::Window> window2(
       CreateTestWindowInShellWithBounds(gfx::Rect(110, 110, 100, 100)));
   scoped_ptr<aura::Window> window3(
       CreateTestWindowInShellWithBounds(gfx::Rect(120, 120, 100, 100)));
   window1->Hide();
   window2->Hide();
   window3->Hide();
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
-  wm::GetWindowSettings(window3.get())->set_window_position_managed(true);
+  wm::GetWindowState(window1.get())->set_window_position_managed(true);
+  wm::GetWindowState(window2.get())->set_window_position_managed(true);
+  wm::GetWindowState(window3.get())->set_window_position_managed(true);
 
   window1->Show();
   wm::ActivateWindow(window1.get());
   window2->Show();
   wm::ActivateWindow(window2.get());
   window3->Show();
   wm::ActivateWindow(window3.get());
   EXPECT_EQ(0, window1->bounds().x());
   EXPECT_EQ(window2->GetRootWindow()->bounds().right(),
             window2->bounds().right());
@@ skipping 20 matching lines @@
   window2->Hide();
   EXPECT_EQ("120,120 100x100", window3->bounds().ToString());
 }
 
 // Test that user placed windows go back to their user placement after the user
 // closes all other windows.
 TEST_F(WorkspaceControllerTest, TestUserHandledWindowRestore) {
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   gfx::Rect user_pos = gfx::Rect(16, 42, 640, 320);
   window1->SetBounds(user_pos);
-  ash::wm::SetPreAutoManageWindowBounds(window1.get(), user_pos);
+  wm::WindowState* controller1 =

[James Cook, 2013/09/18 20:44:17]

controller1 -> window1_state to be consistent with other test below

[oshima, 2013/09/19 01:52:01]

Done.

+      wm::GetWindowState(window1.get());
+
+  controller1->SetPreAutoManageWindowBounds(user_pos);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   // Create a second window to let the auto manager kick in.
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
   window1->Hide();
   window2->Hide();
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
+  wm::GetWindowState(window1.get())->set_window_position_managed(true);
+  wm::GetWindowState(window2.get())->set_window_position_managed(true);
   window1->Show();
   EXPECT_EQ(user_pos.ToString(), window1->bounds().ToString());
   window2->Show();
 
   // |window1| should be flush left and |window2| flush right.
   EXPECT_EQ("0," + base::IntToString(user_pos.y()) +
             " 640x320", window1->bounds().ToString());
   EXPECT_EQ(
       base::IntToString(desktop_area.width() - window2->bounds().width()) +
       ",48 256x512", window2->bounds().ToString());
   window2->Hide();
 
   // After the other window get hidden the window has to move back to the
   // previous position and the bounds should still be set and unchanged.
   EXPECT_EQ(user_pos.ToString(), window1->bounds().ToString());
-  ASSERT_TRUE(ash::wm::GetPreAutoManageWindowBounds(window1.get()));
+  ASSERT_TRUE(controller1->pre_auto_manage_window_bounds());
   EXPECT_EQ(user_pos.ToString(),
-            ash::wm::GetPreAutoManageWindowBounds(window1.get())->ToString());
+            controller1->pre_auto_manage_window_bounds()->ToString());
 }
 
 // Test that a window from normal to minimize will repos the remaining.
 TEST_F(WorkspaceControllerTest, ToMinimizeRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
+  wm::WindowState* window1_state = wm::GetWindowState(window1.get());
+  window1_state->set_window_position_managed(true);
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
+  wm::WindowState* window2_state = wm::GetWindowState(window2.get());
+  window2_state->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
-  ash::wm::MinimizeWindow(window1.get());
+  window1_state->Minimize();
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
-  EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
+  EXPECT_TRUE(window2_state->IsNormal());
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 
-  ash::wm::RestoreWindow(window1.get());
+  window1_state->Restore();
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,48 256x512", window2->bounds().ToString());
 }
 
 // Test that minimizing an initially maximized window will repos the remaining.
 TEST_F(WorkspaceControllerTest, MaxToMinRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
+  wm::WindowState* window1_state = wm::GetWindowState(window1.get());
+  window1_state->set_window_position_managed(true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
+  wm::WindowState* window2_state = wm::GetWindowState(window2.get());
+  window2_state->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
-  ash::wm::MaximizeWindow(window1.get());
-  ash::wm::MinimizeWindow(window1.get());
+  window1_state->Maximize();
+  window1_state->Minimize();
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
-  EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
+  EXPECT_TRUE(window2_state->IsNormal());
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",48 256x512", window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, minimizing will repos the remaining.
 TEST_F(WorkspaceControllerTest, NormToMaxToMinRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
+  wm::WindowState* window1_state = wm::GetWindowState(window1.get());
+  window1_state->set_window_position_managed(true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
+  wm::WindowState* window2_state = wm::GetWindowState(window2.get());
+  window2_state->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 40, 256, 512));
 
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
 
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 
-  ash::wm::MaximizeWindow(window1.get());
-  ash::wm::MinimizeWindow(window1.get());
+  window1_state->Maximize();
+  window1_state->Minimize();
 
   // |window2| should be centered now.
   EXPECT_TRUE(window2->IsVisible());
-  EXPECT_TRUE(ash::wm::IsWindowNormal(window2.get()));
+  EXPECT_TRUE(window2_state->IsNormal());
   EXPECT_EQ(base::IntToString(
                 (desktop_area.width() - window2->bounds().width()) / 2) +
             ",40 256x512", window2->bounds().ToString());
 }
 
 // Test that nomral, maximize, normal will repos the remaining.
 TEST_F(WorkspaceControllerTest, NormToMaxToNormRepositionsRemaining) {
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
+  wm::WindowState* window1_state = wm::GetWindowState(window1.get());
+  window1_state->set_window_position_managed(true);
   gfx::Rect desktop_area = window1->parent()->bounds();
 
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
+  wm::GetWindowState(window2.get())->set_window_position_managed(true);
   window2->SetBounds(gfx::Rect(32, 40, 256, 512));
 
   // Trigger the auto window placement function by showing (and hiding) it.
   window1->Hide();
   window1->Show();
 
   // |window1| should be flush right and |window3| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 
-  ash::wm::MaximizeWindow(window1.get());
-  ash::wm::RestoreWindow(window1.get());
+  window1_state->Maximize();
+  window1_state->Restore();
 
   // |window1| should be flush right and |window2| flush left.
   EXPECT_EQ(base::IntToString(
                 desktop_area.width() - window1->bounds().width()) +
             ",32 640x320", window1->bounds().ToString());
   EXPECT_EQ("0,40 256x512", window2->bounds().ToString());
 }
 
 // Test that animations are triggered.
 TEST_F(WorkspaceControllerTest, AnimatedNormToMaxToNormRepositionsRemaining) {
   ui::ScopedAnimationDurationScaleMode normal_duration_mode(
       ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
   scoped_ptr<aura::Window> window1(CreateTestWindowInShellWithId(0));
   window1->Hide();
   window1->SetBounds(gfx::Rect(16, 32, 640, 320));
   gfx::Rect desktop_area = window1->parent()->bounds();
   scoped_ptr<aura::Window> window2(CreateTestWindowInShellWithId(1));
   window2->Hide();
   window2->SetBounds(gfx::Rect(32, 48, 256, 512));
 
-  wm::GetWindowSettings(window1.get())->set_window_position_managed(true);
-  wm::GetWindowSettings(window2.get())->set_window_position_managed(true);
+  wm::GetWindowState(window1.get())->set_window_position_managed(true);
+  wm::GetWindowState(window2.get())->set_window_position_managed(true);
   // Make sure nothing is animating.
   window1->layer()->GetAnimator()->StopAnimating();
   window2->layer()->GetAnimator()->StopAnimating();
   window2->Show();
 
   // The second window should now animate.
   EXPECT_FALSE(window1->layer()->GetAnimator()->is_animating());
   EXPECT_TRUE(window2->layer()->GetAnimator()->is_animating());
   window2->layer()->GetAnimator()->StopAnimating();
 
@@ skipping 153 matching lines @@
   generator.PressLeftButton();
   generator.MoveMouseTo(100, 100);
   // The bounds shouldn't change (drag should result in nothing happening
   // now.
   EXPECT_EQ(max_bounds.ToString(), w1->bounds().ToString());
 
   generator.ReleaseLeftButton();
   EXPECT_EQ(0, observer.change_count());
 
   // Set tracked to false and repeat, now the window should move.
-  wm::GetWindowSettings(w1.get())->SetTrackedByWorkspace(false);
+  wm::GetWindowState(w1.get())->SetTrackedByWorkspace(false);
   generator.MoveMouseTo(5, 5);
   generator.PressLeftButton();
   generator.MoveMouseBy(100, 100);
   EXPECT_EQ(gfx::Rect(max_bounds.x() + 100, max_bounds.y() + 100,
                       max_bounds.width(), max_bounds.height()).ToString(),
             w1->bounds().ToString());
 
   generator.ReleaseLeftButton();
-  wm::GetWindowSettings(w1.get())->SetTrackedByWorkspace(true);
+  wm::GetWindowState(w1.get())->SetTrackedByWorkspace(true);
   // Marking the window tracked again should snap back to origin.
   EXPECT_EQ(max_bounds.ToString(), w1->bounds().ToString());
   EXPECT_EQ(0, observer.change_count());
 
   w1->parent()->parent()->RemoveObserver(&observer);
 }
 
 // Verifies setting tracked by workspace to false and then dragging a maximized
 // window can change the bound.
 TEST_F(WorkspaceControllerTest, DragMaximizedNonTrackedWindow) {
@@ skipping 19 matching lines @@
   generator.PressLeftButton();
   generator.MoveMouseTo(100, 100);
   // The bounds shouldn't change (drag should result in nothing happening
   // now.
   EXPECT_EQ(max_bounds.ToString(), w1->bounds().ToString());
 
   generator.ReleaseLeftButton();
   EXPECT_EQ(0, observer.change_count());
 
   // Set tracked to false and repeat, now the window should move.
-  wm::GetWindowSettings(w1.get())->SetTrackedByWorkspace(false);
+  wm::GetWindowState(w1.get())->SetTrackedByWorkspace(false);
   generator.MoveMouseTo(5, 5);
   generator.PressLeftButton();
   generator.MoveMouseBy(100, 100);
   EXPECT_EQ(gfx::Rect(max_bounds.x() + 100, max_bounds.y() + 100,
                       max_bounds.width(), max_bounds.height()).ToString(),
             w1->bounds().ToString());
 
   generator.ReleaseLeftButton();
-  wm::GetWindowSettings(w1.get())->SetTrackedByWorkspace(true);
+  wm::GetWindowState(w1.get())->SetTrackedByWorkspace(true);
   // Marking the window tracked again should snap back to origin.
   EXPECT_EQ(max_bounds.ToString(), w1->bounds().ToString());
   EXPECT_EQ(0, observer.change_count());
 
   w1->parent()->parent()->RemoveObserver(&observer);
 }
 
 // Verifies that a new maximized window becomes visible after its activation
 // is requested, even though it does not become activated because a system
 // modal window is active.
 TEST_F(WorkspaceControllerTest, SwitchFromModal) {
   scoped_ptr<Window> modal_window(CreateTestWindowUnparented());
   modal_window->SetBounds(gfx::Rect(10, 11, 21, 22));
   modal_window->SetProperty(aura::client::kModalKey, ui::MODAL_TYPE_SYSTEM);
   SetDefaultParentByPrimaryRootWindow(modal_window.get());
   modal_window->Show();
   wm::ActivateWindow(modal_window.get());
 
   scoped_ptr<Window> maximized_window(CreateTestWindow());
   maximized_window->SetProperty(
       aura::client::kShowStateKey, ui::SHOW_STATE_MAXIMIZED);
   maximized_window->Show();
   wm::ActivateWindow(maximized_window.get());
   EXPECT_TRUE(maximized_window->IsVisible());
 }
 
 }  // namespace internal
 }  // namespace ash