Enable mash shelf tooltips.

ash/shelf/shelf_view.h

 // 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.
 
 #ifndef ASH_SHELF_SHELF_VIEW_H_
 #define ASH_SHELF_SHELF_VIEW_H_
 
 #include <string>
 #include <utility>
 #include <vector>
 
-#include "ash/shelf/shelf_button_host.h"
 #include "ash/shelf/shelf_button_pressed_metric_tracker.h"
 #include "ash/shelf/shelf_item_delegate.h"
 #include "ash/shelf/shelf_model_observer.h"
+#include "ash/shelf/shelf_tooltip_manager.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "base/macros.h"
 #include "base/observer_list.h"
 #include "ui/app_list/views/app_list_drag_and_drop_host.h"
 #include "ui/views/animation/bounds_animator_observer.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/button/button.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/view.h"
 #include "ui/views/view_model.h"
@@ skipping 11 matching lines @@
 class Shelf;
 class ShelfDelegate;
 class ShelfIconObserver;
 class ShelfItemDelegateManager;
 class ShelfModel;
 struct ShelfItem;
 class DragImageView;
 class OverflowBubble;
 class OverflowButton;
 class ShelfButton;
-class ShelfTooltipManager;
 
 namespace test {
 class ShelfViewTestAPI;
 }
 
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_BOTTOM;
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_LEFT;
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_RIGHT;
 extern const int SHELF_ALIGNMENT_UMA_ENUM_VALUE_COUNT;
 
 class ASH_EXPORT ShelfView : public views::View,
                              public ShelfModelObserver,
                              public views::ButtonListener,
-                             public ShelfButtonHost,
                              public views::ContextMenuController,
                              public views::FocusTraversable,
                              public views::BoundsAnimatorObserver,
                              public app_list::ApplicationDragAndDropHost {
  public:
   ShelfView(ShelfModel* model, ShelfDelegate* delegate, Shelf* shelf);
   ~ShelfView() override;
 
-  ShelfTooltipManager* tooltip_manager() { return tooltip_.get(); }
-
   Shelf* shelf() const { return shelf_; }
   ShelfModel* model() const { return model_; }
 
   void Init();
 
   void OnShelfAlignmentChanged();
   void SchedulePaintForAllButtons();
 
   // Returns the ideal bounds of the specified item, or an empty rect if id
   // isn't know. If the item is in an overflow shelf, the overflow icon location
@@ skipping 17 matching lines @@
   void set_owner_overflow_bubble(OverflowBubble* owner) {
     owner_overflow_bubble_ = owner;
   }
 
   views::View* GetAppListButtonView() const;
 
   // Returns true if the mouse cursor exits the area for launcher tooltip.
   // There are thin gaps between launcher buttons but the tooltip shouldn't hide
   // in the gaps, but the tooltip should hide if the mouse moved totally outside
   // of the buttons area.
-  bool ShouldHideTooltip(const gfx::Point& cursor_location);
+  bool ShouldHideTooltip(const gfx::Point& cursor_location) const;
+
+  // Returns true if a tooltip should be shown for the shelf item |view|.
+  bool ShouldShowTooltipForView(const views::View* view) const;
+
+  // Returns the title of the shelf item |view|.
+  base::string16 GetTitleForView(const views::View* view) const;
 
   // Returns rectangle bounding all visible launcher items. Used screen
   // coordinate system.
   gfx::Rect GetVisibleItemsBoundsInScreen();
 
   // Overridden from FocusTraversable:
   views::FocusSearch* GetFocusSearch() override;
   FocusTraversable* GetFocusTraversableParent() override;
   View* GetFocusTraversableParentView() override;
 
   // Overridden from app_list::ApplicationDragAndDropHost:
   void CreateDragIconProxy(const gfx::Point& location_in_screen_coordinates,
                            const gfx::ImageSkia& icon,
                            views::View* replaced_view,
                            const gfx::Vector2d& cursor_offset_from_center,
                            float scale_factor) override;
   void UpdateDragIconProxy(
       const gfx::Point& location_in_screen_coordinates) override;
   void DestroyDragIconProxy() override;
   bool StartDrag(const std::string& app_id,
                  const gfx::Point& location_in_screen_coordinates) override;
   bool Drag(const gfx::Point& location_in_screen_coordinates) override;
   void EndDrag(bool cancel) override;
 
+  // The shelf buttons use the Pointer interface to enable item reordering.
+  enum Pointer { NONE, DRAG_AND_DROP, MOUSE, TOUCH };
+  void PointerPressedOnButton(views::View* view,
+                              Pointer pointer,
+                              const ui::LocatedEvent& event);
+  void PointerDraggedOnButton(views::View* view,
+                              Pointer pointer,
+                              const ui::LocatedEvent& event);
+  void PointerReleasedOnButton(views::View* view,
+                               Pointer pointer,
+                               bool canceled);
+
   // Return the view model for test purposes.
   const views::ViewModel* view_model_for_test() const {
     return view_model_.get();
   }
 
  private:
   friend class ash::test::ShelfViewTestAPI;
 
   class FadeOutAnimationDelegate;
   class StartFadeAnimationDelegate;
@@ skipping 95 matching lines @@
   void StartFadeInLastVisibleItem();
 
   // Updates the visible range of overflow items in |overflow_view|.
   void UpdateOverflowRange(ShelfView* overflow_view) const;
 
   // Overridden from views::View:
   gfx::Size GetPreferredSize() const override;
   void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
   FocusTraversable* GetPaneFocusTraversable() override;
   void GetAccessibleState(ui::AXViewState* state) override;
+  void ViewHierarchyChanged(
+      const ViewHierarchyChangedDetails& details) override;
 
   // Overridden from ui::EventHandler:
   void OnGestureEvent(ui::GestureEvent* event) override;
 
   // Overridden from ShelfModelObserver:
   void ShelfItemAdded(int model_index) override;
   void ShelfItemRemoved(int model_index, ShelfID id) override;
   void ShelfItemChanged(int model_index, const ShelfItem& old_item) override;
   void ShelfItemMoved(int start_index, int target_index) override;
 
-  // Overridden from ShelfButtonHost:
-  void PointerPressedOnButton(views::View* view,
-                              Pointer pointer,
-                              const ui::LocatedEvent& event) override;
-  void PointerDraggedOnButton(views::View* view,
-                              Pointer pointer,
-                              const ui::LocatedEvent& event) override;
-  void PointerReleasedOnButton(views::View* view,
-                               Pointer pointer,
-                               bool canceled) override;
-  void MouseMovedOverButton(views::View* view) override;
-  void MouseEnteredButton(views::View* view) override;
-  void MouseExitedButton(views::View* view) override;
-  base::string16 GetAccessibleName(const views::View* view) override;
-
   // Overridden from views::ButtonListener:
   void ButtonPressed(views::Button* sender, const ui::Event& event) override;
 
   // Show a list of all running items for this shelf |item|; it only shows a
   // menu if there are multiple running items. |source| specifies the view
   // responsible for showing the menu, and the bubble will point towards it.
   // The |event_flags| are the flags of the event which triggered this menu.
   void ShowListMenuForView(const ShelfItem& item,
                            views::View* source,
                            const ui::Event& event);
@@ skipping 18 matching lines @@
   void OnBoundsAnimatorDone(views::BoundsAnimator* animator) override;
 
   // Returns true if the (press down) |event| is a repost event from an event
   // which just closed the menu of a shelf item. If it occurs on the same shelf
   // item, we should ignore the call.
   bool IsRepostEvent(const ui::Event& event);
 
   // Convenience accessor to model_->items().
   const ShelfItem* ShelfItemForView(const views::View* view) const;
 
-  // Returns true if a tooltip should be shown for |view|.
-  bool ShouldShowTooltipForView(const views::View* view) const;
-
   // Get the distance from the given |coordinate| to the closest point on this
   // launcher/shelf.
   int CalculateShelfDistance(const gfx::Point& coordinate) const;
 
   // The model; owned by Launcher.
   ShelfModel* model_;
 
   // Delegate; owned by Launcher.
   ShelfDelegate* delegate_;
 
@@ skipping 12 matching lines @@
   mutable int last_visible_index_;
 
   scoped_ptr<views::BoundsAnimator> bounds_animator_;
 
   OverflowButton* overflow_button_;
 
   scoped_ptr<OverflowBubble> overflow_bubble_;
 
   OverflowBubble* owner_overflow_bubble_;
 
-  scoped_ptr<ShelfTooltipManager> tooltip_;
+  ShelfTooltipManager tooltip_;
 
   // Pointer device that initiated the current drag operation. If there is no
   // current dragging operation, this is NONE.
   Pointer drag_pointer_;
 
   // The view being dragged. This is set immediately when the mouse is pressed.
   // |dragging_| is set only if the mouse is dragged far enough.
   ShelfButton* drag_view_;
 
   // Position of the mouse down event in |drag_view_|'s coordinates.
@@ skipping 84 matching lines @@
 
   // Tracks UMA metrics based on shelf button press actions.
   ShelfButtonPressedMetricTracker shelf_button_pressed_metric_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfView);
 };
 
 }  // namespace ash
 
 #endif  // ASH_SHELF_SHELF_VIEW_H_