[Cleanup] Rename WindowSettings to WindowState

ash/wm/dock/docked_window_layout_manager.cc

 // Copyright (c) 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/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/gfx/rect.h"
@@ skipping 49 matching lines @@
   aura::Window* dock = Shell::GetContainer(
       wm::GetRootWindowMatching(near_location),
       kShellWindowId_DockedContainer);
   return static_cast<internal::DockedWindowLayoutManager*>(
       dock->layout_manager());
 }
 
 // Certain windows (minimized, hidden or popups) do not matter to docking.
 bool IsUsedByLayout(aura::Window* window) {
   return (window->IsVisible() &&
-          !wm::IsWindowMinimized(window) &&
+          !wm::GetWindowState(window)->IsMinimized() &&
           window->type() != aura::client::WINDOW_TYPE_POPUP);
 }
 
 // A functor used to sort the windows in order of their center Y position.
 // |delta| is a pre-calculated distance from the bottom of one window to the top
 // of the next. Its value can be positive (gap) or negative (overlap).
 // Half of |delta| is used as a transition point at which windows could ideally
 // swap positions.
 struct CompareWindowPos {
   CompareWindowPos(aura::Window* dragged_window, float delta)
@@ skipping 306 matching lines @@
 
 void DockedWindowLayoutManager::OnWindowPropertyChanged(aura::Window* window,
                                                         const void* key,
                                                         intptr_t old) {
   if (key != aura::client::kShowStateKey)
     return;
   // The window property will still be set, but no actual change will occur
   // until WillChangeVisibilityState is called when the shelf is visible again
   if (shelf_hidden_)
     return;
-  if (wm::IsWindowMinimized(window))
-    MinimizeWindow(window);
+  if (wm::GetWindowState(window)->IsMinimized())
+    MinimizeDockedWindow(window);
   else
-    RestoreWindow(window);
+    RestoreDockedWindow(window);
 }
 
 void DockedWindowLayoutManager::OnWindowBoundsChanged(
     aura::Window* window,
     const gfx::Rect& old_bounds,
     const gfx::Rect& new_bounds) {
   // Only relayout if the dragged window would get docked.
   if (window == dragged_window_ && is_dragged_window_docked_)
     Relayout();
 }
@@ skipping 44 matching lines @@
   shelf_hidden_ = new_state == ash::SHELF_HIDDEN;
   {
     // prevent Relayout from getting called multiple times during this
     base::AutoReset<bool> auto_reset_in_layout(&in_layout_, true);
     for (size_t i = 0; i < dock_container_->children().size(); ++i) {
       aura::Window* window = dock_container_->children()[i];
       if (window->type() == aura::client::WINDOW_TYPE_POPUP)
         continue;
       if (shelf_hidden_) {
         if (window->IsVisible())
-          MinimizeWindow(window);
+          MinimizeDockedWindow(window);
       } else {
-        if (!wm::IsWindowMinimized(window))
-          RestoreWindow(window);
+        if (!wm::GetWindowState(window)->IsMinimized())
+          RestoreDockedWindow(window);
       }
     }
   }
   Relayout();
   UpdateDockBounds();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockLayoutManager private implementation:
 
-void DockedWindowLayoutManager::MinimizeWindow(aura::Window* window) {
+void DockedWindowLayoutManager::MinimizeDockedWindow(aura::Window* window) {
   DCHECK_NE(window->type(), aura::client::WINDOW_TYPE_POPUP);
   views::corewm::SetWindowVisibilityAnimationType(
       window, WINDOW_VISIBILITY_ANIMATION_TYPE_MINIMIZE);
   window->Hide();
-  if (wm::IsActiveWindow(window))
-    wm::DeactivateWindow(window);
+  wm::WindowState* window_state = wm::GetWindowState(window);
+  if (window_state->IsActive())
+    window_state->Deactivate();
 }
 
-void DockedWindowLayoutManager::RestoreWindow(aura::Window* window) {
+void DockedWindowLayoutManager::RestoreDockedWindow(aura::Window* window) {
   DCHECK_NE(window->type(), aura::client::WINDOW_TYPE_POPUP);
   window->Show();
 }
 
 void DockedWindowLayoutManager::OnWindowDocked(aura::Window* window) {
   DCHECK(!is_dragged_window_docked_);
   is_dragged_window_docked_ = true;
 
   // If there are no other docked windows update alignment.
   if (!IsAnyWindowDocked())
@@ skipping 219 matching lines @@
 
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   UpdateDockBounds();
 }
 
 }  // namespace internal
 }  // namespace ash