Move app list

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/launcher/launcher.h"
@@ skipping 10 matching lines @@
 #include "base/memory/scoped_ptr.h"
 #include "grit/ui_resources.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/window.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/compositor/layer.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
 
+namespace {
+const int kExpectedAppIndex = 2;
+}
+
 namespace ash {
 namespace test {
 
 ////////////////////////////////////////////////////////////////////////////////
 // LauncherIconObserver tests.
 
 class TestLauncherIconObserver : public LauncherIconObserver {
  public:
   explicit TestLauncherIconObserver(Launcher* launcher)
       : launcher_(launcher),
@@ skipping 205 matching lines @@
     return test_api_->GetButton(index);
   }
 
   LauncherItem GetItemByID(LauncherID id) {
     LauncherItems::const_iterator items = model_->ItemByID(id);
     return *items;
   }
 
   void CheckModelIDs(
       const std::vector<std::pair<LauncherID, views::View*> >& id_map) {
-    ASSERT_EQ(static_cast<int>(id_map.size()), test_api_->GetButtonCount());
-    ASSERT_EQ(id_map.size(), model_->items().size());
-    for (size_t i = 0; i < id_map.size(); ++i) {
-      EXPECT_EQ(id_map[i].first, model_->items()[i].id);
-      EXPECT_EQ(id_map[i].second, test_api_->GetButton(i));
+    size_t map_index = 0;
+    for (size_t model_index = 0;
+         model_index < model_->items().size();
+         ++model_index) {
+      ash::LauncherItem item = model_->items()[model_index];
+//      if (item.type == ash::TYPE_APP_LIST)
+//        continue;
+      ash::LauncherID id = item.id;
+      EXPECT_EQ(id_map[map_index].first, id);
+      EXPECT_EQ(id_map[map_index].second, GetButtonByID(id));
+      ++map_index;
     }
+    ASSERT_EQ(map_index, id_map.size());
   }
 
   views::View* SimulateDrag(internal::LauncherButtonHost::Pointer pointer,
                             int button_index,
                             int destination_index) {
+    // Add kExpectedAppIndex to each button index to allow default icons.
     internal::LauncherButtonHost* button_host = launcher_view_.get();
 
     // Mouse down.
-    views::View* button = test_api_->GetButton(button_index);
+    views::View* button =
+        test_api_->GetButton(kExpectedAppIndex + button_index);
     ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED,
                                button->bounds().origin(),
                                button->bounds().origin(), 0);
     button_host->PointerPressedOnButton(button, pointer, click_event);
 
     // Drag.
-    views::View* destination = test_api_->GetButton(destination_index);
+    views::View* destination =
+        test_api_->GetButton(kExpectedAppIndex + 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(
       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) {
-      id_map->push_back(std::make_pair(model_->items()[i].id,
-                                       test_api_->GetButton(i)));
+      internal::LauncherButton* button = test_api_->GetButton(i);
+//      if (!button)
+//        continue;
+
+      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 = 1; i <= 5; ++i) {
+    for (int i = 0; i < 5; ++i) {
       LauncherID id = AddAppShortcut();
-      id_map->insert(id_map->begin() + i,
-                     std::make_pair(id, test_api_->GetButton(i)));
+      id_map->push_back(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();
@@ skipping 110 matching lines @@
     ++added_count;
   }
 
   // LauncherView should be big enough to hold at least 3 new buttons.
   ASSERT_GE(added_count, 3);
 
   // Wait for the last animation to finish.
   test_api_->RunMessageLoopUntilAnimationsDone();
 
   // Verifies non-overflow buttons are visible.
-  for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) {
+  for (int i = 1; i <= test_api_->GetLastVisibleIndex(); ++i) {
     internal::LauncherButton* button = test_api_->GetButton(i);
     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 launcher icon is being
 // dragged.
 TEST_F(LauncherViewTest, ModelChangesWhileDragging) {
   internal::LauncherButtonHost* button_host = launcher_view_.get();
 
   std::vector<std::pair<LauncherID, views::View*> > id_map;
   SetupForDragTest(&id_map);
 
   // Dragging changes model order.
   views::View* dragged_button = SimulateDrag(
-      internal::LauncherButtonHost::MOUSE, 1, 3);
-  std::rotate(id_map.begin() + 1, id_map.begin() + 2, id_map.begin() + 4);
+      internal::LauncherButtonHost::MOUSE, 0, 2);
+  std::rotate(id_map.begin() + kExpectedAppIndex,
+              id_map.begin() + kExpectedAppIndex + 1,
+              id_map.begin() + kExpectedAppIndex + 3);
   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);
+  std::rotate(id_map.begin() + kExpectedAppIndex,
+              id_map.begin() + kExpectedAppIndex + 2,
+              id_map.begin() + kExpectedAppIndex + 3);
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
 
   // Deleting an item keeps the remaining intact.
-  dragged_button = SimulateDrag(internal::LauncherButtonHost::MOUSE, 1, 3);
-  model_->RemoveItemAt(3);
-  id_map.erase(id_map.begin() + 3);
+  dragged_button = SimulateDrag(internal::LauncherButtonHost::MOUSE, 0, 2);
+  model_->RemoveItemAt(kExpectedAppIndex + 1);
+  id_map.erase(id_map.begin() + kExpectedAppIndex + 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);
+  dragged_button = SimulateDrag(internal::LauncherButtonHost::MOUSE, 0, 2);
   LauncherID new_id = AddAppShortcut();
-  id_map.insert(id_map.begin() + 5,
-                std::make_pair(new_id, test_api_->GetButton(5)));
+  id_map.push_back(std::make_pair(new_id, GetButtonByID(new_id)));
   ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map));
   button_host->PointerReleasedOnButton(dragged_button,
                                        internal::LauncherButtonHost::MOUSE,
                                        false);
 }
 
 // Check that 2nd drag from the other pointer would be ignored.
 TEST_F(LauncherViewTest, SimultaneousDrag) {
   internal::LauncherButtonHost* button_host = launcher_view_.get();
 
   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);
+      internal::LauncherButtonHost::MOUSE, 0, 2);
+  std::rotate(id_map.begin() + kExpectedAppIndex,
+              id_map.begin() + kExpectedAppIndex + 1,
+              id_map.begin() + kExpectedAppIndex + 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, 4, 2);
+      internal::LauncherButtonHost::TOUCH, 3, 1);
 
   // 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);
+      internal::LauncherButtonHost::TOUCH, 3, 1);
+  std::rotate(id_map.begin() + kExpectedAppIndex + 2,
+              id_map.begin() + kExpectedAppIndex + 3,
+              id_map.begin() + kExpectedAppIndex + 4);
   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, 3);
+      internal::LauncherButtonHost::MOUSE, 0, 1);
 
   // 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));
 }
 
@@ skipping 80 matching lines @@
   button_host->MouseEnteredButton(tab_button);
   EXPECT_FALSE(tooltip_manager->IsVisible());
   EXPECT_EQ(tab_button, GetTooltipAnchorView());
 }
 
 TEST_F(LauncherViewTest, ShouldHideTooltipTest) {
   LauncherID app_button_id = AddAppShortcut();
   LauncherID tab_button_id = AddTabbedBrowser();
 
   // The tooltip shouldn't hide if the mouse is on normal buttons.
-  for (int i = 0; i < test_api_->GetButtonCount() - 1; i++) {
+  for (int i = 0; i < test_api_->GetButtonCount(); i++) {
     internal::LauncherButton* button = test_api_->GetButton(i);
+    if (!button)
+      continue;
+
     EXPECT_FALSE(launcher_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "LauncherView tries to hide on button " << i;
   }
 
   // The tooltip should not hide on the app-list button.
   views::View* app_list_button = launcher_view_->GetAppListButtonView();
   EXPECT_FALSE(launcher_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 
   // The tooltip shouldn't hide if the mouse is in the gap between two buttons.
   gfx::Rect app_button_rect = GetButtonByID(app_button_id)->GetMirroredBounds();
   gfx::Rect tab_button_rect = GetButtonByID(tab_button_id)->GetMirroredBounds();
   ASSERT_FALSE(app_button_rect.Intersects(tab_button_rect));
   EXPECT_FALSE(launcher_view_->ShouldHideTooltip(
       app_button_rect.Union(tab_button_rect).CenterPoint()));
 
   // The tooltip should hide if it's outside of all buttons.
   gfx::Rect all_area;
-  for (int i = 0; i < test_api_->GetButtonCount() - 1; i++) {
-    all_area = all_area.Union(test_api_->GetButton(i)->GetMirroredBounds());
+  for (int i = 0; i < test_api_->GetButtonCount(); i++) {
+    internal::LauncherButton* button = test_api_->GetButton(i);
+    if (!button)
+      continue;
+
+    all_area = all_area.Union(button->GetMirroredBounds());
   }
   all_area = all_area.Union(
       launcher_view_->GetAppListButtonView()->GetMirroredBounds());
   EXPECT_FALSE(launcher_view_->ShouldHideTooltip(all_area.origin()));
   EXPECT_FALSE(launcher_view_->ShouldHideTooltip(
       gfx::Point(all_area.right() - 1, all_area.bottom() - 1)));
   EXPECT_TRUE(launcher_view_->ShouldHideTooltip(
       gfx::Point(all_area.right(), all_area.y())));
   EXPECT_TRUE(launcher_view_->ShouldHideTooltip(
       gfx::Point(all_area.x() - 1, all_area.y())));
   EXPECT_TRUE(launcher_view_->ShouldHideTooltip(
       gfx::Point(all_area.x(), all_area.y() - 1)));
   EXPECT_TRUE(launcher_view_->ShouldHideTooltip(
       gfx::Point(all_area.x(), all_area.bottom())));
 }
 
 TEST_F(LauncherViewTest, ShouldHideTooltipWithAppListWindowTest) {
   Shell::GetInstance()->ToggleAppList();
   ASSERT_TRUE(Shell::GetInstance()->GetAppListWindow());
 
   // The tooltip shouldn't hide if the mouse is on normal buttons.
-  for (int i = 0; i < test_api_->GetButtonCount() - 1; i++) {
+  for (int i = 1; i < test_api_->GetButtonCount(); i++) {
     internal::LauncherButton* button = test_api_->GetButton(i);
+    if (!button)
+      continue;
+
     EXPECT_FALSE(launcher_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "LauncherView tries to hide on button " << i;
   }
 
   // The tooltip should hide on the app-list button.
   views::View* app_list_button = launcher_view_->GetAppListButtonView();
   EXPECT_TRUE(launcher_view_->ShouldHideTooltip(
       app_list_button->GetMirroredBounds().CenterPoint()));
 }
@@ skipping 27 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);
 }
 
 }  // namespace test
 }  // namespace ash