Enable mash shelf tooltips.

ash/shelf/shelf_view_unittest.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 <utility>
 #include <vector>
 
@@ skipping 88 matching lines @@
     shelf_view_test_->SetAnimationDuration(1);
   }
 
   void TearDown() override {
     observer_.reset();
     AshTestBase::TearDown();
   }
 
   TestShelfIconObserver* observer() { return observer_.get(); }
 
-  ShelfViewTestAPI* shelf_view_test() {
-    return shelf_view_test_.get();
-  }
+  ShelfViewTestAPI* shelf_view_test() { return shelf_view_test_.get(); }
 
   Shelf* ShelfForSecondaryDisplay() {
     return Shelf::ForWindow(Shell::GetAllRootWindows()[1]);
   }
 
  private:
   scoped_ptr<TestShelfIconObserver> observer_;
   scoped_ptr<ShelfViewTestAPI> shelf_view_test_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewIconObserverTest);
@@ skipping 303 matching lines @@
         gfx::Rect shelf_view_bounds = shelf_view_->GetLocalBounds();
         gfx::Rect item_bounds = test_api_->GetBoundsByIndex(i);
         EXPECT_GE(item_bounds.x(), 0);
         EXPECT_GE(item_bounds.y(), 0);
         EXPECT_LE(item_bounds.right(), shelf_view_bounds.width());
         EXPECT_LE(item_bounds.bottom(), shelf_view_bounds.height());
       }
     }
   }
 
-  ShelfButton* SimulateButtonPressed(ShelfButtonHost::Pointer pointer,
+  ShelfButton* SimulateButtonPressed(ShelfView::Pointer pointer,
                                      int button_index) {
-    ShelfButtonHost* button_host = shelf_view_;
     ShelfButton* button = test_api_->GetButton(button_index);
     ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED, gfx::Point(),
                                button->GetBoundsInScreen().origin(),
                                ui::EventTimeForNow(), 0, 0);
-    button_host->PointerPressedOnButton(button, pointer, click_event);
+    shelf_view_->PointerPressedOnButton(button, pointer, click_event);
     return button;
   }
 
   // Simulates a single mouse click.
   void SimulateClick(int button_index) {
-    ShelfButtonHost* button_host = shelf_view_;
-    ShelfButton* button =
-        SimulateButtonPressed(ShelfButtonHost::MOUSE, button_index);
+    ShelfButton* button = SimulateButtonPressed(ShelfView::MOUSE, button_index);
     ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, gfx::Point(),
                                  button->GetBoundsInScreen().origin(),
                                  ui::EventTimeForNow(), 0, 0);
     test_api_->ButtonPressed(button, release_event);
-    button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
+    shelf_view_->PointerReleasedOnButton(button, ShelfView::MOUSE, false);
   }
 
   // Simulates the second click of a double click.
   void SimulateDoubleClick(int button_index) {
-    ShelfButtonHost* button_host = shelf_view_;
-    ShelfButton* button =
-        SimulateButtonPressed(ShelfButtonHost::MOUSE, button_index);
+    ShelfButton* button = SimulateButtonPressed(ShelfView::MOUSE, button_index);
     ui::MouseEvent release_event(ui::ET_MOUSE_RELEASED, gfx::Point(),
                                  button->GetBoundsInScreen().origin(),
                                  ui::EventTimeForNow(), ui::EF_IS_DOUBLE_CLICK,
                                  0);
     test_api_->ButtonPressed(button, release_event);
-    button_host->PointerReleasedOnButton(button, ShelfButtonHost::MOUSE, false);
+    shelf_view_->PointerReleasedOnButton(button, ShelfView::MOUSE, false);
   }
 
   void DoDrag(int dist_x,
               int dist_y,
               views::View* button,
-              ShelfButtonHost::Pointer pointer,
+              ShelfView::Pointer pointer,
               views::View* to) {
     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, gfx::Point(dist_x, dist_y),
                               to->GetBoundsInScreen().origin(),
                               ui::EventTimeForNow(), 0, 0);
-    static_cast<ShelfButtonHost*>(shelf_view_)
-        ->PointerDraggedOnButton(button, pointer, drag_event);
+    shelf_view_->PointerDraggedOnButton(button, pointer, drag_event);
   }
 
   /*
    * Trigger ContinueDrag of the shelf
    * The argument progressively means whether to simulate the drag progress (a
    * series of changes of the posistion of dragged item), like the normal user
    * drag behavior.
    */
   void ContinueDrag(views::View* button,
-                    ShelfButtonHost::Pointer pointer,
+                    ShelfView::Pointer pointer,
                     int from_index,
                     int to_index,
                     bool progressively) {
     views::View* to = test_api_->GetButton(to_index);
     views::View* from = test_api_->GetButton(from_index);
     int dist_x = to->x() - from->x();
     int dist_y = to->y() - from->y();
     if (progressively) {
       int sgn = dist_x > 0 ? 1 : -1;
       dist_x = abs(dist_x);
       for (; dist_x; dist_x -= std::min(10, dist_x))
         DoDrag(sgn * std::min(10, abs(dist_x)), 0, button, pointer, to);
     } else {
       DoDrag(dist_x, dist_y, button, pointer, to);
     }
   }
 
   /*
    * Simulate drag operation.
    * Argument progressively means whether to simulate the drag progress (a
    * series of changes of the posistion of dragged item) like the behavior of
    * user drags.
    */
-  views::View* SimulateDrag(ShelfButtonHost::Pointer pointer,
+  views::View* SimulateDrag(ShelfView::Pointer pointer,
                             int button_index,
                             int destination_index,
                             bool progressively) {
     views::View* button = SimulateButtonPressed(pointer, button_index);
 
     if (!progressively) {
       ContinueDrag(button, pointer, button_index, destination_index, false);
     } else if (button_index < destination_index) {
       for (int cur_index = button_index + 1; cur_index <= destination_index;
            cur_index++)
         ContinueDrag(button, pointer, cur_index - 1, cur_index, true);
     } else if (button_index > destination_index) {
       for (int cur_index = button_index - 1; cur_index >= destination_index;
            cur_index--)
         ContinueDrag(button, pointer, cur_index + 1, cur_index, true);
     }
     return button;
   }
 
   void DragAndVerify(
       int from,
       int to,
-      ShelfButtonHost* button_host,
+      ShelfView* shelf_view,
       const std::vector<std::pair<int, views::View*>>& expected_id_map) {
     views::View* dragged_button =
-        SimulateDrag(ShelfButtonHost::MOUSE, from, to, true);
-    button_host->PointerReleasedOnButton(dragged_button, ShelfButtonHost::MOUSE,
-                                         false);
+        SimulateDrag(ShelfView::MOUSE, from, to, true);
+    shelf_view->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE,
+                                        false);
     test_api_->RunMessageLoopUntilAnimationsDone();
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(expected_id_map));
   }
 
   void SetupForDragTest(
       std::vector<std::pair<ShelfID, views::View*> >* id_map) {
     // Initialize |id_map| with the automatically-created shelf buttons.
     for (size_t i = 0; i < model_->items().size(); ++i) {
       ShelfButton* button = test_api_->GetButton(i);
       id_map->push_back(std::make_pair(model_->items()[i].id, button));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
 
     // Add 5 app shelf buttons for testing.
     for (int i = 0; i < 5; ++i) {
       ShelfID id = AddAppShortcut();
       // App Icon is located at index 0, and browser shortcut is located at
       // index 1. So we should start to add app shortcut at index 2.
       id_map->insert(id_map->begin() + (i + browser_index_ + 1),
                      std::make_pair(id, GetButtonByID(id)));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
   }
 
-  views::View* GetTooltipAnchorView() {
-    return shelf_view_->tooltip_manager()->anchor_;
-  }
-
   void AddButtonsUntilOverflow() {
     int items_added = 0;
     while (!test_api_->IsOverflowButtonVisible()) {
       AddAppShortcut();
       ++items_added;
       ASSERT_LT(items_added, 10000);
     }
   }
 
-  void ShowTooltip() {
-    shelf_view_->tooltip_manager()->ShowInternal();
-  }
-
   void TestDraggingAnItemFromOverflowToShelf(bool cancel) {
     test_api_->ShowOverflowBubble();
     ASSERT_TRUE(test_api_->overflow_bubble() &&
                 test_api_->overflow_bubble()->IsShowing());
 
     ash::test::ShelfViewTestAPI test_api_for_overflow(
       test_api_->overflow_bubble()->shelf_view());
 
     int total_item_count = model_->item_count();
 
@@ skipping 505 matching lines @@
     if (button) {
       EXPECT_TRUE(button->visible()) << "button index=" << i;
       EXPECT_EQ(1.0f, button->layer()->opacity()) << "button index=" << i;
     }
   }
 }
 
 // Check that model changes are handled correctly while a shelf icon is being
 // dragged.
 TEST_F(ShelfViewTest, ModelChangesWhileDragging) {
-  ShelfButtonHost* button_host = shelf_view_;
-
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Dragging browser shortcut at index 1.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
-  views::View* dragged_button =
-      SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
+  views::View* dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(
-      dragged_button, ShelfButtonHost::MOUSE, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 
   // Dragging changes model order.
-  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
+  dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Cancelling the drag operation restores previous order.
-  button_host->PointerReleasedOnButton(
-      dragged_button, ShelfButtonHost::MOUSE, true);
+  shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, true);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 3,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Deleting an item keeps the remaining intact.
-  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
+  dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   model_->RemoveItemAt(1);
   id_map.erase(id_map.begin() + 1);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(
-      dragged_button, ShelfButtonHost::MOUSE, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
 
   // Adding a shelf item cancels the drag and respects the order.
-  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
+  dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   ShelfID new_id = AddAppShortcut();
   id_map.insert(id_map.begin() + 6,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(
-      dragged_button, ShelfButtonHost::MOUSE, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
 
   // Adding a shelf item at the end (i.e. a panel)  canels drag and respects
   // the order.
-  dragged_button = SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
+  dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   new_id = AddPanel();
   id_map.insert(id_map.begin() + 7,
                 std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(
-      dragged_button, ShelfButtonHost::MOUSE, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
 }
 
 // Check that 2nd drag from the other pointer would be ignored.
 TEST_F(ShelfViewTest, SimultaneousDrag) {
-  ShelfButtonHost* button_host = shelf_view_;
-
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Start a mouse drag.
   views::View* dragged_button_mouse =
-      SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
+      SimulateDrag(ShelfView::MOUSE, 1, 3, false);
   std::rotate(id_map.begin() + 1,
               id_map.begin() + 2,
               id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   // Attempt a touch drag before the mouse drag finishes.
   views::View* dragged_button_touch =
-      SimulateDrag(ShelfButtonHost::TOUCH, 4, 2, false);
+      SimulateDrag(ShelfView::TOUCH, 4, 2, false);
 
   // Nothing changes since 2nd drag is ignored.
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Finish the mouse drag.
-  button_host->PointerReleasedOnButton(
-      dragged_button_mouse, ShelfButtonHost::MOUSE, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button_mouse, ShelfView::MOUSE,
+                                       false);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Now start a touch drag.
-  dragged_button_touch = SimulateDrag(ShelfButtonHost::TOUCH, 4, 2, false);
+  dragged_button_touch = SimulateDrag(ShelfView::TOUCH, 4, 2, false);
   std::rotate(id_map.begin() + 3,
               id_map.begin() + 4,
               id_map.begin() + 5);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // And attempt a mouse drag before the touch drag finishes.
-  dragged_button_mouse = SimulateDrag(ShelfButtonHost::MOUSE, 1, 2, false);
+  dragged_button_mouse = SimulateDrag(ShelfView::MOUSE, 1, 2, false);
 
   // Nothing changes since 2nd drag is ignored.
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
-  button_host->PointerReleasedOnButton(
-      dragged_button_touch, ShelfButtonHost::TOUCH, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button_touch, ShelfView::TOUCH,
+                                       false);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 }
 
 // Check that whether the ash behaves correctly if not draggable
 // item are in front of the shelf.
 TEST_F(ShelfViewTest, DragWithNotDraggableItemInFront) {
   std::vector<std::pair<ShelfID, views::View*>> id_map;
   SetupForDragTest(&id_map);
 
   (static_cast<TestShelfItemDelegate*>(
        item_manager_->GetShelfItemDelegate(id_map[1].first)))
       ->set_is_draggable(false);
   (static_cast<TestShelfItemDelegate*>(
        item_manager_->GetShelfItemDelegate(id_map[2].first)))
       ->set_is_draggable(false);
 
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(3, 1, shelf_view_, id_map));
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(3, 2, shelf_view_, id_map));
 
   std::rotate(id_map.begin() + 3, id_map.begin() + 4, id_map.begin() + 5);
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(4, 1, shelf_view_, id_map));
   std::rotate(id_map.begin() + 3, id_map.begin() + 5, id_map.begin() + 6);
   ASSERT_NO_FATAL_FAILURE(DragAndVerify(5, 1, shelf_view_, id_map));
 }
 
 // Check that clicking first on one item and then dragging another works as
 // expected.
 TEST_F(ShelfViewTest, ClickOneDragAnother) {
-  ShelfButtonHost* button_host = shelf_view_;
-
   std::vector<std::pair<ShelfID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // A click on item 1 is simulated.
   SimulateClick(1);
 
   // Dragging browser index at 0 should change the model order correctly.
   EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
-  views::View* dragged_button =
-      SimulateDrag(ShelfButtonHost::MOUSE, 1, 3, false);
-  std::rotate(id_map.begin() + 1,
-              id_map.begin() + 2,
-              id_map.begin() + 4);
+  views::View* dragged_button = SimulateDrag(ShelfView::MOUSE, 1, 3, false);
+  std::rotate(id_map.begin() + 1, id_map.begin() + 2, id_map.begin() + 4);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
-  button_host->PointerReleasedOnButton(
-      dragged_button, ShelfButtonHost::MOUSE, false);
+  shelf_view_->PointerReleasedOnButton(dragged_button, ShelfView::MOUSE, false);
   EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
 }
 
 // Tests that double-clicking an item does not activate it twice.
 TEST_F(ShelfViewTest, ClickingTwiceActivatesOnce) {
   // Watch for selection of the browser shortcut.
   ShelfID browser_shelf_id = model_->items()[browser_index_].id;
   ShelfItemSelectionTracker* selection_tracker = new ShelfItemSelectionTracker;
   item_manager_->SetShelfItemDelegate(
       browser_shelf_id, scoped_ptr<ShelfItemDelegate>(selection_tracker));
@@ skipping 102 matching lines @@
       SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
   shelf_view_->shelf()->shelf_layout_manager()->SetAutoHideBehavior(
       SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
 }
 
 TEST_F(ShelfViewTest, ShelfTooltipTest) {
-  ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
-            test_api_->GetButtonCount());
+  ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, test_api_->GetButtonCount());
 
   // Prepare some items to the shelf.
   ShelfID app_button_id = AddAppShortcut();
   ShelfID platform_button_id = AddPlatformApp();
 
   ShelfButton* app_button = GetButtonByID(app_button_id);
   ShelfButton* platform_button = GetButtonByID(platform_button_id);
 
-  ShelfButtonHost* button_host = shelf_view_;
-  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
+  ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
+  EXPECT_TRUE(test_api_->shelf_view()->GetWidget()->GetNativeWindow());
+  ui::test::EventGenerator generator(ash::Shell::GetPrimaryRootWindow());
 
-  button_host->MouseEnteredButton(app_button);
+  generator.MoveMouseTo(app_button->GetBoundsInScreen().CenterPoint());
   // There's a delay to show the tooltip, so it's not visible yet.
   EXPECT_FALSE(tooltip_manager->IsVisible());
-  EXPECT_EQ(app_button, GetTooltipAnchorView());
+  EXPECT_EQ(nullptr, tooltip_manager->GetCurrentAnchorView());
 
-  ShowTooltip();
+  tooltip_manager->ShowTooltip(app_button);
   EXPECT_TRUE(tooltip_manager->IsVisible());
+  EXPECT_EQ(app_button, tooltip_manager->GetCurrentAnchorView());
 
-  // Once it's visible, it keeps visibility and is pointing to the same
-  // item.
-  button_host->MouseExitedButton(app_button);
+  // The tooltip will continue showing while the cursor moves between buttons.
+  const gfx::Point midpoint =
+      gfx::UnionRects(app_button->GetBoundsInScreen(),
+                      platform_button->GetBoundsInScreen())
+          .CenterPoint();
+  generator.MoveMouseTo(midpoint);
   EXPECT_TRUE(tooltip_manager->IsVisible());
-  EXPECT_EQ(app_button, GetTooltipAnchorView());
+  EXPECT_EQ(app_button, tooltip_manager->GetCurrentAnchorView());
 
-  // When entered to another item, it switches to the new item.  There is no
-  // delay for the visibility.
-  button_host->MouseEnteredButton(platform_button);
+  // When the cursor moves over another item, its tooltip shows immediately.
+  generator.MoveMouseTo(platform_button->GetBoundsInScreen().CenterPoint());
   EXPECT_TRUE(tooltip_manager->IsVisible());
-  EXPECT_EQ(platform_button, GetTooltipAnchorView());
-
-  button_host->MouseExitedButton(platform_button);
+  EXPECT_EQ(platform_button, tooltip_manager->GetCurrentAnchorView());
   tooltip_manager->Close();
 
-  // Next time: enter app_button -> move immediately to tab_button.
-  button_host->MouseEnteredButton(app_button);
-  button_host->MouseExitedButton(app_button);
-  button_host->MouseEnteredButton(platform_button);
+  // Now cursor over the app_button and move immediately to the platform_button.
+  generator.MoveMouseTo(app_button->GetBoundsInScreen().CenterPoint());
+  generator.MoveMouseTo(midpoint);
+  generator.MoveMouseTo(platform_button->GetBoundsInScreen().CenterPoint());
   EXPECT_FALSE(tooltip_manager->IsVisible());
-  EXPECT_EQ(platform_button, GetTooltipAnchorView());
+  EXPECT_EQ(nullptr, tooltip_manager->GetCurrentAnchorView());
 }
 
 // Verify a fix for crash caused by a tooltip update for a deleted shelf
 // button, see crbug.com/288838.
 TEST_F(ShelfViewTest, RemovingItemClosesTooltip) {
-  ShelfButtonHost* button_host = shelf_view_;
-  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
+  ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
 
   // Add an item to the shelf.
   ShelfID app_button_id = AddAppShortcut();
   ShelfButton* app_button = GetButtonByID(app_button_id);
 
   // Spawn a tooltip on that item.
-  button_host->MouseEnteredButton(app_button);
-  ShowTooltip();
+  tooltip_manager->ShowTooltip(app_button);
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Remove the app shortcut while the tooltip is open. The tooltip should be
   // closed.
   RemoveByID(app_button_id);
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Change the shelf layout. This should not crash.
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
                                           Shell::GetPrimaryRootWindow());
 }
 
 // Changing the shelf alignment closes any open tooltip.
 TEST_F(ShelfViewTest, ShelfAlignmentClosesTooltip) {
-  ShelfButtonHost* button_host = shelf_view_;
-  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
+  ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
 
   // Add an item to the shelf.
   ShelfID app_button_id = AddAppShortcut();
   ShelfButton* app_button = GetButtonByID(app_button_id);
 
   // Spawn a tooltip on the item.
-  button_host->MouseEnteredButton(app_button);
-  ShowTooltip();
+  tooltip_manager->ShowTooltip(app_button);
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Changing shelf alignment hides the tooltip.
   Shell::GetInstance()->SetShelfAlignment(SHELF_ALIGNMENT_LEFT,
                                           Shell::GetPrimaryRootWindow());
   EXPECT_FALSE(tooltip_manager->IsVisible());
 }
 
 TEST_F(ShelfViewTest, ShouldHideTooltipTest) {
   ShelfID app_button_id = AddAppShortcut();
@@ skipping 63 matching lines @@
 
   // The tooltip should hide on the app-list button.
   views::View* app_list_button = shelf_view_->GetAppListButtonView();
   EXPECT_TRUE(shelf_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 }
 
 // Test that by moving the mouse cursor off the button onto the bubble it closes
 // the bubble.
 TEST_F(ShelfViewTest, ShouldHideTooltipWhenHoveringOnTooltip) {
-  ShelfTooltipManager* tooltip_manager = shelf_view_->tooltip_manager();
-  tooltip_manager->CreateZeroDelayTimerForTest();
+  ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
+  tooltip_manager->set_timer_delay_for_test(0);
   ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
 
   // Move the mouse off any item and check that no tooltip is shown.
   generator.MoveMouseTo(gfx::Point(0, 0));
   EXPECT_FALSE(tooltip_manager->IsVisible());
 
   // Move the mouse over the button and check that it is visible.
   views::View* app_list_button = shelf_view_->GetAppListButtonView();
   gfx::Rect bounds = app_list_button->GetBoundsInScreen();
   generator.MoveMouseTo(bounds.CenterPoint());
@@ skipping 427 matching lines @@
   test_api_->RunMessageLoopUntilAnimationsDone();
   CheckAllItemsAreInBounds();
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool());
 INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest,
     testing::Bool());
 
 }  // namespace test
 }  // namespace ash