Rename bounds accessors to be intuitive and consistent

ash/wm/shelf_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/shelf_layout_manager.h"
 
 #include <algorithm>
 
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
@@ skipping 164 matching lines @@
       Shell::GetInstance()->status_area_widget();
   if (status_area_widget)
     Shell::GetInstance()->status_area_widget()->SetShelfAlignment(alignment);
   LayoutShelf();
   return true;
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   // TODO(oshima): this is wrong. Figure out what display shelf is on
   // and everything should be based on it.
-  gfx::Rect bounds(ScreenAsh::GetDisplayParentBounds(
+  gfx::Rect bounds(ScreenAsh::GetDisplayBoundsInParent(
       status_->GetNativeView()));
   int width = 0, height = 0;
   GetShelfSize(&width, &height);
   switch (alignment_) {
     case SHELF_ALIGNMENT_BOTTOM:
       return gfx::Rect(bounds.x(), bounds.bottom() - height,
                        bounds.width(), height);
     case SHELF_ALIGNMENT_LEFT:
       return gfx::Rect(bounds.x(), bounds.y(), width, bounds.height());
     case SHELF_ALIGNMENT_RIGHT:
@@ skipping 120 matching lines @@
 void ShelfLayoutManager::OnWindowActivated(aura::Window* active,
                                            aura::Window* old_active) {
   UpdateAutoHideStateNow();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
 gfx::Rect ShelfLayoutManager::GetMaximizedWindowBounds(
     aura::Window* window) {
-  gfx::Rect bounds(ScreenAsh::GetDisplayParentBounds(window));
+  gfx::Rect bounds(ScreenAsh::GetDisplayBoundsInParent(window));
   if (auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_DEFAULT ||
       auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) {
     AdjustBoundsBasedOnAlignment(kAutoHideSize, &bounds);
     return bounds;
   }
   // SHELF_AUTO_HIDE_BEHAVIOR_NEVER maximized windows don't get any taller.
   return GetUnmaximizedWorkAreaBounds(window);
 }
 
 gfx::Rect ShelfLayoutManager::GetUnmaximizedWorkAreaBounds(
     aura::Window* window) {
-  gfx::Rect bounds(ScreenAsh::GetDisplayParentBounds(window));
+  gfx::Rect bounds(ScreenAsh::GetDisplayBoundsInParent(window));
   int size;
   if (auto_hide_behavior_ == SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS) {
     size = kAutoHideSize;
   } else {
     int width, height;
     GetShelfSize(&width, &height);
     size = std::max(width, height);
   }
   AdjustBoundsBasedOnAlignment(size, &bounds);
   return bounds;
@@ skipping 59 matching lines @@
 }
 
 void ShelfLayoutManager::StopAnimating() {
   if (launcher_widget())
     GetLayer(launcher_widget())->GetAnimator()->StopAnimating();
   GetLayer(status_)->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::GetShelfSize(int* width, int* height) {
   *width = *height = 0;
-  gfx::Rect status_bounds(status_->GetWindowScreenBounds());
+  gfx::Rect status_bounds(status_->GetWindowBoundsInScreen());
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
   if (alignment_ == SHELF_ALIGNMENT_BOTTOM)
     *height = std::max(launcher_size.height(), status_bounds.height());
   else
     *width = std::max(launcher_size.width(), status_bounds.width());
 }
 
 void ShelfLayoutManager::AdjustBoundsBasedOnAlignment(int inset,
                                                       gfx::Rect* bounds) const {
   switch (alignment_) {
     case SHELF_ALIGNMENT_BOTTOM:
       bounds->Inset(gfx::Insets(0, 0, inset, 0));
       break;
     case SHELF_ALIGNMENT_LEFT:
       bounds->Inset(gfx::Insets(0, inset, 0, 0));
       break;
     case SHELF_ALIGNMENT_RIGHT:
       bounds->Inset(gfx::Insets(0, 0, 0, inset));
       break;
   }
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(
     const State& state,
     TargetBounds* target_bounds) {
   const gfx::Rect& available_bounds(
       status_->GetNativeView()->GetRootWindow()->bounds());
-  gfx::Rect status_bounds(status_->GetWindowScreenBounds());
+  gfx::Rect status_bounds(status_->GetWindowBoundsInScreen());
   gfx::Size launcher_size = launcher_ ?
       launcher_widget()->GetContentsView()->GetPreferredSize() : gfx::Size();
   int shelf_size = 0;
   int shelf_width = 0, shelf_height = 0;
   GetShelfSize(&shelf_width, &shelf_height);
   if (state.visibility_state == VISIBLE ||
       (state.visibility_state == AUTO_HIDE &&
        state.auto_hide_state == AUTO_HIDE_SHOWN)) {
     shelf_size = std::max(shelf_width, shelf_height);
   } else if (state.visibility_state == AUTO_HIDE &&
@@ skipping 87 matching lines @@
 
   if (launcher_widget()->IsActive() || status_->IsActive())
     return AUTO_HIDE_SHOWN;
 
   // Don't show if the user is dragging the mouse.
   if (event_filter_.get() && event_filter_->in_mouse_drag())
     return AUTO_HIDE_HIDDEN;
 
   aura::RootWindow* root = launcher_widget()->GetNativeView()->GetRootWindow();
   bool mouse_over_launcher =
-      launcher_widget()->GetWindowScreenBounds().Contains(
+      launcher_widget()->GetWindowBoundsInScreen().Contains(
           root->last_mouse_location());
   return mouse_over_launcher ? AUTO_HIDE_SHOWN : AUTO_HIDE_HIDDEN;
 }
 
 void ShelfLayoutManager::UpdateHitTestBounds() {
   gfx::Insets insets;
   // Only modify the hit test when the shelf is visible, so we don't mess with
   // hover hit testing in the auto-hide state.
   if (state_.visibility_state == VISIBLE) {
     // Let clicks at the very top of the launcher through so windows can be
@@ skipping 27 matching lines @@
 int ShelfLayoutManager::GetWorkAreaSize(const State& state, int size) const {
   if (state.visibility_state == VISIBLE)
     return size;
   if (state.visibility_state == AUTO_HIDE)
     return kAutoHideSize;
   return 0;
 }
 
 }  // namespace internal
 }  // namespace ash