| // 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 <vector> |
| |
| #include "ash/ash_switches.h" |
| #include "ash/launcher/launcher.h" |
| #include "ash/launcher/launcher_button.h" |
| #include "ash/launcher/launcher_item_delegate_manager.h" |
| #include "ash/launcher/launcher_model.h" |
| #include "ash/launcher/launcher_types.h" |
| #include "ash/root_window_controller.h" |
| #include "ash/shelf/shelf_icon_observer.h" |
| #include "ash/shelf/shelf_layout_manager.h" |
| #include "ash/shelf/shelf_tooltip_manager.h" |
| #include "ash/shelf/shelf_widget.h" |
| #include "ash/shell.h" |
| #include "ash/shell_window_ids.h" |
| #include "ash/test/ash_test_base.h" |
| #include "ash/test/launcher_test_api.h" |
| #include "ash/test/shelf_view_test_api.h" |
| #include "ash/test/shell_test_api.h" |
| #include "ash/test/test_launcher_delegate.h" |
| #include "ash/test/test_launcher_item_delegate.h" |
| #include "base/basictypes.h" |
| #include "base/command_line.h" |
| #include "base/compiler_specific.h" |
| #include "base/memory/scoped_ptr.h" |
| #include "grit/ash_resources.h" |
| #include "ui/aura/root_window.h" |
| #include "ui/aura/test/aura_test_base.h" |
| #include "ui/aura/test/event_generator.h" |
| #include "ui/aura/window.h" |
| #include "ui/base/l10n/l10n_util.h" |
| #include "ui/compositor/layer.h" |
| #include "ui/events/event.h" |
| #include "ui/events/event_constants.h" |
| #include "ui/views/view_model.h" |
| #include "ui/views/widget/widget.h" |
| #include "ui/views/widget/widget_delegate.h" |
| |
| namespace ash { |
| namespace test { |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // ShelfIconObserver tests. |
| |
| class TestShelfIconObserver : public ShelfIconObserver { |
| public: |
| explicit TestShelfIconObserver(Launcher* launcher) |
| : launcher_(launcher), |
| change_notified_(false) { |
| if (launcher_) |
| launcher_->AddIconObserver(this); |
| } |
| |
| virtual ~TestShelfIconObserver() { |
| if (launcher_) |
| launcher_->RemoveIconObserver(this); |
| } |
| |
| // ShelfIconObserver implementation. |
| virtual void OnShelfIconPositionsChanged() OVERRIDE { |
| change_notified_ = true; |
| } |
| |
| int change_notified() const { return change_notified_; } |
| void Reset() { change_notified_ = false; } |
| |
| private: |
| Launcher* launcher_; |
| bool change_notified_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestShelfIconObserver); |
| }; |
| |
| class ShelfViewIconObserverTest : public ash::test::AshTestBase { |
| public: |
| ShelfViewIconObserverTest() {} |
| virtual ~ShelfViewIconObserverTest() {} |
| |
| virtual void SetUp() OVERRIDE { |
| AshTestBase::SetUp(); |
| Launcher* launcher = Launcher::ForPrimaryDisplay(); |
| observer_.reset(new TestShelfIconObserver(launcher)); |
| |
| shelf_view_test_.reset(new ShelfViewTestAPI( |
| LauncherTestAPI(launcher).shelf_view())); |
| shelf_view_test_->SetAnimationDuration(1); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| observer_.reset(); |
| AshTestBase::TearDown(); |
| } |
| |
| TestShelfIconObserver* observer() { return observer_.get(); } |
| |
| ShelfViewTestAPI* shelf_view_test() { |
| return shelf_view_test_.get(); |
| } |
| |
| Launcher* LauncherForSecondaryDisplay() { |
| return Launcher::ForWindow(Shell::GetAllRootWindows()[1]); |
| } |
| |
| private: |
| scoped_ptr<TestShelfIconObserver> observer_; |
| scoped_ptr<ShelfViewTestAPI> shelf_view_test_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ShelfViewIconObserverTest); |
| }; |
| |
| TEST_F(ShelfViewIconObserverTest, AddRemove) { |
| ash::test::TestLauncherDelegate* launcher_delegate = |
| ash::test::TestLauncherDelegate::instance(); |
| ASSERT_TRUE(launcher_delegate); |
| |
| views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW); |
| params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
| params.bounds = gfx::Rect(0, 0, 200, 200); |
| params.context = CurrentContext(); |
| |
| scoped_ptr<views::Widget> widget(new views::Widget()); |
| widget->Init(params); |
| launcher_delegate->AddLauncherItem(widget->GetNativeWindow()); |
| shelf_view_test()->RunMessageLoopUntilAnimationsDone(); |
| EXPECT_TRUE(observer()->change_notified()); |
| observer()->Reset(); |
| |
| widget->Show(); |
| widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow()); |
| shelf_view_test()->RunMessageLoopUntilAnimationsDone(); |
| EXPECT_TRUE(observer()->change_notified()); |
| observer()->Reset(); |
| } |
| |
| // Sometimes fails on trybots on win7_aura. http://crbug.com/177135 |
| #if defined(OS_WIN) |
| #define MAYBE_AddRemoveWithMultipleDisplays \ |
| DISABLED_AddRemoveWithMultipleDisplays |
| #else |
| #define MAYBE_AddRemoveWithMultipleDisplays \ |
| AddRemoveWithMultipleDisplays |
| #endif |
| // Make sure creating/deleting an window on one displays notifies a |
| // launcher on external display as well as one on primary. |
| TEST_F(ShelfViewIconObserverTest, MAYBE_AddRemoveWithMultipleDisplays) { |
| UpdateDisplay("400x400,400x400"); |
| TestShelfIconObserver second_observer(LauncherForSecondaryDisplay()); |
| |
| ash::test::TestLauncherDelegate* launcher_delegate = |
| ash::test::TestLauncherDelegate::instance(); |
| ASSERT_TRUE(launcher_delegate); |
| |
| views::Widget::InitParams params(views::Widget::InitParams::TYPE_WINDOW); |
| params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET; |
| params.bounds = gfx::Rect(0, 0, 200, 200); |
| params.context = CurrentContext(); |
| |
| scoped_ptr<views::Widget> widget(new views::Widget()); |
| widget->Init(params); |
| launcher_delegate->AddLauncherItem(widget->GetNativeWindow()); |
| shelf_view_test()->RunMessageLoopUntilAnimationsDone(); |
| EXPECT_TRUE(observer()->change_notified()); |
| EXPECT_TRUE(second_observer.change_notified()); |
| observer()->Reset(); |
| second_observer.Reset(); |
| |
| widget->GetNativeWindow()->parent()->RemoveChild(widget->GetNativeWindow()); |
| shelf_view_test()->RunMessageLoopUntilAnimationsDone(); |
| EXPECT_TRUE(observer()->change_notified()); |
| EXPECT_TRUE(second_observer.change_notified()); |
| |
| observer()->Reset(); |
| second_observer.Reset(); |
| } |
| |
| TEST_F(ShelfViewIconObserverTest, BoundsChanged) { |
| ash::ShelfWidget* shelf = Shell::GetPrimaryRootWindowController()->shelf(); |
| Launcher* launcher = Launcher::ForPrimaryDisplay(); |
| gfx::Size shelf_size = |
| shelf->GetWindowBoundsInScreen().size(); |
| shelf_size.set_width(shelf_size.width() / 2); |
| ASSERT_GT(shelf_size.width(), 0); |
| launcher->SetShelfViewBounds(gfx::Rect(shelf_size)); |
| // No animation happens for ShelfView bounds change. |
| EXPECT_TRUE(observer()->change_notified()); |
| observer()->Reset(); |
| } |
| |
| //////////////////////////////////////////////////////////////////////////////// |
| // ShelfView tests. |
| |
| class ShelfViewTest : public AshTestBase { |
| public: |
| ShelfViewTest() : model_(NULL), shelf_view_(NULL), browser_index_(1) {} |
| virtual ~ShelfViewTest() {} |
| |
| virtual void SetUp() OVERRIDE { |
| AshTestBase::SetUp(); |
| test::ShellTestApi test_api(Shell::GetInstance()); |
| model_ = test_api.launcher_model(); |
| Launcher* launcher = Launcher::ForPrimaryDisplay(); |
| shelf_view_ = test::LauncherTestAPI(launcher).shelf_view(); |
| |
| // The bounds should be big enough for 4 buttons + overflow chevron. |
| shelf_view_->SetBounds(0, 0, 500, |
| internal::ShelfLayoutManager::GetPreferredShelfSize()); |
| |
| test_api_.reset(new ShelfViewTestAPI(shelf_view_)); |
| test_api_->SetAnimationDuration(1); // Speeds up animation for test. |
| |
| item_manager_ = |
| ash::Shell::GetInstance()->launcher_item_delegate_manager(); |
| DCHECK(item_manager_); |
| |
| // Add browser shortcut launcher item at index 0 for test. |
| AddBrowserShortcut(); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| test_api_.reset(); |
| AshTestBase::TearDown(); |
| } |
| |
| protected: |
| void CreateAndSetLauncherItemDelegateForID(LauncherID id) { |
| scoped_ptr<LauncherItemDelegate> delegate( |
| new ash::test::TestLauncherItemDelegate(NULL)); |
| item_manager_->SetLauncherItemDelegate(id, delegate.Pass()); |
| } |
| |
| LauncherID AddBrowserShortcut() { |
| LauncherItem browser_shortcut; |
| browser_shortcut.type = TYPE_BROWSER_SHORTCUT; |
| |
| LauncherID id = model_->next_id(); |
| model_->AddAt(browser_index_, browser_shortcut); |
| CreateAndSetLauncherItemDelegateForID(id); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| return id; |
| } |
| |
| LauncherID AddAppShortcut() { |
| LauncherItem item; |
| item.type = TYPE_APP_SHORTCUT; |
| item.status = STATUS_CLOSED; |
| |
| LauncherID id = model_->next_id(); |
| model_->Add(item); |
| CreateAndSetLauncherItemDelegateForID(id); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| return id; |
| } |
| |
| LauncherID AddPanel() { |
| LauncherID id = AddPanelNoWait(); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| return id; |
| } |
| |
| LauncherID AddPlatformAppNoWait() { |
| LauncherItem item; |
| item.type = TYPE_PLATFORM_APP; |
| item.status = STATUS_RUNNING; |
| |
| LauncherID id = model_->next_id(); |
| model_->Add(item); |
| CreateAndSetLauncherItemDelegateForID(id); |
| return id; |
| } |
| |
| LauncherID AddPanelNoWait() { |
| LauncherItem item; |
| item.type = TYPE_APP_PANEL; |
| item.status = STATUS_RUNNING; |
| |
| LauncherID id = model_->next_id(); |
| model_->Add(item); |
| CreateAndSetLauncherItemDelegateForID(id); |
| return id; |
| } |
| |
| LauncherID AddPlatformApp() { |
| LauncherID id = AddPlatformAppNoWait(); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| return id; |
| } |
| |
| void RemoveByID(LauncherID id) { |
| model_->RemoveItemAt(model_->ItemIndexByID(id)); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| } |
| |
| internal::LauncherButton* GetButtonByID(LauncherID id) { |
| int index = model_->ItemIndexByID(id); |
| 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) { |
| 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]; |
| 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()); |
| } |
| |
| void VerifyLauncherItemBoundsAreValid() { |
| for (int i=0;i <= test_api_->GetLastVisibleIndex(); ++i) { |
| if (test_api_->GetButton(i)) { |
| gfx::Rect shelf_view_bounds = shelf_view_->GetLocalBounds(); |
| gfx::Rect item_bounds = test_api_->GetBoundsByIndex(i); |
| EXPECT_TRUE(item_bounds.x() >= 0); |
| EXPECT_TRUE(item_bounds.y() >= 0); |
| EXPECT_TRUE(item_bounds.right() <= shelf_view_bounds.width()); |
| EXPECT_TRUE(item_bounds.bottom() <= shelf_view_bounds.height()); |
| } |
| } |
| } |
| |
| views::View* SimulateButtonPressed( |
| internal::LauncherButtonHost::Pointer pointer, |
| int button_index) { |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| views::View* button = test_api_->GetButton(button_index); |
| ui::MouseEvent click_event(ui::ET_MOUSE_PRESSED, |
| button->bounds().origin(), |
| button->GetBoundsInScreen().origin(), 0); |
| button_host->PointerPressedOnButton(button, pointer, click_event); |
| return button; |
| } |
| |
| views::View* SimulateClick(internal::LauncherButtonHost::Pointer pointer, |
| int button_index) { |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| views::View* button = SimulateButtonPressed(pointer, button_index); |
| button_host->PointerReleasedOnButton(button, |
| internal::LauncherButtonHost::MOUSE, |
| false); |
| return button; |
| } |
| |
| views::View* SimulateDrag(internal::LauncherButtonHost::Pointer pointer, |
| int button_index, |
| int destination_index) { |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| views::View* button = SimulateButtonPressed(pointer, button_index); |
| |
| // Drag. |
| views::View* destination = test_api_->GetButton(destination_index); |
| ui::MouseEvent drag_event(ui::ET_MOUSE_DRAGGED, |
| destination->bounds().origin(), |
| destination->GetBoundsInScreen().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) { |
| 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(); |
| // 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 ShowTooltip() { |
| shelf_view_->tooltip_manager()->ShowInternal(); |
| } |
| |
| LauncherModel* model_; |
| internal::ShelfView* shelf_view_; |
| int browser_index_; |
| LauncherItemDelegateManager* item_manager_; |
| |
| scoped_ptr<ShelfViewTestAPI> test_api_; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(ShelfViewTest); |
| }; |
| |
| class ShelfViewLegacyShelfLayoutTest : public ShelfViewTest { |
| public: |
| ShelfViewLegacyShelfLayoutTest() : ShelfViewTest() { |
| browser_index_ = 0; |
| } |
| |
| virtual ~ShelfViewLegacyShelfLayoutTest() {} |
| |
| virtual void SetUp() OVERRIDE { |
| CommandLine::ForCurrentProcess()->AppendSwitch( |
| ash::switches::kAshDisableAlternateShelfLayout); |
| ShelfViewTest::SetUp(); |
| } |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(ShelfViewLegacyShelfLayoutTest); |
| }; |
| |
| class ScopedTextDirectionChange { |
| public: |
| ScopedTextDirectionChange(bool is_rtl) |
| : is_rtl_(is_rtl) { |
| original_locale_ = l10n_util::GetApplicationLocale(std::string()); |
| if (is_rtl_) |
| base::i18n::SetICUDefaultLocale("he"); |
| CheckTextDirectionIsCorrect(); |
| } |
| |
| ~ScopedTextDirectionChange() { |
| if (is_rtl_) |
| base::i18n::SetICUDefaultLocale(original_locale_); |
| } |
| |
| private: |
| void CheckTextDirectionIsCorrect() { |
| ASSERT_EQ(is_rtl_, base::i18n::IsRTL()); |
| } |
| |
| bool is_rtl_; |
| std::string original_locale_; |
| }; |
| |
| class ShelfViewTextDirectionTest |
| : public ShelfViewTest, |
| public testing::WithParamInterface<bool> { |
| public: |
| ShelfViewTextDirectionTest() : text_direction_change_(GetParam()) {} |
| virtual ~ShelfViewTextDirectionTest() {} |
| |
| virtual void SetUp() OVERRIDE { |
| ShelfViewTest::SetUp(); |
| } |
| |
| virtual void TearDown() OVERRIDE { |
| ShelfViewTest::TearDown(); |
| } |
| |
| 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) { |
| LauncherID id = AddPlatformApp(); |
| internal::LauncherButton* 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()); |
| } |
| |
| // 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_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_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button until overflow. |
| int items_added = 0; |
| LauncherID last_added = AddPlatformApp(); |
| while (!test_api_->IsOverflowButtonVisible()) { |
| // Added button is visible after animation while in this loop. |
| EXPECT_TRUE(GetButtonByID(last_added)->visible()); |
| |
| last_added = AddPlatformApp(); |
| ++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_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| LauncherID browser_button_id = AddPlatformApp(); |
| |
| // 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); |
| } |
| |
| // And the platform app button is invisible. |
| EXPECT_FALSE(GetButtonByID(browser_button_id)->visible()); |
| } |
| |
| TEST_F(ShelfViewLegacyShelfLayoutTest, |
| AddAppShortcutWithBrowserButtonUntilOverflow) { |
| // All buttons should be visible. |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| LauncherID browser_button_id = AddPlatformApp(); |
| |
| // 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 platform app button is invisible. |
| EXPECT_FALSE(GetButtonByID(browser_button_id)->visible()); |
| } |
| |
| TEST_F(ShelfViewTest, AddPanelHidesPlatformAppButton) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button until overflow, remember last visible platform app |
| // button. |
| int items_added = 0; |
| LauncherID first_added = AddPlatformApp(); |
| EXPECT_TRUE(GetButtonByID(first_added)->visible()); |
| while (true) { |
| LauncherID added = AddPlatformApp(); |
| if (test_api_->IsOverflowButtonVisible()) { |
| EXPECT_FALSE(GetButtonByID(added)->visible()); |
| RemoveByID(added); |
| break; |
| } |
| ++items_added; |
| ASSERT_LT(items_added, 10000); |
| } |
| |
| LauncherID panel = AddPanel(); |
| EXPECT_TRUE(test_api_->IsOverflowButtonVisible()); |
| |
| RemoveByID(panel); |
| EXPECT_FALSE(test_api_->IsOverflowButtonVisible()); |
| } |
| |
| TEST_F(ShelfViewLegacyShelfLayoutTest, AddPanelHidesPlatformAppButton) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button until overflow, remember last visible platform app |
| // button. |
| int items_added = 0; |
| LauncherID first_added = AddPlatformApp(); |
| EXPECT_TRUE(GetButtonByID(first_added)->visible()); |
| LauncherID last_visible = first_added; |
| while (true) { |
| LauncherID added = AddPlatformApp(); |
| if (test_api_->IsOverflowButtonVisible()) { |
| EXPECT_FALSE(GetButtonByID(added)->visible()); |
| break; |
| } |
| last_visible = added; |
| ++items_added; |
| ASSERT_LT(items_added, 10000); |
| } |
| |
| LauncherID panel = AddPanel(); |
| EXPECT_TRUE(GetButtonByID(panel)->visible()); |
| EXPECT_FALSE(GetButtonByID(last_visible)->visible()); |
| |
| RemoveByID(panel); |
| EXPECT_TRUE(GetButtonByID(last_visible)->visible()); |
| } |
| |
| // When there are more panels then platform app buttons we should hide panels |
| // rather than platform apps. |
| TEST_F(ShelfViewTest, PlatformAppHidesExcessPanels) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button. |
| LauncherID platform_app = AddPlatformApp(); |
| LauncherID first_panel = AddPanel(); |
| |
| EXPECT_TRUE(GetButtonByID(platform_app)->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 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(); |
| ++items_added; |
| ASSERT_LT(items_added, 10000); |
| } |
| EXPECT_TRUE(GetButtonByID(last_panel)->visible()); |
| EXPECT_FALSE(GetButtonByID(platform_app)->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(ShelfViewTest, RemoveButtonRevealsOverflowed) { |
| // All buttons should be visible. |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app buttons until overflow. |
| int items_added = 0; |
| LauncherID first_added = AddPlatformApp(); |
| LauncherID last_added = first_added; |
| while (!test_api_->IsOverflowButtonVisible()) { |
| last_added = AddPlatformApp(); |
| ++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_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button until overflow. |
| int items_added = 0; |
| LauncherID last_added = AddPlatformApp(); |
| while (!test_api_->IsOverflowButtonVisible()) { |
| last_added = AddPlatformApp(); |
| ++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_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add a few platform buttons quickly without wait for animation. |
| int added_count = 0; |
| while (!test_api_->IsOverflowButtonVisible()) { |
| AddPlatformAppNoWait(); |
| ++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(); |
| |
| // Verifies non-overflow buttons are visible. |
| for (int i = 0; i <= test_api_->GetLastVisibleIndex(); ++i) { |
| internal::LauncherButton* button = test_api_->GetButton(i); |
| 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 launcher icon is being |
| // dragged. |
| TEST_F(ShelfViewTest, ModelChangesWhileDragging) { |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| |
| std::vector<std::pair<LauncherID, 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( |
| 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(ShelfViewLegacyShelfLayoutTest, ModelChangesWhileDragging) { |
| internal::LauncherButtonHost* button_host = shelf_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); |
| EXPECT_TRUE(model_->items()[2].type == TYPE_BROWSER_SHORTCUT); |
| |
| // Dragging changes model order. |
| 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)); |
| |
| // Cancelling the drag operation restores previous order. |
| button_host->PointerReleasedOnButton(dragged_button, |
| internal::LauncherButtonHost::MOUSE, |
| true); |
| std::rotate(id_map.begin(), |
| id_map.begin() + 2, |
| id_map.begin() + 3); |
| ASSERT_NO_FATAL_FAILURE(CheckModelIDs(id_map)); |
| |
| // Deleting an item keeps the remaining intact. |
| dragged_button = SimulateDrag(internal::LauncherButtonHost::MOUSE, 0, 2); |
| 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, 0, 2); |
| LauncherID new_id = AddAppShortcut(); |
| id_map.insert(id_map.begin() + 5, |
| 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, 0, 2); |
| 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); |
| } |
| |
| // Check that 2nd drag from the other pointer would be ignored. |
| TEST_F(ShelfViewTest, SimultaneousDrag) { |
| internal::LauncherButtonHost* button_host = shelf_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); |
| 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); |
| |
| // 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)); |
| } |
| |
| // Check that clicking first on one item and then dragging another works as |
| // expected. |
| TEST_F(ShelfViewTest, ClickOneDragAnother) { |
| internal::LauncherButtonHost* button_host = shelf_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); |
| } |
| |
| // Confirm that item status changes are reflected in the buttons. |
| TEST_F(ShelfViewTest, LauncherItemStatus) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button. |
| LauncherID last_added = AddPlatformApp(); |
| LauncherItem item = GetItemByID(last_added); |
| int index = model_->ItemIndexByID(last_added); |
| 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(ShelfViewLegacyShelfLayoutTest, |
| LauncherItemPositionReflectedOnStateChanged) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add 2 items to the launcher. |
| LauncherID item1_id = AddPlatformApp(); |
| 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); |
| } |
| |
| // Confirm that item status changes are reflected in the buttons |
| // for platform apps. |
| TEST_F(ShelfViewTest, LauncherItemStatusPlatformApp) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add platform app button. |
| LauncherID last_added = AddPlatformApp(); |
| LauncherItem item = GetItemByID(last_added); |
| int index = model_->ItemIndexByID(last_added); |
| 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()); |
| } |
| |
| // Confirm that launcher item bounds are correctly updated on shelf changes. |
| TEST_F(ShelfViewTest, LauncherItemBoundsCheck) { |
| VerifyLauncherItemBoundsAreValid(); |
| shelf_view_->shelf_layout_manager()->SetAutoHideBehavior( |
| SHELF_AUTO_HIDE_BEHAVIOR_ALWAYS); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| VerifyLauncherItemBoundsAreValid(); |
| shelf_view_->shelf_layout_manager()->SetAutoHideBehavior( |
| SHELF_AUTO_HIDE_BEHAVIOR_NEVER); |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| VerifyLauncherItemBoundsAreValid(); |
| } |
| |
| TEST_F(ShelfViewTest, ShelfTooltipTest) { |
| ASSERT_EQ(test_api_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Prepare some items to the launcher. |
| LauncherID app_button_id = AddAppShortcut(); |
| LauncherID platform_button_id = AddPlatformApp(); |
| |
| internal::LauncherButton* app_button = GetButtonByID(app_button_id); |
| internal::LauncherButton* platform_button = GetButtonByID(platform_button_id); |
| |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| internal::ShelfTooltipManager* tooltip_manager = |
| shelf_view_->tooltip_manager(); |
| |
| button_host->MouseEnteredButton(app_button); |
| // There's a delay to show the tooltip, so it's not visible yet. |
| EXPECT_FALSE(tooltip_manager->IsVisible()); |
| EXPECT_EQ(app_button, GetTooltipAnchorView()); |
| |
| ShowTooltip(); |
| EXPECT_TRUE(tooltip_manager->IsVisible()); |
| |
| // Once it's visible, it keeps visibility and is pointing to the same |
| // item. |
| button_host->MouseExitedButton(app_button); |
| EXPECT_TRUE(tooltip_manager->IsVisible()); |
| EXPECT_EQ(app_button, GetTooltipAnchorView()); |
| |
| // When entered to another item, it switches to the new item. There is no |
| // delay for the visibility. |
| button_host->MouseEnteredButton(platform_button); |
| EXPECT_TRUE(tooltip_manager->IsVisible()); |
| EXPECT_EQ(platform_button, GetTooltipAnchorView()); |
| |
| button_host->MouseExitedButton(platform_button); |
| 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); |
| EXPECT_FALSE(tooltip_manager->IsVisible()); |
| EXPECT_EQ(platform_button, GetTooltipAnchorView()); |
| } |
| |
| // Verify a fix for crash caused by a tooltip update for a deleted launcher |
| // button, see crbug.com/288838. |
| TEST_F(ShelfViewTest, RemovingItemClosesTooltip) { |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| internal::ShelfTooltipManager* tooltip_manager = |
| shelf_view_->tooltip_manager(); |
| |
| // Add an item to the launcher. |
| LauncherID app_button_id = AddAppShortcut(); |
| internal::LauncherButton* app_button = GetButtonByID(app_button_id); |
| |
| // Spawn a tooltip on that item. |
| button_host->MouseEnteredButton(app_button); |
| ShowTooltip(); |
| 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. |
| ash::Shell::GetInstance()->SetShelfAlignment( |
| ash::SHELF_ALIGNMENT_LEFT, |
| ash::Shell::GetPrimaryRootWindow()); |
| } |
| |
| // Changing the shelf alignment closes any open tooltip. |
| TEST_F(ShelfViewTest, ShelfAlignmentClosesTooltip) { |
| internal::LauncherButtonHost* button_host = shelf_view_; |
| internal::ShelfTooltipManager* tooltip_manager = |
| shelf_view_->tooltip_manager(); |
| |
| // Add an item to the launcher. |
| LauncherID app_button_id = AddAppShortcut(); |
| internal::LauncherButton* app_button = GetButtonByID(app_button_id); |
| |
| // Spawn a tooltip on the item. |
| button_host->MouseEnteredButton(app_button); |
| ShowTooltip(); |
| EXPECT_TRUE(tooltip_manager->IsVisible()); |
| |
| // Changing shelf alignment hides the tooltip. |
| ash::Shell::GetInstance()->SetShelfAlignment( |
| ash::SHELF_ALIGNMENT_LEFT, |
| ash::Shell::GetPrimaryRootWindow()); |
| EXPECT_FALSE(tooltip_manager->IsVisible()); |
| } |
| |
| TEST_F(ShelfViewTest, ShouldHideTooltipTest) { |
| LauncherID app_button_id = AddAppShortcut(); |
| LauncherID platform_button_id = AddPlatformApp(); |
| |
| // The tooltip shouldn't hide if the mouse is on normal buttons. |
| for (int i = 0; i < test_api_->GetButtonCount(); i++) { |
| internal::LauncherButton* button = test_api_->GetButton(i); |
| if (!button) |
| continue; |
| |
| EXPECT_FALSE(shelf_view_->ShouldHideTooltip( |
| button->GetMirroredBounds().CenterPoint())) |
| << "ShelfView tries to hide on button " << i; |
| } |
| |
| // The tooltip should not hide on the app-list button. |
| views::View* app_list_button = shelf_view_->GetAppListButtonView(); |
| EXPECT_FALSE(shelf_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 platform_button_rect = |
| GetButtonByID(platform_button_id)->GetMirroredBounds(); |
| ASSERT_FALSE(app_button_rect.Intersects(platform_button_rect)); |
| EXPECT_FALSE(shelf_view_->ShouldHideTooltip( |
| gfx::UnionRects(app_button_rect, platform_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(); i++) { |
| internal::LauncherButton* button = test_api_->GetButton(i); |
| if (!button) |
| continue; |
| |
| all_area.Union(button->GetMirroredBounds()); |
| } |
| all_area.Union(shelf_view_->GetAppListButtonView()->GetMirroredBounds()); |
| EXPECT_FALSE(shelf_view_->ShouldHideTooltip(all_area.origin())); |
| EXPECT_FALSE(shelf_view_->ShouldHideTooltip( |
| gfx::Point(all_area.right() - 1, all_area.bottom() - 1))); |
| EXPECT_TRUE(shelf_view_->ShouldHideTooltip( |
| gfx::Point(all_area.right(), all_area.y()))); |
| EXPECT_TRUE(shelf_view_->ShouldHideTooltip( |
| gfx::Point(all_area.x() - 1, all_area.y()))); |
| EXPECT_TRUE(shelf_view_->ShouldHideTooltip( |
| gfx::Point(all_area.x(), all_area.y() - 1))); |
| EXPECT_TRUE(shelf_view_->ShouldHideTooltip( |
| gfx::Point(all_area.x(), all_area.bottom()))); |
| } |
| |
| TEST_F(ShelfViewTest, ShouldHideTooltipWithAppListWindowTest) { |
| Shell::GetInstance()->ToggleAppList(NULL); |
| ASSERT_TRUE(Shell::GetInstance()->GetAppListWindow()); |
| |
| // The tooltip shouldn't hide if the mouse is on normal buttons. |
| for (int i = 1; i < test_api_->GetButtonCount(); i++) { |
| internal::LauncherButton* button = test_api_->GetButton(i); |
| if (!button) |
| continue; |
| |
| EXPECT_FALSE(shelf_view_->ShouldHideTooltip( |
| button->GetMirroredBounds().CenterPoint())) |
| << "ShelfView tries to hide on button " << i; |
| } |
| |
| // 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) { |
| internal::ShelfTooltipManager* tooltip_manager = |
| shelf_view_->tooltip_manager(); |
| tooltip_manager->CreateZeroDelayTimerForTest(); |
| aura::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()); |
| // 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); |
| // 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); |
| // 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()); |
| } |
| |
| // 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_->GetLastVisibleIndex() + 1, |
| test_api_->GetButtonCount()); |
| |
| // Add buttons until overflow. Let the non-overflow add animations finish but |
| // leave the last running. |
| int items_added = 0; |
| AddPlatformAppNoWait(); |
| while (!test_api_->IsOverflowButtonVisible()) { |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| AddPlatformAppNoWait(); |
| ++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() - kLauncherPreferredSize); |
| shelf_view_->SetBoundsRect(bounds); |
| ASSERT_TRUE(test_api_->IsOverflowButtonVisible()); |
| |
| // Finish the animation. |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| |
| // App list button should ends up in its new ideal bounds. |
| 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(ShelfViewLegacyShelfLayoutTest, 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()); |
| } |
| |
| class ShelfViewVisibleBoundsTest : public ShelfViewTest, |
| public testing::WithParamInterface<bool> { |
| public: |
| ShelfViewVisibleBoundsTest() : text_direction_change_(GetParam()) {} |
| |
| void CheckAllItemsAreInBounds() { |
| gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen(); |
| gfx::Rect launcher_bounds = shelf_view_->GetBoundsInScreen(); |
| EXPECT_TRUE(launcher_bounds.Contains(visible_bounds)); |
| for (int i = 0; i < test_api_->GetButtonCount(); ++i) |
| if (internal::LauncherButton* button = test_api_->GetButton(i)) |
| EXPECT_TRUE(visible_bounds.Contains(button->GetBoundsInScreen())); |
| CheckAppListButtonIsInBounds(); |
| } |
| |
| void CheckAppListButtonIsInBounds() { |
| gfx::Rect visible_bounds = shelf_view_->GetVisibleItemsBoundsInScreen(); |
| gfx::Rect app_list_button_bounds = shelf_view_->GetAppListButtonView()-> |
| GetBoundsInScreen(); |
| EXPECT_TRUE(visible_bounds.Contains(app_list_button_bounds)); |
| } |
| |
| private: |
| ScopedTextDirectionChange text_direction_change_; |
| |
| DISALLOW_COPY_AND_ASSIGN(ShelfViewVisibleBoundsTest); |
| }; |
| |
| TEST_P(ShelfViewVisibleBoundsTest, ItemsAreInBounds) { |
| // Adding elements leaving some empty space. |
| for (int i = 0; i < 3; i++) { |
| AddAppShortcut(); |
| } |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| EXPECT_FALSE(test_api_->IsOverflowButtonVisible()); |
| CheckAllItemsAreInBounds(); |
| // Same for overflow case. |
| while (!test_api_->IsOverflowButtonVisible()) { |
| AddAppShortcut(); |
| } |
| test_api_->RunMessageLoopUntilAnimationsDone(); |
| CheckAllItemsAreInBounds(); |
| } |
| |
| INSTANTIATE_TEST_CASE_P(LtrRtl, ShelfViewTextDirectionTest, testing::Bool()); |
| INSTANTIATE_TEST_CASE_P(VisibleBounds, ShelfViewVisibleBoundsTest, |
| testing::Bool()); |
| |
| } // namespace test |
| } // namespace ash |