ash:Shelf - Enable Alternate Shelf and Side Shelf by default.

ash/launcher/launcher_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/launcher/launcher_view.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 195 matching lines @@
     launcher_view_ = launcher->GetLauncherViewForTest();
 
     // The bounds should be big enough for 4 buttons + overflow chevron.
     launcher_view_->SetBounds(0, 0, 500, 50);
 
     test_api_.reset(new LauncherViewTestAPI(launcher_view_));
     test_api_->SetAnimationDuration(1);  // Speeds up animation for test.
 
     // Add browser shortcut launcher item at index 0 for test.
     AddBrowserShortcut();
- }
+  }
 
   virtual void TearDown() OVERRIDE {
     test_api_.reset();
     AshTestBase::TearDown();
   }
 
  protected:
-  LauncherID AddBrowserShortcut() {
+  virtual LauncherID AddBrowserShortcut() {
     LauncherItem browser_shortcut;
     browser_shortcut.type = TYPE_BROWSER_SHORTCUT;
     browser_shortcut.is_incognito = false;
 
     LauncherID id = model_->next_id();
-    model_->AddAt(0, browser_shortcut);
+    model_->AddAt(1, browser_shortcut);
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
 
   LauncherID AddAppShortcut() {
     LauncherItem item;
     item.type = TYPE_APP_SHORTCUT;
     item.status = STATUS_CLOSED;
 
     LauncherID id = model_->next_id();
@@ skipping 123 matching lines @@
 
     // Drag.
     views::View* destination = test_api_->GetButton(destination_index);
     ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED,
                               destination->bounds().origin(),
                               destination->bounds().origin(), 0);
     button_host->PointerDraggedOnButton(button, pointer, drag_event);
     return button;
   }
 
-  void SetupForDragTest(
+  virtual void SetupForDragTest(
       std::vector<std::pair<LauncherID, views::View*> >* id_map) {
     // Initialize |id_map| with the automatically-created launcher buttons.
     for (size_t i = 0; i < model_->items().size(); ++i) {
       internal::LauncherButton* 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 launcher buttons for testing.
     for (int i = 0; i < 5; ++i) {
       LauncherID id = AddAppShortcut();
-      // browser shortcut is located at index 0. So we should start to add app
-      // shortcut at index 1.
-      id_map->insert(id_map->begin() + (i + 1),
+      // App Icon is located at index 0, and browser shortcut is located at
+      // index 1. So we should start to add app shortcuts at index 2.
+      id_map->insert(id_map->begin() + (i + 2),
                      std::make_pair(id, GetButtonByID(id)));
     }
     ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
   }
 
   views::View* GetTooltipAnchorView() {
     return launcher_view_->tooltip_manager()->anchor_;
   }
 
   void ShowTooltip() {
     launcher_view_->tooltip_manager()->ShowInternal();
   }
 
   LauncherModel* model_;
   internal::LauncherView* launcher_view_;
 
   scoped_ptr<LauncherViewTestAPI> test_api_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LauncherViewTest);
 };
 
+class LauncherViewLegacyShelfLayoutTest : public LauncherViewTest {
+ public:
+  LauncherViewLegacyShelfLayoutTest() : LauncherViewTest() {}

[James Cook, 2013/08/22 00:19:12]

see below, but this could do something like:

{
  set_browser_shortcut_index(0);
  set_app_shortcut_index(1);
}

[Harry McCleave, 2013/08/27 00:37:00]

Done.

+
+  virtual void SetUp() OVERRIDE {
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        ash::switches::kAshDisableAlternateShelfLayout);
+    LauncherViewTest::SetUp();
+  }
+
+ protected:
+  virtual LauncherID AddBrowserShortcut() OVERRIDE {
+    LauncherItem browser_shortcut;
+    browser_shortcut.type = TYPE_BROWSER_SHORTCUT;
+    browser_shortcut.is_incognito = false;
+
+    LauncherID id = model_->next_id();
+    model_->AddAt(0, browser_shortcut);
+    test_api_->RunMessageLoopUntilAnimationsDone();
+    return id;
+  }
+
+  virtual void SetupForDragTest(

[James Cook, 2013/08/22 00:19:12]

This feels to me like it doesn't need to be duplicated, especially since you're
just changing i+1 to i+2.  Maybe put this functionality in the base class and
provide a variable that sets the initial index of app shortcuts.

[Harry McCleave, 2013/08/27 00:37:00]

Done.

+      std::vector<std::pair<LauncherID, views::View*> >* id_map) OVERRIDE {
+    // Initialize |id_map| with the automatically-created launcher buttons.
+    for (size_t i = 0; i < model_->items().size(); ++i) {
+      internal::LauncherButton* 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 launcher buttons for testing.
+    for (int i = 0; i < 5; ++i) {
+      LauncherID id = AddAppShortcut();
+      // browser shortcut is located at index 0. So we should start to add app
+      // shortcut at index 1.
+      id_map->insert(id_map->begin() + (i + 1),
+                     std::make_pair(id, GetButtonByID(id)));
+    }
+    ASSERT_NO_FATAL_FAILURE(CheckModelIDs(*id_map));
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LauncherViewLegacyShelfLayoutTest);
+};
+
 class LauncherViewTextDirectionTest
     : public LauncherViewTest,
       public testing::WithParamInterface<bool> {
  public:
   LauncherViewTextDirectionTest() : is_rtl_(GetParam()) {}
   virtual ~LauncherViewTextDirectionTest() {}
 
   virtual void SetUp() OVERRIDE {
     LauncherViewTest::SetUp();
     original_locale_ = l10n_util::GetApplicationLocale(std::string());
@@ skipping 112 matching lines @@
   LauncherID last_added = AddAppShortcut();
   while (!test_api_->IsOverflowButtonVisible()) {
     // Added button is visible after animation while in this loop.
     EXPECT_TRUE(GetButtonByID(last_added)->visible());
 
     last_added = AddAppShortcut();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
+  EXPECT_FALSE(GetButtonByID(browser_button_id)->visible());
+}
+
+TEST_F(LauncherViewLegacyShelfLayoutTest,
+       AddAppShortcutWithBrowserButtonUntilOverflow) {
+  // All buttons should be visible.
+  ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
+            test_api_->GetButtonCount());
+
+  LauncherID browser_button_id = AddTabbedBrowser();
+
+  // Add app shortcut until overflow.
+  int items_added = 0;
+  LauncherID last_added = AddAppShortcut();
+  while (!test_api_->IsOverflowButtonVisible()) {
+    // Added button is visible after animation while in this loop.
+    EXPECT_TRUE(GetButtonByID(last_added)->visible());
+
+    last_added = AddAppShortcut();
+    ++items_added;
+    ASSERT_LT(items_added, 10000);
+  }
+
   // The last added app short button should be visible.
   EXPECT_TRUE(GetButtonByID(last_added)->visible());
   // And the browser button is invisible.
   EXPECT_FALSE(GetButtonByID(browser_button_id)->visible());
 }
 
 TEST_F(LauncherViewTest, AddPanelHidesTabbedBrowser) {
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
 
   // Add tabbed browser until overflow, remember last visible tabbed browser.
   int items_added = 0;
   LauncherID first_added = AddTabbedBrowser();
   EXPECT_TRUE(GetButtonByID(first_added)->visible());
+  while (true) {
+    LauncherID added = AddTabbedBrowser();
+    if (test_api_->IsOverflowButtonVisible()) {
+      EXPECT_FALSE(GetButtonByID(added)->visible());
+      RemoveByID(added);
+      break;
+    }
+    ++items_added;
+    ASSERT_LT(items_added, 10000);
+  }
+
+  EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
+  LauncherID panel = AddPanel();
+  EXPECT_TRUE(GetButtonByID(panel)->visible());
+  EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
+  RemoveByID(panel);
+  EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
+}
+
+TEST_F(LauncherViewLegacyShelfLayoutTest, AddPanelHidesTabbedBrowser) {
+  ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
+            test_api_->GetButtonCount());
+
+  // Add tabbed browser until overflow, remember last visible tabbed browser.
+  int items_added = 0;
+  LauncherID first_added = AddTabbedBrowser();
+  EXPECT_TRUE(GetButtonByID(first_added)->visible());
   LauncherID last_visible = first_added;
   while (true) {
     LauncherID added = AddTabbedBrowser();
     if (test_api_->IsOverflowButtonVisible()) {
       EXPECT_FALSE(GetButtonByID(added)->visible());
       break;
     }
     last_visible = added;
     ++items_added;
     ASSERT_LT(items_added, 10000);
@@ skipping 40 matching lines @@
   while (GetButtonByID(browser)->visible() &&
          GetButtonByID(last_panel)->visible()) {
     browser = AddTabbedBrowser();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
   EXPECT_TRUE(GetButtonByID(last_panel)->visible());
   EXPECT_FALSE(GetButtonByID(browser)->visible());
 }
 
+TEST_F(LauncherViewLegacyShelfLayoutTest, BrowserHidesExcessPanels) {
+  ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
+            test_api_->GetButtonCount());
+
+  // Add tabbed browser.
+  LauncherID browser = AddTabbedBrowser();
+  LauncherID first_panel = AddPanel();
+
+  EXPECT_TRUE(GetButtonByID(browser)->visible());
+  EXPECT_TRUE(GetButtonByID(first_panel)->visible());
+
+  // Add panels until there is an overflow.
+  LauncherID last_panel = first_panel;
+  int items_added = 0;
+  while (!test_api_->IsOverflowButtonVisible()) {
+    last_panel = AddPanel();
+    ++items_added;
+    ASSERT_LT(items_added, 10000);
+  }
+
+  // The first panel should now be hidden by the new browsers needing space.
+  EXPECT_FALSE(GetButtonByID(first_panel)->visible());
+  EXPECT_TRUE(GetButtonByID(last_panel)->visible());
+  EXPECT_TRUE(GetButtonByID(browser)->visible());
+
+  // Adding browsers should eventually begin to hide browsers. We will add
+  // browsers until either the last panel or browser is hidden.
+  items_added = 0;
+  while (GetButtonByID(browser)->visible() &&
+         GetButtonByID(last_panel)->visible()) {
+    browser = AddTabbedBrowser();
+    ++items_added;
+    ASSERT_LT(items_added, 10000);
+  }
+  EXPECT_TRUE(GetButtonByID(last_panel)->visible());
+  EXPECT_FALSE(GetButtonByID(browser)->visible());
+}
+
 // Adds button until overflow then removes first added one. Verifies that
 // the last added one changes from invisible to visible and overflow
 // chevron is gone.
 TEST_F(LauncherViewTest, RemoveButtonRevealsOverflowed) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
 
   // Add tabbed browser until overflow.
   int items_added = 0;
@@ skipping 71 matching lines @@
 
 // Check that model changes are handled correctly while a launcher icon is being
 // dragged.
 TEST_F(LauncherViewTest, ModelChangesWhileDragging) {
   internal::LauncherButtonHost* button_host = launcher_view_;
 
   std::vector<std::pair<LauncherID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Dragging browser shortcut at index 0.
+  EXPECT_TRUE(model_->items()[1].type == TYPE_BROWSER_SHORTCUT);
+  views::View* dragged_button = SimulateDrag(
+      internal::LauncherButtonHost::MOUSE, 1, 3);
+  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,
+                                       internal::LauncherButtonHost::MOUSE,
+                                       false);
+  EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
+
+  // Dragging changes model order.
+  dragged_button = SimulateDrag(
+      internal::LauncherButtonHost::MOUSE, 1, 3);
+  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,
+                                       internal::LauncherButtonHost::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(internal::LauncherButtonHost::MOUSE, 1, 3);
+  model_->RemoveItemAt(1);
+  id_map.erase(id_map.begin() + 1);
+  ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
+  button_host->PointerReleasedOnButton(dragged_button,
+                                       internal::LauncherButtonHost::MOUSE,
+                                       false);
+
+  // Adding a launcher item cancels the drag and respects the order.
+  dragged_button = SimulateDrag(internal::LauncherButtonHost::MOUSE, 1, 3);
+  LauncherID 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,
+                                       internal::LauncherButtonHost::MOUSE,
+                                       false);
+
+  // Adding a launcher item at the end (i.e. a panel)  canels drag and respects
+  // the order.
+  dragged_button = SimulateDrag(internal::LauncherButtonHost::MOUSE, 1, 3);
+  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,
+                                       internal::LauncherButtonHost::MOUSE,
+                                       false);
+}
+
+TEST_F(LauncherViewLegacyShelfLayoutTest, ModelChangesWhileDragging) {
+  internal::LauncherButtonHost* button_host = launcher_view_;
+
+  std::vector<std::pair<LauncherID, views::View*> > id_map;
+  SetupForDragTest(&id_map);
+
+  // Dragging browser shortcut at index 0.
   EXPECT_TRUE(model_->items()[0].type == TYPE_BROWSER_SHORTCUT);
   views::View* dragged_button = SimulateDrag(
       internal::LauncherButtonHost::MOUSE, 0, 2);
   std::rotate(id_map.begin(),
               id_map.begin() + 1,
               id_map.begin() + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::LauncherButtonHost::MOUSE,
                                        false);
@@ skipping 49 matching lines @@
 
 // Check that 2nd drag from the other pointer would be ignored.
 TEST_F(LauncherViewTest, SimultaneousDrag) {
   internal::LauncherButtonHost* button_host = launcher_view_;
 
   std::vector<std::pair<LauncherID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Start a mouse drag.
   views::View* dragged_button_mouse = SimulateDrag(
+      internal::LauncherButtonHost::MOUSE, 1, 3);
+  std::rotate(id_map.begin() + 1,
+              id_map.begin() + 2,
+              id_map.begin() + 4);
+
+  // Attempt a touch drag before the mouse drag finishes.
+  views::View* dragged_button_touch = SimulateDrag(
+      internal::LauncherButtonHost::TOUCH, 4, 2);
+  (void)button_host;(void)dragged_button_mouse;(void)dragged_button_touch;
+  // Nothing changes since 2nd drag is ignored.
+  ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
+
+  // Finish the mouse drag.
+  button_host->PointerReleasedOnButton(dragged_button_mouse,
+                                       internal::LauncherButtonHost::MOUSE,
+                                       false);
+  ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
+
+  // Now start a touch drag.
+  dragged_button_touch = SimulateDrag(
+      internal::LauncherButtonHost::TOUCH, 4, 2);
+  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(
+      internal::LauncherButtonHost::MOUSE, 1, 2);
+
+  // Nothing changes since 2nd drag is ignored.
+  ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
+
+  button_host->PointerReleasedOnButton(dragged_button_touch,
+                                       internal::LauncherButtonHost::TOUCH,
+                                       false);
+  ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
+}
+
+TEST_F(LauncherViewLegacyShelfLayoutTest, SimultaneousDrag) {
+  internal::LauncherButtonHost* button_host = launcher_view_;
+
+  std::vector<std::pair<LauncherID, views::View*> > id_map;
+  SetupForDragTest(&id_map);
+
+  // Start a mouse drag.
+  views::View* dragged_button_mouse = SimulateDrag(
       internal::LauncherButtonHost::MOUSE, 0, 2);
   std::rotate(id_map.begin(),
               id_map.begin() + 1,
               id_map.begin() + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   // Attempt a touch drag before the mouse drag finishes.
   views::View* dragged_button_touch = SimulateDrag(
       internal::LauncherButtonHost::TOUCH, 3, 1);
 
   // Nothing changes since 2nd drag is ignored.
@@ skipping 31 matching lines @@
 TEST_F(LauncherViewTest, ClickOneDragAnother) {
   internal::LauncherButtonHost* button_host = launcher_view_;
 
   std::vector<std::pair<LauncherID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // A click on item 1 is simulated.
   SimulateClick(internal::LauncherButtonHost::MOUSE, 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(
+      internal::LauncherButtonHost::MOUSE, 1, 3);
+  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,
+                                       internal::LauncherButtonHost::MOUSE,
+                                       false);
+  EXPECT_TRUE(model_->items()[3].type == TYPE_BROWSER_SHORTCUT);
+}
+
+TEST_F(LauncherViewLegacyShelfLayoutTest, ClickOneDragAnother) {
+  internal::LauncherButtonHost* button_host = launcher_view_;
+
+  std::vector<std::pair<LauncherID, views::View*> > id_map;
+  SetupForDragTest(&id_map);
+
+  // A click on item 1 is simulated.
+  SimulateClick(internal::LauncherButtonHost::MOUSE, 1);
+
+  // Dragging browser index at 0 should change the model order correctly.
   EXPECT_TRUE(model_->items()[0].type == TYPE_BROWSER_SHORTCUT);
   views::View* dragged_button = SimulateDrag(
       internal::LauncherButtonHost::MOUSE, 0, 2);
   std::rotate(id_map.begin(),
               id_map.begin() + 1,
               id_map.begin() + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::LauncherButtonHost::MOUSE,
                                        false);
@@ skipping 12 matching lines @@
   internal::LauncherButton* button = GetButtonByID(last_added);
   ASSERT_EQ(internal::LauncherButton::STATE_RUNNING, button->state());
   item.status = ash::STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(internal::LauncherButton::STATE_ACTIVE, button->state());
   item.status = ash::STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(internal::LauncherButton::STATE_ATTENTION, button->state());
 }
 
-TEST_F(LauncherViewTest, LauncherItemPositionReflectedOnStateChanged) {
+TEST_F(LauncherViewLegacyShelfLayoutTest,
+       LauncherItemPositionReflectedOnStateChanged) {
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
 
   // Add 2 items to the launcher.
   LauncherID item1_id = AddTabbedBrowser();
   LauncherID item2_id = AddPlatformAppNoWait();
   internal::LauncherButton* item1_button = GetButtonByID(item1_id);
   internal::LauncherButton* item2_button = GetButtonByID(item2_id);
 
   internal::LauncherButton::State state_mask =
       static_cast<internal::LauncherButton::State>
           (internal::LauncherButton::STATE_NORMAL |
           internal::LauncherButton::STATE_HOVERED |
           internal::LauncherButton::STATE_RUNNING |
           internal::LauncherButton::STATE_ACTIVE |
           internal::LauncherButton::STATE_ATTENTION |
           internal::LauncherButton::STATE_FOCUSED);
 
   // Clear the button states.
   item1_button->ClearState(state_mask);
   item2_button->ClearState(state_mask);
 
   // Since default alignment in tests is bottom, state is reflected in y-axis.
   ASSERT_EQ(item1_button->GetIconBounds().y(),
             item2_button->GetIconBounds().y());
   item1_button->AddState(internal::LauncherButton::STATE_HOVERED);
   ASSERT_NE(item1_button->GetIconBounds().y(),
             item2_button->GetIconBounds().y());
   item1_button->ClearState(internal::LauncherButton::STATE_HOVERED);
-
-  // Enable the alternate shelf layout.
-  CommandLine::ForCurrentProcess()->AppendSwitch(
-      ash::switches::kAshUseAlternateShelfLayout);
-  launcher_view_->Layout();
-
-  // Since default alignment in tests is bottom, state is reflected in y-axis.
-  // In alternate shelf layout there is no visible hovered state.
-  ASSERT_EQ(item1_button->GetIconBounds().y(),
-            item2_button->GetIconBounds().y());
-  item1_button->AddState(internal::LauncherButton::STATE_HOVERED);
-  ASSERT_EQ(item1_button->GetIconBounds().y(),
-            item2_button->GetIconBounds().y());
 }
 
 // Confirm that item status changes are reflected in the buttons
 // for platform apps.
 TEST_F(LauncherViewTest, LauncherItemStatusPlatformApp) {
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
 
   // Add tabbed browser.
   LauncherID last_added = AddPlatformApp();
@@ skipping 154 matching lines @@
   // Move the mouse over the button and check that it is visible.
   views::View* app_list_button = launcher_view_->GetAppListButtonView();
   gfx::Rect bounds = app_list_button->GetBoundsInScreen();
   generator.MoveMouseTo(bounds.CenterPoint());
   // Wait for the timer to go off.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Move the mouse cursor slightly to the right of the item. The tooltip should
   // stay open.
-  generator.MoveMouseBy(-(bounds.width() / 2 + 5), 0);
+  generator.MoveMouseBy(bounds.width() / 2 + 5, 0);
   // Make sure there is no delayed close.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Move back - it should still stay open.
-  generator.MoveMouseBy(bounds.width() / 2 + 5, 0);
+  generator.MoveMouseBy(-(bounds.width() / 2 + 5), 0);
   // Make sure there is no delayed close.
   RunAllPendingInMessageLoop();
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Now move the mouse cursor slightly above the item - so that it is over the
   // tooltip bubble. Now it should disappear.
   generator.MoveMouseBy(0, -(bounds.height() / 2 + 5));
   // Wait until the delayed close kicked in.
   RunAllPendingInMessageLoop();
   EXPECT_FALSE(tooltip_manager->IsVisible());
@@ skipping 31 matching lines @@
   const int app_list_button_index = test_api_->GetButtonCount() - 1;
   const gfx::Rect& app_list_ideal_bounds =
       test_api_->GetIdealBoundsByIndex(app_list_button_index);
   const gfx::Rect& app_list_bounds =
       test_api_->GetBoundsByIndex(app_list_button_index);
   EXPECT_EQ(app_list_bounds, app_list_ideal_bounds);
 }
 
 // Check that the first item in the list follows Fitt's law by including the
 // first pixel and being therefore bigger then the others.
-TEST_F(LauncherViewTest, CheckFittsLaw) {
+TEST_F(LauncherViewLegacyShelfLayoutTest, CheckFittsLaw) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1,
             test_api_->GetButtonCount());
   gfx::Rect ideal_bounds_0 = test_api_->GetIdealBoundsByIndex(0);
   gfx::Rect ideal_bounds_1 = test_api_->GetIdealBoundsByIndex(1);
   EXPECT_GT(ideal_bounds_0.width(), ideal_bounds_1.width());
 }
 
 INSTANTIATE_TEST_CASE_P(LtrRtl, LauncherViewTextDirectionTest, testing::Bool());
 
 }  // namespace test
 }  // namespace ash