[Cleanup] Screen cleanup

ash/wm/base_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/base_layout_manager.h"
 
-#include "ash/screen_ash.h"
+#include "ash/screen_util.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shell.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/aura_constants.h"
@@ skipping 24 matching lines @@
     (*i)->RemoveObserver(this);
   Shell::GetInstance()->RemoveShellObserver(this);
   Shell::GetInstance()->activation_client()->RemoveObserver(this);
 }
 
 // static
 gfx::Rect BaseLayoutManager::BoundsWithScreenEdgeVisible(
     aura::Window* window,
     const gfx::Rect& restore_bounds) {
   gfx::Rect max_bounds =
-      ash::ScreenAsh::GetMaximizedWindowBoundsInParent(window);
+      ash::ScreenUtil::GetMaximizedWindowBoundsInParent(window);
   // If the restore_bounds are more than 1 grid step away from the size the
   // window would be when maximized, inset it.
   max_bounds.Inset(ash::internal::WorkspaceWindowResizer::kScreenEdgeInset,
                    ash::internal::WorkspaceWindowResizer::kScreenEdgeInset);
   if (restore_bounds.Contains(max_bounds))
     return max_bounds;
   return restore_bounds;
 }
 
 /////////////////////////////////////////////////////////////////////////////
@@ skipping 30 matching lines @@
   if (visible && window_state->IsMinimized())
     window_state->Unminimize();
 }
 
 void BaseLayoutManager::SetChildBounds(aura::Window* child,
                                        const gfx::Rect& requested_bounds) {
   gfx::Rect child_bounds(requested_bounds);
   wm::WindowState* window_state = wm::GetWindowState(child);
   // Some windows rely on this to set their initial bounds.
   if (window_state->IsMaximized())
-    child_bounds = ScreenAsh::GetMaximizedWindowBoundsInParent(child);
+    child_bounds = ScreenUtil::GetMaximizedWindowBoundsInParent(child);
   else if (window_state->IsFullscreen())
-    child_bounds = ScreenAsh::GetDisplayBoundsInParent(child);
+    child_bounds = ScreenUtil::GetDisplayBoundsInParent(child);
   SetChildBoundsDirect(child, child_bounds);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, aura::WindowObserver overrides:
 
 void BaseLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (root_window_ == window) {
     root_window_->RemoveObserver(this);
     root_window_ = NULL;
@@ skipping 98 matching lines @@
     AdjustWindowBoundsForWorkAreaChange(wm::GetWindowState(*it), reason);
   }
 }
 
 void BaseLayoutManager::AdjustWindowBoundsForWorkAreaChange(
     wm::WindowState* window_state,
     AdjustWindowReason reason) {
   aura::Window* window = window_state->window();
   if (window_state->IsMaximized()) {
     SetChildBoundsDirect(
-        window, ScreenAsh::GetMaximizedWindowBoundsInParent(window));
+        window, ScreenUtil::GetMaximizedWindowBoundsInParent(window));
   } else if (window_state->IsFullscreen()) {
     SetChildBoundsDirect(
-        window, ScreenAsh::GetDisplayBoundsInParent(window));
+        window, ScreenUtil::GetDisplayBoundsInParent(window));
   } else {
     // The work area may be smaller than the full screen.
     gfx::Rect display_rect =
-        ScreenAsh::GetDisplayWorkAreaBoundsInParent(window);
+        ScreenUtil::GetDisplayWorkAreaBoundsInParent(window);
     // Put as much of the window as possible within the display area.
     gfx::Rect bounds = window->bounds();
     bounds.AdjustToFit(display_rect);
     window->SetBounds(bounds);
   }
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, private:
 
@@ skipping 14 matching lines @@
 
     case wm::SHOW_TYPE_LEFT_SNAPPED:
     case wm::SHOW_TYPE_RIGHT_SNAPPED:
       if (window_state->HasRestoreBounds())
         SetChildBoundsDirect(window, window_state->GetRestoreBoundsInParent());
       window_state->ClearRestoreBounds();
       break;
 
     case wm::SHOW_TYPE_MAXIMIZED:
       SetChildBoundsDirect(
-          window, ScreenAsh::GetMaximizedWindowBoundsInParent(window));
+          window, ScreenUtil::GetMaximizedWindowBoundsInParent(window));
       break;
 
     case wm::SHOW_TYPE_FULLSCREEN:
       // Don't animate the full-screen window transition.
       // TODO(jamescook): Use animation here.  Be sure the lock screen works.
       SetChildBoundsDirect(window,
-                           ScreenAsh::GetDisplayBoundsInParent(window));
+                           ScreenUtil::GetDisplayBoundsInParent(window));
       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:
       break;
   }
 }
 
 }  // namespace internal
 }  // namespace ash