[Cleanup] Screen cleanup

ash/wm/workspace/workspace_layout_manager.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_layout_manager.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/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/always_on_top_controller.h"
 #include "ash/wm/base_layout_manager.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_positioner.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 24 matching lines @@
   // Move only if the restore bounds is outside of
   // the display. There is no information about in which
   // display it should be restored, so this is best guess.
   // TODO(oshima): Restore information should contain the
   // work area information like WindowResizer does for the
   // last window location.
   gfx::Rect display_area = Shell::GetScreen()->GetDisplayNearestWindow(
       window_state->window()).bounds();
 
   if (!display_area.Intersects(restore_bounds)) {
+    const gfx::Display& display =
+        Shell::GetScreen()->GetDisplayMatching(restore_bounds);
     DisplayController* display_controller =
         Shell::GetInstance()->display_controller();
-    const gfx::Display& display =
-        display_controller->GetDisplayMatching(restore_bounds);
     aura::Window* new_root =
         display_controller->GetRootWindowForDisplayId(display.id());
     if (new_root != window_state->window()->GetRootWindow()) {
       aura::Window* new_container =
           Shell::GetContainer(new_root, window_state->window()->parent()->id());
       new_container->AddChild(window_state->window());
     }
   }
 }
 
 }  // namespace
 
 WorkspaceLayoutManager::WorkspaceLayoutManager(aura::Window* window)
     : BaseLayoutManager(window->GetRootWindow()),
       shelf_(NULL),
       window_(window),
-      work_area_in_parent_(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
+      work_area_in_parent_(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
           window->parent())),
       is_fullscreen_(GetRootWindowController(
           window->GetRootWindow())->GetWindowForFullscreenMode() != NULL) {
 }
 
 WorkspaceLayoutManager::~WorkspaceLayoutManager() {
 }
 
 void WorkspaceLayoutManager::SetShelf(internal::ShelfLayoutManager* shelf) {
   shelf_ = shelf;
@@ skipping 47 matching lines @@
                                     child_bounds.width()));
     child_bounds.set_height(std::min(work_area_in_parent_.height(),
                                      child_bounds.height()));
     AdjustSnappedBounds(window_state, &child_bounds);
     SetChildBoundsDirect(child, child_bounds);
   }
   UpdateShelfVisibility();
 }
 
 void WorkspaceLayoutManager::OnDisplayWorkAreaInsetsChanged() {
-  const gfx::Rect work_area(ScreenAsh::GetDisplayWorkAreaBoundsInParent(
+  const gfx::Rect work_area(ScreenUtil::GetDisplayWorkAreaBoundsInParent(
       window_->parent()));
   if (work_area != work_area_in_parent_) {
     AdjustAllWindowsBoundsForWorkAreaChange(
         ADJUST_WINDOW_WORK_AREA_INSETS_CHANGED);
   }
 }
 
 void WorkspaceLayoutManager::OnWindowPropertyChanged(Window* window,
                                                      const void* key,
                                                      intptr_t old) {
@@ skipping 45 matching lines @@
   // Notify observers that fullscreen state may be changing.
   if (window_state->IsFullscreen() || old_type == wm::SHOW_TYPE_FULLSCREEN)
     UpdateFullscreenState();
 
   UpdateShelfVisibility();
 }
 
 void WorkspaceLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(
     AdjustWindowReason reason) {
   work_area_in_parent_ =
-      ScreenAsh::GetDisplayWorkAreaBoundsInParent(window_->parent());
+      ScreenUtil::GetDisplayWorkAreaBoundsInParent(window_->parent());
   BaseLayoutManager::AdjustAllWindowsBoundsForWorkAreaChange(reason);
 }
 
 void WorkspaceLayoutManager::AdjustWindowBoundsForWorkAreaChange(
     wm::WindowState* window_state,
     AdjustWindowReason reason) {
   if (window_state->is_dragged())
     return;
 
   // Do not cross fade here: the window's layer hierarchy may be messed up for
   // the transition between mirroring and extended. See also: crbug.com/267698
   // TODO(oshima): Differentiate display change and shelf visibility change, and
   // bring back CrossFade animation.
   if (window_state->IsMaximized() &&
       reason == ADJUST_WINDOW_WORK_AREA_INSETS_CHANGED) {
     SetChildBoundsDirect(window_state->window(),
-                         ScreenAsh::GetMaximizedWindowBoundsInParent(
+                         ScreenUtil::GetMaximizedWindowBoundsInParent(
                              window_state->window()->parent()->parent()));
     return;
   }
 
   if (SetMaximizedOrFullscreenBounds(window_state))
     return;
 
   gfx::Rect bounds = window_state->window()->bounds();
   switch (reason) {
     case ADJUST_WINDOW_DISPLAY_SIZE_CHANGED:
@@ skipping 24 matching lines @@
     return;
   }
 
   Window* window = window_state->window();
   gfx::Rect bounds = window->bounds();
 
   // Use entire display instead of workarea because the workarea can
   // be further shrunk by the docked area. The logic ensures 30%
   // visibility which should be enough to see where the window gets
   // moved.
-  gfx::Rect display_area = ScreenAsh::GetDisplayBoundsInParent(window);
+  gfx::Rect display_area = ScreenUtil::GetDisplayBoundsInParent(window);
 
   int min_width = bounds.width() * kMinimumPercentOnScreenArea;
   int min_height = bounds.height() * kMinimumPercentOnScreenArea;
   ash::wm::AdjustBoundsToEnsureWindowVisibility(
       display_area, min_width, min_height, &bounds);
   AdjustSnappedBounds(window_state, &bounds);
   if (window->bounds() != bounds)
     window->SetBounds(bounds);
 }
 
@@ skipping 40 matching lines @@
           show_type == wm::SHOW_TYPE_RIGHT_SNAPPED) {
         AdjustSnappedBounds(window_state, &bounds_in_parent);
       } else {
         bounds_in_parent = BaseLayoutManager::BoundsWithScreenEdgeVisible(
             window->parent()->parent(),
             bounds_in_parent);
       }
       break;
 
     case wm::SHOW_TYPE_MAXIMIZED:
-      bounds_in_parent = ScreenAsh::GetMaximizedWindowBoundsInParent(
+      bounds_in_parent = ScreenUtil::GetMaximizedWindowBoundsInParent(
           window->parent()->parent());
       break;
 
     case wm::SHOW_TYPE_FULLSCREEN:
-      bounds_in_parent = ScreenAsh::GetDisplayBoundsInParent(
+      bounds_in_parent = ScreenUtil::GetDisplayBoundsInParent(
           window->parent()->parent());
       break;
 
     case wm::SHOW_TYPE_MINIMIZED:
     case wm::SHOW_TYPE_INACTIVE:
     case wm::SHOW_TYPE_DETACHED:
     case wm::SHOW_TYPE_END:
     case wm::SHOW_TYPE_AUTO_POSITIONED:
       return;
   }
@@ skipping 12 matching lines @@
 
 bool WorkspaceLayoutManager::SetMaximizedOrFullscreenBounds(
     wm::WindowState* window_state) {
   DCHECK(!window_state->is_dragged());
 
   // During animations there is a transform installed on the workspace
   // windows. For this reason this code uses the parent so that the transform is
   // ignored.
   if (window_state->IsMaximized()) {
     SetChildBoundsDirect(
-        window_state->window(), ScreenAsh::GetMaximizedWindowBoundsInParent(
+        window_state->window(), ScreenUtil::GetMaximizedWindowBoundsInParent(
             window_state->window()->parent()->parent()));
     return true;
   }
   if (window_state->IsFullscreen()) {
     SetChildBoundsDirect(
         window_state->window(),
-        ScreenAsh::GetDisplayBoundsInParent(
+        ScreenUtil::GetDisplayBoundsInParent(
             window_state->window()->parent()->parent()));
     return true;
   }
   return false;
 }
 
 void WorkspaceLayoutManager::AdjustSnappedBounds(wm::WindowState* window_state,
                                                  gfx::Rect* bounds) {
   if (window_state->is_dragged() || !window_state->IsSnapped())
     return;
-  gfx::Rect maximized_bounds = ScreenAsh::GetMaximizedWindowBoundsInParent(
+  gfx::Rect maximized_bounds = ScreenUtil::GetMaximizedWindowBoundsInParent(
       window_state->window()->parent()->parent());
   if (window_state->window_show_type() == wm::SHOW_TYPE_LEFT_SNAPPED)
     bounds->set_x(maximized_bounds.x());
   else if (window_state->window_show_type() == wm::SHOW_TYPE_RIGHT_SNAPPED)
     bounds->set_x(maximized_bounds.right() - bounds->width());
   bounds->set_y(maximized_bounds.y());
   // TODO(varkha): Set width to 50% here for snapped windows.
   bounds->set_height(maximized_bounds.height());
 }
 
 void WorkspaceLayoutManager::SetChildBoundsAnimated(Window* child,
                                                     const gfx::Rect& bounds) {
   const int kBoundsChangeSlideDurationMs = 120;
 
   ui::Layer* layer = child->layer();
   ui::ScopedLayerAnimationSettings slide_settings(layer->GetAnimator());
   slide_settings.SetPreemptionStrategy(
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   slide_settings.SetTransitionDuration(
       base::TimeDelta::FromMilliseconds(kBoundsChangeSlideDurationMs));
   SetChildBoundsDirect(child, bounds);
 }
 
 }  // namespace internal
 }  // namespace ash