[Cleanup] Rename WindowSettings to WindowState

ash/wm/workspace/workspace_window_resizer.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 <algorithm>
 #include <cmath>
 #include <utility>
 #include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/default_window_resizer.h"
 #include "ash/wm/dock/docked_window_layout_manager.h"
 #include "ash/wm/dock/docked_window_resizer.h"
 #include "ash/wm/drag_window_resizer.h"
 #include "ash/wm/panels/panel_window_resizer.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 "base/command_line.h"
 #include "base/memory/weak_ptr.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/client/window_types.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/transform.h"
 
 namespace ash {
 
 scoped_ptr<WindowResizer> CreateWindowResizer(
     aura::Window* window,
     const gfx::Point& point_in_parent,
     int window_component,
     aura::client::WindowMoveSource source) {
   DCHECK(window);
+  wm::WindowState* window_state = wm::GetWindowState(window);
   // No need to return a resizer when the window cannot get resized.
-  if (!wm::CanResizeWindow(window) && window_component != HTCAPTION)
+  if (!window_state->CanResize() && window_component != HTCAPTION)
     return scoped_ptr<WindowResizer>();
 
   // TODO(varkha): The chaining of window resizers causes some of the logic
   // to be repeated and the logic flow difficult to control. With some windows
   // classes using reparenting during drag operations it becomes challenging to
   // implement proper transition from one resizer to another during or at the
   // end of the drag. This also causes http://crbug.com/247085.
   // It seems the only thing the panel or dock resizer needs to do is notify the
   // layout manager when a docked window is being dragged. We should have a
   // better way of doing this, perhaps by having a way of observing drags or
   // having a generic drag window wrapper which informs a layout manager that a
   // drag has started or stopped.
   // It may be possible to refactor and eliminate chaining.
   WindowResizer* window_resizer = NULL;
   if (window->parent() &&
       (window->parent()->id() == internal::kShellWindowId_DefaultContainer ||
        window->parent()->id() == internal::kShellWindowId_DockedContainer ||
        window->parent()->id() == internal::kShellWindowId_PanelContainer)) {
     // Allow dragging maximized windows if it's not tracked by workspace. This
     // is set by tab dragging code.
-    if (!wm::IsWindowNormal(window) &&
+    if (!window_state->IsNormal() &&
         (window_component != HTCAPTION ||
-         wm::GetWindowSettings(window)->tracked_by_workspace())) {
+         window_state->tracked_by_workspace())) {
       return scoped_ptr<WindowResizer>();
     }
     window_resizer = internal::WorkspaceWindowResizer::Create(
         window,
         point_in_parent,
         window_component,
         source,
         std::vector<aura::Window*>());
-  } else if (wm::IsWindowNormal(window)) {
+  } else if (window_state->IsNormal()) {
     window_resizer = DefaultWindowResizer::Create(
         window, point_in_parent, window_component, source);
   }
   if (window_resizer) {
     window_resizer = internal::DragWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component, source);
   }
   if (window_resizer && window->type() == aura::client::WINDOW_TYPE_PANEL) {
     window_resizer = PanelWindowResizer::Create(
         window_resizer, window, point_in_parent, window_component, source);
@@ skipping 273 matching lines @@
           switches::kAshEnableDockedWindows)) {
     sticky_size = kStickyDistancePixels;
   } else if ((details_.bounds_change & kBoundsChange_Resizes) &&
       details_.source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     sticky_size = kScreenEdgeInsetForTouchResize;
   } else {
     sticky_size = kScreenEdgeInset;
   }
   // |bounds| is in |window()->parent()|'s coordinates.
   gfx::Rect bounds = CalculateBoundsForDrag(details_, location_in_parent);
-
-  if (wm::IsWindowNormal(window()))
+  if (window_state()->IsNormal())
     AdjustBoundsForMainWindow(sticky_size, &bounds);
 
   if (bounds != window()->bounds()) {
     if (!did_move_or_resize_) {
       if (!details_.restore_bounds.IsEmpty())
-        ClearRestoreBounds(window());
+        window_state()->ClearRestoreBounds();
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
   gfx::Point location_in_screen = location_in_parent;
   wm::ConvertPointToScreen(window()->parent(), &location_in_screen);
 
   aura::RootWindow* root = NULL;
   gfx::Display display =
@@ skipping 22 matching lines @@
     UpdateSnapPhantomWindow(location_in_parent, bounds);
   } else {
     snap_type_ = SNAP_NONE;
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     UpdateDockedState(false);
   }
 }
 
 void WorkspaceWindowResizer::CompleteDrag(int event_flags) {
-  wm::GetWindowSettings(details_.window)->set_bounds_changed_by_user(true);
+  window_state()->set_bounds_changed_by_user(true);
   snap_phantom_window_controller_.reset();
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
   // When the window is not in the normal show state, we do not snap the window.
   // This happens when the user minimizes or maximizes the window by keyboard
   // shortcut while dragging it. If the window is the result of dragging a tab
   // out of a maximized window, it's already in the normal show state when this
   // is called, so it does not matter.
-  if (wm::IsWindowNormal(window()) &&
+  if (window_state()->IsNormal() &&
       (window()->type() != aura::client::WINDOW_TYPE_PANEL ||
-       !wm::GetWindowSettings(window())->panel_attached()) &&
+       !window_state()->panel_attached()) &&
       (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT)) {
-    if (!GetRestoreBoundsInScreen(window())) {
+    if (!window_state()->HasRestoreBounds()) {
       gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
           window()->parent(), details_.initial_bounds_in_parent);
-      SetRestoreBoundsInScreen(window(), details_.restore_bounds.IsEmpty() ?
-                               initial_bounds :
-                               details_.restore_bounds);
+      window_state()->SetRestoreBoundsInScreen(
+          details_.restore_bounds.IsEmpty() ?
+          initial_bounds :
+          details_.restore_bounds);
     }
     DCHECK(snap_sizer_);
-    if (wm::CanResizeWindow(window()) &&
+    if (window_state()->CanResize() &&
         !dock_layout_->is_dragged_window_docked() &&
         !snap_sizer_->target_bounds().IsEmpty()) {
       window()->SetBounds(snap_sizer_->target_bounds());
     }
     return;
   }
 }
 
 void WorkspaceWindowResizer::RevertDrag() {
   snap_phantom_window_controller_.reset();
 
   if (!did_move_or_resize_)
     return;
 
   window()->SetBounds(details_.initial_bounds_in_parent);
-  if (!details_.restore_bounds.IsEmpty())
-    SetRestoreBoundsInScreen(details_.window, details_.restore_bounds);
+  if (!details_.restore_bounds.IsEmpty()) {
+    window_state()->SetRestoreBoundsInScreen(details_.restore_bounds);
+  }
 
   if (details_.window_component == HTRIGHT) {
     int last_x = details_.initial_bounds_in_parent.right();
     for (size_t i = 0; i < attached_windows_.size(); ++i) {
       gfx::Rect bounds(attached_windows_[i]->bounds());
       bounds.set_x(last_x);
       bounds.set_width(initial_size_[i]);
       attached_windows_[i]->SetBounds(bounds);
       last_x = attached_windows_[i]->bounds().right();
     }
@@ skipping 249 matching lines @@
         matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
                              &magnetism_edge_)) {
       return true;
     }
     window_tracker_.Remove(magnetism_window_);
     magnetism_window_ = NULL;
   }
 
   // Avoid magnetically snapping to popups, menus, tooltips, controls and
   // windows that are not tracked by workspace.
-  if (!wm::CanResizeWindow(window()) ||
-      !wm::GetWindowSettings(window())->tracked_by_workspace())
+  if (!window_state()->CanResize() || !window_state()->tracked_by_workspace())
     return false;
 
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     const aura::RootWindow* root_window = *iter;
     // Test all children from the desktop in each root window.
     const aura::Window::Windows& children = Shell::GetContainer(
         root_window, kShellWindowId_DefaultContainer)->children();
     for (aura::Window::Windows::const_reverse_iterator i = children.rbegin();
          i != children.rend() && !matcher.AreEdgesObscured(); ++i) {
-      aura::Window* other = *i;
-      if (other == window() ||
-          !other->IsVisible() ||
-          !wm::IsWindowNormal(other) ||
-          !wm::CanResizeWindow(other)) {
+      wm::WindowState* other_state = wm::GetWindowState(*i);
+      if (other_state->window() == window() ||
+          !other_state->window()->IsVisible() ||
+          !other_state->IsNormal() ||
+          !other_state->CanResize()) {
         continue;
       }
-      if (matcher.ShouldAttach(other->GetBoundsInScreen(), &magnetism_edge_)) {
-        magnetism_window_ = other;
+      if (matcher.ShouldAttach(
+              other_state->window()->GetBoundsInScreen(), &magnetism_edge_)) {
+        magnetism_window_ = other_state->window();
         window_tracker_.Add(magnetism_window_);
         return true;
       }
     }
   }
   return false;
 }
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
     int sticky_size,
@@ skipping 115 matching lines @@
       NOTREACHED();
   }
   return 0;
 }
 
 void WorkspaceWindowResizer::UpdateSnapPhantomWindow(const gfx::Point& location,
                                                      const gfx::Rect& bounds) {
   if (!did_move_or_resize_ || details_.window_component != HTCAPTION)
     return;
 
+#if 0

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

Did you mean to include this?

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

Done.

+  if (!wm::CanSnapWindow(window()))
+    return;
+
+  if (window()->type() == aura::client::WINDOW_TYPE_PANEL &&
+      wm::GetWindowState(window())->panel_attached()) {
+    return;
+  }
+#endif
   SnapType last_type = snap_type_;
   snap_type_ = GetSnapType(location);
   if (snap_type_ == SNAP_NONE || snap_type_ != last_type) {
     snap_phantom_window_controller_.reset();
     snap_sizer_.reset();
     UpdateDockedState(false);
     if (snap_type_ == SNAP_NONE)
       return;
   }
   SnapSizer::Edge edge = (snap_type_ == SNAP_LEFT) ?
       SnapSizer::LEFT_EDGE : SnapSizer::RIGHT_EDGE;
 
   if (!snap_sizer_) {
     snap_sizer_.reset(new SnapSizer(window(),
                                     location,
                                     edge,
                                     internal::SnapSizer::OTHER_INPUT));
   } else {
     snap_sizer_->Update(location);
   }
 
   const bool can_dock = dock_layout_->CanDockWindow(window(), snap_type_);
-  if (!wm::CanSnapWindow(window()) && !can_dock)
+  if (!window_state()->CanSnap() && !can_dock)
     return;
 
   // Update phantom window with snapped or docked guide bounds.
   // Windows that cannot be snapped or are less wide than kMaxDockWidth can get
   // docked without going through a snapping sequence.
   gfx::Rect phantom_bounds;
   if (!can_dock ||
       window()->bounds().width() > DockedWindowLayoutManager::kMaxDockWidth)
     phantom_bounds = snap_sizer_->target_bounds();
   const bool is_docked = can_dock &&
@@ skipping 66 matching lines @@
     if (!dock_layout_->is_dragged_window_docked())
       dock_layout_->DockDraggedWindow(window());
   } else {
     if (dock_layout_->is_dragged_window_docked())
       dock_layout_->UndockDraggedWindow();
   }
 }
 
 }  // namespace internal
 }  // namespace ash