Cleanup ash shelf accessor functions.

ash/shelf/shelf_view.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_view.h"
 
 #include <algorithm>
 
 #include "ash/ash_constants.h"
 #include "ash/ash_switches.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/metrics/user_metrics_recorder.h"
-#include "ash/root_window_controller.h"
 #include "ash/scoped_target_root_window.h"
 #include "ash/shelf/app_list_button.h"
 #include "ash/shelf/overflow_bubble.h"
 #include "ash/shelf/overflow_bubble_view.h"
 #include "ash/shelf/overflow_button.h"
+#include "ash/shelf/shelf.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_delegate.h"
 #include "ash/shelf/shelf_icon_observer.h"
 #include "ash/shelf/shelf_item_delegate_manager.h"
-#include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_menu_model.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "base/auto_reset.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "grit/ash_strings.h"
@@ skipping 321 matching lines @@
     view_->layer()->SetOpacity(1.0f);
   }
 
  private:
   ShelfView* shelf_view_;
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
-ShelfView::ShelfView(ShelfModel* model,
-                     ShelfDelegate* delegate,
-                     ShelfLayoutManager* manager)
+ShelfView::ShelfView(ShelfModel* model, ShelfDelegate* delegate, Shelf* shelf)
     : model_(model),
       delegate_(delegate),
+      shelf_(shelf),
       view_model_(new views::ViewModel),
       first_visible_index_(0),
       last_visible_index_(-1),
       overflow_button_(NULL),
       owner_overflow_bubble_(NULL),
       drag_pointer_(NONE),
       drag_view_(NULL),
       start_drag_index_(-1),
       context_menu_id_(0),
       leading_inset_(kDefaultLeadingInset),
       cancelling_drag_model_changed_(false),
       last_hidden_index_(0),
       closing_event_time_(base::TimeDelta()),
       got_deleted_(NULL),
       drag_and_drop_item_pinned_(false),
       drag_and_drop_shelf_id_(0),
       drag_replaced_view_(nullptr),
       dragged_off_shelf_(false),
       snap_back_from_rip_off_view_(NULL),
       item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
-      layout_manager_(manager),
       overflow_mode_(false),
       main_shelf_(NULL),
       dragged_off_from_overflow_to_shelf_(false),
       is_repost_event_(false),
       last_pressed_index_(-1) {
   DCHECK(model_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
-  tooltip_.reset(new ShelfTooltipManager(manager, this));
+  tooltip_.reset(new ShelfTooltipManager(shelf->shelf_layout_manager(), this));
 }
 
 ShelfView::~ShelfView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
   // If we are inside the MenuRunner, we need to know if we were getting
   // deleted while it was running.
   if (got_deleted_)
     *got_deleted_ = true;
 }
 
 void ShelfView::Init() {
   model_->AddObserver(this);
 
   const ShelfItems& items(model_->items());
   for (ShelfItems::const_iterator i = items.begin(); i != items.end(); ++i) {
     views::View* child = CreateViewForItem(*i);
     child->SetPaintToLayer(true);
     view_model_->Add(child, static_cast<int>(i - items.begin()));
     AddChildView(child);
   }
-  overflow_button_ = new OverflowButton(this, shelf_layout_manager());
+  overflow_button_ = new OverflowButton(this, shelf_);
   overflow_button_->set_context_menu_controller(this);
   ConfigureChildView(overflow_button_);
   AddChildView(overflow_button_);
 
   // We'll layout when our bounds change.
 }
 
 void ShelfView::OnShelfAlignmentChanged() {
   overflow_button_->OnShelfAlignmentChanged();
   LayoutToIdealBounds();
@@ skipping 44 matching lines @@
                                         const gfx::Point& midpoint) {
   int current_index = model_->ItemIndexByID(id);
   int first_panel_index = model_->FirstPanelIndex();
   if (current_index < first_panel_index)
     return;
 
   gfx::Point midpoint_in_view(GetMirroredXInView(midpoint.x()),
                               midpoint.y());
   int target_index = current_index;
   while (target_index > first_panel_index &&
-         layout_manager_->PrimaryAxisValue(
-             view_model_->ideal_bounds(target_index).x(),
-             view_model_->ideal_bounds(target_index).y()) >
-         layout_manager_->PrimaryAxisValue(midpoint_in_view.x(),
-                                           midpoint_in_view.y())) {
+         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
+                                  view_model_->ideal_bounds(target_index).y()) >
+             shelf_->PrimaryAxisValue(midpoint_in_view.x(),
+                                      midpoint_in_view.y())) {
     --target_index;
   }
   while (target_index < view_model_->view_size() - 1 &&
-         layout_manager_->PrimaryAxisValue(
+         shelf_->PrimaryAxisValue(
              view_model_->ideal_bounds(target_index).right(),
              view_model_->ideal_bounds(target_index).bottom()) <
-         layout_manager_->PrimaryAxisValue(midpoint_in_view.x(),
-                                           midpoint_in_view.y())) {
+             shelf_->PrimaryAxisValue(midpoint_in_view.x(),
+                                      midpoint_in_view.y())) {
     ++target_index;
   }
   if (current_index != target_index)
     model_->Move(current_index, target_index);
 }
 
 bool ShelfView::IsShowingMenu() const {
   return (launcher_menu_runner_.get() &&
        launcher_menu_runner_->IsRunning());
 }
@@ skipping 191 matching lines @@
     // should be always true regardless of its position.
     if (dragged_off_from_overflow_to_shelf_ &&
         view_model_->view_at(i) == drag_view_)
       view_model_->view_at(i)->SetVisible(true);
     else
       view_model_->view_at(i)->SetVisible(visible);
   }
 }
 
 void ShelfView::CalculateIdealBounds(IdealBounds* bounds) const {
-  int available_size = layout_manager_->PrimaryAxisValue(width(), height());
+  int available_size = shelf_->PrimaryAxisValue(width(), height());
   DCHECK(model_->item_count() == view_model_->view_size());
   if (!available_size)
     return;
 
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
   int x = 0;
   int y = 0;
   int button_size = kShelfButtonSize;
   int button_spacing = kShelfButtonSpacing;
 
-  int w = layout_manager_->PrimaryAxisValue(button_size, width());
-  int h = layout_manager_->PrimaryAxisValue(height(), button_size);
+  int w = shelf_->PrimaryAxisValue(button_size, width());
+  int h = shelf_->PrimaryAxisValue(height(), button_size);
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i < first_visible_index_) {
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, 0, 0));
       continue;
     }
 
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
-    x = layout_manager_->PrimaryAxisValue(x + w + button_spacing, x);
-    y = layout_manager_->PrimaryAxisValue(y, y + h + button_spacing);
+    x = shelf_->PrimaryAxisValue(x + w + button_spacing, x);
+    y = shelf_->PrimaryAxisValue(y, y + h + button_spacing);
   }
 
   if (is_overflow_mode()) {
     const_cast<ShelfView*>(this)->UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
   // Right aligned icons.
   int end_position = available_size - button_spacing;
-  x = layout_manager_->PrimaryAxisValue(end_position, 0);
-  y = layout_manager_->PrimaryAxisValue(0, end_position);
+  x = shelf_->PrimaryAxisValue(end_position, 0);
+  y = shelf_->PrimaryAxisValue(0, end_position);
   for (int i = view_model_->view_size() - 1;
        i >= first_panel_index; --i) {
-    x = layout_manager_->PrimaryAxisValue(x - w - button_spacing, x);
-    y = layout_manager_->PrimaryAxisValue(y, y - h - button_spacing);
+    x = shelf_->PrimaryAxisValue(x - w - button_spacing, x);
+    y = shelf_->PrimaryAxisValue(y, y - h - button_spacing);
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
-    end_position = layout_manager_->PrimaryAxisValue(x, y);
+    end_position = shelf_->PrimaryAxisValue(x, y);
   }
 
   // Icons on the left / top are guaranteed up to kLeftIconProportion of
   // the available space.
-  int last_icon_position = layout_manager_->PrimaryAxisValue(
-      view_model_->ideal_bounds(last_button_index).right(),
-      view_model_->ideal_bounds(last_button_index).bottom()) + button_size;
+  int last_icon_position =
+      shelf_->PrimaryAxisValue(
+          view_model_->ideal_bounds(last_button_index).right(),
+          view_model_->ideal_bounds(last_button_index).bottom()) +
+      button_size;
   int reserved_icon_space = available_size * kReservedNonPanelIconProportion;
   if (last_icon_position < reserved_icon_space)
     end_position = last_icon_position;
   else
     end_position = std::max(end_position, reserved_icon_space);
 
   bounds->overflow_bounds.set_size(
-      gfx::Size(layout_manager_->PrimaryAxisValue(w, width()),
-                layout_manager_->PrimaryAxisValue(height(), h)));
+      gfx::Size(shelf_->PrimaryAxisValue(w, width()),
+                shelf_->PrimaryAxisValue(height(), h)));
 
   last_visible_index_ = DetermineLastVisibleIndex(
       end_position - button_size);
   last_hidden_index_ = DetermineFirstVisiblePanelIndex(end_position) - 1;
   bool show_overflow = last_visible_index_ < last_button_index ||
       last_hidden_index_ >= first_panel_index;
 
   // Create Space for the overflow button
   if (show_overflow) {
     // The following code makes sure that platform apps icons (aligned to left /
@@ skipping 27 matching lines @@
     view_model_->view_at(i)->SetVisible(visible);
   }
 
   overflow_button_->SetVisible(show_overflow);
   if (show_overflow) {
     DCHECK_NE(0, view_model_->view_size());
     if (last_visible_index_ == -1) {
       x = 0;
       y = 0;
     } else {
-      x = layout_manager_->PrimaryAxisValue(
+      x = shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).right(),
           view_model_->ideal_bounds(last_visible_index_).x());
-      y = layout_manager_->PrimaryAxisValue(
+      y = shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).y(),
           view_model_->ideal_bounds(last_visible_index_).bottom());
     }
     // Set all hidden panel icon positions to be on the overflow button.
     for (int i = first_panel_index; i <= last_hidden_index_; ++i)
       view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
 
     // Add more space between last visible item and overflow button.
     // Without this, two buttons look too close compared with other items.
-    x = layout_manager_->PrimaryAxisValue(x + button_spacing, x);
-    y = layout_manager_->PrimaryAxisValue(y, y + button_spacing);
+    x = shelf_->PrimaryAxisValue(x + button_spacing, x);
+    y = shelf_->PrimaryAxisValue(y, y + button_spacing);
 
     bounds->overflow_bounds.set_x(x);
     bounds->overflow_bounds.set_y(y);
     if (overflow_bubble_.get() && overflow_bubble_->IsShowing())
       UpdateOverflowRange(overflow_bubble_->shelf_view());
   } else {
     if (overflow_bubble_)
       overflow_bubble_->Hide();
   }
 }
 
 int ShelfView::DetermineLastVisibleIndex(int max_value) const {
   int index = model_->FirstPanelIndex() - 1;
   while (index >= 0 &&
-         layout_manager_->PrimaryAxisValue(
-             view_model_->ideal_bounds(index).right(),
-             view_model_->ideal_bounds(index).bottom()) > max_value) {
+         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).right(),
+                                  view_model_->ideal_bounds(index).bottom()) >
+             max_value) {
     index--;
   }
   return index;
 }
 
 int ShelfView::DetermineFirstVisiblePanelIndex(int min_value) const {
   int index = model_->FirstPanelIndex();
   while (index < view_model_->view_size() &&
-         layout_manager_->PrimaryAxisValue(
-             view_model_->ideal_bounds(index).right(),
-             view_model_->ideal_bounds(index).bottom()) < min_value) {
+         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).right(),
+                                  view_model_->ideal_bounds(index).bottom()) <
+             min_value) {
     ++index;
   }
   return index;
 }
 
 void ShelfView::AddIconObserver(ShelfIconObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void ShelfView::RemoveIconObserver(ShelfIconObserver* observer) {
@@ skipping 16 matching lines @@
 
 views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
   views::View* view = NULL;
   switch (item.type) {
     case TYPE_BROWSER_SHORTCUT:
     case TYPE_APP_SHORTCUT:
     case TYPE_WINDOWED_APP:
     case TYPE_PLATFORM_APP:
     case TYPE_DIALOG:
     case TYPE_APP_PANEL: {
-      ShelfButton* button = ShelfButton::Create(this, this, layout_manager_);
+      ShelfButton* button = ShelfButton::Create(this, this, shelf_);
       button->SetImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_LIST: {
-      view = new AppListButton(this, this, layout_manager_->shelf_widget());
+      view = new AppListButton(this, this, shelf_->shelf_widget());
       break;
     }
 
     default:
       break;
   }
   view->set_context_menu_controller(this);
 
   DCHECK(view);
   ConfigureChildView(view);
@@ skipping 63 matching lines @@
   // Constrain the location to the range of valid indices for the type.
   std::pair<int, int> indices(GetDragRange(current_index));
   int first_drag_index = indices.first;
   int last_drag_index = indices.second;
   // If the last index isn't valid, we're overflowing. Constrain to the app list
   // (which is the last visible item).
   if (first_drag_index < model_->FirstPanelIndex() &&
       last_drag_index > last_visible_index_)
     last_drag_index = last_visible_index_;
   int x = 0, y = 0;
-  if (layout_manager_->IsHorizontalAlignment()) {
+  if (shelf_->IsHorizontalAlignment()) {
     x = std::max(view_model_->ideal_bounds(indices.first).x(),
                      drag_point.x() - drag_origin_.x());
     x = std::min(view_model_->ideal_bounds(last_drag_index).right() -
                  view_model_->ideal_bounds(current_index).width(),
                  x);
     if (drag_view_->x() == x)
       return;
     drag_view_->SetX(x);
   } else {
     y = std::max(view_model_->ideal_bounds(indices.first).y(),
                      drag_point.y() - drag_origin_.y());
     y = std::min(view_model_->ideal_bounds(last_drag_index).bottom() -
                  view_model_->ideal_bounds(current_index).height(),
                  y);
     if (drag_view_->y() == y)
       return;
     drag_view_->SetY(y);
   }
 
-  int target_index =
-      views::ViewModelUtils::DetermineMoveIndex(
-          *view_model_, drag_view_,
-          layout_manager_->IsHorizontalAlignment() ?
-              views::ViewModelUtils::HORIZONTAL :
-              views::ViewModelUtils::VERTICAL,
-          x, y);
+  int target_index = views::ViewModelUtils::DetermineMoveIndex(
+      *view_model_, drag_view_,
+      shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
+                                      : views::ViewModelUtils::VERTICAL,
+      x, y);
   target_index =
       std::min(indices.second, std::max(target_index, indices.first));
 
   int first_draggable_item = 0;
   while (first_draggable_item < static_cast<int>(model_->items().size()) &&
          !item_manager_->GetShelfItemDelegate(
                            model_->items()[first_draggable_item].id)
               ->IsDraggable()) {
     first_draggable_item++;
   }
@@ skipping 226 matching lines @@
 
 void ShelfView::ToggleOverflowBubble() {
   if (IsShowingOverflowBubble()) {
     overflow_bubble_->Hide();
     return;
   }
 
   if (!overflow_bubble_)
     overflow_bubble_.reset(new OverflowBubble());
 
-  ShelfView* overflow_view =
-      new ShelfView(model_, delegate_, layout_manager_);
+  ShelfView* overflow_view = new ShelfView(model_, delegate_, shelf_);
   overflow_view->overflow_mode_ = true;
   overflow_view->Init();
   overflow_view->set_owner_overflow_bubble(overflow_bubble_.get());
   overflow_view->OnShelfAlignmentChanged();
   overflow_view->main_shelf_ = this;
   UpdateOverflowRange(overflow_view);
 
   overflow_bubble_->Show(overflow_button_, overflow_view);
 
   Shell::GetInstance()->UpdateShelfVisibility();
@@ skipping 62 matching lines @@
     const int last_button_index = view_model_->view_size() - 1;
     gfx::Rect last_button_bounds =
         view_model_->view_at(last_button_index)->bounds();
     if (overflow_button_->visible() &&
         model_->GetItemIndexForType(TYPE_APP_PANEL) == -1) {
       // When overflow button is visible and shelf has no panel items,
       // last_button_bounds should be overflow button's bounds.
       last_button_bounds = overflow_button_->bounds();
     }
 
-    if (layout_manager_->IsHorizontalAlignment()) {
+    if (shelf_->IsHorizontalAlignment()) {
       preferred_size = gfx::Size(last_button_bounds.right() + leading_inset_,
                                  kShelfSize);
     } else {
       preferred_size = gfx::Size(kShelfSize,
                                  last_button_bounds.bottom() + leading_inset_);
     }
   }
   gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
 
   // In overflow mode, we should use OverflowBubbleView as a source for
@@ skipping 53 matching lines @@
       dragged_off_shelf_ &&
       !dragged_off_from_overflow_to_shelf_ &&
       RemovableByRipOff(view_model_->GetIndexOfView(drag_view_)) == REMOVABLE)
     last_button_index--;
 
   const gfx::Rect last_button_bounds =
       last_button_index  >= first_visible_index_ ?
           view_model_->ideal_bounds(last_button_index) :
           gfx::Rect(gfx::Size(kShelfSize, kShelfSize));
 
-  if (layout_manager_->IsHorizontalAlignment()) {
+  if (shelf_->IsHorizontalAlignment())
     return gfx::Size(last_button_bounds.right() + leading_inset_, kShelfSize);
-  }
 
   return gfx::Size(kShelfSize,
                    last_button_bounds.bottom() + leading_inset_);
 }
 
 void ShelfView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
   // This bounds change is produced by the shelf movement and all content has
   // to follow. Using an animation at that time would produce a time lag since
   // the animation of the BoundsAnimator has itself a delay before it arrives
   // at the required location. As such we tell the animator to go there
@@ skipping 180 matching lines @@
     return;  // View is being deleted or not draggable, ignore request.
 
   // Only when the repost event occurs on the same shelf item, we should ignore
   // the call in ShelfView::ButtonPressed(...).
   is_repost_event_ = IsRepostEvent(event) && (last_pressed_index_ == index);
 
   CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
   drag_view_ = static_cast<ShelfButton*>(view);
   drag_origin_ = gfx::Point(event.x(), event.y());
   UMA_HISTOGRAM_ENUMERATION("Ash.ShelfAlignmentUsage",
-      layout_manager_->SelectValueForShelfAlignment(
-          SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
-          SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
-          SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT,
-          -1),
-      SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
+                            shelf_->SelectValueForShelfAlignment(
+                                SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
+                                SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
+                                SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT, -1),
+                            SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
 }
 
 void ShelfView::PointerDraggedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   // To prepare all drag types (moving an item in the shelf and dragging off),
   // we should check the x-axis and y-axis offset.
   if (!dragging() && drag_view_ &&
       ((std::abs(event.x() - drag_origin_.x()) >= kMinimumDragDistance) ||
        (std::abs(event.y() - drag_origin_.y()) >= kMinimumDragDistance))) {
@@ skipping 193 matching lines @@
   launcher_menu_runner_.reset(new views::MenuRunner(
       menu_model, context_menu ? views::MenuRunner::CONTEXT_MENU : 0));
 
   ScopedTargetRootWindow scoped_target(
       source->GetWidget()->GetNativeView()->GetRootWindow());
 
   // Determine the menu alignment dependent on the shelf.
   views::MenuAnchorPosition menu_alignment = views::MENU_ANCHOR_TOPLEFT;
   gfx::Rect anchor_point = gfx::Rect(click_point, gfx::Size());
 
-  ShelfWidget* shelf = RootWindowController::ForShelf(
-      GetWidget()->GetNativeView())->shelf();
   if (!context_menu) {
     // Application lists use a bubble.
-    ShelfAlignment align = shelf->GetAlignment();
+    ShelfAlignment align = shelf_->alignment();
     anchor_point = source->GetBoundsInScreen();
 
     // It is possible to invoke the menu while it is sliding into view. To cover
     // that case, the screen coordinates are offsetted by the animation delta.
     gfx::Vector2d offset =
         source->GetWidget()->GetNativeWindow()->bounds().origin() -
         source->GetWidget()->GetNativeWindow()->GetTargetBounds().origin();
     anchor_point.set_x(anchor_point.x() - offset.x());
     anchor_point.set_y(anchor_point.y() - offset.y());
 
@@ skipping 15 matching lines @@
       case SHELF_ALIGNMENT_TOP:
         menu_alignment = views::MENU_ANCHOR_BUBBLE_BELOW;
         break;
     }
   }
   // If this gets deleted while we are in the menu, the shelf will be gone
   // as well.
   bool got_deleted = false;
   got_deleted_ = &got_deleted;
 
-  shelf->ForceUndimming(true);
+  ShelfWidget* shelf_widget = shelf_->shelf_widget();
+  shelf_widget->ForceUndimming(true);
   // NOTE: if you convert to HAS_MNEMONICS be sure and update menu building
   // code.
   if (launcher_menu_runner_->RunMenuAt(source->GetWidget(),
                                        NULL,
                                        anchor_point,
                                        menu_alignment,
                                        source_type) ==
       views::MenuRunner::MENU_DELETED) {
     if (!got_deleted) {
       got_deleted_ = NULL;
-      shelf->ForceUndimming(false);
+      shelf_widget->ForceUndimming(false);
     }
     return;
   }
   got_deleted_ = NULL;
-  shelf->ForceUndimming(false);
+  shelf_widget->ForceUndimming(false);
 
   // If it is a context menu and we are showing overflow bubble
   // we want to hide overflow bubble.
   if (owner_overflow_bubble_)
     owner_overflow_bubble_->HideBubbleAndRefreshButton();
 
   // Unpinning an item will reset the |launcher_menu_runner_| before coming
   // here.
   if (launcher_menu_runner_)
     closing_event_time_ = launcher_menu_runner_->closing_event_time();
@@ skipping 52 matching lines @@
     return false;
   const ShelfItem* item = ShelfItemForView(view);
   if (!item)
     return true;
   ShelfItemDelegate* item_delegate =
       item_manager_->GetShelfItemDelegate(item->id);
   return item_delegate->ShouldShowTooltip();
 }
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
-  ShelfWidget* shelf = RootWindowController::ForShelf(
-      GetWidget()->GetNativeView())->shelf();
-  ShelfAlignment align = shelf->GetAlignment();
   const gfx::Rect bounds = GetBoundsInScreen();
-  int distance = 0;
-  switch (align) {
-    case SHELF_ALIGNMENT_BOTTOM:
-      distance = bounds.y() - coordinate.y();
-      break;
-    case SHELF_ALIGNMENT_LEFT:
-      distance = coordinate.x() - bounds.right();
-      break;
-    case SHELF_ALIGNMENT_RIGHT:
-      distance = bounds.x() - coordinate.x();
-      break;
-    case SHELF_ALIGNMENT_TOP:
-      distance = coordinate.y() - bounds.bottom();
-      break;
-  }
+  int distance = shelf_->SelectValueForShelfAlignment(
+      bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
+      bounds.x() - coordinate.x(), coordinate.y() - bounds.bottom());
   return distance > 0 ? distance : 0;
 }
 
 }  // namespace ash