[Cleanup] Rename WindowSettings to WindowState

ash/wm/caption_buttons/frame_maximize_button.cc

 // Copyright 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/caption_buttons/frame_maximize_button.h"
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/touch/touch_uma.h"
 #include "ash/wm/caption_buttons/maximize_bubble_controller.h"
-#include "ash/wm/property_util.h"
 #include "ash/wm/window_animations.h"
-#include "ash/wm/window_settings.h"
+#include "ash/wm/window_state.h"
 #include "ash/wm/workspace/phantom_window_controller.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "grit/ash_strings.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/event.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/image/image.h"
@@ skipping 60 matching lines @@
       frame_(frame),
       observing_frame_(false),
       is_snap_enabled_(false),
       exceeded_drag_threshold_(false),
       press_is_gesture_(false),
       snap_type_(SNAP_NONE),
       bubble_appearance_delay_ms_(kBubbleAppearanceDelayMS) {
   // TODO(sky): nuke this. It's temporary while we don't have good images.
   SetImageAlignment(ALIGN_LEFT, ALIGN_BOTTOM);
 
-  if (ash::Shell::IsForcedMaximizeMode())
+  if (Shell::IsForcedMaximizeMode())
     views::View::SetVisible(false);
 }
 
 FrameMaximizeButton::~FrameMaximizeButton() {
   // Before the window gets destroyed, the maximizer dialog needs to be shut
   // down since it would otherwise call into a deleted object.
   maximizer_.reset();
   if (observing_frame_)
     OnWindowDestroying(frame_->GetNativeWindow());
 }
@@ skipping 201 matching lines @@
       event->SetHandled();
       return;
     }
   }
 
   ImageButton::OnGestureEvent(event);
 }
 
 void FrameMaximizeButton::SetVisible(bool visible) {
   // In the enforced maximized mode we do not allow to be made visible.
-  if (ash::Shell::IsForcedMaximizeMode())
+  if (Shell::IsForcedMaximizeMode())
     return;
 
   views::View::SetVisible(visible);
 }
 
 void FrameMaximizeButton::ProcessStartEvent(const ui::LocatedEvent& event) {
   DCHECK(is_snap_enabled_);
   // Prepare the help menu.
   if (!maximizer_) {
     maximizer_.reset(new MaximizeBubbleController(
@@ skipping 162 matching lines @@
     case SNAP_MINIMIZE: {
       gfx::Rect rect = GetMinimizeAnimationTargetBoundsInScreen(window);
       if (!rect.IsEmpty()) {
         // PhantomWindowController insets slightly, outset it so the phantom
         // doesn't appear inset.
         rect.Inset(-8, -8);
       }
       return rect;
     }
     case SNAP_RESTORE: {
-      const gfx::Rect* restore = GetRestoreBoundsInScreen(window);
-      return restore ? *restore : frame_->GetWindowBoundsInScreen();
+      wm::WindowState* window_state = wm::GetWindowState(window);
+      return window_state->HasRestoreBounds() ?
+          window_state->GetRestoreBoundsInScreen() :
+          frame_->GetWindowBoundsInScreen();
     }
     case SNAP_NONE:
       NOTREACHED();
   }
   return gfx::Rect();
 }
 
 gfx::Point FrameMaximizeButton::LocationForSnapSizer(
     const gfx::Point& location) const {
   gfx::Point result(location);
   views::View::ConvertPointToScreen(this, &result);
   return result;
 }
 
 void FrameMaximizeButton::Snap(SnapSizer* snap_sizer) {
-  ash::Shell* shell = ash::Shell::GetInstance();
+  Shell* shell = Shell::GetInstance();
+  wm::WindowState* window_state = wm::GetWindowState(frame_->GetNativeWindow());
   switch (snap_type_) {
     case SNAP_LEFT:
     case SNAP_RIGHT: {
       // Others might also have set up a restore rectangle already. If so, we
       // should not overwrite the restore rectangle.
       gfx::Rect current_bounds_in_screen = frame_->GetWindowBoundsInScreen();
       snap_sizer->SnapWindowToTargetBounds();
-      if (GetRestoreBoundsInScreen(frame_->GetNativeWindow()) == NULL) {
-        ash::SetRestoreBoundsInScreen(frame_->GetNativeWindow(),
-                                      current_bounds_in_screen);
-      }
+      if (!window_state->HasRestoreBounds())
+        window_state->SetRestoreBoundsInScreen(current_bounds_in_screen);
       shell->delegate()->RecordUserMetricsAction(
           snap_type_ == SNAP_LEFT ?
-              ash::UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_LEFT :
-              ash::UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_RIGHT);
+              UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_LEFT :
+              UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE_RIGHT);
       break;
     }
     case SNAP_MAXIMIZE:
       frame_->Maximize();
       shell->delegate()->RecordUserMetricsAction(
-          ash::UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE);
+          UMA_WINDOW_MAXIMIZE_BUTTON_MAXIMIZE);
       break;
     case SNAP_MINIMIZE:
       frame_->Minimize();
       shell->delegate()->RecordUserMetricsAction(
-          ash::UMA_WINDOW_MAXIMIZE_BUTTON_MINIMIZE);
+          UMA_WINDOW_MAXIMIZE_BUTTON_MINIMIZE);
       break;
     case SNAP_RESTORE:
       frame_->Restore();
       shell->delegate()->RecordUserMetricsAction(
-          ash::UMA_WINDOW_MAXIMIZE_BUTTON_RESTORE);
+          UMA_WINDOW_MAXIMIZE_BUTTON_RESTORE);
       break;
     case SNAP_NONE:
       NOTREACHED();
   }
 }
 
 MaximizeBubbleFrameState
 FrameMaximizeButton::GetMaximizeBubbleFrameState() const {
+  wm::WindowState* window_state =
+      wm::GetWindowState(frame_->GetNativeWindow());
   // When there are no restore bounds, we are in normal mode.
-  if (!ash::GetRestoreBoundsInScreen(frame_->GetNativeWindow()))
+  if (!window_state->HasRestoreBounds())
     return FRAME_STATE_NONE;
   // The normal maximized test can be used.
   if (frame_->IsMaximized())
     return FRAME_STATE_FULL;
   // For Left/right maximize we need to check the dimensions.
   gfx::Rect bounds = frame_->GetWindowBoundsInScreen();
   gfx::Rect screen = Shell::GetScreen()->GetDisplayNearestWindow(
       frame_->GetNativeView()).work_area();
   if (bounds.width() < (screen.width() * kMinSnapSizePercent) / 100)
     return FRAME_STATE_NONE;
   // We might still have a horizontally filled window at this point which we
   // treat as no special state.
   if (bounds.y() != screen.y() || bounds.height() != screen.height())
     return FRAME_STATE_NONE;
 
   // We have to be in a maximize mode at this point.
   if (bounds.x() == screen.x())
     return FRAME_STATE_SNAP_LEFT;
   if (bounds.right() == screen.right())
     return FRAME_STATE_SNAP_RIGHT;
   // If we come here, it is likely caused by the fact that the
   // "VerticalResizeDoubleClick" stored a restore rectangle. In that case
   // we allow all maximize operations (and keep the restore rectangle).
   return FRAME_STATE_NONE;
 }
 
 }  // namespace ash