[Cleanup] Rename WindowSettings to WindowState

ash/wm/workspace/workspace_window_resizer_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/wm/workspace/workspace_window_resizer.h"
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/test/ash_test_base.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 "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/event_generator.h"
@@ skipping 511 matching lines @@
   EXPECT_EQ("10,100 200x266", window2_->bounds().ToString());
   EXPECT_EQ("20,366 100x134", window3_->bounds().ToString());
 }
 
 
 // Assertions around dragging to the left/right edge of the screen.
 TEST_F(WorkspaceWindowResizerTest, Edge) {
   int bottom =
       ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
   window_->SetBounds(gfx::Rect(20, 30, 50, 60));
+  wm::WindowState* window_state = wm::GetWindowState(window_.get());
+
   {
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION,
         aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 0, 10), 0);
     resizer->CompleteDrag(0);
     EXPECT_EQ("0,0 720x" + base::IntToString(bottom),
               window_->bounds().ToString());
-    ASSERT_TRUE(GetRestoreBoundsInScreen(window_.get()));
+    ASSERT_TRUE(window_state->HasRestoreBounds());
     EXPECT_EQ("20,30 50x60",
-              GetRestoreBoundsInScreen(window_.get())->ToString());
+              window_state->GetRestoreBoundsInScreen().ToString());
   }
   // Try the same with the right side.
   {
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION,
         aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
     ASSERT_TRUE(resizer.get());
     resizer->Drag(CalculateDragPoint(*resizer, 800, 10), 0);
     resizer->CompleteDrag(0);
     EXPECT_EQ("80,0 720x" + base::IntToString(bottom),
               window_->bounds().ToString());
-    ASSERT_TRUE(GetRestoreBoundsInScreen(window_.get()));
+    ASSERT_TRUE(window_state->HasRestoreBounds());
     EXPECT_EQ("20,30 50x60",
-              GetRestoreBoundsInScreen(window_.get())->ToString());
+              window_state->GetRestoreBoundsInScreen().ToString());
   }
 
   // Test if the restore bounds is correct in multiple displays.
-  ClearRestoreBounds(window_.get());
+  window_state->ClearRestoreBounds();
 
   if (!SupportsMultipleDisplays())
     return;
 
   UpdateDisplay("800x600,200x600");
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   EXPECT_EQ(root_windows[0], window_->GetRootWindow());
   window_->SetBoundsInScreen(gfx::Rect(800, 10, 50, 60),
                              ScreenAsh::GetSecondaryDisplay());
   EXPECT_EQ(root_windows[1], window_->GetRootWindow());
   {
     bottom =
         ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_.get()).bottom();
     EXPECT_EQ("800,10 50x60", window_->GetBoundsInScreen().ToString());
 
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION,
         aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
     ASSERT_TRUE(resizer.get());
 
     resizer->Drag(CalculateDragPoint(*resizer, 199, 00), 0);
     resizer->CompleteDrag(0);
     // With the resolution of 200x600 we will hit in this case the 50% screen
     // size setting.
     EXPECT_EQ("100,0 100x" + base::IntToString(bottom),
               window_->bounds().ToString());
     EXPECT_EQ("800,10 50x60",
-              GetRestoreBoundsInScreen(window_.get())->ToString());
+              window_state->GetRestoreBoundsInScreen().ToString());
   }
 }
 
 // Check that non resizable windows will not get resized.
 TEST_F(WorkspaceWindowResizerTest, NonResizableWindows) {
   window_->SetBounds(gfx::Rect(20, 30, 50, 60));
   window_->SetProperty(aura::client::kCanResizeKey, false);
 
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION,
@@ skipping 522 matching lines @@
   // Ctrl + drag the window to new poistion by adding (10, 12) to its origin,
   // the window should move to the exact position.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 12), 0);
   resizer->CompleteDrag(ui::EF_CONTROL_DOWN);
   EXPECT_EQ("106,124 320x160", window_->bounds().ToString());
 }
 
 // Verifies that a dragged window will restore to its pre-maximized size.
 TEST_F(WorkspaceWindowResizerTest, RestoreToPreMaximizeCoordinates) {
   window_->SetBounds(gfx::Rect(0, 0, 1000, 1000));
-  SetRestoreBoundsInScreen(window_.get(), gfx::Rect(96, 112, 320, 160));
+  wm::WindowState* window_state = wm::GetWindowState(window_.get());
+  window_state->SetRestoreBoundsInScreen(gfx::Rect(96, 112, 320, 160));
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
   ASSERT_TRUE(resizer.get());
   // Drag the window to new position by adding (10, 10) to original point,
   // the window should get restored.
   resizer->Drag(CalculateDragPoint(*resizer, 10, 10), 0);
   resizer->CompleteDrag(0);
   EXPECT_EQ("10,10 320x160", window_->bounds().ToString());
   // The restore rectangle should get cleared as well.
-  EXPECT_EQ(NULL, GetRestoreBoundsInScreen(window_.get()));
+  EXPECT_FALSE(window_state->HasRestoreBounds());
 }
 
 // Verifies that a dragged window will restore to its pre-maximized size.
 TEST_F(WorkspaceWindowResizerTest, RevertResizeOperation) {
   const gfx::Rect initial_bounds(0, 0, 200, 400);
   window_->SetBounds(initial_bounds);
-  SetRestoreBoundsInScreen(window_.get(), gfx::Rect(96, 112, 320, 160));
+
+  wm::WindowState* window_state = wm::GetWindowState(window_.get());
+  window_state->SetRestoreBoundsInScreen(gfx::Rect(96, 112, 320, 160));
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION,
       aura::client::WINDOW_MOVE_SOURCE_MOUSE, empty_windows()));
   ASSERT_TRUE(resizer.get());
   // Drag the window to new poistion by adding (180, 16) to original point,
   // the window should get restored.
   resizer->Drag(CalculateDragPoint(*resizer, 180, 16), 0);
   resizer->RevertDrag();
   EXPECT_EQ(initial_bounds.ToString(), window_->bounds().ToString());
   EXPECT_EQ("96,112 320x160",
-      GetRestoreBoundsInScreen(window_.get())->ToString());
+            window_state->GetRestoreBoundsInScreen().ToString());
 }
 
 // Check that only usable sizes get returned by the resizer.
 TEST_F(WorkspaceWindowResizerTest, MagneticallyAttach) {
   window_->SetBounds(gfx::Rect(10, 10, 20, 30));
   window2_->SetBounds(gfx::Rect(150, 160, 25, 20));
   window2_->Show();
 
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTCAPTION,
@@ skipping 190 matching lines @@
   {
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION,
         aura::client::WINDOW_MOVE_SOURCE_MOUSE, no_attached_windows));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the bottom.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 100), 0);
     EXPECT_EQ("0,150 400x200", window_->bounds().ToString());
     resizer->RevertDrag();
 
-    EXPECT_FALSE(
-        wm::GetWindowSettings(window_.get())->bounds_changed_by_user());
+    EXPECT_FALSE(wm::GetWindowState(window_.get())->bounds_changed_by_user());
   }
 
   // Check that a completed move / size does change the user coordinates.
   {
     scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
         window_.get(), gfx::Point(), HTCAPTION,
         aura::client::WINDOW_MOVE_SOURCE_MOUSE, no_attached_windows));
     ASSERT_TRUE(resizer.get());
     // Move it 100 to the bottom.
     resizer->Drag(CalculateDragPoint(*resizer, 0, 100), 0);
     EXPECT_EQ("0,150 400x200", window_->bounds().ToString());
     resizer->CompleteDrag(0);
-    EXPECT_TRUE(
-        wm::GetWindowSettings(window_.get())->bounds_changed_by_user());
+    EXPECT_TRUE(wm::GetWindowState(window_.get())->bounds_changed_by_user());
   }
 }
 
 // Test that a window with a specified max size doesn't exceed it when dragged.
 TEST_F(WorkspaceWindowResizerTest, TestMaxSizeEnforced) {
   window_->SetBounds(gfx::Rect(0, 0, 400, 300));
   delegate_.set_max_size(gfx::Size(401, 301));
 
   scoped_ptr<WorkspaceWindowResizer> resizer(WorkspaceWindowResizer::Create(
       window_.get(), gfx::Point(), HTBOTTOMRIGHT,
@@ skipping 521 matching lines @@
   RunAnimationTillComplete(phantom_controller->animation_.get());
 
   // Hide phantom controller. Both widgets should close.
   phantom_controller->Hide();
   EXPECT_FALSE(phantom_controller->phantom_widget_);
   EXPECT_FALSE(phantom_controller->phantom_widget_start_);
 }
 
 }  // namespace internal
 }  // namespace ash