Combine shelf platform and windowed app types.

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/common/shelf/shelf_view.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 #include <vector>
@@ skipping 339 matching lines @@
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
 
   ShelfID AddPanel() {
     ShelfID id = AddPanelNoWait();
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
 
-  ShelfID AddPlatformAppNoWait() {
+  ShelfID AddAppNoWait() {

[Mr4D (OOO till 08-26), 2016/11/23 23:11:51]

I suppose these names too...

[msw, 2016/11/24 00:00:55]

Ditto.

     ShelfItem item;
-    item.type = TYPE_PLATFORM_APP;
+    item.type = TYPE_APP;
     item.status = STATUS_RUNNING;
 
     ShelfID id = model_->next_id();
     model_->Add(item);
     CreateAndSetShelfItemDelegateForID(id);
     return id;
   }
 
   ShelfID AddPanelNoWait() {
     ShelfItem item;
     item.type = TYPE_APP_PANEL;
     item.status = STATUS_RUNNING;
 
     ShelfID id = model_->next_id();
     model_->Add(item);
     CreateAndSetShelfItemDelegateForID(id);
     return id;
   }
 
-  ShelfID AddPlatformApp() {
-    ShelfID id = AddPlatformAppNoWait();
+  ShelfID AddApp() {
+    ShelfID id = AddAppNoWait();
     test_api_->RunMessageLoopUntilAnimationsDone();
     return id;
   }
 
   void SetShelfItemTypeToAppShortcut(ShelfID id) {
     int index = model_->ItemIndexByID(id);
     DCHECK_GE(index, 0);
 
     ShelfItem item = model_->items()[index];
 
-    if (item.type == TYPE_PLATFORM_APP || item.type == TYPE_WINDOWED_APP) {
+    if (item.type == TYPE_APP) {
       item.type = TYPE_APP_SHORTCUT;
       model_->Set(index, item);
     }
     test_api_->RunMessageLoopUntilAnimationsDone();
   }
 
   void RemoveByID(ShelfID id) {
     model_->RemoveItemAt(model_->ItemIndexByID(id));
     test_api_->RunMessageLoopUntilAnimationsDone();
   }
@@ skipping 324 matching lines @@
 
  private:
   ScopedTextDirectionChange text_direction_change_;
 
   DISALLOW_COPY_AND_ASSIGN(ShelfViewTextDirectionTest);
 };
 
 // Checks that the ideal item icon bounds match the view's bounds in the screen
 // in both LTR and RTL.
 TEST_P(ShelfViewTextDirectionTest, IdealBoundsOfItemIcon) {
-  ShelfID id = AddPlatformApp();
+  ShelfID id = AddApp();
   ShelfButton* button = GetButtonByID(id);
   gfx::Rect item_bounds = button->GetBoundsInScreen();
   gfx::Point icon_offset = button->GetIconBounds().origin();
   item_bounds.Offset(icon_offset.OffsetFromOrigin());
   gfx::Rect ideal_bounds = shelf_view_->GetIdealBoundsOfItemIcon(id);
   gfx::Point screen_origin;
   views::View::ConvertPointToScreen(shelf_view_, &screen_origin);
   ideal_bounds.Offset(screen_origin.x(), screen_origin.y());
   EXPECT_EQ(item_bounds.x(), ideal_bounds.x());
   EXPECT_EQ(item_bounds.y(), ideal_bounds.y());
 }
 
 // Check that items in the overflow area are returning the overflow button as
 // ideal bounds.
 TEST_F(ShelfViewTest, OverflowButtonBounds) {
-  ShelfID first_id = AddPlatformApp();
-  ShelfID overflow_id = AddPlatformApp();
+  ShelfID first_id = AddApp();
+  ShelfID overflow_id = AddApp();
   int items_added = 0;
   while (!test_api_->IsOverflowButtonVisible()) {
     // Added button is visible after animation while in this loop.
     EXPECT_TRUE(GetButtonByID(overflow_id)->visible());
-    overflow_id = AddPlatformApp();
+    overflow_id = AddApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
-  ShelfID last_id = AddPlatformApp();
+  ShelfID last_id = AddApp();
 
   gfx::Rect first_bounds = shelf_view_->GetIdealBoundsOfItemIcon(first_id);
   gfx::Rect overflow_bounds =
       shelf_view_->GetIdealBoundsOfItemIcon(overflow_id);
   gfx::Rect last_bounds = shelf_view_->GetIdealBoundsOfItemIcon(last_id);
 
   // Check that all items have the same size and that the overflow items are
   // identical whereas the first one does not match either of them.
   EXPECT_EQ(first_bounds.size().ToString(), last_bounds.size().ToString());
   EXPECT_NE(first_bounds.ToString(), last_bounds.ToString());
   EXPECT_EQ(overflow_bounds.ToString(), last_bounds.ToString());
 }
 
 // Checks that shelf view contents are considered in the correct drag group.
 TEST_F(ShelfViewTest, EnforceDragType) {
-  EXPECT_TRUE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_PLATFORM_APP));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_SHORTCUT));
-  EXPECT_FALSE(
-      test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_BROWSER_SHORTCUT));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_WINDOWED_APP));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_LIST));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_PLATFORM_APP, TYPE_APP_PANEL));
+  EXPECT_TRUE(test_api_->SameDragType(TYPE_APP, TYPE_APP));
+  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP, TYPE_APP_SHORTCUT));
+  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP, TYPE_BROWSER_SHORTCUT));
+  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP, TYPE_APP_LIST));
+  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP, TYPE_APP_PANEL));
 
   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_SHORTCUT));
   EXPECT_TRUE(
       test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_BROWSER_SHORTCUT));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_WINDOWED_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_SHORTCUT, TYPE_APP_PANEL));
 
   EXPECT_TRUE(
       test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_BROWSER_SHORTCUT));
-  EXPECT_FALSE(
-      test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_WINDOWED_APP));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_BROWSER_SHORTCUT, TYPE_APP_PANEL));
 
-  EXPECT_TRUE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_WINDOWED_APP));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_APP_LIST));
-  EXPECT_FALSE(test_api_->SameDragType(TYPE_WINDOWED_APP, TYPE_APP_PANEL));
-
   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_LIST, TYPE_APP_LIST));
   EXPECT_FALSE(test_api_->SameDragType(TYPE_APP_LIST, TYPE_APP_PANEL));
 
   EXPECT_TRUE(test_api_->SameDragType(TYPE_APP_PANEL, TYPE_APP_PANEL));
 }
 
 // Adds platform app button until overflow and verifies that the last added
 // platform app button is hidden.
 TEST_F(ShelfViewTest, AddBrowserUntilOverflow) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button until overflow.
   int items_added = 0;
-  ShelfID last_added = AddPlatformApp();
+  ShelfID last_added = AddApp();
   while (!test_api_->IsOverflowButtonVisible()) {
     // Added button is visible after animation while in this loop.
     EXPECT_TRUE(GetButtonByID(last_added)->visible());
 
-    last_added = AddPlatformApp();
+    last_added = AddApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // The last added button should be invisible.
   EXPECT_FALSE(GetButtonByID(last_added)->visible());
 }
 
 // Adds one platform app button then adds app shortcut until overflow. Verifies
 // that the browser button gets hidden on overflow and last added app shortcut
 // is still visible.
 TEST_F(ShelfViewTest, AddAppShortcutWithBrowserButtonUntilOverflow) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
-  ShelfID browser_button_id = AddPlatformApp();
+  ShelfID browser_button_id = AddApp();
 
   // Add app shortcut until overflow.
   int items_added = 0;
   ShelfID 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);
   }
 
   // And the platform app button is invisible.
   EXPECT_FALSE(GetButtonByID(browser_button_id)->visible());
 }
 
 TEST_F(ShelfViewTest, AddPanelHidesPlatformAppButton) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button until overflow, remember last visible platform app
   // button.
   int items_added = 0;
-  ShelfID first_added = AddPlatformApp();
+  ShelfID first_added = AddApp();
   EXPECT_TRUE(GetButtonByID(first_added)->visible());
   while (true) {
-    ShelfID added = AddPlatformApp();
+    ShelfID added = AddApp();
     if (test_api_->IsOverflowButtonVisible()) {
       EXPECT_FALSE(GetButtonByID(added)->visible());
       RemoveByID(added);
       break;
     }
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   ShelfID panel = AddPanel();
   EXPECT_TRUE(test_api_->IsOverflowButtonVisible());
 
   RemoveByID(panel);
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 }
 
 // When there are more panels then platform app buttons we should hide panels
 // rather than platform apps.
 TEST_F(ShelfViewTest, PlatformAppHidesExcessPanels) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
-  ShelfID platform_app = AddPlatformApp();
+  ShelfID platform_app = AddApp();
   ShelfID first_panel = AddPanel();
 
   EXPECT_TRUE(GetButtonByID(platform_app)->visible());
   EXPECT_TRUE(GetButtonByID(first_panel)->visible());
 
   // Add panels until there is an overflow.
   ShelfID 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 platform apps needing
   // space.
   EXPECT_FALSE(GetButtonByID(first_panel)->visible());
   EXPECT_TRUE(GetButtonByID(last_panel)->visible());
   EXPECT_TRUE(GetButtonByID(platform_app)->visible());
 
   // Adding platform apps should eventually begin to hide platform apps. We will
   // add platform apps until either the last panel or platform app is hidden.
   items_added = 0;
   while (GetButtonByID(platform_app)->visible() &&
          GetButtonByID(last_panel)->visible()) {
-    platform_app = AddPlatformApp();
+    platform_app = AddApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
   EXPECT_TRUE(GetButtonByID(last_panel)->visible());
   EXPECT_FALSE(GetButtonByID(platform_app)->visible());
 }
 
 // Making sure that no buttons on the shelf will ever overlap after adding many
 // of them.
 TEST_F(ShelfViewTest, AssertNoButtonsOverlap) {
   std::vector<ShelfID> button_ids;
   // Add app icons until the overflow button is visible.
   while (!test_api_->IsOverflowButtonVisible()) {
-    ShelfID id = AddPlatformApp();
+    ShelfID id = AddApp();
     button_ids.push_back(id);
   }
   ASSERT_LT(button_ids.size(), 10000U);
   ASSERT_GT(button_ids.size(), 2U);
 
   // Remove 2 icons to make more room for panel icons, the overflow button
   // should go away.
   for (int i = 0; i < 2; ++i) {
     ShelfID id = button_ids.back();
     RemoveByID(id);
@@ skipping 66 matching lines @@
 
 // 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(ShelfViewTest, RemoveButtonRevealsOverflowed) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app buttons until overflow.
   int items_added = 0;
-  ShelfID first_added = AddPlatformApp();
+  ShelfID first_added = AddApp();
   ShelfID last_added = first_added;
   while (!test_api_->IsOverflowButtonVisible()) {
-    last_added = AddPlatformApp();
+    last_added = AddApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // Expect add more than 1 button. First added is visible and last is not.
   EXPECT_NE(first_added, last_added);
   EXPECT_TRUE(GetButtonByID(first_added)->visible());
   EXPECT_FALSE(GetButtonByID(last_added)->visible());
 
   // Remove first added.
   RemoveByID(first_added);
 
   // Last added button becomes visible and overflow chevron is gone.
   EXPECT_TRUE(GetButtonByID(last_added)->visible());
   EXPECT_EQ(1.0f, GetButtonByID(last_added)->layer()->opacity());
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 }
 
 // Verifies that remove last overflowed button should hide overflow chevron.
 TEST_F(ShelfViewTest, RemoveLastOverflowed) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button until overflow.
   int items_added = 0;
-  ShelfID last_added = AddPlatformApp();
+  ShelfID last_added = AddApp();
   while (!test_api_->IsOverflowButtonVisible()) {
-    last_added = AddPlatformApp();
+    last_added = AddApp();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   RemoveByID(last_added);
   EXPECT_FALSE(test_api_->IsOverflowButtonVisible());
 }
 
 // Adds platform app button without waiting for animation to finish and verifies
 // that all added buttons are visible.
 TEST_F(ShelfViewTest, AddButtonQuickly) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add a few platform buttons quickly without wait for animation.
   int added_count = 0;
   while (!test_api_->IsOverflowButtonVisible()) {
-    AddPlatformAppNoWait();
+    AddAppNoWait();
     ++added_count;
     ASSERT_LT(added_count, 10000);
   }
 
   // ShelfView 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();
 
@@ skipping 197 matching lines @@
 
   EXPECT_TRUE(selection_tracker->WasSelected());
 }
 
 // Confirm that item status changes are reflected in the buttons.
 TEST_F(ShelfViewTest, ShelfItemStatus) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
-  ShelfID last_added = AddPlatformApp();
+  ShelfID last_added = AddApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
   ShelfButton* button = GetButtonByID(last_added);
   ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
 }
 
 // Confirm that item status changes are reflected in the buttons
 // for platform apps.
 TEST_F(ShelfViewTest, ShelfItemStatusPlatformApp) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add platform app button.
-  ShelfID last_added = AddPlatformApp();
+  ShelfID last_added = AddApp();
   ShelfItem item = GetItemByID(last_added);
   int index = model_->ItemIndexByID(last_added);
   ShelfButton* button = GetButtonByID(last_added);
   ASSERT_EQ(ShelfButton::STATE_RUNNING, button->state());
   item.status = STATUS_ACTIVE;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ACTIVE, button->state());
   item.status = STATUS_ATTENTION;
   model_->Set(index, item);
   ASSERT_EQ(ShelfButton::STATE_ATTENTION, button->state());
 }
 
 // Confirm that shelf item bounds are correctly updated on shelf changes.
 TEST_F(ShelfViewTest, ShelfItemBoundsCheck) {
   VerifyShelfItemBoundsAreValid();
   shelf_view_->wm_shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
   shelf_view_->wm_shelf()->SetAutoHideBehavior(SHELF_AUTO_HIDE_BEHAVIOR_NEVER);
   test_api_->RunMessageLoopUntilAnimationsDone();
   VerifyShelfItemBoundsAreValid();
 }
 
 TEST_F(ShelfViewTest, ShelfTooltipTest) {
   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();
+  ShelfID platform_button_id = AddApp();
 
   ShelfButton* app_button = GetButtonByID(app_button_id);
   ShelfButton* platform_button = GetButtonByID(platform_button_id);
 
   ShelfTooltipManager* tooltip_manager = test_api_->tooltip_manager();
   EXPECT_TRUE(test_api_->shelf_view()->GetWidget()->GetNativeWindow());
   ui::test::EventGenerator& generator = GetEventGenerator();
 
   generator.MoveMouseTo(app_button->GetBoundsInScreen().CenterPoint());
   // There's a delay to show the tooltip, so it's not visible yet.
@@ skipping 61 matching lines @@
   tooltip_manager->ShowTooltip(app_button);
   EXPECT_TRUE(tooltip_manager->IsVisible());
 
   // Changing shelf alignment hides the tooltip.
   GetPrimaryShelf()->SetAlignment(SHELF_ALIGNMENT_LEFT);
   EXPECT_FALSE(tooltip_manager->IsVisible());
 }
 
 TEST_F(ShelfViewTest, ShouldHideTooltipTest) {
   ShelfID app_button_id = AddAppShortcut();
-  ShelfID platform_button_id = AddPlatformApp();
+  ShelfID platform_button_id = AddApp();
 
   // The tooltip shouldn't hide if the mouse is on normal buttons.
   for (int i = 0; i < test_api_->GetButtonCount(); i++) {
     ShelfButton* button = test_api_->GetButton(i);
     if (!button)
       continue;
 
     EXPECT_FALSE(shelf_view_->ShouldHideTooltip(
         button->GetMirroredBounds().CenterPoint()))
         << "ShelfView tries to hide on button " << i;
@@ skipping 99 matching lines @@
 // Resizing shelf view while an add animation without fade-in is running,
 // which happens when overflow happens. App list button should end up in its
 // new ideal bounds.
 TEST_F(ShelfViewTest, ResizeDuringOverflowAddAnimation) {
   // All buttons should be visible.
   ASSERT_EQ(test_api_->GetButtonCount(), test_api_->GetLastVisibleIndex() + 1);
 
   // Add buttons until overflow. Let the non-overflow add animations finish but
   // leave the last running.
   int items_added = 0;
-  AddPlatformAppNoWait();
+  AddAppNoWait();
   while (!test_api_->IsOverflowButtonVisible()) {
     test_api_->RunMessageLoopUntilAnimationsDone();
-    AddPlatformAppNoWait();
+    AddAppNoWait();
     ++items_added;
     ASSERT_LT(items_added, 10000);
   }
 
   // Resize shelf view with that animation running and stay overflown.
   gfx::Rect bounds = shelf_view_->bounds();
   bounds.set_width(bounds.width() - GetShelfConstant(SHELF_SIZE));
   shelf_view_->SetBoundsRect(bounds);
   ASSERT_TRUE(test_api_->IsOverflowButtonVisible());
 
@@ skipping 232 matching lines @@
   TestDraggingAnItemFromOverflowToShelf(false);
   TestDraggingAnItemFromOverflowToShelf(true);
 }
 
 // Checks creating app shortcut for an opened platform app in overflow bubble
 // should be invisible to the shelf. See crbug.com/605793.
 TEST_F(ShelfViewTest, CheckOverflowStatusPinOpenedAppToShelf) {
   AddButtonsUntilOverflow();
 
   // Add a running Platform app.
-  ShelfID platform_app_id = AddPlatformApp();
+  ShelfID platform_app_id = AddApp();
   EXPECT_FALSE(GetButtonByID(platform_app_id)->visible());
 
   // Make the added running platform app to be an app shortcut.
   // This app shortcut should be a swapped view in overflow bubble, which is
   // invisible.
   SetShelfItemTypeToAppShortcut(platform_app_id);
   EXPECT_FALSE(GetButtonByID(platform_app_id)->visible());
 }
 
 // Tests that the AppListButton renders as active in response to touches.
@@ skipping 1354 matching lines @@
                 IsEmpty());
 
     ASSERT_TRUE(test_api_->IsShowingOverflowBubble());
   }
 }
 
 #endif  // !defined(OS_WIN)
 
 }  // namespace test
 }  // namespace ash