[Cleanup] Rename WindowSettings to WindowState

ash/wm/frame_painter.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/frame_painter.h"
 
 #include <vector>
 
 #include "ash/ash_constants.h"
 #include "ash/root_window_controller.h"
 #include "ash/root_window_settings.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/caption_buttons/frame_caption_button_container_view.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 "base/logging.h"  // DCHECK
 #include "grit/ash_resources.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
@@ skipping 196 matching lines @@
       previous_theme_frame_overlay_id_(0),
       previous_opacity_(0),
       crossfade_theme_frame_id_(0),
       crossfade_theme_frame_overlay_id_(0),
       crossfade_opacity_(0) {}
 
 FramePainter::~FramePainter() {
   // Sometimes we are destroyed before the window closes, so ensure we clean up.
   if (window_) {
     window_->RemoveObserver(this);
-    wm::GetWindowSettings(window_)->RemoveObserver(this);
+    wm::GetWindowState(window_)->RemoveObserver(this);
   }
 }
 
 void FramePainter::Init(
     views::Widget* frame,
     views::View* window_icon,
     FrameCaptionButtonContainerView* caption_button_container) {
   DCHECK(frame);
   // window_icon may be NULL.
   DCHECK(caption_button_container);
@@ skipping 23 matching lines @@
       kResizeOutsideBoundsScaleForTouch);
   // Ensure we get resize cursors for a few pixels outside our bounds.
   window_->SetHitTestBoundsOverrideOuter(mouse_insets, touch_insets);
   // Ensure we get resize cursors just inside our bounds as well.
   window_->set_hit_test_bounds_override_inner(mouse_insets);
 
   // Watch for maximize/restore/fullscreen state changes.  Observer removes
   // itself in OnWindowDestroying() below, or in the destructor if we go away
   // before the window.
   window_->AddObserver(this);
-  wm::GetWindowSettings(window_)->AddObserver(this);
+  wm::GetWindowState(window_)->AddObserver(this);
 
   // Solo-window header updates are handled by the workspace controller when
   // this window is added to the desktop.
 }
 
 // static
 void FramePainter::SetSoloWindowHeadersEnabled(bool enabled) {
   solo_window_header_enabled = enabled;
 }
 
@@ skipping 99 matching lines @@
 }
 
 bool FramePainter::ShouldUseMinimalHeaderStyle(Themed header_themed) const {
   // Use the minimalistic header style whenever |frame_| is maximized or
   // fullscreen EXCEPT:
   // - If the user has installed a theme with custom images for the header.
   // - For windows which are not tracked by the workspace code (which are used
   //   for tab dragging).
   return (frame_->IsMaximized() || frame_->IsFullscreen()) &&
       header_themed == THEMED_NO &&
-      wm::GetWindowSettings(frame_->GetNativeWindow())->tracked_by_workspace();
+      wm::GetWindowState(frame_->GetNativeWindow())->tracked_by_workspace();
 }
 
 void FramePainter::PaintHeader(views::NonClientFrameView* view,
                                gfx::Canvas* canvas,
                                HeaderMode header_mode,
                                int theme_frame_id,
                                int theme_frame_overlay_id) {
   bool initial_paint = (previous_theme_frame_id_ == 0);
   if (!initial_paint &&
       (previous_theme_frame_id_ != theme_frame_id ||
@@ skipping 204 matching lines @@
   previous_theme_frame_id_ = 0;
   previous_theme_frame_overlay_id_ = 0;
 
   if (crossfade_animation_.get() && crossfade_animation_->is_animating()) {
     crossfade_animation_.reset();
     frame_->non_client_view()->SchedulePaintInRect(header_frame_bounds_);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// WindowSettings::jObserver overrides:
+// WindowState::Observer overrides:
 void FramePainter::OnTrackedByWorkspaceChanged(aura::Window* window,
                                                bool old) {
   // When 'TrackedByWorkspace' changes, we are going to paint the header
   // differently. Schedule a paint to ensure everything is updated correctly.
-  if (wm::GetWindowSettings(window)->tracked_by_workspace())
+  if (wm::GetWindowState(window)->tracked_by_workspace())
     frame_->non_client_view()->SchedulePaint();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // aura::WindowObserver overrides:
 
 void FramePainter::OnWindowPropertyChanged(aura::Window* window,
                                            const void* key,
                                            intptr_t old) {
   if (key != aura::client::kShowStateKey)
     return;
 
   // Maximized and fullscreen windows don't want resize handles overlapping the
   // content area, because when the user moves the cursor to the right screen
   // edge we want them to be able to hit the scroll bar.
-  if (ash::wm::IsWindowMaximized(window) ||
-      ash::wm::IsWindowFullscreen(window)) {
+  wm::WindowState* window_state = wm::GetWindowState(window);
+  if (window_state->IsMaximizedOrFullscreen()) {
     window->set_hit_test_bounds_override_inner(gfx::Insets());
   } else {
     window->set_hit_test_bounds_override_inner(
         gfx::Insets(kResizeInsideBoundsSize, kResizeInsideBoundsSize,
                     kResizeInsideBoundsSize, kResizeInsideBoundsSize));
   }
 }
 
 void FramePainter::OnWindowVisibilityChanged(aura::Window* window,
                                              bool visible) {
   // OnWindowVisibilityChanged can be called for the child windows of |window_|.
   if (window != window_)
     return;
 
   // Window visibility change may trigger the change of window solo-ness in a
   // different window.
   UpdateSoloWindowInRoot(window_->GetRootWindow(), visible ? NULL : window_);
 }
 
 void FramePainter::OnWindowDestroying(aura::Window* destroying) {
   DCHECK_EQ(window_, destroying);
 
   // Must be removed here and not in the destructor, as the aura::Window is
   // already destroyed when our destructor runs.
   window_->RemoveObserver(this);
-  wm::GetWindowSettings(window_)->RemoveObserver(this);
+  wm::GetWindowState(window_)->RemoveObserver(this);
 
   // If we have two or more windows open and we close this one, we might trigger
   // the solo window appearance for another window.
   UpdateSoloWindowInRoot(window_->GetRootWindow(), window_);
 
   window_ = NULL;
 }
 
 void FramePainter::OnWindowBoundsChanged(aura::Window* window,
                                          const gfx::Rect& old_bounds,
@@ skipping 39 matching lines @@
 int FramePainter::GetCaptionButtonContainerCenterY() const {
   return caption_button_container_->y() +
       caption_button_container_->height() / 2;
 }
 
 int FramePainter::GetHeaderCornerRadius() const {
   // Use square corners for maximized and fullscreen windows when they are
   // tracked by the workspace code. (Windows which are not tracked by the
   // workspace code are used for tab dragging.)
   bool square_corners = ((frame_->IsMaximized() || frame_->IsFullscreen())) &&
-      wm::GetWindowSettings(frame_->GetNativeWindow())->tracked_by_workspace();
+      wm::GetWindowState(frame_->GetNativeWindow())->tracked_by_workspace();
   const int kCornerRadius = 2;
   return square_corners ? 0 : kCornerRadius;
 }
 
 int FramePainter::GetHeaderOpacity(
     HeaderMode header_mode,
     int theme_frame_id,
     int theme_frame_overlay_id) const {
   // User-provided themes are painted fully opaque.
   ui::ThemeProvider* theme_provider = frame_->GetThemeProvider();
@@ skipping 36 matching lines @@
   std::vector<Window*> windows = GetWindowsForSoloHeaderUpdate(root_window);
   for (std::vector<Window*>::const_iterator it = windows.begin();
        it != windows.end();
        ++it) {
     Window* window = *it;
     // Various sorts of windows "don't count" for this computation.
     if (ignore_window == window ||
         !IsSoloWindowHeaderCandidate(window) ||
         !IsVisibleToRoot(window))
       continue;
-    if (wm::IsWindowMaximized(window))
+    if (wm::GetWindowState(window)->IsMaximized())
       return false;
     ++visible_window_count;
     if (visible_window_count > 1)
       return false;
   }
   // Count must be tested because all windows might be "don't count" windows
   // in the loop above.
   return visible_window_count == 1;
 }
 
@@ skipping 43 matching lines @@
   // icon. Don't use |window_icon_| for this computation as it may be NULL.
   int title_y = GetCaptionButtonContainerCenterY() - title_font.GetHeight() / 2;
   return gfx::Rect(
       title_x,
       std::max(0, title_y),
       std::max(0, caption_button_container_->x() - kTitleLogoSpacing - title_x),
       title_font.GetHeight());
 }
 
 }  // namespace ash