CrOS Shelf: Put alignment selection logic in |Shelf| and remove duplicates

Change-Id: I42931af323cbfbd4da06eeb11c93cc06258ba74d
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2025467
Commit-Queue: Alex Newcomer <newcomer@chromium.org>
Reviewed-by: Alex Newcomer <newcomer@chromium.org>
Cr-Commit-Position: refs/heads/master@{#736076}

ash/shelf/shelf.cc

@@ -287,24 +287,6 @@ bool Shelf::IsHorizontalAlignment() const {
   return true;
 }
 
-int Shelf::SelectValueForShelfAlignment(int bottom, int left, int right) const {
-  switch (alignment_) {
-    case ShelfAlignment::kBottom:
-    case ShelfAlignment::kBottomLocked:
-      return bottom;
-    case ShelfAlignment::kLeft:
-      return left;
-    case ShelfAlignment::kRight:
-      return right;
-  }
-  NOTREACHED();
-  return bottom;
-}
-
-int Shelf::PrimaryAxisValue(int horizontal, int vertical) const {
-  return IsHorizontalAlignment() ? horizontal : vertical;
-}
-
 void Shelf::SetAutoHideBehavior(ShelfAutoHideBehavior auto_hide_behavior) {
   DCHECK(shelf_layout_manager_);
 

ash/shelf/shelf.h

@@ -104,10 +104,26 @@ class ASH_EXPORT Shelf : public ShelfLayoutManagerObserver {
   bool IsHorizontalAlignment() const;
 
   // Returns a value based on shelf alignment.
-  int SelectValueForShelfAlignment(int bottom, int left, int right) const;
+  template <typename T>
+  T SelectValueForShelfAlignment(T bottom, T left, T right) const {
+    switch (alignment_) {
+      case ShelfAlignment::kBottom:
+      case ShelfAlignment::kBottomLocked:
+        return bottom;
+      case ShelfAlignment::kLeft:
+        return left;
+      case ShelfAlignment::kRight:
+        return right;
+    }
+    NOTREACHED();
+    return bottom;
+  }
 
   // Returns |horizontal| if shelf is horizontal, otherwise |vertical|.
-  int PrimaryAxisValue(int horizontal, int vertical) const;
+  template <typename T>
+  T PrimaryAxisValue(T horizontal, T vertical) const {
+    return IsHorizontalAlignment() ? horizontal : vertical;
+  }
 
   void SetAutoHideBehavior(ShelfAutoHideBehavior behavior);
 

ash/shelf/shelf_layout_manager.cc

@@ -458,7 +458,7 @@ gfx::Rect ShelfLayoutManager::GetIdealBounds() const {
   const int shelf_size = ShelfConfig::Get()->shelf_size();
   aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
   gfx::Rect rect(screen_util::GetDisplayBoundsInParent(shelf_window));
-  return SelectValueForShelfAlignment(
+  return shelf_->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,
@@ -1603,13 +1603,15 @@ void ShelfLayoutManager::CalculateTargetBounds(
       screen_util::GetDisplayBoundsWithShelf(shelf_widget_->GetNativeWindow());
   available_bounds.Inset(work_area->GetAccessibilityInsets());
 
-  int shelf_width = PrimaryAxisValue(available_bounds.width(), shelf_size);
-  int shelf_height = PrimaryAxisValue(shelf_size, available_bounds.height());
-  const int shelf_primary_position = SelectValueForShelfAlignment(
+  int shelf_width =
+      shelf_->PrimaryAxisValue(available_bounds.width(), shelf_size);
+  int shelf_height =
+      shelf_->PrimaryAxisValue(shelf_size, available_bounds.height());
+  const int shelf_primary_position = shelf_->SelectValueForShelfAlignment(
       available_bounds.bottom() - shelf_in_screen_portion,
       available_bounds.x() - shelf_size + shelf_in_screen_portion,
       available_bounds.right() - shelf_in_screen_portion);
-  gfx::Point shelf_origin = SelectValueForShelfAlignment(
+  gfx::Point shelf_origin = shelf_->SelectValueForShelfAlignment(
       gfx::Point(available_bounds.x(), shelf_primary_position),
       gfx::Point(shelf_primary_position, available_bounds.y()),
       gfx::Point(shelf_primary_position, available_bounds.y()));
@@ -1625,7 +1627,7 @@ void ShelfLayoutManager::CalculateTargetBounds(
   else
     status_size.set_width(shelf_size);
 
-  gfx::Point status_origin = SelectValueForShelfAlignment(
+  gfx::Point status_origin = shelf_->SelectValueForShelfAlignment(
       gfx::Point(0, 0),
       gfx::Point(shelf_width - status_size.width(),
                  shelf_height - status_size.height()),
@@ -1684,7 +1686,7 @@ void ShelfLayoutManager::CalculateTargetBounds(
   if (drag_status_ == kDragInProgress)
     UpdateTargetBoundsForGesture(hotseat_target_state);
 
-  target_bounds_.shelf_insets = SelectValueForShelfAlignment(
+  target_bounds_.shelf_insets = shelf_->SelectValueForShelfAlignment(
       gfx::Insets(0, 0,
                   GetShelfInset(state.visibility_state,
                                 IsHotseatEnabled()
@@ -1698,7 +1700,7 @@ void ShelfLayoutManager::CalculateTargetBounds(
   // that can change the size of the shelf.
   const bool showing_login_shelf = !state.IsActiveSessionState();
   if (chromeos::switches::ShouldShowScrollableShelf() && !showing_login_shelf) {
-    target_bounds_.shelf_bounds_in_shelf = SelectValueForShelfAlignment(
+    target_bounds_.shelf_bounds_in_shelf = shelf_->SelectValueForShelfAlignment(
         gfx::Rect(target_bounds_.nav_bounds_in_shelf.right(), 0,
                   shelf_width - status_size.width() -
                       target_bounds_.nav_bounds_in_shelf.width() -
@@ -1715,7 +1717,7 @@ void ShelfLayoutManager::CalculateTargetBounds(
                       target_bounds_.nav_bounds_in_shelf.height() -
                       home_button_edge_spacing));
   } else {
-    target_bounds_.shelf_bounds_in_shelf = SelectValueForShelfAlignment(
+    target_bounds_.shelf_bounds_in_shelf = shelf_->SelectValueForShelfAlignment(
         gfx::Rect(0, 0, shelf_width - status_size.width(),
                   target_bounds_.shelf_bounds.height()),
         gfx::Rect(0, 0, target_bounds_.shelf_bounds.width(),
@@ -1771,7 +1773,7 @@ void ShelfLayoutManager::UpdateTargetBoundsForGesture(
     // because there should be a linear transition to the home launcher gesture.
     translate = drag_amount_;
   } else {
-    const bool resist = SelectValueForShelfAlignment(
+    const bool resist = shelf_->SelectValueForShelfAlignment(
         drag_amount_<-resistance_free_region, drag_amount_>
             resistance_free_region,
         drag_amount_ < -resistance_free_region);
@@ -1789,7 +1791,7 @@ void ShelfLayoutManager::UpdateTargetBoundsForGesture(
 
   const gfx::Rect available_bounds =
       screen_util::GetDisplayBoundsWithShelf(shelf_widget_->GetNativeWindow());
-  const int baseline = SelectValueForShelfAlignment(
+  const int baseline = shelf_->SelectValueForShelfAlignment(
       available_bounds.bottom() - (shelf_hidden_at_start ? 0 : shelf_size),
       available_bounds.x() - (shelf_hidden_at_start ? shelf_size : 0),
       available_bounds.right() - (shelf_hidden_at_start ? 0 : shelf_size));
@@ -1880,7 +1882,7 @@ gfx::Rect ShelfLayoutManager::GetVisibleShelfBounds() const {
 
 gfx::Rect ShelfLayoutManager::GetAutoHideShowShelfRegionInScreen() const {
   gfx::Rect shelf_bounds_in_screen = GetVisibleShelfBounds();
-  gfx::Vector2d offset = SelectValueForShelfAlignment(
+  gfx::Vector2d offset = shelf_->SelectValueForShelfAlignment(
       gfx::Vector2d(0, shelf_bounds_in_screen.height()),
       gfx::Vector2d(-kMaxAutoHideShowShelfRegionSize, 0),
       gfx::Vector2d(shelf_bounds_in_screen.width(), 0));
@@ -2446,7 +2448,7 @@ void ShelfLayoutManager::UpdateDrag(const ui::LocatedEvent& event_in_screen,
   } else {
     if (drag_start_point_in_screen_ == gfx::Point())
       drag_start_point_in_screen_ = event_in_screen.location();
-    drag_amount_ += PrimaryAxisValue(scroll_y, scroll_x);
+    drag_amount_ += shelf_->PrimaryAxisValue(scroll_y, scroll_x);
     if (event_in_screen.type() == ui::ET_SCROLL_FLING_START) {
       last_drag_velocity_ =
           event_in_screen.AsGestureEvent()->details().velocity_y();

ash/shelf/shelf_layout_manager.h

@@ -268,28 +268,6 @@ class ASH_EXPORT ShelfLayoutManager
     return drag_status_ == kDragAppListInProgress;
   }
 
-  // TODO(harrym|oshima): These templates will be moved to a new Shelf class.
-  // A helper function for choosing values specific to a shelf alignment.
-  template <typename T>
-  T SelectValueForShelfAlignment(T bottom, T left, T right) const {
-    switch (shelf_->alignment()) {
-      case ShelfAlignment::kBottom:
-      case ShelfAlignment::kBottomLocked:
-        return bottom;
-      case ShelfAlignment::kLeft:
-        return left;
-      case ShelfAlignment::kRight:
-        return right;
-    }
-    NOTREACHED();
-    return right;
-  }
-
-  template <typename T>
-  T PrimaryAxisValue(T horizontal, T vertical) const {
-    return shelf_->IsHorizontalAlignment() ? horizontal : vertical;
-  }
-
  private:
   class UpdateShelfObserver;
   friend class DimShelfLayoutManagerTestBase;

ash/shelf/test/shelf_layout_manager_test_base.cc

@@ -74,22 +74,19 @@ class ShelfDragCallback {
     Shelf* shelf = AshTestBase::GetPrimaryShelf();
     gfx::Rect shelf_bounds = GetShelfWidget()->GetWindowBoundsInScreen();
 
-    float scroll_delta =
-        GetShelfLayoutManager()->PrimaryAxisValue(scroll_.y(), scroll_.x());
-    bool increasing_drag =
-        GetShelfLayoutManager()->SelectValueForShelfAlignment(
-            scroll_delta<0, scroll_delta> 0, scroll_delta < 0);
-    const int shelf_size = GetShelfLayoutManager()->PrimaryAxisValue(
-        shelf_bounds.height(), shelf_bounds.width());
+    float scroll_delta = shelf->PrimaryAxisValue(scroll_.y(), scroll_.x());
+    bool increasing_drag = shelf->SelectValueForShelfAlignment(
+        scroll_delta<0, scroll_delta> 0, scroll_delta < 0);
+    const int shelf_size =
+        shelf->PrimaryAxisValue(shelf_bounds.height(), shelf_bounds.width());
     if (was_visible_on_drag_start_) {
       if (increasing_drag) {
         // If dragging inwards from the visible state, then the shelf should
         // 'overshoot', but not by more than the scroll delta.
-        const int bounds_delta =
-            GetShelfLayoutManager()->SelectValueForShelfAlignment(
-                visible_shelf_bounds_.y() - shelf_bounds.y(),
-                shelf_bounds.x() - visible_shelf_bounds_.x(),
-                visible_shelf_bounds_.x() - shelf_bounds.x());
+        const int bounds_delta = shelf->SelectValueForShelfAlignment(
+            visible_shelf_bounds_.y() - shelf_bounds.y(),
+            shelf_bounds.x() - visible_shelf_bounds_.x(),
+            visible_shelf_bounds_.x() - shelf_bounds.x());
         EXPECT_GE(bounds_delta, 0);
         EXPECT_LE(bounds_delta, std::abs(scroll_delta));
       } else {