[Cleanup] Screen cleanup

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/screen_util.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/window_state.h"
 #include "ash/wm/window_util.h"
@@ skipping 367 matching lines @@
       RestackWindows();
     }
     did_move_or_resize_ = true;
   }
 
   gfx::Point location_in_screen = location_in_parent;
   wm::ConvertPointToScreen(GetTarget()->parent(), &location_in_screen);
 
   aura::Window* root = NULL;
   gfx::Display display =
-      ScreenAsh::FindDisplayContainingPoint(location_in_screen);
+      ScreenUtil::FindDisplayContainingPoint(location_in_screen);
   // Track the last screen that the pointer was on to keep the snap phantom
   // window there.
   if (display.is_valid()) {
     root = Shell::GetInstance()->display_controller()->
         GetRootWindowForDisplayId(display.id());
   }
   if (!attached_windows_.empty())
     LayoutAttachedWindows(&bounds);
   if (bounds != GetTarget()->bounds()) {
     // SetBounds needs to be called to update the layout which affects where the
@@ skipping 28 matching lines @@
   // 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 (window_state()->IsNormalShowState() &&
       (GetTarget()->type() != ui::wm::WINDOW_TYPE_PANEL ||
        !window_state()->panel_attached() ||
        dock_layout_->is_dragged_window_docked()) &&
       (snap_type_ == SNAP_LEFT || snap_type_ == SNAP_RIGHT)) {
     if (!window_state()->HasRestoreBounds()) {
-      gfx::Rect initial_bounds = ScreenAsh::ConvertRectToScreen(
+      gfx::Rect initial_bounds = ScreenUtil::ConvertRectToScreen(
           GetTarget()->parent(), details().initial_bounds_in_parent);
       window_state()->SetRestoreBoundsInScreen(
           details().restore_bounds.IsEmpty() ?
           initial_bounds :
           details().restore_bounds);
     }
     DCHECK(snap_sizer_);
     if (window_state()->CanResize() &&
         !dock_layout_->is_dragged_window_docked()) {
       snap_sizer_->SnapWindowToTargetBounds();
@@ skipping 85 matching lines @@
                             std::max(PrimaryAxisSize(min), kMinOnscreenSize));
     total_min_ += min_size;
     total_initial_size_ += initial_size;
     total_available += std::max(min_size, initial_size) - min_size;
   }
   instance_ = this;
 }
 
 void WorkspaceWindowResizer::LayoutAttachedWindows(
     gfx::Rect* bounds) {
-  gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(GetTarget()));
+  gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
+      GetTarget()));
   int initial_size = PrimaryAxisSize(details().initial_bounds_in_parent.size());
   int current_size = PrimaryAxisSize(bounds->size());
   int start = PrimaryAxisCoordinate(bounds->right(), bounds->bottom());
   int end = PrimaryAxisCoordinate(work_area.right(), work_area.bottom());
 
   int delta = current_size - initial_size;
   int available_size = end - start;
   std::vector<int> sizes;
   int leftovers = CalculateAttachedSizes(delta, available_size, &sizes);
 
@@ skipping 119 matching lines @@
     int min = PrimaryAxisSize(delegate->GetMinimumSize());
     int max = PrimaryAxisSize(delegate->GetMaximumSize());
 
     sizes->push_back(WindowSize(initial_size, min, max));
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapToOtherWindows(gfx::Rect* bounds) {
   if (UpdateMagnetismWindow(*bounds, kAllMagnetismEdges)) {
     gfx::Point point = OriginForMagneticAttach(
-        ScreenAsh::ConvertRectToScreen(GetTarget()->parent(), *bounds),
+        ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), *bounds),
         magnetism_window_->GetBoundsInScreen(),
         magnetism_edge_);
     aura::client::GetScreenPositionClient(GetTarget()->GetRootWindow())->
         ConvertPointFromScreen(GetTarget()->parent(), &point);
     bounds->set_origin(point);
   }
 }
 
 void WorkspaceWindowResizer::MagneticallySnapResizeToOtherWindows(
     gfx::Rect* bounds) {
   const uint32 edges = WindowComponentToMagneticEdge(
       details().window_component);
   if (UpdateMagnetismWindow(*bounds, edges)) {
-    *bounds = ScreenAsh::ConvertRectFromScreen(
+    *bounds = ScreenUtil::ConvertRectFromScreen(
         GetTarget()->parent(),
         BoundsForMagneticResizeAttach(
-            ScreenAsh::ConvertRectToScreen(GetTarget()->parent(), *bounds),
+            ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), *bounds),
             magnetism_window_->GetBoundsInScreen(),
             magnetism_edge_));
   }
 }
 
 bool WorkspaceWindowResizer::UpdateMagnetismWindow(const gfx::Rect& bounds,
                                                    uint32 edges) {
   // |bounds| are in coordinates of original window's parent.
   gfx::Rect bounds_in_screen =
-      ScreenAsh::ConvertRectToScreen(GetTarget()->parent(), bounds);
+      ScreenUtil::ConvertRectToScreen(GetTarget()->parent(), bounds);
   MagnetismMatcher matcher(bounds_in_screen, edges);
 
   // If we snapped to a window then check it first. That way we don't bounce
   // around when close to multiple edges.
   if (magnetism_window_) {
     if (window_tracker_.Contains(magnetism_window_) &&
         matcher.ShouldAttach(magnetism_window_->GetBoundsInScreen(),
                              &magnetism_edge_)) {
       return true;
     }
@@ skipping 35 matching lines @@
 
 void WorkspaceWindowResizer::AdjustBoundsForMainWindow(
     int sticky_size,
     gfx::Rect* bounds) {
   gfx::Point last_mouse_location_in_screen = last_mouse_location_;
   wm::ConvertPointToScreen(GetTarget()->parent(),
                            &last_mouse_location_in_screen);
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestPoint(
       last_mouse_location_in_screen);
   gfx::Rect work_area =
-      ScreenAsh::ConvertRectFromScreen(GetTarget()->parent(),
+      ScreenUtil::ConvertRectFromScreen(GetTarget()->parent(),
                                        display.work_area());
   if (details().window_component == HTCAPTION) {
     // Adjust the bounds to the work area where the mouse cursor is located.
     // Always keep kMinOnscreenHeight or the window height (whichever is less)
     // on the bottom.
     int max_y = work_area.bottom() - std::min(kMinOnscreenHeight,
                                               bounds->height());
     if (bounds->y() > max_y) {
       bounds->set_y(max_y);
     } else if (bounds->y() <= work_area.y()) {
@@ skipping 148 matching lines @@
       DockedWindowLayoutManager::kMaxDockWidth)) {
     phantom_bounds = snap_sizer_->target_bounds();
   }
   const bool should_dock = can_dock &&
       (phantom_bounds.IsEmpty() ||
        snap_sizer_->end_of_sequence() ||
        dock_layout_->is_dragged_window_docked());
   SetDraggedWindowDocked(should_dock);
   snap_type_ = GetSnapType(location);
   if (dock_layout_->is_dragged_window_docked()) {
-    phantom_bounds = ScreenAsh::ConvertRectFromScreen(
+    phantom_bounds = ScreenUtil::ConvertRectFromScreen(
         GetTarget()->parent(), dock_layout_->dragged_bounds());
   }
 
   if (phantom_bounds.IsEmpty()) {
     snap_phantom_window_controller_.reset();
     return;
   }
 
   if (!snap_phantom_window_controller_) {
     snap_phantom_window_controller_.reset(
         new PhantomWindowController(GetTarget()));
   }
-  snap_phantom_window_controller_->Show(ScreenAsh::ConvertRectToScreen(
+  snap_phantom_window_controller_->Show(ScreenUtil::ConvertRectToScreen(
       GetTarget()->parent(), phantom_bounds));
 }
 
 void WorkspaceWindowResizer::RestackWindows() {
   if (attached_windows_.empty())
     return;
   // Build a map from index in children to window, returning if there is a
   // window with a different parent.
   typedef std::map<size_t, aura::Window*> IndexToWindowMap;
   IndexToWindowMap map;
@@ skipping 18 matching lines @@
     ++i;
     if (i != map.rend())
       parent->StackChildBelow(i->second, window);
   }
 }
 
 SnapType WorkspaceWindowResizer::GetSnapType(
     const gfx::Point& location) const {
   // TODO: this likely only wants total display area, not the area of a single
   // display.
-  gfx::Rect area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(GetTarget()));
+  gfx::Rect area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(GetTarget()));
   if (details().source == aura::client::WINDOW_MOVE_SOURCE_TOUCH) {
     // Increase tolerance for touch-snapping near the screen edges. This is only
     // necessary when the work area left or right edge is same as screen edge.
-    gfx::Rect display_bounds(ScreenAsh::GetDisplayBoundsInParent(GetTarget()));
+    gfx::Rect display_bounds(ScreenUtil::GetDisplayBoundsInParent(GetTarget()));
     int inset_left = 0;
     if (area.x() == display_bounds.x())
       inset_left = kScreenEdgeInsetForTouchResize;
     int inset_right = 0;
     if (area.right() == display_bounds.right())
       inset_right = kScreenEdgeInsetForTouchResize;
     area.Inset(inset_left, 0, inset_right, 0);
   }
   if (location.x() <= area.x())
     return SNAP_LEFT;
@@ skipping 13 matching lines @@
   } else {
     if (dock_layout_->is_dragged_window_docked()) {
       dock_layout_->UndockDraggedWindow();
       window_state()->set_bounds_changed_by_user(true);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash