Remove unused ash::SHELF_ALIGNMENT_TOP

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 <cstring>
 #include <string>
@@ skipping 258 matching lines @@
   if (IsAlignmentLocked())
     return SHELF_ALIGNMENT_BOTTOM;
   return alignment_;
 }
 
 gfx::Rect ShelfLayoutManager::GetIdealBounds() {
   gfx::Rect rect(ScreenUtil::GetDisplayBoundsInParent(shelf_->GetNativeView()));
   return SelectValueForShelfAlignment(
       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::Rect(rect.x(), rect.y(), rect.width(), kShelfSize));
+      gfx::Rect(rect.right() - kShelfSize, rect.y(), kShelfSize,
+                rect.height()));
 }
 
 void ShelfLayoutManager::LayoutShelf() {
   TargetBounds target_bounds;
   CalculateTargetBounds(state_, &target_bounds);
   UpdateBoundsAndOpacity(target_bounds, false, NULL);
 
   if (shelf_->shelf()) {
     // Update insets in ShelfWindowTargeter when shelf bounds change.
     FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
@@ skipping 130 matching lines @@
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = drag_ratio > kDragHideThreshold;
     } else {
       bool correct_direction = false;
       switch (GetAlignment()) {
         case SHELF_ALIGNMENT_BOTTOM:
         case SHELF_ALIGNMENT_RIGHT:
           correct_direction = gesture_drag_amount_ < 0;
           break;
         case SHELF_ALIGNMENT_LEFT:
-        case SHELF_ALIGNMENT_TOP:
           correct_direction = gesture_drag_amount_ > 0;
           break;
       }
       should_change = correct_direction && drag_ratio > kDragHideThreshold;
     }
   } else if (gesture.type() == ui::ET_SCROLL_FLING_START) {
     if (gesture_drag_auto_hide_state_ == SHELF_AUTO_HIDE_SHOWN) {
       should_change = horizontal ? fabs(gesture.details().velocity_y()) > 0 :
                                    fabs(gesture.details().velocity_x()) > 0;
     } else {
-      should_change = SelectValueForShelfAlignment(
-          gesture.details().velocity_y() < 0,
-          gesture.details().velocity_x() > 0,
-          gesture.details().velocity_x() < 0,
-          gesture.details().velocity_y() > 0);
+      should_change =
+          SelectValueForShelfAlignment(gesture.details().velocity_y() < 0,
+                                       gesture.details().velocity_x() > 0,
+                                       gesture.details().velocity_x() < 0);
     }
   } else {
     NOTREACHED();
   }
 
   if (!should_change) {
     CancelGestureDrag();
     return;
   }
   if (shelf_) {
@@ skipping 57 matching lines @@
 }
 
 void ShelfLayoutManager::OnWindowActivated(
     aura::client::ActivationChangeObserver::ActivationReason reason,
     aura::Window* gained_active,
     aura::Window* lost_active) {
   UpdateAutoHideStateNow();
 }
 
 bool ShelfLayoutManager::IsHorizontalAlignment() const {
-  return GetAlignment() == SHELF_ALIGNMENT_BOTTOM ||
-         GetAlignment() == SHELF_ALIGNMENT_TOP;
+  return GetAlignment() == SHELF_ALIGNMENT_BOTTOM;
 }
 
 void ShelfLayoutManager::SetChromeVoxPanelHeight(int height) {
   chromevox_panel_height_ = height;
   LayoutShelf();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfLayoutManager, private:
 
@@ skipping 203 matching lines @@
   int shelf_height = PrimaryAxisValue(shelf_size, available_bounds.height());
   int bottom_shelf_vertical_offset = available_bounds.bottom();
   if (keyboard_bounds_.IsEmpty())
     bottom_shelf_vertical_offset -= shelf_height;
   else
     bottom_shelf_vertical_offset -= keyboard_bounds_.height();
 
   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()),
-      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_->status_area_widget()->GetWindowBoundsInScreen().size());
   if (IsHorizontalAlignment())
     status_size.set_height(kShelfSize);
   else
     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()),
       gfx::Point(0, shelf_height - status_size.height()));
   if (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(
       gfx::Insets(0, 0, GetWorkAreaSize(state, shelf_height), 0),
       gfx::Insets(0, GetWorkAreaSize(state, shelf_width), 0, 0),
-      gfx::Insets(0, 0, 0, GetWorkAreaSize(state, shelf_width)),
-      gfx::Insets(GetWorkAreaSize(state, shelf_height), 0, 0, 0));
+      gfx::Insets(0, 0, 0, GetWorkAreaSize(state, shelf_width)));
 
   // TODO(varkha): The functionality of managing insets for display areas
   // should probably be pushed to a separate component. This would simplify or
   // remove entirely the dependency on keyboard and dock.
 
   if (!keyboard_bounds_.IsEmpty() && !keyboard::IsKeyboardOverscrollEnabled()) {
     // Also push in the work area inset for the keyboard if it is visible.
     gfx::Insets keyboard_insets(0, 0, keyboard_bounds_.height(), 0);
     target_bounds->work_area_insets += keyboard_insets;
   }
@@ skipping 21 matching lines @@
        state.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
        gesture_drag_status_ != GESTURE_DRAG_IN_PROGRESS) ?
       0.0f : target_bounds->opacity;
 
   if (gesture_drag_status_ == GESTURE_DRAG_IN_PROGRESS)
     UpdateTargetBoundsForGesture(target_bounds);
 
   // This needs to happen after calling UpdateTargetBoundsForGesture(), because
   // that can change the size of the shelf.
   target_bounds->shelf_bounds_in_shelf = SelectValueForShelfAlignment(
-      gfx::Rect(0, 0,
-                shelf_width - status_size.width(),
+      gfx::Rect(0, 0, shelf_width - status_size.width(),
                 target_bounds->shelf_bounds_in_root.height()),
       gfx::Rect(0, 0, target_bounds->shelf_bounds_in_root.width(),
                 shelf_height - status_size.height()),
       gfx::Rect(0, 0, target_bounds->shelf_bounds_in_root.width(),
-                shelf_height - status_size.height()),
-      gfx::Rect(0, 0,
-                shelf_width - status_size.width(),
-                target_bounds->shelf_bounds_in_root.height()));
+                shelf_height - status_size.height()));
 
   available_bounds.Subtract(target_bounds->shelf_bounds_in_root);
   available_bounds.Subtract(keyboard_bounds_);
   user_work_area_bounds_ =
       ScreenUtil::ConvertRectToScreen(root_window_, available_bounds);
 }
 
 void ShelfLayoutManager::UpdateTargetBoundsForGesture(
     TargetBounds* target_bounds) const {
   CHECK_EQ(GESTURE_DRAG_IN_PROGRESS, gesture_drag_status_);
   bool horizontal = IsHorizontalAlignment();
   gfx::Rect available_bounds =
       ScreenUtil::GetShelfDisplayBoundsInRoot(root_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 = kShelfSize - kAutoHideSize;
   }
 
   bool resist = SelectValueForShelfAlignment(
       gesture_drag_amount_ < -resistance_free_region,
       gesture_drag_amount_ > resistance_free_region,
-      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 {
@@ skipping 69 matching lines @@
 void ShelfLayoutManager::StopAutoHideTimer() {
   auto_hide_timer_.Stop();
   mouse_over_shelf_when_auto_hide_timer_started_ = false;
 }
 
 gfx::Rect ShelfLayoutManager::GetAutoHideShowShelfRegionInScreen() const {
   gfx::Rect shelf_bounds_in_screen = shelf_->GetWindowBoundsInScreen();
   gfx::Vector2d offset = SelectValueForShelfAlignment(
       gfx::Vector2d(0, shelf_bounds_in_screen.height()),
       gfx::Vector2d(-kMaxAutoHideShowShelfRegionSize, 0),
-      gfx::Vector2d(shelf_bounds_in_screen.width(), 0),
-      gfx::Vector2d(0, -kMaxAutoHideShowShelfRegionSize));
+      gfx::Vector2d(shelf_bounds_in_screen.width(), 0));
 
   gfx::Rect show_shelf_region_in_screen = shelf_bounds_in_screen;
   show_shelf_region_in_screen += offset;
   if (IsHorizontalAlignment())
     show_shelf_region_in_screen.set_height(kMaxAutoHideShowShelfRegionSize);
   else
     show_shelf_region_in_screen.set_width(kMaxAutoHideShowShelfRegionSize);
 
   // TODO: Figure out if we need any special handling when the keyboard is
   // visible.
@@ skipping 62 matching lines @@
   if (!cursor_client->IsMouseEventsEnabled())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   gfx::Rect shelf_region = shelf_->GetWindowBoundsInScreen();
   if (shelf_->status_area_widget() &&
       shelf_->status_area_widget()->IsMessageBubbleShown() &&
       IsVisible()) {
     // Increase the the hit test area to prevent the shelf from disappearing
     // when the mouse is over the bubble gap.
     ShelfAlignment alignment = GetAlignment();
-    shelf_region.Inset(alignment == SHELF_ALIGNMENT_RIGHT ?
-                           -kNotificationBubbleGapHeight : 0,
-                       alignment == SHELF_ALIGNMENT_BOTTOM ?
-                           -kNotificationBubbleGapHeight : 0,
-                       alignment == SHELF_ALIGNMENT_LEFT ?
-                           -kNotificationBubbleGapHeight : 0,
-                       alignment == SHELF_ALIGNMENT_TOP ?
-                           -kNotificationBubbleGapHeight : 0);
+    shelf_region.Inset(
+        alignment == SHELF_ALIGNMENT_RIGHT ? -kNotificationBubbleGapHeight : 0,
+        alignment == SHELF_ALIGNMENT_BOTTOM ? -kNotificationBubbleGapHeight : 0,
+        alignment == SHELF_ALIGNMENT_LEFT ? -kNotificationBubbleGapHeight : 0,
+        0);
   }
 
   gfx::Point cursor_position_in_screen =
       gfx::Screen::GetScreen()->GetCursorScreenPoint();
   if (shelf_region.Contains(cursor_position_in_screen))
     return SHELF_AUTO_HIDE_SHOWN;
 
   // When the shelf is auto hidden and the shelf is on the boundary between two
   // displays, it is hard to trigger showing the shelf. For instance, if a
   // user's primary display is left of their secondary display, it is hard to
@@ skipping 112 matching lines @@
     return false;
   }
   if (session_state_delegate->IsUserSessionBlocked() ||
       state_.is_adding_user_screen) {
     return true;
   }
   return false;
 }
 
 }  // namespace ash