| // Copyright 2023 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/ui/views/toolbar/toolbar_controller.h" |
| |
| #include <gtest/gtest.h> |
| |
| #include <memory> |
| #include <variant> |
| |
| #include "base/memory/raw_ptr.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "chrome/browser/ui/toolbar/pinned_toolbar/pinned_toolbar_actions_model.h" |
| #include "chrome/browser/ui/views/chrome_layout_provider.h" |
| #include "chrome/browser/ui/views/toolbar/overflow_button.h" |
| #include "chrome/browser/ui/views/toolbar/pinned_toolbar_button_status_indicator.h" |
| #include "chrome/browser/ui/views/toolbar/toolbar_view.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "chrome/test/views/chrome_views_test_base.h" |
| #include "components/vector_icons/vector_icons.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "ui/actions/actions.h" |
| #include "ui/events/test/event_generator.h" |
| #include "ui/gfx/geometry/size.h" |
| #include "ui/menus/simple_menu_model.h" |
| #include "ui/views/controls/menu/menu_item_view.h" |
| #include "ui/views/controls/menu/submenu_view.h" |
| #include "ui/views/interaction/element_tracker_views.h" |
| #include "ui/views/layout/fill_layout.h" |
| #include "ui/views/layout/flex_layout.h" |
| #include "ui/views/layout/flex_layout_types.h" |
| #include "ui/views/test/views_test_base.h" |
| #include "ui/views/test/views_test_utils.h" |
| #include "ui/views/view_class_properties.h" |
| #include "ui/views/widget/widget.h" |
| #include "ui/views/widget/widget_utils.h" |
| |
| namespace { |
| // Toolbar button size is ~34dp. |
| constexpr gfx::Size kButtonSize(34, 34); |
| |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyButton1); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyButton2); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyButton3); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyButton4); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyObservedView); |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyActivateView); |
| |
| class TestDelegate : public ToolbarController::PinnedActionsDelegate { |
| public: |
| MOCK_METHOD(void, |
| DummyAction, |
| (actions::ActionItem*, actions::ActionInvocationContext)); |
| TestDelegate() { |
| for (const auto& id : action_ids_) { |
| action_items_.push_back( |
| actions::ActionItem::ActionItemBuilder( |
| base::BindRepeating(&TestDelegate::DummyAction, |
| base::Unretained(this))) |
| .SetActionId(id) |
| .SetImage( |
| ui::ImageModel::FromVectorIcon(vector_icons::kDogfoodIcon)) |
| .SetProperty(kActionItemUnderlineIndicatorKey, true) |
| .SetText( |
| base::StrCat({u"DummyAction", base::NumberToString16(id)})) |
| .Build()); |
| if (id == 0) { |
| kIdToOverflowedMap_[id] = false; |
| } else { |
| kIdToOverflowedMap_[id] = true; |
| ++overflowed_count_; |
| } |
| kIdToItemMap_[id] = action_items_[id].get(); |
| } |
| } |
| ~TestDelegate() override = default; |
| |
| actions::ActionItem* GetActionItemFor(actions::ActionId id) override { |
| return kIdToItemMap_.at(id); |
| } |
| bool IsOverflowed(actions::ActionId id) override { |
| return kIdToOverflowedMap_.at(id); |
| } |
| views::View* GetContainerView() override { return container_view_; } |
| void SetContainerView(views::View* view) { container_view_ = view; } |
| bool ShouldAnyButtonsOverflow(gfx::Size available_size) const override { |
| return true; |
| } |
| int get_overflowed_count() { return overflowed_count_; } |
| std::vector<actions::ActionId> get_action_ids() { return action_ids_; } |
| |
| const std::vector<actions::ActionId>& PinnedActionIds() const override { |
| return action_ids_; |
| } |
| |
| private: |
| int overflowed_count_ = 0; |
| std::vector<actions::ActionId> action_ids_ = {0, 1, 2}; |
| std::vector<std::unique_ptr<actions::ActionItem>> action_items_; |
| base::flat_map<actions::ActionId, |
| raw_ptr<actions::ActionItem, CtnExperimental>> |
| kIdToItemMap_; |
| base::flat_map<actions::ActionId, bool> kIdToOverflowedMap_; |
| raw_ptr<views::View> container_view_; |
| }; |
| |
| class TestDelegateFromModel : public ToolbarController::PinnedActionsDelegate { |
| public: |
| MOCK_METHOD(void, |
| DummyAction, |
| (actions::ActionItem*, actions::ActionInvocationContext)); |
| explicit TestDelegateFromModel(PinnedToolbarActionsModel* model) { |
| model_ = model; |
| } |
| ~TestDelegateFromModel() override = default; |
| |
| actions::ActionItem* GetActionItemFor(actions::ActionId id) override { |
| for (const auto& action_item : action_items_) { |
| if (action_item->GetActionId() == id) { |
| return action_item.get(); |
| } |
| } |
| action_items_.push_back( |
| actions::ActionItem::ActionItemBuilder( |
| base::BindRepeating(&TestDelegateFromModel::DummyAction, |
| base::Unretained(this))) |
| .SetActionId(id) |
| .SetImage( |
| ui::ImageModel::FromVectorIcon(vector_icons::kDogfoodIcon)) |
| .SetProperty(kActionItemUnderlineIndicatorKey, true) |
| .SetText(base::StrCat({u"DummyAction", base::NumberToString16(id)})) |
| .Build()); |
| return action_items_.back().get(); |
| } |
| bool IsOverflowed(actions::ActionId id) override { return false; } |
| views::View* GetContainerView() override { return &container_view_; } |
| bool ShouldAnyButtonsOverflow(gfx::Size available_size) const override { |
| return false; |
| } |
| const std::vector<actions::ActionId>& PinnedActionIds() const override { |
| return model_->PinnedActionIds(); |
| } |
| |
| private: |
| raw_ptr<PinnedToolbarActionsModel> model_; |
| views::View container_view_; |
| std::vector<std::unique_ptr<actions::ActionItem>> action_items_; |
| }; |
| |
| class MockToolbarController : public ToolbarController { |
| public: |
| MockToolbarController( |
| const std::vector<ToolbarController::ResponsiveElementInfo>& |
| responsive_elements, |
| const std::vector<ui::ElementIdentifier>& elements_in_overflow_order, |
| int element_flex_order_start, |
| views::View* toolbar_container_view, |
| OverflowButton* overflow_button, |
| TestDelegate* delegate, |
| TestingProfile* profile) |
| : ToolbarController(responsive_elements, |
| elements_in_overflow_order, |
| element_flex_order_start, |
| toolbar_container_view, |
| overflow_button, |
| delegate, |
| PinnedToolbarActionsModel::Get(profile)) {} |
| MOCK_METHOD(bool, PopOut, (ui::ElementIdentifier identifier), (override)); |
| MOCK_METHOD(bool, EndPopOut, (ui::ElementIdentifier identifier), (override)); |
| }; |
| |
| class PopOutHandlerTest : public ChromeViewsTestBase { |
| public: |
| PopOutHandlerTest() = default; |
| |
| PopOutHandlerTest(const PopOutHandlerTest&) = delete; |
| PopOutHandlerTest& operator=(const PopOutHandlerTest&) = delete; |
| |
| ~PopOutHandlerTest() override = default; |
| |
| protected: |
| views::Widget* widget() { return widget_.get(); } |
| views::View* container_view() { return container_view_; } |
| OverflowButton* overflow_button() { return overflow_button_; } |
| |
| private: |
| std::unique_ptr<views::Widget> widget_; |
| raw_ptr<views::View, DanglingUntriaged> container_view_; |
| raw_ptr<OverflowButton, DanglingUntriaged> overflow_button_; |
| |
| void SetUp() override { |
| ChromeViewsTestBase::SetUp(); |
| |
| widget_ = std::make_unique<views::Widget>(); |
| views::Widget::InitParams params = |
| CreateParams(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, |
| views::Widget::InitParams::TYPE_WINDOW_FRAMELESS); |
| params.bounds = gfx::Rect(0, 0, 650, 650); |
| widget_->Init(std::move(params)); |
| widget_->Show(); |
| |
| std::unique_ptr<views::View> toolbar_container_view = |
| std::make_unique<views::View>(); |
| toolbar_container_view |
| ->SetLayoutManager(std::make_unique<views::FlexLayout>()) |
| ->SetOrientation(views::LayoutOrientation::kHorizontal) |
| .SetCrossAxisAlignment(views::LayoutAlignment::kCenter) |
| .SetDefault(views::kFlexBehaviorKey, |
| views::FlexSpecification( |
| views::LayoutOrientation::kHorizontal, |
| views::MinimumFlexSizeRule::kPreferredSnapToZero, |
| views::MaximumFlexSizeRule::kPreferred)); |
| container_view_ = |
| widget_->SetContentsView(std::move(toolbar_container_view)); |
| |
| auto overflow_button = std::make_unique<OverflowButton>(); |
| overflow_button_ = |
| container_view_->AddChildView(std::move(overflow_button)); |
| } |
| |
| void TearDown() override { |
| widget_.reset(); |
| ChromeViewsTestBase::TearDown(); |
| } |
| }; |
| |
| TEST_F(PopOutHandlerTest, PopOutAndEndPopOut) { |
| DEFINE_LOCAL_ELEMENT_IDENTIFIER_VALUE(kDummyButton); |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| auto test_profile = std::make_unique<TestingProfile>(); |
| |
| MockToolbarController toolbar_controller( |
| std::vector<ToolbarController::ResponsiveElementInfo>{ |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo( |
| kDummyButton, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView, kDummyObservedView), |
| false)}, |
| std::vector<ui::ElementIdentifier>({kDummyButton}), 1, container_view(), |
| overflow_button(), test_delegate.get(), test_profile.get()); |
| |
| overflow_button()->set_toolbar_controller(&toolbar_controller); |
| |
| ui::ElementContext context = |
| views::ElementTrackerViews::GetContextForWidget(widget()); |
| ToolbarController::PopOutHandler pop_out_controller( |
| &toolbar_controller, context, kDummyButton, kDummyObservedView); |
| |
| EXPECT_CALL(toolbar_controller, PopOut(kDummyButton)); |
| auto observed_view = std::make_unique<views::View>(); |
| observed_view->SetProperty(views::kElementIdentifierKey, kDummyObservedView); |
| views::View* view = container_view()->AddChildView(std::move(observed_view)); |
| |
| EXPECT_CALL(toolbar_controller, EndPopOut(kDummyButton)); |
| container_view()->RemoveChildViewT<views::View>(view); |
| } |
| |
| constexpr int kElementFlexOrderStart = 1; |
| |
| } // namespace |
| |
| class TestToolbarController : public ToolbarController { |
| public: |
| TestToolbarController( |
| const std::vector<ToolbarController::ResponsiveElementInfo>& |
| responsive_elements, |
| const std::vector<ui::ElementIdentifier>& elements_in_overflow_order, |
| int element_flex_order_start, |
| views::View* toolbar_container_view, |
| OverflowButton* overflow_button, |
| TestDelegate* delegate, |
| PinnedToolbarActionsModel* model) |
| : ToolbarController(responsive_elements, |
| elements_in_overflow_order, |
| element_flex_order_start, |
| toolbar_container_view, |
| overflow_button, |
| delegate, |
| model) {} |
| |
| std::u16string GetMenuText(const ToolbarController::ResponsiveElementInfo& |
| element_info) const override { |
| static const base::flat_map<ui::ElementIdentifier, std::u16string> |
| kToolbarToMenuTextMap = {{kDummyButton1, u"DummyButton1"}, |
| {kDummyButton2, u"DummyButton2"}, |
| {kDummyButton3, u"DummyButton3"}, |
| {kDummyButton4, u"DummyButton4"}}; |
| |
| return kToolbarToMenuTextMap.at( |
| std::get<ToolbarController::ElementIdInfo>(element_info.overflow_id) |
| .overflow_identifier); |
| } |
| }; |
| |
| class ToolbarControllerUnitTest : public ChromeViewsTestBase { |
| public: |
| ToolbarControllerUnitTest() = default; |
| ToolbarControllerUnitTest(const ToolbarControllerUnitTest&) = delete; |
| ToolbarControllerUnitTest& operator=(const ToolbarControllerUnitTest&) = |
| delete; |
| ~ToolbarControllerUnitTest() override = default; |
| |
| void SetUp() override { |
| ChromeViewsTestBase::SetUp(); |
| widget_ = |
| CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET); |
| widget_->Show(); |
| |
| std::unique_ptr<views::View> toolbar_container_view = |
| std::make_unique<views::View>(); |
| toolbar_container_view |
| ->SetLayoutManager(std::make_unique<views::FlexLayout>()) |
| ->SetOrientation(views::LayoutOrientation::kHorizontal) |
| .SetCrossAxisAlignment(views::LayoutAlignment::kCenter) |
| .SetDefault(views::kFlexBehaviorKey, |
| views::FlexSpecification( |
| views::LayoutOrientation::kHorizontal, |
| views::MinimumFlexSizeRule::kPreferredSnapToZero, |
| views::MaximumFlexSizeRule::kPreferred)); |
| toolbar_container_view_ = |
| widget_->SetContentsView(std::move(toolbar_container_view)); |
| |
| std::vector<ui::ElementIdentifier> element_ids = { |
| kDummyButton1, kDummyButton2, kDummyButton3}; |
| InitToolbarContainerViewWithTestButtons(element_ids); |
| |
| auto overflow_button = std::make_unique<OverflowButton>(); |
| overflow_button_ = |
| toolbar_container_view_->AddChildView(std::move(overflow_button)); |
| overflow_button_->SetVisible(false); |
| test_delegate_ = std::make_unique<TestDelegate>(); |
| testing_profile_ = std::make_unique<TestingProfile>(); |
| toolbar_controller_ = std::make_unique<TestToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>{ |
| {ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo( |
| kDummyButton1, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView, kDummyObservedView), |
| false), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo( |
| kDummyButton2, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView, kDummyObservedView), |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo( |
| kDummyButton3, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView, kDummyObservedView), |
| true)}}, |
| std::vector<ui::ElementIdentifier>( |
| {kDummyButton3, kDummyButton2, kDummyButton1}), |
| kElementFlexOrderStart, toolbar_container_view_, overflow_button_, |
| test_delegate_.get(), |
| PinnedToolbarActionsModel::Get(testing_profile_.get())); |
| overflow_button_->set_toolbar_controller(toolbar_controller_.get()); |
| event_generator_ = std::make_unique<ui::test::EventGenerator>( |
| views::GetRootWindow(widget_.get())); |
| } |
| |
| // Add test buttons with `ids` to `toolbar_container_view_`. |
| void InitToolbarContainerViewWithTestButtons( |
| std::vector<ui::ElementIdentifier> ids) { |
| for (size_t i = 0; i < ids.size(); ++i) { |
| auto button = std::make_unique<views::View>(); |
| button->SetProperty(views::kElementIdentifierKey, ids[i]); |
| button->SetPreferredSize(kButtonSize); |
| button->GetViewAccessibility().SetRole(ax::mojom::Role::kButton); |
| button->GetViewAccessibility().SetName( |
| base::StrCat({u"DummyButton", base::NumberToString16(i)})); |
| button->SetVisible(true); |
| test_buttons_.emplace_back( |
| toolbar_container_view_->AddChildView(std::move(button))); |
| } |
| } |
| |
| void TearDown() override { |
| overflow_button_->set_toolbar_controller(nullptr); |
| overflow_button_ = nullptr; |
| toolbar_container_view_ = nullptr; |
| event_generator_.reset(); |
| toolbar_controller_.reset(); |
| widget_.reset(); |
| test_delegate_.reset(); |
| testing_profile_.reset(); |
| ChromeViewsTestBase::TearDown(); |
| } |
| |
| void UpdateOverflowButtonVisibility() { |
| toolbar_controller()->overflow_button()->SetVisible( |
| toolbar_controller()->ShouldShowOverflowButton(widget()->GetSize())); |
| } |
| |
| views::Widget* widget() { return widget_.get(); } |
| ToolbarController* toolbar_controller() { return toolbar_controller_.get(); } |
| ui::test::EventGenerator* event_generator() { return event_generator_.get(); } |
| views::View* toolbar_container_view() { return toolbar_container_view_; } |
| OverflowButton* overflow_button() { return overflow_button_; } |
| const std::vector<raw_ptr<views::View, VectorExperimental>>& test_buttons() { |
| return test_buttons_; |
| } |
| const ui::SimpleMenuModel* overflow_menu() { |
| return toolbar_controller_->menu_model_for_testing(); |
| } |
| std::vector<const ToolbarController::ResponsiveElementInfo*> |
| GetOverflowedElements() { |
| return toolbar_controller()->GetOverflowedElements(); |
| } |
| const std::vector<ToolbarController::ResponsiveElementInfo>& |
| GetResponsiveElements(const ToolbarController* toolbar_controller) { |
| return toolbar_controller->responsive_elements_; |
| } |
| bool IsOverflowed(const ToolbarController::ResponsiveElementInfo& element) { |
| return toolbar_controller_->IsOverflowed(element); |
| } |
| |
| std::vector<ToolbarController::ResponsiveElementInfo> |
| GetResponsiveElementsWithOrderedActions( |
| const ToolbarController* toolbar_controller) const { |
| return toolbar_controller->GetResponsiveElementsWithOrderedActions(); |
| } |
| PinnedToolbarActionsModel* GetPinnedToolbarActionsModel() { |
| return PinnedToolbarActionsModel::Get(testing_profile_.get()); |
| } |
| |
| private: |
| std::unique_ptr<views::Widget> widget_; |
| std::unique_ptr<ToolbarController> toolbar_controller_; |
| std::unique_ptr<ui::test::EventGenerator> event_generator_; |
| raw_ptr<views::View> toolbar_container_view_; |
| raw_ptr<OverflowButton> overflow_button_; |
| std::unique_ptr<TestDelegate> test_delegate_; |
| std::unique_ptr<TestingProfile> testing_profile_; |
| |
| // Buttons being tested. |
| std::vector<raw_ptr<views::View, VectorExperimental>> test_buttons_; |
| }; |
| |
| TEST_F(ToolbarControllerUnitTest, OverflowButtonVisibility) { |
| // Initialize widget width with total width of all test buttons. |
| // Should not see overflowed buttons. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * test_buttons().size(), |
| kButtonSize.height())); |
| EXPECT_EQ(GetOverflowedElements().size(), size_t(0)); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_FALSE(overflow_button()->GetVisible()); |
| |
| // Shrink widget width with one button width smaller. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| EXPECT_EQ(GetOverflowedElements().size(), size_t(1)); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, OverflowedButtonsMatchMenu) { |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| widget()->LayoutRootViewIfNecessary(); |
| event_generator()->MoveMouseTo( |
| overflow_button()->GetBoundsInScreen().CenterPoint()); |
| event_generator()->PressLeftButton(); |
| |
| const ui::SimpleMenuModel* menu = overflow_menu(); |
| const auto overflowed_buttons = GetOverflowedElements(); |
| |
| // Overflowed buttons should match overflow menu. |
| EXPECT_TRUE(menu); |
| const auto& responsive_elements = GetResponsiveElements(toolbar_controller()); |
| for (size_t i = 0; i < responsive_elements.size(); ++i) { |
| if (IsOverflowed(responsive_elements[i])) { |
| EXPECT_EQ(toolbar_controller()->GetMenuText(responsive_elements[i]), |
| menu->GetLabelAt(menu->GetIndexOfCommandId(i).value())); |
| } |
| } |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, RunningMenuAddsStatusIndicator) { |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| widget()->LayoutRootViewIfNecessary(); |
| event_generator()->MoveMouseTo( |
| overflow_button()->GetBoundsInScreen().CenterPoint()); |
| event_generator()->PressLeftButton(); |
| |
| const ui::SimpleMenuModel* menu = overflow_menu(); |
| |
| // Overflowed buttons should match overflow menu. |
| EXPECT_TRUE(menu); |
| views::SubmenuView* sub_menu = |
| toolbar_controller()->root_menu_item()->GetSubmenu(); |
| |
| for (auto* menu_item : sub_menu->GetMenuItems()) { |
| PinnedToolbarButtonStatusIndicator* status_indicator = nullptr; |
| |
| for (auto& child : menu_item->icon_view()->children()) { |
| if (views::AsViewClass<PinnedToolbarButtonStatusIndicator>(child)) { |
| status_indicator = |
| views::AsViewClass<PinnedToolbarButtonStatusIndicator>(child); |
| } |
| |
| EXPECT_TRUE(status_indicator); |
| } |
| } |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, MenuSeparator) { |
| // Set widget to be small enough to ensure all the buttons overflow. |
| widget()->SetSize(gfx::Size(1, 1)); |
| UpdateOverflowButtonVisibility(); |
| |
| // All 3 buttons overflowed. |
| EXPECT_EQ(GetOverflowedElements().size(), static_cast<size_t>(3)); |
| const auto menu = toolbar_controller()->CreateOverflowMenuModel(); |
| EXPECT_TRUE(menu); |
| |
| // There is no separator between button1 and 2 because button1 is not a menu |
| // section end. |
| // There is a separator between button2 and button3 because |
| // 1) button2 is a section end; |
| // 2) the section button2 is in is valid; |
| // 3) the section button3 is in is valid. |
| // There is no separator after button3 because there is no valid next section. |
| EXPECT_EQ(menu->GetItemCount(), static_cast<size_t>(4)); |
| EXPECT_EQ(menu->GetTypeAt(0), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(0), u"DummyButton1"); |
| EXPECT_EQ(menu->GetTypeAt(1), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(1), u"DummyButton2"); |
| EXPECT_EQ(menu->GetTypeAt(2), ui::MenuModel::ItemType::TYPE_SEPARATOR); |
| EXPECT_EQ(menu->GetTypeAt(3), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(3), u"DummyButton3"); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, InValidFirstSectionAddsNoLeadingSeparator) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| std::unique_ptr<ToolbarController> test_controller = |
| std::make_unique<TestToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>( |
| {ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton1, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton2, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton3, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true)}), |
| std::vector<ui::ElementIdentifier>( |
| {kDummyButton3, kDummyButton2, kDummyButton1}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), test_delegate.get(), |
| GetPinnedToolbarActionsModel()); |
| |
| widget()->SetSize(kButtonSize); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| views::View* button1 = test_buttons()[0]; |
| views::View* button2 = test_buttons()[1]; |
| views::View* button3 = test_buttons()[2]; |
| |
| // Button2 and 3 overflowed. |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| EXPECT_EQ(GetOverflowedElements().size(), static_cast<size_t>(2)); |
| const auto menu = test_controller->CreateOverflowMenuModel(); |
| EXPECT_TRUE(menu); |
| |
| // The first section (contains Button1) is invalid. It should not add a |
| // separator before Button2. |
| EXPECT_EQ(menu->GetItemCount(), static_cast<size_t>(3)); |
| EXPECT_EQ(menu->GetTypeAt(0), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(0), u"DummyButton2"); |
| EXPECT_EQ(menu->GetTypeAt(1), ui::MenuModel::ItemType::TYPE_SEPARATOR); |
| EXPECT_EQ(menu->GetTypeAt(2), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(2), u"DummyButton3"); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, InValidSectionInMiddleAddsNoExtraSeparator) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| std::unique_ptr<ToolbarController> test_controller = |
| std::make_unique<TestToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>( |
| {ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton1, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton2, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton3, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true)}), |
| std::vector<ui::ElementIdentifier>( |
| {kDummyButton1, kDummyButton3, kDummyButton2}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), test_delegate.get(), |
| GetPinnedToolbarActionsModel()); |
| |
| widget()->SetSize(kButtonSize); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| views::View* button1 = test_buttons()[0]; |
| views::View* button2 = test_buttons()[1]; |
| views::View* button3 = test_buttons()[2]; |
| |
| // Button1 and 3 overflowed. |
| EXPECT_FALSE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| EXPECT_EQ(GetOverflowedElements().size(), static_cast<size_t>(2)); |
| const auto menu = test_controller->CreateOverflowMenuModel(); |
| EXPECT_TRUE(menu); |
| |
| // The second section (contains Button2) is invalid. It should not add a |
| // redundant separator. |
| EXPECT_EQ(menu->GetItemCount(), static_cast<size_t>(3)); |
| EXPECT_EQ(menu->GetTypeAt(0), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(0), u"DummyButton1"); |
| EXPECT_EQ(menu->GetTypeAt(1), ui::MenuModel::ItemType::TYPE_SEPARATOR); |
| EXPECT_EQ(menu->GetTypeAt(2), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(2), u"DummyButton3"); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, InValidLastSectionAddsNoTrailingSeparator) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| std::unique_ptr<ToolbarController> test_controller = |
| std::make_unique<TestToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>( |
| {ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton1, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton2, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton3, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| true)}), |
| std::vector<ui::ElementIdentifier>( |
| {kDummyButton1, kDummyButton2, kDummyButton3}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), test_delegate.get(), |
| GetPinnedToolbarActionsModel()); |
| |
| widget()->SetSize(kButtonSize); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| views::View* button1 = test_buttons()[0]; |
| views::View* button2 = test_buttons()[1]; |
| views::View* button3 = test_buttons()[2]; |
| |
| // Button1 and 2 overflowed. |
| EXPECT_FALSE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| EXPECT_EQ(GetOverflowedElements().size(), static_cast<size_t>(2)); |
| const auto menu = test_controller->CreateOverflowMenuModel(); |
| EXPECT_TRUE(menu); |
| |
| // The third section (contains Button3) is invalid. It should not add a |
| // redundant trailing separator. |
| EXPECT_EQ(menu->GetItemCount(), static_cast<size_t>(3)); |
| EXPECT_EQ(menu->GetTypeAt(0), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(0), u"DummyButton1"); |
| EXPECT_EQ(menu->GetTypeAt(1), ui::MenuModel::ItemType::TYPE_SEPARATOR); |
| EXPECT_EQ(menu->GetTypeAt(2), ui::MenuModel::ItemType::TYPE_COMMAND); |
| EXPECT_EQ(menu->GetLabelAt(2), u"DummyButton2"); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, PopOutState) { |
| auto& pop_out_state = toolbar_controller()->pop_out_state_for_testing(); |
| EXPECT_FALSE(pop_out_state.at(kDummyButton1)->original_spec.has_value()); |
| EXPECT_FALSE(pop_out_state.at(kDummyButton2)->original_spec.has_value()); |
| EXPECT_FALSE(pop_out_state.at(kDummyButton3)->original_spec.has_value()); |
| EXPECT_EQ(pop_out_state.at(kDummyButton1)->responsive_spec.order(), |
| kElementFlexOrderStart); |
| EXPECT_EQ(pop_out_state.at(kDummyButton2)->responsive_spec.order(), |
| kElementFlexOrderStart + 1); |
| EXPECT_EQ(pop_out_state.at(kDummyButton3)->responsive_spec.order(), |
| kElementFlexOrderStart + 2); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, PopOutButton) { |
| views::View* button1 = test_buttons()[0]; |
| views::View* button2 = test_buttons()[1]; |
| views::View* button3 = test_buttons()[2]; |
| |
| // Enough space to accommodate 3 buttons. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * test_buttons().size(), |
| kButtonSize.height())); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| |
| // Not enough space. Button3 is hidden. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| |
| // Pop out button3. Button2 is hidden. |
| EXPECT_TRUE(toolbar_controller()->PopOut(kDummyButton3)); |
| views::test::RunScheduledLayout(toolbar_container_view()); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| |
| // Button3 is already popped out. |
| EXPECT_FALSE(toolbar_controller()->PopOut(kDummyButton3)); |
| |
| // End button3 pop out. Button3 is hidden again. |
| EXPECT_TRUE(toolbar_controller()->EndPopOut(kDummyButton3)); |
| views::test::RunScheduledLayout(toolbar_container_view()); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| |
| // Button3 already ended popped out. |
| EXPECT_FALSE(toolbar_controller()->EndPopOut(kDummyButton3)); |
| |
| // kDummyButton4 does not exist. |
| EXPECT_FALSE(toolbar_controller()->PopOut(kDummyButton4)); |
| } |
| |
| // Buttons overflow in order: 3, 2, 1. |
| TEST_F(ToolbarControllerUnitTest, ButtonsOverflowRightToLeftInContainer) { |
| views::View* button1 = test_buttons()[0]; |
| views::View* button2 = test_buttons()[1]; |
| views::View* button3 = test_buttons()[2]; |
| |
| // Enough space to accommodate 3 buttons. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * test_buttons().size(), |
| kButtonSize.height())); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| |
| // Not enough space. Button3 is hidden. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| |
| // Keep resizing smaller. Button2 is hidden. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 2), |
| kButtonSize.height())); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| |
| // Keep resizing smaller. Button1 is hidden. |
| widget()->SetSize(gfx::Size(1, kButtonSize.height())); |
| EXPECT_FALSE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| } |
| |
| // Buttons overflow in order: 1, 2, 3. |
| TEST_F(ToolbarControllerUnitTest, ButtonsOverflowLeftToRightInContainer) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| std::unique_ptr<ToolbarController> dummy_controller = |
| std::make_unique<TestToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>( |
| {ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton1, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| false), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton2, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| false), |
| ToolbarController::ResponsiveElementInfo( |
| ToolbarController::ElementIdInfo{kDummyButton3, 0, |
| &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| false)}), |
| std::vector<ui::ElementIdentifier>( |
| {kDummyButton1, kDummyButton2, kDummyButton3}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), test_delegate.get(), |
| GetPinnedToolbarActionsModel()); |
| |
| views::View* button1 = test_buttons()[0]; |
| views::View* button2 = test_buttons()[1]; |
| views::View* button3 = test_buttons()[2]; |
| |
| // Enough space to accommodate 3 buttons. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * test_buttons().size(), |
| kButtonSize.height())); |
| EXPECT_TRUE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| |
| // Not enough space. Button1 is hidden. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| EXPECT_FALSE(button1->GetVisible()); |
| EXPECT_TRUE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| |
| // Keep resizing smaller. Button2 is hidden. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 2), |
| kButtonSize.height())); |
| EXPECT_FALSE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_TRUE(button3->GetVisible()); |
| |
| // Keep resizing smaller. Button3 is hidden. |
| widget()->SetSize(gfx::Size(1, kButtonSize.height())); |
| EXPECT_FALSE(button1->GetVisible()); |
| EXPECT_FALSE(button2->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, MenuItemUsability) { |
| views::View* button3 = test_buttons()[2]; |
| button3->SetEnabled(false); |
| |
| // Not enough space. Button3 is hidden. |
| widget()->SetSize(gfx::Size(kButtonSize.width() * (test_buttons().size() - 1), |
| kButtonSize.height())); |
| UpdateOverflowButtonVisibility(); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| EXPECT_FALSE(button3->GetVisible()); |
| |
| widget()->LayoutRootViewIfNecessary(); |
| event_generator()->MoveMouseTo( |
| overflow_button()->GetBoundsInScreen().CenterPoint()); |
| event_generator()->PressLeftButton(); |
| |
| const ui::SimpleMenuModel* menu = overflow_menu(); |
| const auto overflowed_buttons = GetOverflowedElements(); |
| |
| EXPECT_TRUE(menu); |
| const auto& responsive_elements = GetResponsiveElements(toolbar_controller()); |
| for (size_t i = 0; i < responsive_elements.size(); ++i) { |
| if (IsOverflowed(responsive_elements[i])) { |
| EXPECT_EQ(ToolbarController::FindToolbarElementWithId( |
| toolbar_container_view(), |
| std::get<ToolbarController::ElementIdInfo>( |
| responsive_elements[i].overflow_id) |
| .overflow_identifier) |
| ->GetEnabled(), |
| menu->IsEnabledAt(menu->GetIndexOfCommandId(i).value())); |
| } |
| } |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, ResponsiveActionsAreOrdered) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| |
| using ElementIdInfo = ToolbarController::ElementIdInfo; |
| using ResponsiveElementInfo = ToolbarController::ResponsiveElementInfo; |
| using ActionId = actions::ActionId; |
| |
| ResponsiveElementInfo element0( |
| ElementIdInfo{kDummyButton1, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| false); |
| ResponsiveElementInfo action0(test_delegate->get_action_ids()[0]); |
| ResponsiveElementInfo action1(test_delegate->get_action_ids()[1]); |
| ResponsiveElementInfo action2(test_delegate->get_action_ids()[2]); |
| |
| auto test_controller = ToolbarController( |
| std::vector<ResponsiveElementInfo>( |
| {action2, action1, action0, element0, action2, action0}), |
| std::vector<ui::ElementIdentifier>({kDummyButton1}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), test_delegate.get(), |
| GetPinnedToolbarActionsModel()); |
| |
| std::vector<ToolbarController::ResponsiveElementInfo> elements = |
| GetResponsiveElementsWithOrderedActions(&test_controller); |
| EXPECT_EQ(int(elements.size()), 6); |
| |
| // Both sections of actions are reordered |
| EXPECT_EQ(std::get<ActionId>(elements[0].overflow_id), |
| std::get<ActionId>(action0.overflow_id)); |
| EXPECT_EQ(std::get<ActionId>(elements[1].overflow_id), |
| std::get<ActionId>(action1.overflow_id)); |
| EXPECT_EQ(std::get<ActionId>(elements[2].overflow_id), |
| std::get<ActionId>(action2.overflow_id)); |
| EXPECT_EQ( |
| std::get<ElementIdInfo>(elements[3].overflow_id).overflow_identifier, |
| std::get<ElementIdInfo>(element0.overflow_id).overflow_identifier); |
| EXPECT_EQ(std::get<ActionId>(elements[4].overflow_id), |
| std::get<ActionId>(action0.overflow_id)); |
| EXPECT_EQ(std::get<ActionId>(elements[5].overflow_id), |
| std::get<ActionId>(action2.overflow_id)); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, ResponsiveActionsRemainOrdered) { |
| using ResponsiveElementInfo = ToolbarController::ResponsiveElementInfo; |
| using ActionId = actions::ActionId; |
| |
| ResponsiveElementInfo action0(0); |
| ResponsiveElementInfo action1(1); |
| PinnedToolbarActionsModel* model = GetPinnedToolbarActionsModel(); |
| model->UpdatePinnedState(std::get<ActionId>(action0.overflow_id), true); |
| model->UpdatePinnedState(std::get<ActionId>(action1.overflow_id), true); |
| auto delegate = std::make_unique<TestDelegateFromModel>(model); |
| |
| // Create the controller with the ActionIds in the reversed order |
| // (action1, action0) with respect to delegate.PinnedActionIds(). |
| // They should be sorted in responsive_elements right after the controller |
| // is instantiated. |
| auto controller = ToolbarController( |
| std::vector<ResponsiveElementInfo>({action1, action0}), |
| std::vector<ui::ElementIdentifier>({kDummyButton1}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), delegate.get(), model); |
| std::vector<ResponsiveElementInfo> elements = |
| GetResponsiveElements(&controller); |
| EXPECT_EQ(int(elements.size()), 2); |
| EXPECT_EQ(std::get<ActionId>(elements[0].overflow_id), |
| std::get<ActionId>(action0.overflow_id)); |
| EXPECT_EQ(std::get<ActionId>(elements[1].overflow_id), |
| std::get<ActionId>(action1.overflow_id)); |
| |
| // Move action1 to the first index. responsive_elements should be reordered. |
| model->MovePinnedAction(std::get<ActionId>(action1.overflow_id), 0); |
| elements = GetResponsiveElements(&controller); |
| EXPECT_EQ(int(elements.size()), 2); |
| EXPECT_EQ(std::get<ActionId>(elements[0].overflow_id), |
| std::get<ActionId>(action1.overflow_id)); |
| EXPECT_EQ(std::get<ActionId>(elements[1].overflow_id), |
| std::get<ActionId>(action0.overflow_id)); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, ResponsiveActionsAreNotOrdered) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| |
| using ElementIdInfo = ToolbarController::ElementIdInfo; |
| using ResponsiveElementInfo = ToolbarController::ResponsiveElementInfo; |
| using ActionId = actions::ActionId; |
| |
| ResponsiveElementInfo element0( |
| ElementIdInfo{kDummyButton1, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| false); |
| ResponsiveElementInfo element1( |
| ElementIdInfo{kDummyButton2, 0, &vector_icons::kErrorIcon, |
| kDummyActivateView}, |
| false); |
| ResponsiveElementInfo action0(test_delegate->get_action_ids()[0]); |
| ResponsiveElementInfo action1(test_delegate->get_action_ids()[1]); |
| ResponsiveElementInfo action2(test_delegate->get_action_ids()[2]); |
| |
| auto test_controller = ToolbarController( |
| std::vector<ResponsiveElementInfo>( |
| {element1, element0, action2, element0, action0, element0, action1}), |
| std::vector<ui::ElementIdentifier>({kDummyButton1, kDummyButton2}), |
| kElementFlexOrderStart, toolbar_container_view(), |
| const_cast<OverflowButton*>(overflow_button()), test_delegate.get(), |
| GetPinnedToolbarActionsModel()); |
| |
| std::vector<ToolbarController::ResponsiveElementInfo> elements = |
| GetResponsiveElementsWithOrderedActions(&test_controller); |
| EXPECT_EQ(int(elements.size()), 7); |
| |
| // Only sections of actions are reordered, so we |
| // expect the order not to change |
| EXPECT_EQ( |
| std::get<ElementIdInfo>(elements[0].overflow_id).overflow_identifier, |
| std::get<ElementIdInfo>(element1.overflow_id).overflow_identifier); |
| EXPECT_EQ( |
| std::get<ElementIdInfo>(elements[1].overflow_id).overflow_identifier, |
| std::get<ElementIdInfo>(element0.overflow_id).overflow_identifier); |
| EXPECT_EQ(std::get<ActionId>(elements[2].overflow_id), |
| std::get<ActionId>(action2.overflow_id)); |
| EXPECT_EQ( |
| std::get<ElementIdInfo>(elements[3].overflow_id).overflow_identifier, |
| std::get<ElementIdInfo>(element0.overflow_id).overflow_identifier); |
| EXPECT_EQ(std::get<ActionId>(elements[4].overflow_id), |
| std::get<ActionId>(action0.overflow_id)); |
| EXPECT_EQ( |
| std::get<ElementIdInfo>(elements[5].overflow_id).overflow_identifier, |
| std::get<ElementIdInfo>(element0.overflow_id).overflow_identifier); |
| EXPECT_EQ(std::get<ActionId>(elements[6].overflow_id), |
| std::get<ActionId>(action1.overflow_id)); |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, SupportActionIds) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| auto test_controller = std::make_unique<ToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>( |
| {ToolbarController::ResponsiveElementInfo( |
| test_delegate->get_action_ids()[0]), |
| ToolbarController::ResponsiveElementInfo( |
| test_delegate->get_action_ids()[1]), |
| ToolbarController::ResponsiveElementInfo( |
| test_delegate->get_action_ids()[2])}), |
| std::vector<ui::ElementIdentifier>(), kElementFlexOrderStart, |
| toolbar_container_view(), const_cast<OverflowButton*>(overflow_button()), |
| test_delegate.get(), GetPinnedToolbarActionsModel()); |
| test_delegate->SetContainerView( |
| toolbar_container_view()->AddChildView(std::make_unique<views::View>())); |
| |
| toolbar_controller()->overflow_button()->SetVisible( |
| test_controller->ShouldShowOverflowButton(widget()->GetSize())); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| const auto menu = test_controller->CreateOverflowMenuModel(); |
| EXPECT_TRUE(menu); |
| EXPECT_EQ(menu->GetItemCount(), |
| static_cast<size_t>(test_delegate->get_overflowed_count())); |
| |
| // Overflowed actions should match overflow menu. |
| const auto& responsive_elements = |
| GetResponsiveElements(test_controller.get()); |
| for (size_t i = 0; i < responsive_elements.size(); ++i) { |
| if (IsOverflowed(responsive_elements[i])) { |
| size_t index = menu->GetIndexOfCommandId(i).value(); |
| EXPECT_EQ(test_controller->GetMenuText(responsive_elements[i]), |
| menu->GetLabelAt(index)); |
| EXPECT_CALL(*test_delegate, DummyAction); |
| menu->ActivatedAt(index); |
| } |
| } |
| } |
| |
| TEST_F(ToolbarControllerUnitTest, StatusIndicatorVisibilityUpdates) { |
| auto test_delegate = std::make_unique<TestDelegate>(); |
| auto test_controller = std::make_unique<ToolbarController>( |
| std::vector<ToolbarController::ResponsiveElementInfo>( |
| {ToolbarController::ResponsiveElementInfo( |
| test_delegate->get_action_ids()[0]), |
| ToolbarController::ResponsiveElementInfo( |
| test_delegate->get_action_ids()[1]), |
| ToolbarController::ResponsiveElementInfo( |
| test_delegate->get_action_ids()[2])}), |
| std::vector<ui::ElementIdentifier>(), kElementFlexOrderStart, |
| toolbar_container_view(), const_cast<OverflowButton*>(overflow_button()), |
| test_delegate.get(), GetPinnedToolbarActionsModel()); |
| test_delegate->SetContainerView( |
| toolbar_container_view()->AddChildView(std::make_unique<views::View>())); |
| |
| toolbar_controller()->overflow_button()->SetVisible( |
| test_controller->ShouldShowOverflowButton(widget()->GetSize())); |
| EXPECT_TRUE(overflow_button()->GetVisible()); |
| |
| overflow_button()->set_toolbar_controller(test_controller.get()); |
| |
| widget()->LayoutRootViewIfNecessary(); |
| overflow_button()->RunMenu(); |
| |
| const ui::SimpleMenuModel* menu = test_controller->menu_model_for_testing(); |
| |
| // Overflowed buttons should match overflow menu. |
| EXPECT_TRUE(menu); |
| views::SubmenuView* sub_menu = |
| test_controller->root_menu_item()->GetSubmenu(); |
| |
| for (auto* menu_item : sub_menu->GetMenuItems()) { |
| PinnedToolbarButtonStatusIndicator* status_indicator = |
| PinnedToolbarButtonStatusIndicator::GetStatusIndicator( |
| menu_item->icon_view()); |
| EXPECT_TRUE(status_indicator); |
| EXPECT_EQ(status_indicator->GetVisible(), true); |
| } |
| |
| const auto& responsive_elements = |
| GetResponsiveElements(test_controller.get()); |
| for (size_t i = 0; i < responsive_elements.size(); ++i) { |
| if (IsOverflowed(responsive_elements[i])) { |
| actions::ActionId element_action_id = |
| std::get<actions::ActionId>(responsive_elements[i].overflow_id); |
| test_delegate->GetActionItemFor(element_action_id) |
| ->SetProperty(kActionItemUnderlineIndicatorKey, false); |
| |
| size_t index = menu->GetIndexOfCommandId(i).value(); |
| |
| views::MenuItemView* menu_item = sub_menu->GetMenuItemAt(index); |
| PinnedToolbarButtonStatusIndicator* status_indicator = |
| PinnedToolbarButtonStatusIndicator::GetStatusIndicator( |
| menu_item->icon_view()); |
| EXPECT_EQ(status_indicator->GetVisible(), false); |
| } |
| } |
| |
| for (size_t i = 0; i < responsive_elements.size(); ++i) { |
| if (IsOverflowed(responsive_elements[i])) { |
| actions::ActionId element_action_id = |
| std::get<actions::ActionId>(responsive_elements[i].overflow_id); |
| test_delegate->GetActionItemFor(element_action_id) |
| ->SetProperty(kActionItemUnderlineIndicatorKey, true); |
| |
| size_t index = menu->GetIndexOfCommandId(i).value(); |
| |
| views::MenuItemView* menu_item = sub_menu->GetMenuItemAt(index); |
| PinnedToolbarButtonStatusIndicator* status_indicator = |
| PinnedToolbarButtonStatusIndicator::GetStatusIndicator( |
| menu_item->icon_view()); |
| EXPECT_EQ(status_indicator->GetVisible(), true); |
| } |
| } |
| |
| overflow_button()->set_toolbar_controller(nullptr); |
| } |
