[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/events/event.h"
 #include "ui/base/events/event_handler.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.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(const SnapSizer& snap_sizer) {
-  ash::Shell* shell = ash::Shell::GetInstance();
+  Shell* shell = Shell::GetInstance();
+
   switch (snap_type_) {
     case SNAP_LEFT:
     case SNAP_RIGHT: {
       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);
+      wm::WindowState* window_state = wm::GetWindowState(
+          frame_->GetNativeWindow());
       // Get the bounds in screen coordinates for restore purposes.
       gfx::Rect restore = frame_->GetWindowBoundsInScreen();
       if (frame_->IsMaximized() || frame_->IsFullscreen()) {
-        aura::Window* window = frame_->GetNativeWindow();
         // In case of maximized we have a restore boundary.
-        DCHECK(ash::GetRestoreBoundsInScreen(window));
+        DCHECK(window_state->HasRestoreBounds());
         // If it was maximized we need to recover the old restore set.
-        restore = *ash::GetRestoreBoundsInScreen(window);
+        restore = window_state->GetRestoreBoundsInScreen();
 
         // The auto position manager will kick in when this is the only window.
         // To avoid interference with it we tell it temporarily to not change
         // the coordinates of this window.
-        wm::WindowSettings* settings = wm::GetWindowSettings(window);
-        bool was_managed = settings->window_position_managed();
-        settings->set_window_position_managed(false);
+        bool was_managed = window_state->window_position_managed();
+        window_state->set_window_position_managed(false);
 
         // Set the restore size we want to restore to.
-        ash::SetRestoreBoundsInScreen(window,
-                                      ScreenBoundsForType(snap_type_,
-                                                          snap_sizer));
+        window_state->SetRestoreBoundsInScreen(
+            ScreenBoundsForType(snap_type_, snap_sizer));
         frame_->Restore();
 
         // After the window is where we want it to be we allow the window to be
         // auto managed again.
-        settings->set_window_position_managed(was_managed);
+        window_state->set_window_position_managed(was_managed);
       } else {
         // Others might also have set up a restore rectangle already. If so,
         // we should not overwrite the restore rectangle.
-        bool restore_set =
-            GetRestoreBoundsInScreen(frame_->GetNativeWindow()) != NULL;
+        bool restore_set = window_state->HasRestoreBounds();
         frame_->SetBounds(ScreenBoundsForType(snap_type_, snap_sizer));
         if (restore_set)
           break;
       }
       // Remember the widow's bounds for restoration.
-      ash::SetRestoreBoundsInScreen(frame_->GetNativeWindow(), restore);
+      window_state->SetRestoreBoundsInScreen(restore);
       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