Enable mash shelf tooltips.

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/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_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/shell_delegate.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"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/aura/client/screen_position_client.h"
@@ skipping 180 matching lines @@
 
 bool ShelfMenuModelAdapter::ShouldReserveSpaceForSubmenuIndicator() const {
   return false;
 }
 
 // Custom FocusSearch used to navigate the shelf in the order items are in
 // the ViewModel.
 class ShelfFocusSearch : public views::FocusSearch {
  public:
   explicit ShelfFocusSearch(views::ViewModel* view_model)
-      : FocusSearch(NULL, true, true),
-        view_model_(view_model) {}
+      : FocusSearch(nullptr, true, true), view_model_(view_model) {}
   ~ShelfFocusSearch() override {}
 
   // views::FocusSearch overrides:
   View* FindNextFocusableView(View* starting_view,
                               bool reverse,
                               Direction direction,
                               bool check_starting_view,
                               views::FocusTraversable** focus_traversable,
                               View** focus_traversable_view) override {
     int index = view_model_->GetIndexOfView(starting_view);
@@ skipping 124 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(StartFadeAnimationDelegate);
 };
 
 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),
+      overflow_button_(nullptr),
+      owner_overflow_bubble_(nullptr),
+      tooltip_(this),
       drag_pointer_(NONE),
-      drag_view_(NULL),
+      drag_view_(nullptr),
       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),
+      got_deleted_(nullptr),
       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),
+      snap_back_from_rip_off_view_(nullptr),
       item_manager_(Shell::GetInstance()->shelf_item_delegate_manager()),
       overflow_mode_(false),
-      main_shelf_(NULL),
+      main_shelf_(nullptr),
       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(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;
 }
@@ skipping 16 matching lines @@
   // We'll layout when our bounds change.
 }
 
 void ShelfView::OnShelfAlignmentChanged() {
   overflow_button_->OnShelfAlignmentChanged();
   LayoutToIdealBounds();
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i >= first_visible_index_ && i <= last_visible_index_)
       view_model_->view_at(i)->Layout();
   }
-  tooltip_->Close();
+  tooltip_.Close();
   if (overflow_bubble_)
     overflow_bubble_->Hide();
 }
 
 void ShelfView::SchedulePaintForAllButtons() {
   for (int i = 0; i < view_model_->view_size(); ++i) {
     if (i >= first_visible_index_ && i <= last_visible_index_)
       view_model_->view_at(i)->SchedulePaint();
   }
   if (overflow_button_ && overflow_button_->visible())
@@ skipping 62 matching lines @@
   return overflow_bubble_.get() && overflow_bubble_->IsShowing();
 }
 
 views::View* ShelfView::GetAppListButtonView() const {
   for (int i = 0; i < model_->item_count(); ++i) {
     if (model_->items()[i].type == TYPE_APP_LIST)
       return view_model_->view_at(i);
   }
 
   NOTREACHED() << "Applist button not found";
-  return NULL;
+  return nullptr;
+}
+
+bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) const {
+  gfx::Rect tooltip_bounds;
+  for (int i = 0; i < child_count(); ++i) {
+    const views::View* child = child_at(i);
+    if (child != overflow_button_ && ShouldShowTooltipForView(child))
+      tooltip_bounds.Union(child->GetMirroredBounds());
+  }
+  return !tooltip_bounds.Contains(cursor_location);
+}
+
+bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
+  if (view == GetAppListButtonView() &&
+      Shell::GetInstance()->GetAppListWindow()) {
+    return false;
+  }
+  const ShelfItem* item = ShelfItemForView(view);
+  if (!item)
+    return false;
+  return item_manager_->GetShelfItemDelegate(item->id)->ShouldShowTooltip();
+}
+
+base::string16 ShelfView::GetTitleForView(const views::View* view) const {
+  const ShelfItem* item = ShelfItemForView(view);
+  if (!item)
+    return base::string16();
+  return item_manager_->GetShelfItemDelegate(item->id)->GetTitle();
+}
+
+gfx::Rect ShelfView::GetVisibleItemsBoundsInScreen() {
+  gfx::Size preferred_size = GetPreferredSize();
+  gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
+  ConvertPointToScreen(this, &origin);
+  return gfx::Rect(origin, preferred_size);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShelfView, FocusTraversable implementation:
 
 views::FocusSearch* ShelfView::GetFocusSearch() {
   return focus_search_.get();
 }
 
 views::FocusTraversable* ShelfView::GetFocusTraversableParent() {
@@ skipping 22 matching lines @@
                        cursor_offset_from_center;
   gfx::Rect drag_image_bounds(
       location_in_screen_coordinates - drag_image_offset_,
       size);
   drag_image_->SetBoundsInScreen(drag_image_bounds);
   drag_image_->SetWidgetVisible(true);
 }
 
 void ShelfView::UpdateDragIconProxy(
     const gfx::Point& location_in_screen_coordinates) {
-  // TODO(jennyz): Investigate why drag_image_ becomes NULL at this point per
+  // TODO(jennyz): Investigate why drag_image_ becomes null at this point per
   // crbug.com/34722, while the app list item is still being dragged around.
   if (drag_image_) {
     drag_image_->SetScreenPosition(
         location_in_screen_coordinates - drag_image_offset_);
   }
 }
 
 void ShelfView::DestroyDragIconProxy() {
   drag_image_.reset();
   drag_image_offset_ = gfx::Vector2d(0, 0);
@@ skipping 40 matching lines @@
   drag_and_drop_view->SetSize(gfx::Size());
 
   // First we have to center the mouse cursor over the item.
   gfx::Point pt = drag_and_drop_view->GetBoundsInScreen().CenterPoint();
   views::View::ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root = location_in_screen_coordinates;
   ::wm::ConvertPointFromScreen(
       ash::wm::GetRootWindowAt(location_in_screen_coordinates), &point_in_root);
   ui::MouseEvent event(ui::ET_MOUSE_PRESSED, pt, point_in_root,
                        ui::EventTimeForNow(), 0, 0);
-  PointerPressedOnButton(drag_and_drop_view,
-                         ShelfButtonHost::DRAG_AND_DROP,
-                         event);
+  PointerPressedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
 
   // Drag the item where it really belongs.
   Drag(location_in_screen_coordinates);
   return true;
 }
 
 bool ShelfView::Drag(const gfx::Point& location_in_screen_coordinates) {
   if (!drag_and_drop_shelf_id_ ||
       !GetBoundsInScreen().Contains(location_in_screen_coordinates))
     return false;
 
   gfx::Point pt = location_in_screen_coordinates;
   views::View* drag_and_drop_view = view_model_->view_at(
       model_->ItemIndexByID(drag_and_drop_shelf_id_));
   ConvertPointFromScreen(drag_and_drop_view, &pt);
   gfx::Point point_in_root = location_in_screen_coordinates;
   ::wm::ConvertPointFromScreen(
       ash::wm::GetRootWindowAt(location_in_screen_coordinates), &point_in_root);
   ui::MouseEvent event(ui::ET_MOUSE_DRAGGED, pt, point_in_root,
                        ui::EventTimeForNow(), 0, 0);
-  PointerDraggedOnButton(drag_and_drop_view,
-                         ShelfButtonHost::DRAG_AND_DROP,
-                         event);
+  PointerDraggedOnButton(drag_and_drop_view, DRAG_AND_DROP, event);
   return true;
 }
 
 void ShelfView::EndDrag(bool cancel) {
   if (!drag_and_drop_shelf_id_)
     return;
 
   views::View* drag_and_drop_view = view_model_->view_at(
       model_->ItemIndexByID(drag_and_drop_shelf_id_));
-  PointerReleasedOnButton(
-      drag_and_drop_view, ShelfButtonHost::DRAG_AND_DROP, cancel);
+  PointerReleasedOnButton(drag_and_drop_view, DRAG_AND_DROP, cancel);
 
   // Either destroy the temporarily created item - or - make the item visible.
   if (drag_and_drop_item_pinned_ && cancel) {
     delegate_->UnpinAppWithID(drag_and_drop_app_id_);
   } else if (drag_and_drop_view) {
     if (cancel) {
       // When a hosted drag gets canceled, the item can remain in the same slot
       // and it might have moved within the bounds. In that case the item need
       // to animate back to its correct location.
       AnimateToIdealBounds();
     } else {
       drag_and_drop_view->SetSize(pre_drag_and_drop_size_);
     }
   }
 
   drag_and_drop_shelf_id_ = 0;
 }
 
+void ShelfView::PointerPressedOnButton(views::View* view,
+                                       Pointer pointer,
+                                       const ui::LocatedEvent& event) {
+  if (drag_view_)
+    return;
+
+  int index = view_model_->GetIndexOfView(view);
+  if (index == -1)
+    return;
+
+  ShelfItemDelegate* item_delegate =
+      item_manager_->GetShelfItemDelegate(model_->items()[index].id);
+  if (view_model_->view_size() <= 1 || !item_delegate->IsDraggable())
+    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",
+                            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))) {
+    PrepareForDrag(pointer, event);
+  }
+  if (drag_pointer_ == pointer)
+    ContinueDrag(event);
+}
+
+void ShelfView::PointerReleasedOnButton(views::View* view,
+                                        Pointer pointer,
+                                        bool canceled) {
+  // Reset |is_repost_event| to false.
+  is_repost_event_ = false;
+
+  if (canceled) {
+    CancelDrag(-1);
+  } else if (drag_pointer_ == pointer) {
+    FinalizeRipOffDrag(false);
+    drag_pointer_ = NONE;
+    AnimateToIdealBounds();
+  }
+  // If the drag pointer is NONE, no drag operation is going on and the
+  // drag_view can be released.
+  if (drag_pointer_ == NONE)
+    drag_view_ = nullptr;
+}
+
 void ShelfView::LayoutToIdealBounds() {
   if (bounds_animator_->IsAnimating()) {
     AnimateToIdealBounds();
     return;
   }
 
   IdealBounds ideal_bounds;
   CalculateIdealBounds(&ideal_bounds);
   views::ViewModelUtils::SetViewBoundsToIdealBounds(*view_model_);
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
@@ skipping 187 matching lines @@
     bounds_animator_->AnimateViewTo(view, view_model_->ideal_bounds(i));
     // Now that the item animation starts, we have to make sure that the
     // padding of the first gets properly transferred to the new first item.
     if (i && view->border())
       view->SetBorder(views::Border::NullBorder());
   }
   overflow_button_->SetBoundsRect(ideal_bounds.overflow_bounds);
 }
 
 views::View* ShelfView::CreateViewForItem(const ShelfItem& item) {
-  views::View* view = NULL;
+  views::View* view = nullptr;
   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, shelf_);
+      ShelfButton* button = new ShelfButton(this);
       button->SetImage(item.image);
       ReflectItemStatus(item, button);
       view = button;
       break;
     }
 
     case TYPE_APP_LIST: {
-      view = new AppListButton(this, this, shelf_->shelf_widget());
+      view = new AppListButton(this);
       break;
     }
 
-    default:
-      break;
+    case TYPE_UNDEFINED:
+      return nullptr;
   }
+
   view->set_context_menu_controller(this);
-
-  DCHECK(view);
   ConfigureChildView(view);
   return view;
 }
 
 void ShelfView::FadeIn(views::View* view) {
   view->SetVisible(true);
   view->layer()->SetOpacity(0);
   AnimateToIdealBounds();
   bounds_animator_->SetAnimationDelegate(
       view,
@@ skipping 366 matching lines @@
 void ShelfView::UpdateOverflowRange(ShelfView* overflow_view) const {
   const int first_overflow_index = last_visible_index_ + 1;
   const int last_overflow_index = last_hidden_index_;
   DCHECK_LE(first_overflow_index, last_overflow_index);
   DCHECK_LT(last_overflow_index, view_model_->view_size());
 
   overflow_view->first_visible_index_ = first_overflow_index;
   overflow_view->last_visible_index_ = last_overflow_index;
 }
 
-bool ShelfView::ShouldHideTooltip(const gfx::Point& cursor_location) {
-  gfx::Rect active_bounds;
-
-  for (int i = 0; i < child_count(); ++i) {
-    views::View* child = child_at(i);
-    if (child == overflow_button_)
-      continue;
-    if (!ShouldShowTooltipForView(child))
-      continue;
-
-    gfx::Rect child_bounds = child->GetMirroredBounds();
-    active_bounds.Union(child_bounds);
-  }
-
-  return !active_bounds.Contains(cursor_location);
-}
-
-gfx::Rect ShelfView::GetVisibleItemsBoundsInScreen() {
-  gfx::Size preferred_size = GetPreferredSize();
-  gfx::Point origin(GetMirroredXWithWidthInView(0, preferred_size.width()), 0);
-  ConvertPointToScreen(this, &origin);
-  return gfx::Rect(origin, preferred_size);
-}
-
 gfx::Rect ShelfView::GetBoundsForDragInsertInScreen() {
   gfx::Size preferred_size;
   if (is_overflow_mode()) {
     DCHECK(owner_overflow_bubble_);
     gfx::Rect bubble_bounds =
         owner_overflow_bubble_->bubble_view()->GetBubbleBounds();
     preferred_size = bubble_bounds.size();
   } else {
     const int last_button_index = view_model_->view_size() - 1;
     gfx::Rect last_button_bounds =
@@ skipping 27 matching lines @@
   return gfx::Rect(origin, preferred_size);
 }
 
 int ShelfView::CancelDrag(int modified_index) {
   FinalizeRipOffDrag(true);
   if (!drag_view_)
     return modified_index;
   bool was_dragging = dragging();
   int drag_view_index = view_model_->GetIndexOfView(drag_view_);
   drag_pointer_ = NONE;
-  drag_view_ = NULL;
+  drag_view_ = nullptr;
   if (drag_view_index == modified_index) {
     // The view that was being dragged is being modified. Don't do anything.
     return modified_index;
   }
   if (!was_dragging)
     return modified_index;
 
   // Restore previous position, tracking the position of the modified view.
   bool at_end = modified_index == view_model_->view_size();
-  views::View* modified_view =
-      (modified_index >= 0 && !at_end) ?
-      view_model_->view_at(modified_index) : NULL;
+  views::View* modified_view = (modified_index >= 0 && !at_end)
+                                   ? view_model_->view_at(modified_index)
+                                   : nullptr;
   model_->Move(drag_view_index, start_drag_index_);
 
   // If the modified view will be at the end of the list, return the new end of
   // the list.
   if (at_end)
     return view_model_->view_size();
   return modified_view ? view_model_->GetIndexOfView(modified_view) : -1;
 }
 
 gfx::Size ShelfView::GetPreferredSize() const {
@@ skipping 42 matching lines @@
 
 views::FocusTraversable* ShelfView::GetPaneFocusTraversable() {
   return this;
 }
 
 void ShelfView::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_TOOLBAR;
   state->name = l10n_util::GetStringUTF16(IDS_ASH_SHELF_ACCESSIBLE_NAME);
 }
 
+void ShelfView::ViewHierarchyChanged(
+    const ViewHierarchyChangedDetails& details) {
+  if (details.is_add && details.child == this && GetWidget())
+    tooltip_.Init();
+}
+
 void ShelfView::OnGestureEvent(ui::GestureEvent* event) {
   aura::Window* target_window = static_cast<views::View*>(event->target())
                                     ->GetWidget()
                                     ->GetNativeWindow();
   if (gesture_handler_.ProcessGestureEvent(*event, target_window))
     event->StopPropagation();
 }
 
 void ShelfView::ShelfItemAdded(int model_index) {
   {
@@ skipping 62 matching lines @@
     bounds_animator_->SetAnimationDelegate(
         view,
         scoped_ptr<gfx::AnimationDelegate>(
             new FadeOutAnimationDelegate(this, view)));
   } else {
     // We don't need to show a fade out animation for invisible |view|. When an
     // item is ripped out from the shelf, its |view| is already invisible.
     AnimateToIdealBounds();
   }
 
-  // Close the tooltip because it isn't needed any longer and its anchor view
-  // will be deleted soon.
-  if (tooltip_->GetCurrentAnchorView() == view)
-    tooltip_->Close();
+  if (view == tooltip_.GetCurrentAnchorView())
+    tooltip_.Close();
 }
 
 void ShelfView::ShelfItemChanged(int model_index, const ShelfItem& old_item) {
   const ShelfItem& item(model_->items()[model_index]);
   if (old_item.type != item.type) {
     // Type changed, swap the views.
     model_index = CancelDrag(model_index);
     scoped_ptr<views::View> old_view(view_model_->view_at(model_index));
     bounds_animator_->StopAnimatingView(old_view.get());
     // Removing and re-inserting a view in our view model will strip the ideal
@@ skipping 38 matching lines @@
 void ShelfView::ShelfItemMoved(int start_index, int target_index) {
   view_model_->Move(start_index, target_index);
   // When cancelling a drag due to a shelf item being added, the currently
   // dragged item is moved back to its initial position. AnimateToIdealBounds
   // will be called again when the new item is added to the |view_model_| but
   // at this time the |view_model_| is inconsistent with the |model_|.
   if (!cancelling_drag_model_changed_)
     AnimateToIdealBounds();
 }
 
-void ShelfView::PointerPressedOnButton(views::View* view,
-                                       Pointer pointer,
-                                       const ui::LocatedEvent& event) {
-  if (drag_view_)
-    return;
-
-  int index = view_model_->GetIndexOfView(view);
-  if (index == -1)
-    return;
-
-  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
-      model_->items()[index].id);
-  if (view_model_->view_size() <= 1 || !item_delegate->IsDraggable())
-    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",
-                            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))) {
-    PrepareForDrag(pointer, event);
-  }
-  if (drag_pointer_ == pointer)
-    ContinueDrag(event);
-}
-
-void ShelfView::PointerReleasedOnButton(views::View* view,
-                                        Pointer pointer,
-                                        bool canceled) {
-  // Reset |is_repost_event| to false.
-  is_repost_event_ = false;
-
-  if (canceled) {
-    CancelDrag(-1);
-  } else if (drag_pointer_ == pointer) {
-    FinalizeRipOffDrag(false);
-    drag_pointer_ = NONE;
-    AnimateToIdealBounds();
-  }
-  // If the drag pointer is NONE, no drag operation is going on and the
-  // drag_view can be released.
-  if (drag_pointer_ == NONE)
-    drag_view_ = NULL;
-}
-
-void ShelfView::MouseMovedOverButton(views::View* view) {
-  if (!ShouldShowTooltipForView(view))
-    return;
-
-  if (!tooltip_->IsVisible())
-    tooltip_->ResetTimer();
-}
-
-void ShelfView::MouseEnteredButton(views::View* view) {
-  if (!ShouldShowTooltipForView(view))
-    return;
-
-  if (tooltip_->IsVisible()) {
-    tooltip_->ShowImmediately(view, GetAccessibleName(view));
-  } else {
-    tooltip_->ShowDelayed(view, GetAccessibleName(view));
-  }
-}
-
-void ShelfView::MouseExitedButton(views::View* view) {
-  if (!tooltip_->IsVisible())
-    tooltip_->StopTimer();
-}
-
-base::string16 ShelfView::GetAccessibleName(const views::View* view) {
-  int view_index = view_model_->GetIndexOfView(view);
-  // May be -1 while in the process of animating closed.
-  if (view_index == -1)
-    return base::string16();
-
-  ShelfItemDelegate* item_delegate = item_manager_->GetShelfItemDelegate(
-      model_->items()[view_index].id);
-  return item_delegate->GetTitle();
-}
-
 void ShelfView::ButtonPressed(views::Button* sender, const ui::Event& event) {
   // Do not handle mouse release during drag.
   if (dragging())
     return;
 
   if (sender == overflow_button_) {
     ToggleOverflowBubble();
     shelf_button_pressed_metric_tracker_.ButtonPressed(
         event, sender, ShelfItemDelegate::kNoAction);
     return;
@@ skipping 179 matching lines @@
       // is still in the shelf and show its status again.
       for (int index = 0; index < view_model_->view_size(); index++) {
         views::View* view = view_model_->view_at(index);
         if (view == snap_back_from_rip_off_view_) {
           CHECK_EQ(ShelfButton::kViewClassName, view->GetClassName());
           ShelfButton* button = static_cast<ShelfButton*>(view);
           button->ClearState(ShelfButton::STATE_HIDDEN);
           break;
         }
       }
-      snap_back_from_rip_off_view_ = NULL;
+      snap_back_from_rip_off_view_ = nullptr;
     }
   }
 }
 
 bool ShelfView::IsRepostEvent(const ui::Event& event) {
   if (closing_event_time_ == base::TimeDelta())
     return false;
 
   base::TimeDelta delta =
       base::TimeDelta(event.time_stamp() - closing_event_time_);
   closing_event_time_ = base::TimeDelta();
   // If the current (press down) event is a repost event, the time stamp of
   // these two events should be the same.
   return (delta.InMilliseconds() == 0);
 }
 
 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]);
 }
 
-bool ShelfView::ShouldShowTooltipForView(const views::View* view) const {
-  if (view == GetAppListButtonView() &&
-      Shell::GetInstance()->GetAppListTargetVisibility())
-    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 {
   const gfx::Rect bounds = GetBoundsInScreen();
   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