Rename bounds accessors to be intuitive and consistent

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/ash_switches.h"
 #include "ash/screen_ash.h"
 #include "ash/shell.h"
 #include "ash/wm/shelf_layout_manager.h"
@@ skipping 16 matching lines @@
 // maximized window creates enough space that the resize handles are easily
 // clickable.  We get into this state when updating Chrome OS R18 to R19, as
 // Chrome OS R18 and earlier used only maximized windows and set their restore
 // bounds to the size of the screen.  See crbug.com/108073
 gfx::Rect BoundsWithScreenEdgeVisible(aura::Window* window,
                                       const gfx::Rect& restore_bounds) {
   // If the restore_bounds are more than 1 grid step away from the size the
   // window would be when maximized, inset it.
   int grid_size = ash::Shell::GetInstance()->GetGridSize();
   gfx::Rect max_bounds =
-      ash::ScreenAsh::GetMaximizedWindowParentBounds(window);
+      ash::ScreenAsh::GetMaximizedWindowBoundsInParent(window);
   max_bounds.Inset(grid_size, grid_size);
   if (restore_bounds.Contains(max_bounds))
     return max_bounds;
   return restore_bounds;
 }
 
 }  // namespace
 
 namespace ash {
 namespace internal {
@@ skipping 49 matching lines @@
                        child->GetProperty(internal::kRestoreShowStateKey));
     child->ClearProperty(internal::kRestoreShowStateKey);
   }
 }
 
 void BaseLayoutManager::SetChildBounds(aura::Window* child,
                                        const gfx::Rect& requested_bounds) {
   gfx::Rect child_bounds(requested_bounds);
   // Some windows rely on this to set their initial bounds.
   if (wm::IsWindowMaximized(child))
-    child_bounds = ScreenAsh::GetMaximizedWindowParentBounds(child);
+    child_bounds = ScreenAsh::GetMaximizedWindowBoundsInParent(child);
   else if (wm::IsWindowFullscreen(child))
-    child_bounds = ScreenAsh::GetDisplayParentBounds(child);
+    child_bounds = ScreenAsh::GetDisplayBoundsInParent(child);
   SetChildBoundsDirect(child, child_bounds);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // BaseLayoutManager, RootWindowObserver overrides:
 
 void BaseLayoutManager::OnRootWindowResized(const aura::RootWindow* root,
                                             const gfx::Size& old_size) {
   AdjustWindowSizesForScreenChange();
 }
@@ skipping 67 matching lines @@
                                                          bounds_in_parent));
       }
       window->ClearProperty(aura::client::kRestoreBoundsKey);
       break;
     }
 
     case ui::SHOW_STATE_MAXIMIZED:
       SetRestoreBoundsIfNotSet(window);
       MaybeAnimateToBounds(window,
                            animate,
-                           ScreenAsh::GetMaximizedWindowParentBounds(window));
+                           ScreenAsh::GetMaximizedWindowBoundsInParent(window));
       break;
 
     case ui::SHOW_STATE_FULLSCREEN:
       SetRestoreBoundsIfNotSet(window);
       // Don't animate the full-screen window transition.
       // TODO(jamescook): Use animation here.  Be sure the lock screen works.
       SetChildBoundsDirect(
-          window, ScreenAsh::GetDisplayParentBounds(window));
+          window, ScreenAsh::GetDisplayBoundsInParent(window));
       break;
 
     default:
       break;
   }
 }
 
 void BaseLayoutManager::MaybeAnimateToBounds(aura::Window* window,
                                              bool animate,
                                              const gfx::Rect& new_bounds) {
@@ skipping 14 matching lines @@
   // display size will change.  Maximized windows need to resize to match.
   // We also do this when developers running Aura on a desktop manually resize
   // the host window.
   // We also need to do this when the work area insets changes.
   for (WindowSet::const_iterator it = windows_.begin();
        it != windows_.end();
        ++it) {
     aura::Window* window = *it;
     if (wm::IsWindowMaximized(window)) {
       SetChildBoundsDirect(
-          window, ScreenAsh::GetMaximizedWindowParentBounds(window));
+          window, ScreenAsh::GetMaximizedWindowBoundsInParent(window));
     } else if (wm::IsWindowFullscreen(window)) {
       SetChildBoundsDirect(
-          window, ScreenAsh::GetDisplayParentBounds(window));
+          window, ScreenAsh::GetDisplayBoundsInParent(window));
     } else {
       // The work area may be smaller than the full screen.
       gfx::Rect display_rect =
-          ScreenAsh::GetDisplayWorkAreaParentBounds(window);
+          ScreenAsh::GetDisplayWorkAreaBoundsInParent(window);
       // Put as much of the window as possible within the display area.
       window->SetBounds(window->bounds().AdjustToFit(display_rect));
     }
   }
 }
 
 }  // namespace internal
 }  // namespace ash