[Cleanup] Rename WindowSettings to WindowState

ash/wm/toplevel_window_event_handler.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/toplevel_window_event_handler.h"
 
 #include "ash/shell.h"
-#include "ash/wm/property_util.h"
 #include "ash/wm/resize_shadow_controller.h"
 #include "ash/wm/window_resizer.h"
-#include "ash/wm/window_settings.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
@@ skipping 75 matching lines @@
 ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
   RemoveHandlers();
   if (resizer_)
     resizer_->GetTarget()->RemoveObserver(this);
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowHierarchyChanging(
     const HierarchyChangeParams& params) {
   if (params.receiver != resizer_->GetTarget())
     return;
-
-  if (wm::GetWindowSettings(params.receiver)->continue_drag_after_reparent()) {
-    wm::GetWindowSettings(params.receiver)->
-        set_continue_drag_after_reparent(false);
+  wm::WindowState* state = wm::GetWindowState(params.receiver);
+  if (state->continue_drag_after_reparent()) {
+    state->set_continue_drag_after_reparent(false);
     AddHandlers(params.new_parent);
   } else {
     handler_->CompleteDrag(DRAG_COMPLETE, 0);
   }
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowPropertyChanged(
     aura::Window* window,
     const void* key,
     intptr_t old) {
-  if (key == aura::client::kShowStateKey && !wm::IsWindowNormal(window))
+  if (key == aura::client::kShowStateKey &&

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

Not for this CL, but I wonder WindowState should provide notifications/observer
for show state changes. In particular, if we implement snap states in
WindowState then we might need WindowState to do notifications, such as for
left-snap changing to right-snap.

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

Yes, I'll look into if we can change such that only WindowState listens to 
ShowStateChange, and have more explicit Obsever for ShowState change in ash.

+      !wm::GetWindowState(window)->IsNormal())
     handler_->CompleteDrag(DRAG_COMPLETE, 0);
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowDestroying(
     aura::Window* window) {
   DCHECK(resizer_.get());
   DCHECK_EQ(resizer_->GetTarget(), window);
   handler_->ResizerWindowDestroyed();
 }
 
@@ skipping 148 matching lines @@
 
       if (event->type() == ui::ET_GESTURE_SCROLL_END) {
         event->StopPropagation();
         return;
       }
 
       int component =
           target->delegate()->GetNonClientComponent(event->location());
       if (WindowResizer::GetBoundsChangeForWindowComponent(component) == 0)
         return;
-      if (!wm::IsWindowNormal(target))
+
+      wm::WindowState* window_state = wm::GetWindowState(target);
+      if (!window_state->IsNormal())
         return;
 
       if (fabs(event->details().velocity_y()) >
           kMinVertVelocityForWindowMinimize) {
         // Minimize/maximize.
         if (event->details().velocity_y() > 0 &&
-            wm::CanMinimizeWindow(target)) {
-          wm::MinimizeWindow(target);
-          SetWindowAlwaysRestoresToRestoreBounds(target, true);
-          SetRestoreBoundsInParent(target, pre_drag_window_bounds_);
-        } else if (wm::CanMaximizeWindow(target)) {
-          SetRestoreBoundsInParent(target, pre_drag_window_bounds_);
-          wm::MaximizeWindow(target);
+            window_state->CanMinimize()) {
+          window_state->Minimize();
+          window_state->set_always_restores_to_restore_bounds(true);
+          window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
+        } else if (window_state->CanMaximize()) {
+          window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
+          window_state->Maximize();
         }
-      } else if (wm::CanSnapWindow(target) &&
+      } else if (window_state->CanSnap() &&
                  fabs(event->details().velocity_x()) >
                  kMinHorizVelocityForWindowSwipe) {
         // Snap left/right.
         ui::ScopedLayerAnimationSettings scoped_setter(
             target->layer()->GetAnimator());
         scoped_setter.SetPreemptionStrategy(
             ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
         internal::SnapSizer::SnapWindow(target,
             event->details().velocity_x() < 0 ?
             internal::SnapSizer::LEFT_EDGE : internal::SnapSizer::RIGHT_EDGE);
@@ skipping 210 matching lines @@
 void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
   // We explicitly don't invoke RevertDrag() since that may do things to window.
   // Instead we destroy the resizer.
   window_resizer_.reset();
 
   // End the move loop. This does nothing if we're not in a move loop.
   EndMoveLoop();
 }
 
 }  // namespace ash