Clean up some ash constants.

ash/shelf/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/shelf/shelf_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
 #include <vector>
 
@@ skipping 173 matching lines @@
 bool ShelfLayoutManager::IsVisible() const {
   // status_area_widget() may be nullptr during the shutdown.
   return shelf_widget_->status_area_widget() &&
          shelf_widget_->status_area_widget()->IsVisible() &&
          (state_.visibility_state == SHELF_VISIBLE ||
           (state_.visibility_state == SHELF_AUTO_HIDE &&
            state_.auto_hide_state == SHELF_AUTO_HIDE_SHOWN));
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
-  const int shelf_size = GetShelfConstant(SHELF_SIZE);
   WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   gfx::Rect rect(wm::GetDisplayBoundsInParent(shelf_window));
   return SelectValueForShelfAlignment(
-      gfx::Rect(rect.x(), rect.bottom() - shelf_size, rect.width(), shelf_size),
-      gfx::Rect(rect.x(), rect.y(), shelf_size, rect.height()),
-      gfx::Rect(rect.right() - shelf_size, rect.y(), shelf_size,
+      gfx::Rect(rect.x(), rect.bottom() - kShelfSize, rect.width(), kShelfSize),
+      gfx::Rect(rect.x(), rect.y(), kShelfSize, rect.height()),
+      gfx::Rect(rect.right() - kShelfSize, rect.y(), kShelfSize,
                 rect.height()));
 }
 
 gfx::Size ShelfLayoutManager::GetPreferredSize() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   return target_bounds.shelf_bounds_in_root.size();
 }
 
 void ShelfLayoutManager::LayoutShelfAndUpdateBounds(bool change_work_area) {
@@ skipping 441 matching lines @@
     shelf_widget_->status_area_widget()->Show();
 }
 
 void ShelfLayoutManager::StopAnimating() {
   GetLayer(shelf_widget_)->GetAnimator()->StopAnimating();
   GetLayer(shelf_widget_->status_area_widget())->GetAnimator()->StopAnimating();
 }
 
 void ShelfLayoutManager::CalculateTargetBounds(const State& state,
                                                TargetBounds* target_bounds) {
-  int shelf_size = GetShelfConstant(SHELF_SIZE);
+  int shelf_size = kShelfSize;
   if (state.visibility_state == SHELF_AUTO_HIDE &&
       state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN) {
     // Auto-hidden shelf always starts with the default size. If a gesture-drag
     // is in progress, then the call to UpdateTargetBoundsForGesture() below
     // takes care of setting the height properly.
     shelf_size = kShelfAutoHideSize;
   } else if (state.visibility_state == SHELF_HIDDEN ||
              (!keyboard_bounds_.IsEmpty() &&
               !keyboard::IsKeyboardOverscrollEnabled())) {
     shelf_size = 0;
@@ skipping 13 matching lines @@
   gfx::Point shelf_origin = SelectValueForShelfAlignment(
       gfx::Point(available_bounds.x(), bottom_shelf_vertical_offset),
       gfx::Point(available_bounds.x(), available_bounds.y()),
       gfx::Point(available_bounds.right() - shelf_width, available_bounds.y()));
   target_bounds->shelf_bounds_in_root =
       gfx::Rect(shelf_origin.x(), shelf_origin.y(), shelf_width, shelf_height);
 
   gfx::Size status_size(
       shelf_widget_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (wm_shelf_->IsHorizontalAlignment())
-    status_size.set_height(GetShelfConstant(SHELF_SIZE));
+    status_size.set_height(kShelfSize);
   else
-    status_size.set_width(GetShelfConstant(SHELF_SIZE));
+    status_size.set_width(kShelfSize);
 
   gfx::Point status_origin = SelectValueForShelfAlignment(
       gfx::Point(0, 0), gfx::Point(shelf_width - status_size.width(),
                                    shelf_height - status_size.height()),
       gfx::Point(0, shelf_height - status_size.height()));
   if (wm_shelf_->IsHorizontalAlignment() && !base::i18n::IsRTL())
     status_origin.set_x(shelf_width - status_size.width());
   target_bounds->status_bounds_in_shelf = gfx::Rect(status_origin, status_size);
 
   target_bounds->work_area_insets = SelectValueForShelfAlignment(
@@ skipping 53 matching lines @@
   gfx::Rect available_bounds = wm::GetDisplayBoundsWithShelf(window);
   int resistance_free_region = 0;
 
   if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_HIDDEN &&
       visibility_state() == SHELF_AUTO_HIDE &&
       auto_hide_state() != SHELF_AUTO_HIDE_SHOWN) {
     // If the shelf was hidden when the drag started (and the state hasn't
     // changed since then, e.g. because the tray-menu was shown because of the
     // drag), then allow the drag some resistance-free region at first to make
     // sure the shelf sticks with the finger until the shelf is visible.
-    resistance_free_region = GetShelfConstant(SHELF_SIZE) - kShelfAutoHideSize;
+    resistance_free_region = kShelfSize - kShelfAutoHideSize;
   }
 
   bool resist = SelectValueForShelfAlignment(
       gesture_drag_amount_<-resistance_free_region, gesture_drag_amount_>
           resistance_free_region,
       gesture_drag_amount_ < -resistance_free_region);
 
   float translate = 0.f;
   if (resist) {
     float diff = fabsf(gesture_drag_amount_) - resistance_free_region;
     diff = std::min(diff, sqrtf(diff));
     if (gesture_drag_amount_ < 0)
       translate = -resistance_free_region - diff;
     else
       translate = resistance_free_region + diff;
   } else {
     translate = gesture_drag_amount_;
   }
-  int shelf_insets = GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   if (horizontal) {
     // Move and size the shelf with the gesture.
     int shelf_height = target_bounds->shelf_bounds_in_root.height() - translate;
-    shelf_height = std::max(shelf_height, shelf_insets);
+    shelf_height = std::max(shelf_height, 0);
     target_bounds->shelf_bounds_in_root.set_height(shelf_height);
     if (wm_shelf_->IsHorizontalAlignment()) {
       target_bounds->shelf_bounds_in_root.set_y(available_bounds.bottom() -
                                                 shelf_height);
     }
 
     target_bounds->status_bounds_in_shelf.set_y(0);
   } else {
     // Move and size the shelf with the gesture.
     int shelf_width = target_bounds->shelf_bounds_in_root.width();
     bool right_aligned = wm_shelf_->GetAlignment() == SHELF_ALIGNMENT_RIGHT;
     if (right_aligned)
       shelf_width -= translate;
     else
       shelf_width += translate;
-    shelf_width = std::max(shelf_width, shelf_insets);
+    shelf_width = std::max(shelf_width, 0);
     target_bounds->shelf_bounds_in_root.set_width(shelf_width);
     if (right_aligned) {
       target_bounds->shelf_bounds_in_root.set_x(available_bounds.right() -
                                                 shelf_width);
     }
 
     if (right_aligned) {
       target_bounds->status_bounds_in_shelf.set_x(0);
     } else {
       target_bounds->status_bounds_in_shelf.set_x(
-          target_bounds->shelf_bounds_in_root.width() -
-          GetShelfConstant(SHELF_SIZE));
+          target_bounds->shelf_bounds_in_root.width() - kShelfSize);
     }
   }
 }
 
 void ShelfLayoutManager::MaybeUpdateShelfBackground(AnimationChangeType type) {
   const ShelfBackgroundType new_background_type(GetShelfBackgroundType());
 
   if (new_background_type == shelf_background_type_)
     return;
 
@@ skipping 135 matching lines @@
   WmWindow* shelf_window = WmWindow::Get(shelf_widget_->GetNativeWindow());
   WmWindow* status_window =
       WmWindow::Get(shelf_widget_->status_area_widget()->GetNativeWindow());
   return (shelf_window && shelf_window->Contains(window)) ||
          (status_window && status_window->Contains(window));
 }
 
 int ShelfLayoutManager::GetWorkAreaInsets(const State& state, int size) const {
   if (state.visibility_state == SHELF_VISIBLE)
     return size;
-  if (state.visibility_state == SHELF_AUTO_HIDE)
-    return GetShelfConstant(SHELF_INSETS_FOR_AUTO_HIDE);
   return 0;
 }
 
 void ShelfLayoutManager::OnLockStateEvent(LockStateObserver::EventType event) {
   if (event == EVENT_LOCK_ANIMATION_STARTED) {
     // Enter the screen locked state and update the visibility to avoid an odd
     // animation when transitioning the orientation from L/R to bottom.
     state_.pre_lock_screen_animation_active = true;
     UpdateShelfVisibilityAfterLoginUIChange();
   } else {
@@ skipping 151 matching lines @@
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 void ShelfLayoutManager::CancelGestureDrag() {
   gesture_drag_status_ = GESTURE_DRAG_CANCEL_IN_PROGRESS;
   UpdateVisibilityState();
   gesture_drag_status_ = GESTURE_DRAG_NONE;
 }
 
 }  // namespace ash