[Cleanup] Rename WindowSettings to WindowState

ash/wm/workspace/workspace_event_handler_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_event_handler.h"
 
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/test/ash_test_base.h"
-#include "ash/wm/property_util.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "ash/wm/workspace_controller_test_helper.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/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/screen.h"
@@ skipping 81 matching lines @@
   generator.ReleaseLeftButton();
   generator.set_flags(ui::EF_IS_DOUBLE_CLICK);
   generator.PressLeftButton();
   generator.MoveMouseTo(generator.current_location(), 1);
   generator.ReleaseLeftButton();
   gfx::Rect bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(restored_bounds.x(), bounds_in_screen.x());
   EXPECT_EQ(restored_bounds.width(), bounds_in_screen.width());
   EXPECT_EQ(work_area.y(), bounds_in_screen.y());
   EXPECT_EQ(work_area.height(), bounds_in_screen.height());
+
+  wm::WindowState* window_state = wm::GetWindowState(window.get());
   // Single-axis maximization is not considered real maximization.
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
 
   // Restore.
   generator.DoubleClickLeftButton();
   bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(restored_bounds.ToString(), bounds_in_screen.ToString());
   // Note that it should not even be restored at this point, it should have
   // also cleared the restore rectangle.
-  EXPECT_EQ(NULL, GetRestoreBoundsInScreen(window.get()));
+  EXPECT_FALSE(window_state->HasRestoreBounds());
 
   // Double-click the top resize edge again to maximize vertically, then double
   // click again to restore.
   generator.DoubleClickLeftButton();
   wd.set_window_component(HTCAPTION);
   generator.DoubleClickLeftButton();
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
   bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(restored_bounds.ToString(), bounds_in_screen.ToString());
 
   // Double clicking the left resize edge should maximize horizontally.
   wd.set_window_component(HTLEFT);
   generator.DoubleClickLeftButton();
   bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(restored_bounds.y(), bounds_in_screen.y());
   EXPECT_EQ(restored_bounds.height(), bounds_in_screen.height());
   EXPECT_EQ(work_area.x(), bounds_in_screen.x());
   EXPECT_EQ(work_area.width(), bounds_in_screen.width());
   // Single-axis maximization is not considered real maximization.
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
 
   // Restore.
   wd.set_window_component(HTCAPTION);
   generator.DoubleClickLeftButton();
   EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString());
 
 #if defined(OS_WIN)
   // Multi display test does not run on Win8 bot. crbug.com/247427.
   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
     return;
@@ skipping 15 matching lines @@
   generator2.set_flags(ui::EF_IS_DOUBLE_CLICK);
   generator2.PressLeftButton();
   generator2.MoveMouseTo(generator.current_location(), 1);
   generator2.ReleaseLeftButton();
   generator.DoubleClickLeftButton();
   bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(restored_bounds.x(), bounds_in_screen.x());
   EXPECT_EQ(restored_bounds.width(), bounds_in_screen.width());
   EXPECT_EQ(work_area2.y(), bounds_in_screen.y());
   EXPECT_EQ(work_area2.height(), bounds_in_screen.height());
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
 
   // Restore.
   wd.set_window_component(HTCAPTION);
   generator2.DoubleClickLeftButton();
   EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString());
 
   // X-axis maximization.
   wd.set_window_component(HTLEFT);
   generator2.DoubleClickLeftButton();
   bounds_in_screen = window->GetBoundsInScreen();
   EXPECT_EQ(restored_bounds.y(), bounds_in_screen.y());
   EXPECT_EQ(restored_bounds.height(), bounds_in_screen.height());
   EXPECT_EQ(work_area2.x(), bounds_in_screen.x());
   EXPECT_EQ(work_area2.width(), bounds_in_screen.width());
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
 
   // Restore.
   wd.set_window_component(HTCAPTION);
   generator2.DoubleClickLeftButton();
   EXPECT_EQ(restored_bounds.ToString(), window->GetBoundsInScreen().ToString());
 }
 
 TEST_F(WorkspaceEventHandlerTest,
     DoubleClickSingleAxisDoesntResizeVerticalEdgeIfConstrained) {
   gfx::Rect restored_bounds(10, 10, 50, 50);
@@ skipping 41 matching lines @@
   EXPECT_EQ(restored_bounds.x(), window->bounds().x());
   EXPECT_EQ(restored_bounds.width(), window->bounds().width());
 }
 
 TEST_F(WorkspaceEventHandlerTest, DoubleClickCaptionTogglesMaximize) {
   aura::test::TestWindowDelegate wd;
   scoped_ptr<aura::Window> window(
       CreateTestWindow(&wd, gfx::Rect(1, 2, 30, 40)));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
   wd.set_window_component(HTCAPTION);
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+
+  wm::WindowState* window_state = wm::GetWindowState(window.get());
+  EXPECT_FALSE(window_state->IsMaximized());
   aura::RootWindow* root = Shell::GetPrimaryRootWindow();
   aura::test::EventGenerator generator(root, window.get());
   generator.DoubleClickLeftButton();
   EXPECT_NE("1,2 30x40", window->bounds().ToString());
 
-  EXPECT_TRUE(wm::IsWindowMaximized(window.get()));
+  EXPECT_TRUE(window_state->IsMaximized());
   generator.DoubleClickLeftButton();
 
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_EQ("1,2 30x40", window->bounds().ToString());
 
   // Double-clicking the middle button shouldn't toggle the maximized state.
   WindowPropertyObserver observer(window.get());
   ui::MouseEvent press(ui::ET_MOUSE_PRESSED, generator.current_location(),
                        generator.current_location(),
                        ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_IS_DOUBLE_CLICK);
   root->AsRootWindowHostDelegate()->OnHostMouseEvent(&press);
   ui::MouseEvent release(ui::ET_MOUSE_RELEASED, generator.current_location(),
                          generator.current_location(),
                          ui::EF_IS_DOUBLE_CLICK);
   root->AsRootWindowHostDelegate()->OnHostMouseEvent(&release);
 
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_EQ("1,2 30x40", window->bounds().ToString());
   EXPECT_FALSE(observer.DidPropertyChange(aura::client::kShowStateKey));
 }
 
 TEST_F(WorkspaceEventHandlerTest, DoubleTapCaptionTogglesMaximize) {
   aura::test::TestWindowDelegate wd;
   gfx::Rect bounds(10, 20, 30, 40);
   scoped_ptr<aura::Window> window(CreateTestWindow(&wd, bounds));
   window->SetProperty(aura::client::kCanMaximizeKey, true);
   wd.set_window_component(HTCAPTION);
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+
+  wm::WindowState* window_state = wm::GetWindowState(window.get());
+  EXPECT_FALSE(window_state->IsMaximized());
   aura::test::EventGenerator generator(Shell::GetPrimaryRootWindow(),
                                        window.get());
   generator.GestureTapAt(gfx::Point(25, 25));
   generator.GestureTapAt(gfx::Point(25, 25));
   RunAllPendingInMessageLoop();
   EXPECT_NE(bounds.ToString(), window->bounds().ToString());
-  EXPECT_TRUE(wm::IsWindowMaximized(window.get()));
+  EXPECT_TRUE(window_state->IsMaximized());
 
   generator.GestureTapAt(gfx::Point(5, 5));
   generator.GestureTapAt(gfx::Point(10, 10));
 
-  EXPECT_FALSE(wm::IsWindowMaximized(window.get()));
+  EXPECT_FALSE(window_state->IsMaximized());
   EXPECT_EQ(bounds.ToString(), window->bounds().ToString());
 }
 
 // Verifies deleting the window while dragging doesn't crash.
 TEST_F(WorkspaceEventHandlerTest, DeleteWhenDragging) {
   // Create a large window in the background. This is necessary so that when we
   // delete |window| WorkspaceEventHandler is still the active event handler.
   aura::test::TestWindowDelegate wd2;
   scoped_ptr<aura::Window> window2(
       CreateTestWindow(&wd2, gfx::Rect(0, 0, 500, 500)));
@@ skipping 21 matching lines @@
   ASSERT_TRUE(aura::client::GetWindowMoveClient(window->parent()));
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, window.get());
   aura::client::GetWindowMoveClient(window->parent())
       ->RunMoveLoop(window.release(),
                     gfx::Vector2d(),
                     aura::client::WINDOW_MOVE_SOURCE_MOUSE);
 }
 
 }  // namespace internal
 }  // namespace ash