chromeos: Rename ash::WmShelf to Shelf

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 <memory>
 
 #include "ash/ash_constants.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/public/cpp/shelf_item_delegate.h"
 #include "ash/scoped_root_window_for_new_windows.h"
 #include "ash/screen_util.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_application_menu_model.h"
 #include "ash/shelf/shelf_button.h"
 #include "ash/shelf/shelf_constants.h"
 #include "ash/shelf/shelf_model.h"
 #include "ash/shelf/shelf_widget.h"
-#include "ash/shelf/wm_shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_delegate.h"
 #include "ash/shell_port.h"
 #include "ash/strings/grit/ash_strings.h"
 #include "ash/wm/root_window_finder.h"
 #include "ash/wm_window.h"
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "ui/accessibility/ax_node_data.h"
@@ skipping 199 matching lines @@
  private:
   ShelfView* shelf_view_;
   views::View* view_;
 
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
 // static
 const int ShelfView::kMinimumDragDistance = 8;
 
-ShelfView::ShelfView(ShelfModel* model,
-                     WmShelf* wm_shelf,
-                     ShelfWidget* shelf_widget)
+ShelfView::ShelfView(ShelfModel* model, Shelf* shelf, ShelfWidget* shelf_widget)
     : model_(model),
-      wm_shelf_(wm_shelf),
+      shelf_(shelf),
       shelf_widget_(shelf_widget),
       view_model_(new views::ViewModel),
       tooltip_(this),
       weak_factory_(this) {
   DCHECK(model_);
-  DCHECK(wm_shelf_);
+  DCHECK(shelf_);
   DCHECK(shelf_widget_);
   bounds_animator_.reset(new views::BoundsAnimator(this));
   bounds_animator_->AddObserver(this);
   set_context_menu_controller(this);
   focus_search_.reset(new ShelfFocusSearch(view_model_.get()));
 }
 
 ShelfView::~ShelfView() {
   bounds_animator_->RemoveObserver(this);
   model_->RemoveObserver(this);
 }
 
 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();
     view_model_->Add(child, static_cast<int>(i - items.begin()));
     AddChildView(child);
   }
-  overflow_button_ = new OverflowButton(this, wm_shelf_);
+  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 36 matching lines @@
 
 void ShelfView::UpdatePanelIconPosition(const ShelfID& id,
                                         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 &&
-      wm_shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
+  while (target_index > first_panel_index &&
+         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(target_index).x(),
                                   view_model_->ideal_bounds(target_index).y()) >
-          wm_shelf_->PrimaryAxisValue(midpoint_in_view.x(),
+             shelf_->PrimaryAxisValue(midpoint_in_view.x(),
                                       midpoint_in_view.y())) {
     --target_index;
   }
   while (target_index < view_model_->view_size() - 1 &&
-         wm_shelf_->PrimaryAxisValue(
+         shelf_->PrimaryAxisValue(
              view_model_->ideal_bounds(target_index).right(),
              view_model_->ideal_bounds(target_index).bottom()) <
-             wm_shelf_->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 300 matching lines @@
   is_repost_event_on_same_item_ =
       IsRepostEvent(event) && (last_pressed_index_ == index);
 
   if (pointer == TOUCH)
     touch_press_time_ = base::TimeTicks::Now();
 
   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",
-                            wm_shelf_->SelectValueForShelfAlignment(
+                            shelf_->SelectValueForShelfAlignment(
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM,
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT,
                                 SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT),
                             SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT);
 }
 
 void ShelfView::PointerDraggedOnButton(views::View* view,
                                        Pointer pointer,
                                        const ui::LocatedEvent& event) {
   if (CanPrepareForDrag(pointer, event))
@@ skipping 49 matching lines @@
     if (dragged_to_another_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(gfx::Rect* overflow_bounds) const {
   DCHECK(model_->item_count() == view_model_->view_size());
 
-  int available_size = wm_shelf_->PrimaryAxisValue(width(), height());
+  int available_size = shelf_->PrimaryAxisValue(width(), height());
   int first_panel_index = model_->FirstPanelIndex();
   int last_button_index = first_panel_index - 1;
 
   int x = 0;
   int y = 0;
 
-  int w = wm_shelf_->PrimaryAxisValue(kShelfButtonSize, width());
-  int h = wm_shelf_->PrimaryAxisValue(height(), kShelfButtonSize);
+  int w = shelf_->PrimaryAxisValue(kShelfButtonSize, width());
+  int h = shelf_->PrimaryAxisValue(height(), kShelfButtonSize);
   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 = wm_shelf_->PrimaryAxisValue(x + w + kShelfButtonSpacing, x);
-    y = wm_shelf_->PrimaryAxisValue(y, y + h + kShelfButtonSpacing);
+    x = shelf_->PrimaryAxisValue(x + w + kShelfButtonSpacing, x);
+    y = shelf_->PrimaryAxisValue(y, y + h + kShelfButtonSpacing);
   }
 
   if (is_overflow_mode()) {
     const_cast<ShelfView*>(this)->UpdateAllButtonsVisibilityInOverflowMode();
     return;
   }
 
   // Right aligned icons.
   int end_position = available_size;
-  x = wm_shelf_->PrimaryAxisValue(end_position, 0);
-  y = wm_shelf_->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 = wm_shelf_->PrimaryAxisValue(x - w - kShelfButtonSpacing, x);
-    y = wm_shelf_->PrimaryAxisValue(y, y - h - kShelfButtonSpacing);
+    x = shelf_->PrimaryAxisValue(x - w - kShelfButtonSpacing, x);
+    y = shelf_->PrimaryAxisValue(y, y - h - kShelfButtonSpacing);
     view_model_->set_ideal_bounds(i, gfx::Rect(x, y, w, h));
-    end_position = wm_shelf_->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 =
-      wm_shelf_->PrimaryAxisValue(
+      shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_button_index).right(),
           view_model_->ideal_bounds(last_button_index).bottom()) +
       kShelfButtonSpacing;
   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);
 
-  overflow_bounds->set_size(
-      gfx::Size(wm_shelf_->PrimaryAxisValue(w, width()),
-                wm_shelf_->PrimaryAxisValue(height(), h)));
+  overflow_bounds->set_size(gfx::Size(shelf_->PrimaryAxisValue(w, width()),
+                                      shelf_->PrimaryAxisValue(height(), h)));
 
   last_visible_index_ =
       DetermineLastVisibleIndex(end_position - kShelfButtonSpacing);
   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 = wm_shelf_->PrimaryAxisValue(
+      x = shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).right(),
           view_model_->ideal_bounds(last_visible_index_).x());
-      y = wm_shelf_->PrimaryAxisValue(
+      y = shelf_->PrimaryAxisValue(
           view_model_->ideal_bounds(last_visible_index_).y(),
           view_model_->ideal_bounds(last_visible_index_).bottom());
     }
 
     if (last_visible_index_ >= 0) {
       // Add more space between last visible item and overflow button.
       // Without this, two buttons look too close compared with other items.
-      x = wm_shelf_->PrimaryAxisValue(x + kShelfButtonSpacing, x);
-      y = wm_shelf_->PrimaryAxisValue(y, y + kShelfButtonSpacing);
+      x = shelf_->PrimaryAxisValue(x + kShelfButtonSpacing, x);
+      y = shelf_->PrimaryAxisValue(y, y + kShelfButtonSpacing);
     }
 
     // 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));
 
     overflow_bounds->set_x(x);
     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 &&
-         wm_shelf_->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() &&
-         wm_shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).x(),
-                                     view_model_->ideal_bounds(index).y()) <
+         shelf_->PrimaryAxisValue(view_model_->ideal_bounds(index).x(),
+                                  view_model_->ideal_bounds(index).y()) <
              min_value) {
     ++index;
   }
   return index;
 }
 
 void ShelfView::AnimateToIdealBounds() {
   gfx::Rect overflow_bounds;
   CalculateIdealBounds(&overflow_bounds);
   for (int i = 0; i < view_model_->view_size(); ++i) {
@@ skipping 16 matching lines @@
     case TYPE_APP:
     case TYPE_DIALOG: {
       ShelfButton* button = new ShelfButton(this, this);
       button->SetImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_LIST: {
-      view = new AppListButton(this, this, wm_shelf_);
+      view = new AppListButton(this, this, shelf_);
       break;
     }
 
     case TYPE_UNDEFINED:
       return nullptr;
   }
 
   view->set_context_menu_controller(this);
   ConfigureChildView(view);
   return view;
@@ skipping 51 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 (wm_shelf_->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_,
-      wm_shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
-                                         : views::ViewModelUtils::VERTICAL,
+      shelf_->IsHorizontalAlignment() ? views::ViewModelUtils::HORIZONTAL
+                                      : views::ViewModelUtils::VERTICAL,
       x, y);
   target_index =
       std::min(indices.second, std::max(target_index, indices.first));
 
   // The app list button is always first, and it is the only non-draggable item.
   int first_draggable_item = model_->GetItemIndexForType(TYPE_APP_LIST) + 1;
   DCHECK_EQ(1, first_draggable_item);
   target_index = std::max(target_index, first_draggable_item);
   DCHECK_LT(target_index, model_->item_count());
 
@@ skipping 256 matching lines @@
   view->layer()->SetFillsBoundsOpaquely(false);
 }
 
 void ShelfView::ToggleOverflowBubble() {
   if (IsShowingOverflowBubble()) {
     overflow_bubble_->Hide();
     return;
   }
 
   if (!overflow_bubble_)
-    overflow_bubble_.reset(new OverflowBubble(wm_shelf_));
+    overflow_bubble_.reset(new OverflowBubble(shelf_));
 
-  ShelfView* overflow_view = new ShelfView(model_, wm_shelf_, shelf_widget_);
+  ShelfView* overflow_view = new ShelfView(model_, shelf_, shelf_widget_);
   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);
 
-  wm_shelf_->UpdateVisibilityState();
+  shelf_->UpdateVisibilityState();
 }
 
 void ShelfView::OnFadeOutAnimationEnded() {
   AnimateToIdealBounds();
   StartFadeInLastVisibleItem();
 }
 
 void ShelfView::StartFadeInLastVisibleItem() {
   // If overflow button is visible and there is a valid new last item, fading
   // the new last item in after sliding animation is finished.
@@ skipping 28 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 (wm_shelf_->IsHorizontalAlignment()) {
+    if (shelf_->IsHorizontalAlignment()) {
       preferred_size = gfx::Size(last_button_bounds.right(), kShelfSize);
     } else {
       preferred_size = gfx::Size(kShelfSize, last_button_bounds.bottom());
     }
   }
   gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
 
   // In overflow mode, we should use OverflowBubbleView as a source for
   // converting |origin| to screen coordinates. When a scroll operation is
   // occurred in OverflowBubble, the bounds of ShelfView in OverflowBubble can
@@ skipping 54 matching lines @@
   // invisible items in the shelf.
   if (is_overflow_mode() && dragged_off_shelf_ && !dragged_to_another_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 (wm_shelf_->IsHorizontalAlignment())
+  if (shelf_->IsHorizontalAlignment())
     return gfx::Size(last_button_bounds.right(), kShelfSize);
 
   return gfx::Size(kShelfSize, last_button_bounds.bottom());
 }
 
 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
   // immediately.
   BoundsAnimatorDisabler disabler(bounds_animator_.get());
   LayoutToIdealBounds();
-  wm_shelf_->NotifyShelfIconPositionsChanged();
+  shelf_->NotifyShelfIconPositionsChanged();
 
   if (IsShowingOverflowBubble())
     overflow_bubble_->Hide();
 }
 
 views::FocusTraversable* ShelfView::GetPaneFocusTraversable() {
   return this;
 }
 
 void ShelfView::GetAccessibleNodeData(ui::AXNodeData* node_data) {
   node_data->role = ui::AX_ROLE_TOOLBAR;
   node_data->SetName(l10n_util::GetStringUTF8(IDS_ASH_SHELF_ACCESSIBLE_NAME));
 }
 
 void ShelfView::ViewHierarchyChanged(
     const ViewHierarchyChangedDetails& details) {
   if (details.is_add && details.child == this)
     tooltip_.Init();
 }
 
 void ShelfView::OnGestureEvent(ui::GestureEvent* event) {
-  if (wm_shelf_->ProcessGestureEvent(*event))
+  if (shelf_->ProcessGestureEvent(*event))
     event->StopPropagation();
 }
 
 void ShelfView::ShelfItemAdded(int model_index) {
   {
     base::AutoReset<bool> cancelling_drag(&cancelling_drag_model_changed_,
                                           true);
     model_index = CancelDrag(model_index);
   }
   views::View* view = CreateViewForItem(model_->items()[model_index]);
@@ skipping 162 matching lines @@
                                        ui::MenuSourceType source_type) {
   gfx::Point context_menu_point = point;
   // Align the context menu to the edge of the shelf for touch events.
   if (source_type == ui::MenuSourceType::MENU_SOURCE_TOUCH) {
     aura::Window* shelf_window = shelf_widget_->GetNativeWindow();
     gfx::Rect shelf_bounds =
         is_overflow_mode()
             ? owner_overflow_bubble_->bubble_view()->GetBubbleBounds()
             : ScreenUtil::GetDisplayBoundsWithShelf(shelf_window);
 
-    switch (wm_shelf_->GetAlignment()) {
+    switch (shelf_->alignment()) {
       case SHELF_ALIGNMENT_BOTTOM:
       case SHELF_ALIGNMENT_BOTTOM_LOCKED:
         context_menu_point.SetPoint(point.x(),
                                     shelf_bounds.bottom() - kShelfSize);
         break;
       case SHELF_ALIGNMENT_LEFT:
         context_menu_point.SetPoint(shelf_bounds.x() + kShelfSize, point.y());
         break;
       case SHELF_ALIGNMENT_RIGHT:
         context_menu_point.SetPoint(shelf_bounds.right() - kShelfSize,
                                     point.y());
         break;
     }
   }
   last_pressed_index_ = -1;
 
   const ShelfItem* item = ShelfItemForView(source);
   if (!item) {
     ShellPort::Get()->ShowContextMenu(context_menu_point, source_type);
     return;
   }
 
   std::unique_ptr<ui::MenuModel> context_menu_model(
-      Shell::Get()->shell_delegate()->CreateContextMenu(wm_shelf_, item));
+      Shell::Get()->shell_delegate()->CreateContextMenu(shelf_, item));
   if (!context_menu_model)
     return;
 
   context_menu_id_ = item ? item->id : ShelfID();
   ShowMenu(std::move(context_menu_model), source, context_menu_point, true,
            source_type, nullptr);
 }
 
 void ShelfView::ShowMenu(std::unique_ptr<ui::MenuModel> menu_model,
                          views::View* source,
@@ skipping 27 matching lines @@
     // 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.
     anchor = source->GetBoundsInScreen() +
              (window->GetTargetBounds().origin() - window->bounds().origin());
 
     // Adjust the anchor location for shelf items with asymmetrical borders.
     if (source->border())
       anchor.Inset(source->border()->GetInsets());
 
     // Determine the menu alignment dependent on the shelf.
-    switch (wm_shelf_->GetAlignment()) {
+    switch (shelf_->alignment()) {
       case SHELF_ALIGNMENT_BOTTOM:
       case SHELF_ALIGNMENT_BOTTOM_LOCKED:
         menu_alignment = views::MENU_ANCHOR_BUBBLE_ABOVE;
         break;
       case SHELF_ALIGNMENT_LEFT:
         menu_alignment = views::MENU_ANCHOR_BUBBLE_RIGHT;
         break;
       case SHELF_ALIGNMENT_RIGHT:
         menu_alignment = views::MENU_ANCHOR_BUBBLE_LEFT;
         break;
     }
   } else {
     // Distinguish the touch events that triggered on the bottom or left / right
     // shelf. Since they should have different |MenuAnchorPosition|.
-    if (wm_shelf_->IsHorizontalAlignment())
+    if (shelf_->IsHorizontalAlignment())
       menu_alignment = views::MENU_ANCHOR_FIXED_BOTTOMCENTER;
     else
       menu_alignment = views::MENU_ANCHOR_FIXED_SIDECENTER;
   }
 
   // NOTE: if you convert to HAS_MNEMONICS be sure to update menu building code.
   launcher_menu_runner_->RunMenuAt(source->GetWidget(), nullptr, anchor,
                                    menu_alignment, source_type);
 }
 
 void ShelfView::OnMenuClosed(views::InkDrop* ink_drop) {
   context_menu_id_ = ShelfID();
 
   // Hide the hide overflow bubble after showing a context menu for its items.
   if (owner_overflow_bubble_)
     owner_overflow_bubble_->Hide();
 
   closing_event_time_ = launcher_menu_runner_->closing_event_time();
 
   if (ink_drop)
     ink_drop->AnimateToState(views::InkDropState::DEACTIVATED);
 
   launcher_menu_runner_.reset();
   menu_model_adapter_.reset();
   menu_model_.reset();
   scoped_root_window_for_new_windows_.reset();
 
   // Auto-hide or alignment might have changed, but only for this shelf.
-  wm_shelf_->UpdateVisibilityState();
+  shelf_->UpdateVisibilityState();
 }
 
 void ShelfView::OnBoundsAnimatorProgressed(views::BoundsAnimator* animator) {
-  wm_shelf_->NotifyShelfIconPositionsChanged();
+  shelf_->NotifyShelfIconPositionsChanged();
   PreferredSizeChanged();
 }
 
 void ShelfView::OnBoundsAnimatorDone(views::BoundsAnimator* animator) {
   if (snap_back_from_rip_off_view_ && animator == bounds_animator_.get()) {
     if (!animator->IsAnimating(snap_back_from_rip_off_view_)) {
       // Coming here the animation of the ShelfButton is finished and the
       // previously hidden status can be shown again. Since the button itself
       // might have gone away or changed locations we check that the button
       // is still in the shelf and show its status again.
@@ skipping 20 matching lines @@
   return closing_event_time_ == event.time_stamp();
 }
 
 const ShelfItem* ShelfView::ShelfItemForView(const views::View* view) const {
   const int view_index = view_model_->GetIndexOfView(view);
   return (view_index < 0) ? nullptr : &(model_->items()[view_index]);
 }
 
 int ShelfView::CalculateShelfDistance(const gfx::Point& coordinate) const {
   const gfx::Rect bounds = GetBoundsInScreen();
-  int distance = wm_shelf_->SelectValueForShelfAlignment(
+  int distance = shelf_->SelectValueForShelfAlignment(
       bounds.y() - coordinate.y(), coordinate.x() - bounds.right(),
       bounds.x() - coordinate.x());
   return distance > 0 ? distance : 0;
 }
 
 bool ShelfView::CanPrepareForDrag(Pointer pointer,
                                   const ui::LocatedEvent& event) {
   // Bail if dragging has already begun, or if no item has been pressed.
   if (dragging() || !drag_view_)
     return false;
 
   // Dragging only begins once the pointer has travelled a minimum distance.
   if ((std::abs(event.x() - drag_origin_.x()) < kMinimumDragDistance) &&
       (std::abs(event.y() - drag_origin_.y()) < kMinimumDragDistance)) {
     return false;
   }
 
   // Touch dragging only begins after a delay from the press event. This
   // prevents accidental dragging on swipe or scroll gestures.
   if (pointer == TOUCH &&
       (base::TimeTicks::Now() - touch_press_time_) <
           base::TimeDelta::FromMilliseconds(kTouchDragTimeThresholdMs)) {
     return false;
   }
 
   return true;
 }
 
 }  // namespace ash