// 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 "ash/system/toast/anchored_nudge_manager_impl.h"
#include "ash/constants/ash_features.h"
#include "ash/public/cpp/system/anchored_nudge_data.h"
#include "ash/public/cpp/system/scoped_nudge_pause.h"
#include "ash/root_window_controller.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shelf/hotseat_widget.h"
#include "ash/shelf/shelf.h"
#include "ash/shell.h"
#include "ash/style/system_toast_style.h"
#include "ash/system/toast/anchored_nudge.h"
#include "ash/system/toast/nudge_constants.h"
#include "ash/system/unified/unified_system_tray.h"
#include "ash/test/ash_test_base.h"
#include "ash/wm/tablet_mode/tablet_mode_controller_test_api.h"
#include "base/i18n/rtl.h"
#include "base/test/bind.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/task_environment.h"
#include "ui/aura/window.h"
#include "ui/compositor/scoped_animation_duration_scale_mode.h"
#include "ui/display/manager/display_manager.h"
#include "ui/gfx/geometry/vector2d.h"
#include "ui/views/bubble/bubble_border.h"
#include "ui/views/controls/button/button.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/label.h"
#include "ui/views/focus/focus_manager.h"
#include "ui/views/layout/flex_layout_view.h"
#include "ui/views/widget/widget.h"
namespace ash {
namespace {
constexpr NudgeCatalogName kTestCatalogName =
NudgeCatalogName::kTestCatalogName;
constexpr char kPrimaryButtonPressed[] =
"Ash.NotifierFramework.Nudge.PrimaryButtonPressed";
constexpr char kSecondaryButtonPressed[] =
"Ash.NotifierFramework.Nudge.SecondaryButtonPressed";
constexpr char kNudgeShownCount[] = "Ash.NotifierFramework.Nudge.ShownCount";
constexpr char kNudgeTimeToActionWithin1m[] =
"Ash.NotifierFramework.Nudge.TimeToAction.Within1m";
constexpr char kNudgeTimeToActionWithin1h[] =
"Ash.NotifierFramework.Nudge.TimeToAction.Within1h";
constexpr char kNudgeTimeToActionWithinSession[] =
"Ash.NotifierFramework.Nudge.TimeToAction.WithinSession";
constexpr base::TimeDelta kAnimationSettleDownDuration = base::Seconds(5);
void SetLockedState(bool locked) {
SessionInfo info;
info.state = locked ? session_manager::SessionState::LOCKED
: session_manager::SessionState::ACTIVE;
Shell::Get()->session_controller()->SetSessionInfo(info);
}
AnchoredNudgeManagerImpl* GetAnchoredNudgeManager() {
return Shell::Get()->anchored_nudge_manager();
}
// Creates an `AnchoredNudgeData` object with only the required elements.
AnchoredNudgeData CreateBaseNudgeData(
const std::string& id,
views::View* anchor_view,
const std::u16string& body_text = std::u16string()) {
return AnchoredNudgeData(id, kTestCatalogName, body_text, anchor_view);
}
void CancelNudge(const std::string& id) {
GetAnchoredNudgeManager()->Cancel(id);
}
AnchoredNudge* GetShownNudge(const std::string& id) {
return GetAnchoredNudgeManager()->GetShownNudgeForTest(id);
}
const std::u16string& GetNudgeBodyText(const std::string& id) {
return GetAnchoredNudgeManager()->GetNudgeBodyTextForTest(id);
}
views::LabelButton* GetNudgePrimaryButton(const std::string& id) {
return GetAnchoredNudgeManager()->GetNudgePrimaryButtonForTest(id);
}
views::LabelButton* GetNudgeSecondaryButton(const std::string& id) {
return GetAnchoredNudgeManager()->GetNudgeSecondaryButtonForTest(id);
}
AnchoredNudge* GetNudgeIfShown(const std::string& id) {
return GetAnchoredNudgeManager()->GetNudgeIfShown(id);
}
void PressTab() {
ui::test::EventGenerator generator(Shell::GetPrimaryRootWindow());
generator.PressKey(ui::KeyboardCode::VKEY_TAB, ui::EF_NONE);
}
} // namespace
class AnchoredNudgeManagerImplTest : public AshTestBase {
public:
AnchoredNudgeManagerImplTest()
: AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
};
// Tests that a nudge can be shown and its contents are properly sent.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_SingleNudge) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
const std::u16string body_text = u"Body text";
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view, body_text);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
// Ensure the nudge is visible and has set the provided contents.
AnchoredNudge* nudge = GetShownNudge(id);
ASSERT_TRUE(nudge);
EXPECT_TRUE(nudge->GetVisible());
EXPECT_EQ(anchor_view, nudge->GetAnchorView());
// Ensure the nudge widget was not activated when shown.
EXPECT_FALSE(nudge->GetWidget()->IsActive());
// Cancel the nudge, expect it to be removed from the shown nudges map.
CancelNudge(id);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that two nudges can be shown on screen at the same time.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_TwoNudges) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
auto* contents_view =
widget->SetContentsView(std::make_unique<views::View>());
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
const std::string id_2("id_2");
auto* anchor_view_2 =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data_2 = CreateBaseNudgeData(id_2, anchor_view_2);
// Show the first nudge, expect the first nudge shown.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_FALSE(GetShownNudge(id_2));
// Show the second nudge, expect both nudges shown.
GetAnchoredNudgeManager()->Show(nudge_data_2);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_TRUE(GetShownNudge(id_2));
// Cancel the second nudge, expect the first nudge shown.
CancelNudge(id_2);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_FALSE(GetShownNudge(id_2));
// Cancel the first nudge, expect no nudges shown.
CancelNudge(id);
EXPECT_FALSE(GetShownNudge(id));
EXPECT_FALSE(GetShownNudge(id_2));
}
// Tests that a nudge with buttons can be shown, execute callbacks and dismiss
// the nudge when the button is pressed.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_WithButtons) {
base::HistogramTester histogram_tester;
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
const std::u16string primary_button_text = u"Primary";
const std::u16string secondary_button_text = u"Secondary";
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Add a primary button with no callbacks.
nudge_data.primary_button_text = primary_button_text;
// Show the nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
AnchoredNudge* nudge = GetShownNudge(id);
// Ensure the nudge is visible and has set the provided contents.
ASSERT_TRUE(nudge);
ASSERT_TRUE(GetNudgePrimaryButton(id));
EXPECT_FALSE(GetNudgeSecondaryButton(id));
// Press the primary button, the nudge should have dismissed.
LeftClickOn(GetNudgePrimaryButton(id));
EXPECT_FALSE(GetShownNudge(id));
histogram_tester.ExpectBucketCount(kPrimaryButtonPressed, kTestCatalogName,
1);
// Add callbacks for the primary button.
bool primary_button_callback_ran = false;
nudge_data.primary_button_callback = base::BindLambdaForTesting(
[&primary_button_callback_ran] { primary_button_callback_ran = true; });
// Show the nudge again.
GetAnchoredNudgeManager()->Show(nudge_data);
nudge = GetShownNudge(id);
// Press the primary button, `primary_button_callback` should have executed,
// and the nudge should have dismissed.
LeftClickOn(GetNudgePrimaryButton(id));
EXPECT_TRUE(primary_button_callback_ran);
EXPECT_FALSE(GetShownNudge(id));
histogram_tester.ExpectBucketCount(kPrimaryButtonPressed, kTestCatalogName,
2);
// Add a secondary button with no callbacks.
nudge_data.secondary_button_text = secondary_button_text;
// Show the nudge again, now with a secondary button.
GetAnchoredNudgeManager()->Show(nudge_data);
nudge = GetShownNudge(id);
// Ensure the nudge has a secondary button.
ASSERT_TRUE(GetNudgeSecondaryButton(id));
// Press the secondary button, the nudge should have dismissed.
LeftClickOn(GetNudgeSecondaryButton(id));
EXPECT_FALSE(GetShownNudge(id));
histogram_tester.ExpectBucketCount(kSecondaryButtonPressed, kTestCatalogName,
1);
// Add a callback for the secondary button.
bool secondary_button_callback_ran = false;
nudge_data.secondary_button_callback =
base::BindLambdaForTesting([&secondary_button_callback_ran] {
secondary_button_callback_ran = true;
});
// Show the nudge again.
GetAnchoredNudgeManager()->Show(nudge_data);
nudge = GetShownNudge(id);
// Press the secondary button, `secondary_button_callback` should have
// executed, and the nudge should have dismissed.
LeftClickOn(GetNudgeSecondaryButton(id));
EXPECT_TRUE(secondary_button_callback_ran);
EXPECT_FALSE(GetShownNudge(id));
histogram_tester.ExpectBucketCount(kSecondaryButtonPressed, kTestCatalogName,
2);
}
// Tests that a nudge without an anchor view is shown on its default location.
TEST_F(AnchoredNudgeManagerImplTest, DefaultLocation) {
Shelf* shelf = GetPrimaryShelf();
display::Display primary_display = GetPrimaryDisplay();
gfx::Rect display_bounds = primary_display.bounds();
int shelf_size = ShelfConfig::Get()->shelf_size();
gfx::Rect nudge_bounds;
// Show nudge on its default location by not providing an anchor view.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
GetAnchoredNudgeManager()->Show(nudge_data);
// The nudge should be shown on the leading bottom corner of the work area,
// which for LTR languages is the bottom-left.
shelf->SetAlignment(ShelfAlignment::kBottom);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom() - shelf_size);
shelf->SetAlignment(ShelfAlignment::kLeft);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x() + shelf_size);
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom());
shelf->SetAlignment(ShelfAlignment::kRight);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom());
}
// Tests that a nudge without an anchor view is placed on the right on RTL.
TEST_F(AnchoredNudgeManagerImplTest, DefaultLocation_WithRTL) {
Shelf* shelf = GetPrimaryShelf();
display::Display primary_display = GetPrimaryDisplay();
gfx::Rect display_bounds = primary_display.bounds();
int shelf_size = ShelfConfig::Get()->shelf_size();
gfx::Rect nudge_bounds;
// Turn on RTL mode.
base::i18n::SetRTLForTesting(true);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(base::i18n::IsRTL());
// Show nudge on its default location by not providing an anchor view.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
GetAnchoredNudgeManager()->Show(nudge_data);
// The nudge should be shown on the leading bottom corner of the work area,
// which for RTL languages is the bottom-right.
shelf->SetAlignment(ShelfAlignment::kBottom);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.right(), display_bounds.right());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom() - shelf_size);
shelf->SetAlignment(ShelfAlignment::kLeft);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.right(), display_bounds.right());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom());
shelf->SetAlignment(ShelfAlignment::kRight);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.right(), display_bounds.right() - shelf_size);
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom());
// Turn off RTL mode.
base::i18n::SetRTLForTesting(false);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(base::i18n::IsRTL());
}
// Tests that a nudge without an anchor view updates its baseline based on the
// current hotseat state.
TEST_F(AnchoredNudgeManagerImplTest, DefaultLocation_WithHotseatShown) {
Shelf* shelf = GetPrimaryShelf();
HotseatWidget* hotseat = shelf->hotseat_widget();
display::Display primary_display = GetPrimaryDisplay();
gfx::Rect display_bounds = primary_display.bounds();
int shelf_size = ShelfConfig::Get()->shelf_size();
gfx::Rect nudge_bounds;
// Show nudge on its default location by not providing an anchor view.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
GetAnchoredNudgeManager()->Show(nudge_data);
// The nudge should be shown on the leading bottom corner of the work area.
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom() - shelf_size);
// Test that the nudge updates its baseline when the hotseat is shown.
ash::TabletModeControllerTestApi().EnterTabletMode();
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(hotseat->state(), HotseatState::kShownHomeLauncher);
EXPECT_EQ(nudge_bounds.bottom(),
hotseat->CalculateHotseatYInScreen(hotseat->state()));
}
// Tests that a nudge without an anchor view updates its baseline when the shelf
// hides itself.
TEST_F(AnchoredNudgeManagerImplTest, DefaultLocation_WithAutoHideShelf) {
Shelf* shelf = GetPrimaryShelf();
display::Display primary_display = GetPrimaryDisplay();
gfx::Rect display_bounds = primary_display.bounds();
gfx::Rect nudge_bounds;
// Show nudge on its default location by not providing an anchor view.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
GetAnchoredNudgeManager()->Show(nudge_data);
// The nudge should be shown on the leading bottom corner of the work area.
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x());
EXPECT_EQ(nudge_bounds.bottom(),
display_bounds.bottom() - ShelfConfig::Get()->shelf_size());
// Test that the nudge updates its baseline when the shelf hides itself.
std::unique_ptr<aura::Window> window(
CreateTestWindowInShellWithBounds(gfx::Rect()));
shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
EXPECT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
EXPECT_EQ(nudge_bounds.bottom(),
display_bounds.bottom() -
ShelfConfig::Get()->hidden_shelf_in_screen_portion());
}
// Tests that a nudge updates its location after zooming in/out the UI.
TEST_F(AnchoredNudgeManagerImplTest, DefaultLocation_Zoom) {
const int shelf_size = ShelfConfig::Get()->shelf_size();
gfx::Rect display_bounds;
gfx::Rect nudge_bounds;
// Show nudge on its default location by not providing an anchor view.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
GetAnchoredNudgeManager()->Show(nudge_data);
// Since no zoom factor has been set on the display, it should be 1.
const display::ManagedDisplayInfo& display =
display_manager()->GetDisplayInfo(GetPrimaryDisplay().id());
EXPECT_EQ(
display_manager()->GetDisplayForId(display.id()).device_scale_factor(),
1.f);
// The nudge should be shown on the bottom-left of the work area.
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
display_bounds = GetPrimaryDisplay().bounds();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom() - shelf_size);
// Set the device scale factor to 2.
constexpr float zoom_factor = 2.0f;
display_manager()->UpdateZoomFactor(display.id(), zoom_factor);
EXPECT_EQ(
display_manager()->GetDisplayForId(display.id()).device_scale_factor(),
zoom_factor);
// Nudge bounds should update accordingly.
nudge_bounds = GetShownNudge(id)->GetWidget()->GetWindowBoundsInScreen();
display_bounds = GetPrimaryDisplay().bounds();
EXPECT_EQ(nudge_bounds.x(), display_bounds.x());
EXPECT_EQ(nudge_bounds.bottom(), display_bounds.bottom() - shelf_size);
}
// Tests that attempting to show a nudge with an `id` that's in use cancels
// the existing nudge and replaces it with a new nudge.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_NudgeWithIdAlreadyExists) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
auto* contents_view =
widget->SetContentsView(std::make_unique<views::View>());
// Set up nudge data contents.
const std::string id("id");
const std::u16string text = u"text";
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view, text);
const std::u16string text_2 = u"text_2";
auto* anchor_view_2 =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data_2 = CreateBaseNudgeData(id, anchor_view_2, text_2);
// Show a nudge with some initial contents.
GetAnchoredNudgeManager()->Show(nudge_data);
// First nudge contents should be set.
AnchoredNudge* nudge = GetShownNudge(id);
ASSERT_TRUE(nudge);
EXPECT_EQ(text, GetNudgeBodyText(id));
EXPECT_EQ(anchor_view, nudge->GetAnchorView());
// Attempt to show a nudge with different contents but with the same id.
GetAnchoredNudgeManager()->Show(nudge_data_2);
// The previous nudge should be cancelled and replaced with the new nudge.
nudge = GetShownNudge(id);
ASSERT_TRUE(nudge);
EXPECT_EQ(text_2, GetNudgeBodyText(id));
EXPECT_EQ(anchor_view_2, nudge->GetAnchorView());
}
// Tests that a nudge is not created if its anchor view is not visible.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_InvisibleAnchorView) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Set anchor view visibility to false.
anchor_view->SetVisible(false);
// Attempt to show nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
// Anchor view is not visible, the nudge should not be created.
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge is not created if its anchor view doesn't have a widget.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_AnchorViewWithoutWidget) {
// Set up nudge data contents.
const std::string id("id");
auto contents_view = std::make_unique<views::View>();
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Attempt to show nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
// Anchor view does not have a widget, the nudge should not be created.
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge is not created if its anchor view was deleted.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_DeletedAnchorView) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto contents_view = std::make_unique<views::View>();
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
widget->SetContentsView(contents_view.get());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Anchor view exists, the nudge should be created.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Delete the anchor view, the nudge should not be created.
contents_view->RemoveAllChildViews();
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge will not be shown if a `ScopedNudgePause` exists, and even
// if the `scoped_anchored_nudge_pause` gets destroyed, the nudge is dismissed
// and will not be saved.
TEST_F(AnchoredNudgeManagerImplTest, ShowNudge_ScopedNudgePause) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Set up a `ScopedNudgePause`.
auto scoped_anchored_nudge_pause =
GetAnchoredNudgeManager()->CreateScopedPause();
// Attempt to show nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
// A `ScopedNudgePause` exists, the nudge should not be shown.
EXPECT_FALSE(GetShownNudge(id));
// Destroy the `ScopedNudgePause`, the nudge doesn't exist either.
scoped_anchored_nudge_pause.reset();
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that if a `ScopedNudgePause` creates when a nudge is showing, the nudge
// will be dismissed immediately.
TEST_F(AnchoredNudgeManagerImplTest, CancelNudge_ScopedNudgePause) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// The nudge will be shown.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// After a `ScopedNudgePause` is created, the nudge will be closed
// immediately.
GetAnchoredNudgeManager()->CreateScopedPause();
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge sets the appropriate arrow when it's set to be anchored to
// the shelf, and updates its arrow whenever the shelf alignment changes.
TEST_F(AnchoredNudgeManagerImplTest, NudgeAnchoredToShelf) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Make the nudge set its arrow based on the shelf's position.
nudge_data.anchored_to_shelf = true;
// Set shelf alignment to the left.
Shelf* shelf = GetPrimaryShelf();
EXPECT_EQ(shelf->alignment(), ShelfAlignment::kBottom);
EXPECT_EQ(shelf->GetVisibilityState(), SHELF_VISIBLE);
shelf->SetAlignment(ShelfAlignment::kLeft);
// Show a nudge, expect its arrow to be aligned with left shelf.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_EQ(GetShownNudge(id)->arrow(),
views::BubbleBorder::Arrow::LEFT_BOTTOM);
// Cancel the nudge, and show a new nudge with bottom shelf alignment.
GetAnchoredNudgeManager()->Cancel(id);
shelf->SetAlignment(ShelfAlignment::kBottom);
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_EQ(GetShownNudge(id)->arrow(),
views::BubbleBorder::Arrow::BOTTOM_RIGHT);
// Change the shelf alignment to the right while the nudge is still open,
// nudge arrow should be updated.
shelf->SetAlignment(ShelfAlignment::kRight);
EXPECT_EQ(GetShownNudge(id)->arrow(),
views::BubbleBorder::Arrow::RIGHT_BOTTOM);
// Cancel the nudge and create a new nudge with an arrow that is not
// corner-anchored.
GetAnchoredNudgeManager()->Cancel(id);
nudge_data.arrow = views::BubbleBorder::Arrow::LEFT_CENTER;
GetAnchoredNudgeManager()->Show(nudge_data);
shelf->SetAlignment(ShelfAlignment::kLeft);
EXPECT_EQ(GetShownNudge(id)->arrow(),
views::BubbleBorder::Arrow::LEFT_CENTER);
shelf->SetAlignment(ShelfAlignment::kBottom);
EXPECT_EQ(GetShownNudge(id)->arrow(),
views::BubbleBorder::Arrow::BOTTOM_CENTER);
shelf->SetAlignment(ShelfAlignment::kRight);
EXPECT_EQ(GetShownNudge(id)->arrow(),
views::BubbleBorder::Arrow::RIGHT_CENTER);
}
// Tests that a nudge that is anchored to the shelf is not affected by shelf
// alignment changes of a display where the nudge does not exist.
TEST_F(AnchoredNudgeManagerImplTest,
NudgeAnchoredToShelf_WithASecondaryDisplay) {
// Add a secondary display.
UpdateDisplay("800x700,800x700");
RootWindowController* const secondary_root_window_controller =
Shell::GetRootWindowControllerWithDisplayId(GetSecondaryDisplay().id());
Shelf* shelf = GetPrimaryShelf();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = shelf->status_area_widget()->unified_system_tray();
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Make the nudge set its arrow based on the shelf's position.
nudge_data.anchored_to_shelf = true;
// Set shelf alignment to the left.
shelf->SetAlignment(ShelfAlignment::kLeft);
// Show a nudge, expect its arrow to be aligned with left shelf.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_EQ(views::BubbleBorder::Arrow::LEFT_BOTTOM,
GetShownNudge(id)->arrow());
// Test that changing the shelf alignment on the secondary display does not
// affect the nudge's arrow, since the nudge lives in the primary display.
secondary_root_window_controller->shelf()->SetAlignment(
ShelfAlignment::kBottom);
EXPECT_EQ(views::BubbleBorder::Arrow::LEFT_BOTTOM,
GetShownNudge(id)->arrow());
}
// Tests that a nudge that is anchored to the shelf maintains the shelf visible
// while the nudge is being shown and the shelf is on auto-hide.
TEST_F(AnchoredNudgeManagerImplTest, NudgeAnchoredToShelf_ShelfDoesNotHide) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Make the nudge maintain the shelf visible while it is showing.
nudge_data.anchored_to_shelf = true;
// Verify `shelf` is initially visible.
Shelf* shelf = GetPrimaryShelf();
EXPECT_TRUE(shelf->IsVisible());
// Set `shelf` to always auto-hide, it should not be visible.
shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
EXPECT_FALSE(shelf->IsVisible());
// Show the nudge, `shelf` should be made visible while nudge is showing.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(shelf->IsVisible());
// Cancel the nudge, `shelf` should be hidden again.
GetAnchoredNudgeManager()->Cancel(id);
EXPECT_FALSE(shelf->IsVisible());
}
// Tests that a nudge closes if its anchor view is made invisible.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_WhenAnchorViewIsHiding) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Set the anchor view visibility to false, the nudge should have closed.
anchor_view->SetVisible(false);
EXPECT_FALSE(GetShownNudge(id));
// Set the anchor view visibility to true, the nudge should not reappear.
anchor_view->SetVisible(true);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge closes if its anchor view is deleted.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_WhenAnchorViewIsDeleting) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* contents_view =
widget->SetContentsView(std::make_unique<views::View>());
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Delete the anchor view, the nudge should have closed.
contents_view->RemoveAllChildViews();
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge whose anchor view is a part of a secondary display closes
// when that display is removed.
TEST_F(AnchoredNudgeManagerImplTest,
NudgeCloses_WhenAnchorViewIsDeletingOnSecondaryDisplay) {
// Set up two displays.
UpdateDisplay("800x700,800x700");
RootWindowController* const secondary_root_window_controller =
Shell::GetRootWindowControllerWithDisplayId(GetSecondaryDisplay().id());
// Set up nudge data contents. The anchor view is a child of the secondary
// root window controller, so it will be deleted if the display is removed.
const std::string id("id");
auto* anchor_view = secondary_root_window_controller->shelf()
->status_area_widget()
->unified_system_tray();
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show the nudge in the secondary display.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Remove the secondary display, which deletes the anchor view.
UpdateDisplay("800x700");
// The anchor view was deleted, the nudge should have closed.
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge closes if its anchor view widget is hiding.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_WhenAnchorViewWidgetIsHiding) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Hide the anchor view widget, the nudge should have closed.
widget->Hide();
EXPECT_FALSE(GetShownNudge(id));
// Show the anchor view widget, the nudge should not reappear.
widget->ShowInactive();
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge is properly destroyed on shutdown.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_OnShutdown) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Nudge is left open, no crash.
}
// Tests that nudges expire after their dismiss timer reaches its end.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_WhenDismissTimerExpires) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge with default duration.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// The nudge should expire after `kNudgeDefaultDuration` has passed.
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration + base::Seconds(1));
EXPECT_FALSE(GetShownNudge(id));
// Test that a nudge with medium duration lasts longer than
// `kNudgeDefaultDuration` but expires after `kNudgeMediumDuration`.
nudge_data.duration = NudgeDuration::kMediumDuration;
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration + base::Seconds(1));
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeMediumDuration);
EXPECT_FALSE(GetShownNudge(id));
// Test that a nudge with long duration lasts longer than
// `kNudgeMediumDuration` but expires after `kNudgeLongDuration`.
nudge_data.duration = NudgeDuration::kLongDuration;
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeMediumDuration + base::Seconds(1));
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeLongDuration);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that nudge's default duration is updated to medium duration if the
// nudge has a long body text or a button.
TEST_F(AnchoredNudgeManagerImplTest, NudgeDefaultDurationIsUpdated) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
const std::u16string long_body_text =
u"This is just a body text that has more than sixty characters.";
const std::u16string primary_button_text = u"first";
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge with default duration.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// The nudge should expire after `kNudgeDefaultDuration`.
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration + base::Seconds(1));
EXPECT_FALSE(GetShownNudge(id));
// Add a long body text and show the nudge again.
ASSERT_GE(static_cast<int>(long_body_text.length()),
AnchoredNudgeManagerImpl::kLongBodyTextLength);
nudge_data.body_text = long_body_text;
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// The nudge should not expire after `kNudgeDefaultDuration` has passed, but
// will expire after `kNudgeMediumDuration` since it has a long body text.
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration + base::Seconds(1));
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeMediumDuration);
EXPECT_FALSE(GetShownNudge(id));
// Clear body text, add a button and show the nudge again.
nudge_data.body_text = std::u16string();
nudge_data.primary_button_text = primary_button_text;
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// The nudge should not expire after `kNudgeDefaultDuration` has passed, but
// will expire after `kNudgeMediumDuration` since it has a button.
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration + base::Seconds(1));
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeMediumDuration);
EXPECT_FALSE(GetShownNudge(id));
// Set the duration to long and show the nudge again.
nudge_data.duration = NudgeDuration::kLongDuration;
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Ensure the duration doesn't update back to medium if it was set to long.
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeMediumDuration + base::Seconds(1));
EXPECT_TRUE(GetShownNudge(id));
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeLongDuration);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that nudges are destroyed on session state changes.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_OnSessionStateChanged) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Lock screen, nudge should have closed.
SetLockedState(true);
EXPECT_FALSE(GetShownNudge(id));
// Show a nudge in the locked state.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Unlock screen, nudge should have closed.
SetLockedState(false);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that the nudge widget closes after its hide animation is completed.
TEST_F(AnchoredNudgeManagerImplTest, NudgeCloses_OnHideAnimationComplete) {
// Set animations to last a non-zero, faster than normal duration, since the
// regular duration may last longer in tests and cause flakiness.
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NON_ZERO_DURATION);
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Cancel will trigger the hide animation, the nudge should still exist.
GetAnchoredNudgeManager()->Cancel(id);
EXPECT_TRUE(GetShownNudge(id));
// Attempt cancelling the nudge while hide animation is in progress, these
// calls should be ignored.
GetAnchoredNudgeManager()->Cancel(id);
GetAnchoredNudgeManager()->Cancel(id);
// Fast forward to complete hide animation, the nudge should have closed.
task_environment()->FastForwardBy(kAnimationSettleDownDuration);
ASSERT_FALSE(GetShownNudge(id));
}
TEST_F(AnchoredNudgeManagerImplTest, NudgeHideAnimationInterrupted_OnShutdown) {
// Set animations to last their normal duration.
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Cancel will trigger the hide animation, the nudge should still exist.
GetAnchoredNudgeManager()->Cancel(id);
EXPECT_TRUE(GetShownNudge(id));
// Nudge animation is interrupted on shutdown, no crash.
}
TEST_F(AnchoredNudgeManagerImplTest,
NudgeHideAnimationInterrupted_OnNudgeReplaced) {
// Set animations to last their normal duration.
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Cancel will trigger the hide animation, the nudge should still exist.
GetAnchoredNudgeManager()->Cancel(id);
EXPECT_TRUE(GetShownNudge(id));
// Attempt showing the same nudge again immediately. The hide animation should
// be interrupted, and the nudge will be replaced.
GetAnchoredNudgeManager()->Show(nudge_data);
task_environment()->FastForwardBy(kAnimationSettleDownDuration);
EXPECT_TRUE(GetShownNudge(id));
}
TEST_F(AnchoredNudgeManagerImplTest,
NudgeHideAnimationInterrupted_OnScopedPauseAdded) {
// Set animations to last their normal duration.
ui::ScopedAnimationDurationScaleMode test_duration_mode(
ui::ScopedAnimationDurationScaleMode::NORMAL_DURATION);
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Cancel will trigger the hide animation, the nudge should still exist.
GetAnchoredNudgeManager()->Cancel(id);
EXPECT_TRUE(GetShownNudge(id));
// Create a scoped nudge pause right after, which will close the nudge
// immediately interrupting its hide animation.
GetAnchoredNudgeManager()->CreateScopedPause();
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that the dismiss timer is paused on hover so the nudge won't close.
TEST_F(AnchoredNudgeManagerImplTest, NudgePersists_OnHover) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
AnchoredNudge* nudge = GetShownNudge(id);
EXPECT_TRUE(nudge);
// Wait for half of the nudge's duration.
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration / 2);
// Hover on the nudge and wait for its full duration. It should persist.
GetEventGenerator()->MoveMouseTo(
GetShownNudge(id)->GetBoundsInScreen().CenterPoint());
EXPECT_TRUE(nudge->IsMouseHovered());
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration);
EXPECT_TRUE(nudge);
// Hover out of the nudge and wait its duration. It should be dismissed.
GetEventGenerator()->MoveMouseTo(gfx::Point(-100, -100));
EXPECT_FALSE(nudge->IsMouseHovered());
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration / 2 + base::Seconds(1));
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that the dismiss timer is paused when one of the nudge's children is
// focused so the nudge won't close.
TEST_F(AnchoredNudgeManagerImplTest, NudgePersists_OnFocus) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge with a button so the nudge has a focusable child.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
nudge_data.primary_button_text = u"button";
// Show a nudge with a button.
GetAnchoredNudgeManager()->Show(nudge_data);
ASSERT_TRUE(GetShownNudge(id));
auto* button = GetNudgePrimaryButton(id);
ASSERT_TRUE(button);
// Focus on the nudge's button and wait for its full duration times two. It
// should persist.
button->RequestFocus();
EXPECT_TRUE(button->HasFocus());
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration * 2);
EXPECT_TRUE(GetShownNudge(id));
// Focus out of the nudge and wait its full duration times two. It should be
// dismissed.
button->GetFocusManager()->ClearFocus();
EXPECT_FALSE(button->HasFocus());
task_environment()->FastForwardBy(
AnchoredNudgeManagerImpl::kNudgeDefaultDuration * 2);
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that attempting to cancel a nudge with an invalid `id` should not
// have any effects.
TEST_F(AnchoredNudgeManagerImplTest, CancelNudgeWhichDoesNotExist) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
const std::string id_2("id_2");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Show a nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
// Attempt to cancel nudge with an `id` that does not exist. Should not have
// any effect.
CancelNudge(id_2);
EXPECT_TRUE(GetShownNudge(id));
// Cancel the shown nudge with its valid `id`.
CancelNudge(id);
EXPECT_FALSE(GetShownNudge(id));
// Attempt to cancel the same nudge again. Should not have any effect.
CancelNudge(id);
EXPECT_FALSE(GetShownNudge(id));
}
TEST_F(AnchoredNudgeManagerImplTest, ShownCountMetric) {
base::HistogramTester histogram_tester;
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
histogram_tester.ExpectBucketCount(kNudgeShownCount, kTestCatalogName, 0);
GetAnchoredNudgeManager()->Show(nudge_data);
histogram_tester.ExpectBucketCount(kNudgeShownCount, kTestCatalogName, 1);
GetAnchoredNudgeManager()->Show(nudge_data);
GetAnchoredNudgeManager()->Show(nudge_data);
histogram_tester.ExpectBucketCount(kNudgeShownCount, kTestCatalogName, 3);
}
TEST_F(AnchoredNudgeManagerImplTest, TimeToActionMetric) {
base::HistogramTester histogram_tester;
GetAnchoredNudgeManager()->ResetNudgeRegistryForTesting();
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto* anchor_view = widget->SetContentsView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
// Metric is not recorded if the nudge has not been shown.
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithin1m,
kTestCatalogName, 0);
// Metric is recorded if the action is performed after the nudge was shown.
GetAnchoredNudgeManager()->Show(nudge_data);
task_environment()->FastForwardBy(base::Seconds(1));
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithin1m,
kTestCatalogName, 1);
// Metric is not recorded if the nudge action is performed again without
// another nudge being shown.
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithin1m,
kTestCatalogName, 1);
// Metric is recorded with the appropriate time range after showing nudge
// again and waiting enough time to fall into the "Within1h" time bucket.
GetAnchoredNudgeManager()->Show(nudge_data);
task_environment()->FastForwardBy(base::Minutes(2));
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithin1h,
kTestCatalogName, 1);
// Metric is not recorded if the nudge action is performed again without
// another nudge being shown.
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithin1h,
kTestCatalogName, 1);
// Metric is recorded with the appropriate time range after showing nudge
// again and waiting enough time to fall into the "WithinSession" time bucket.
GetAnchoredNudgeManager()->Show(nudge_data);
task_environment()->FastForwardBy(base::Hours(2));
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithinSession,
kTestCatalogName, 1);
// Metric is not recorded if the nudge action is performed again without
// another nudge being shown.
GetAnchoredNudgeManager()->MaybeRecordNudgeAction(kTestCatalogName);
histogram_tester.ExpectBucketCount(kNudgeTimeToActionWithinSession,
kTestCatalogName, 1);
}
// Tests that a nudge is parented to its anchor view, which has a widget.
TEST_F(AnchoredNudgeManagerImplTest, SetParent_AnchorViewWithWidget) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto contents_view = std::make_unique<views::View>();
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
widget->SetContentsView(contents_view.get());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
nudge_data.set_anchor_view_as_parent = true;
// Anchor view exists, the nudge should be created and parented by it.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_EQ(GetNudgeIfShown(id)->GetWidget()->GetNativeWindow()->parent(),
anchor_view->GetWidget()->GetNativeView()->parent());
}
// Tests that a nudge is not parented to its anchor view if
// `set_anchor_view_as_parent` is not set to true.
TEST_F(AnchoredNudgeManagerImplTest, NotSetParent_AnchorViewWithWidget) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set up nudge data contents.
const std::string id("id");
auto contents_view = std::make_unique<views::View>();
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
widget->SetContentsView(contents_view.get());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
nudge_data.set_anchor_view_as_parent = false;
// Anchor view exists, the nudge should be created but not parented by it.
GetAnchoredNudgeManager()->Show(nudge_data);
EXPECT_TRUE(GetShownNudge(id));
EXPECT_NE(GetNudgeIfShown(id)->GetWidget()->GetNativeWindow()->parent(),
anchor_view->GetWidget()->GetNativeView()->parent());
}
// Tests that a nudge is not created if its anchor view doesn't have a widget
// but `set_anchor_view_as_parent` is set to true.
TEST_F(AnchoredNudgeManagerImplTest, SetParent_AnchorViewWithoutWidget) {
// Set up nudge data contents.
const std::string id("id");
auto contents_view = std::make_unique<views::View>();
auto* anchor_view =
contents_view->AddChildView(std::make_unique<views::View>());
auto nudge_data = CreateBaseNudgeData(id, anchor_view);
nudge_data.set_anchor_view_as_parent = true;
// Attempt to show nudge.
GetAnchoredNudgeManager()->Show(nudge_data);
// Anchor view does not have a widget, the nudge should not be created.
EXPECT_FALSE(GetShownNudge(id));
}
// Tests that a nudge receives focus when it has buttons, and skips focus
// traversal when it has no buttons.
TEST_F(AnchoredNudgeManagerImplTest, FocusTraversable) {
std::unique_ptr<views::Widget> widget = CreateFramelessTestWidget();
// Set widget contents.
views::View* view1;
views::View* view2;
views::View* view3;
widget->SetContentsView(
views::Builder<views::FlexLayoutView>()
.AddChildren(
views::Builder<views::LabelButton>()
.CopyAddressTo(&view1)
.SetFocusBehavior(views::View::FocusBehavior::ALWAYS),
views::Builder<views::LabelButton>()
.CopyAddressTo(&view2)
.SetFocusBehavior(views::View::FocusBehavior::ALWAYS),
views::Builder<views::LabelButton>()
.CopyAddressTo(&view3)
.SetFocusBehavior(views::View::FocusBehavior::ALWAYS))
.Build());
// Setup a nudge without buttons and set `view2` as the anchor view.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, view2);
GetAnchoredNudgeManager()->Show(nudge_data);
// Focus traversal should skip the nudge since it has no buttons.
PressTab();
EXPECT_EQ(widget->GetFocusManager()->GetFocusedView(), view1);
PressTab();
EXPECT_EQ(widget->GetFocusManager()->GetFocusedView(), view2);
PressTab();
EXPECT_EQ(widget->GetFocusManager()->GetFocusedView(), view3);
// When a nudge has buttons, focus traversal should go into them and cycle
// until the nudge is dismissed.
nudge_data.primary_button_text = u"button";
nudge_data.secondary_button_text = u"button";
GetAnchoredNudgeManager()->Show(nudge_data);
PressTab();
EXPECT_EQ(widget->GetFocusManager()->GetFocusedView(), view1);
PressTab();
EXPECT_EQ(widget->GetFocusManager()->GetFocusedView(), view2);
PressTab();
auto* nudge_widget = GetShownNudge(id)->GetWidget();
EXPECT_EQ(nudge_widget->GetFocusManager()->GetFocusedView(),
GetNudgeSecondaryButton(id));
PressTab();
EXPECT_EQ(nudge_widget->GetFocusManager()->GetFocusedView(),
GetNudgePrimaryButton(id));
PressTab();
EXPECT_EQ(nudge_widget->GetFocusManager()->GetFocusedView(),
GetNudgeSecondaryButton(id));
GetAnchoredNudgeManager()->Cancel(id);
EXPECT_EQ(widget->GetFocusManager()->GetFocusedView(), view2);
}
// Tests that a nudge is anchored at the bottom left corner of its anchor
// widget.
TEST_F(AnchoredNudgeManagerImplTest, AnchorInsideWidget_BottomLeft) {
std::unique_ptr<views::Widget> anchor_widget =
CreateTestWidget(views::Widget::InitParams::CLIENT_OWNS_WIDGET);
anchor_widget->SetBounds(
gfx::Rect(gfx::Point(100, 100), gfx::Size(300, 200)));
// Set up nudge data contents.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
nudge_data.anchor_widget = anchor_widget.get();
nudge_data.arrow = views::BubbleBorder::Arrow::BOTTOM_LEFT;
// `anchor_widget` exists, will anchor inside the widget.
GetAnchoredNudgeManager()->Show(nudge_data);
auto* nudge = GetShownNudge(id);
EXPECT_TRUE(nudge);
auto* nudge_widget = nudge->GetWidget();
EXPECT_TRUE(nudge_widget);
auto nudge_bounds = nudge_widget->GetWindowBoundsInScreen();
auto anchor_widget_bounds = anchor_widget->GetWindowBoundsInScreen();
// Compare the bounds alignment with the `kBubbleBorderInsets`.
EXPECT_EQ(nudge_bounds.bottom_left(),
anchor_widget_bounds.bottom_left() +
gfx::Vector2d(kBubbleBorderInsets.left(),
-kBubbleBorderInsets.bottom()));
}
// Tests that a nudge is anchored at the bottom right corner of its anchor
// widget.
TEST_F(AnchoredNudgeManagerImplTest, AnchorInsideWidget_BottomRight) {
std::unique_ptr<views::Widget> anchor_widget =
CreateTestWidget(views::Widget::InitParams::CLIENT_OWNS_WIDGET);
anchor_widget->SetBounds(
gfx::Rect(gfx::Point(100, 100), gfx::Size(300, 200)));
// Set up nudge data contents.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
nudge_data.anchor_widget = anchor_widget.get();
nudge_data.arrow = views::BubbleBorder::Arrow::BOTTOM_RIGHT;
// `anchor_widget` exists, will anchor inside the widget.
GetAnchoredNudgeManager()->Show(nudge_data);
auto* nudge = GetShownNudge(id);
EXPECT_TRUE(nudge);
auto* nudge_widget = nudge->GetWidget();
EXPECT_TRUE(nudge_widget);
auto nudge_bounds = nudge_widget->GetWindowBoundsInScreen();
auto anchor_widget_bounds = anchor_widget->GetWindowBoundsInScreen();
// Compare the bounds alignment with the `kBubbleBorderInsets`.
EXPECT_EQ(nudge_bounds.bottom_right(),
anchor_widget_bounds.bottom_right() +
gfx::Vector2d(-kBubbleBorderInsets.right(),
-kBubbleBorderInsets.bottom()));
}
// Tests that a nudge with an anchor widget is placed on the right on RTL.
TEST_F(AnchoredNudgeManagerImplTest, AnchorInsideWidget_WithRTL) {
// Turn on RTL mode.
base::i18n::SetRTLForTesting(true);
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(base::i18n::IsRTL());
std::unique_ptr<views::Widget> anchor_widget =
CreateTestWidget(views::Widget::InitParams::CLIENT_OWNS_WIDGET);
anchor_widget->SetBounds(
gfx::Rect(gfx::Point(100, 100), gfx::Size(300, 200)));
// Set up nudge data contents.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
nudge_data.anchor_widget = anchor_widget.get();
nudge_data.arrow = views::BubbleBorder::Arrow::BOTTOM_LEFT;
// `anchor_widget` exists, will anchor inside the widget.
GetAnchoredNudgeManager()->Show(nudge_data);
auto* nudge = GetShownNudge(id);
EXPECT_TRUE(nudge);
auto* nudge_widget = nudge->GetWidget();
EXPECT_TRUE(nudge_widget);
auto nudge_bounds = nudge_widget->GetWindowBoundsInScreen();
auto anchor_widget_bounds = anchor_widget->GetWindowBoundsInScreen();
// Compare the bounds alignment with the `kBubbleBorderInsets`.
// The nudge should be shown on the leading bottom corner of the
// `anchor_widget`, which for RTL languages is the bottom-right.
EXPECT_EQ(nudge_bounds.bottom_right(),
anchor_widget_bounds.bottom_right() +
gfx::Vector2d(-kBubbleBorderInsets.right(),
-kBubbleBorderInsets.bottom()));
// Turn off RTL mode.
base::i18n::SetRTLForTesting(false);
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(base::i18n::IsRTL());
}
// Tests that a nudge is anchored at the bottom left corner of its anchor
// widget in the tablet mode.
TEST_F(AnchoredNudgeManagerImplTest, AnchorInsideWidget_TabletMode) {
ash::TabletModeControllerTestApi().EnterTabletMode();
std::unique_ptr<views::Widget> anchor_widget =
CreateTestWidget(views::Widget::InitParams::CLIENT_OWNS_WIDGET);
anchor_widget->SetBounds(
gfx::Rect(gfx::Point(100, 100), gfx::Size(300, 200)));
// Set up nudge data contents.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
nudge_data.anchor_widget = anchor_widget.get();
nudge_data.arrow = views::BubbleBorder::Arrow::BOTTOM_LEFT;
// `anchor_widget` exists, will anchor inside the widget.
GetAnchoredNudgeManager()->Show(nudge_data);
auto* nudge = GetShownNudge(id);
EXPECT_TRUE(nudge);
auto* nudge_widget = nudge->GetWidget();
EXPECT_TRUE(nudge_widget);
auto nudge_bounds = nudge_widget->GetWindowBoundsInScreen();
auto anchor_widget_bounds = anchor_widget->GetWindowBoundsInScreen();
// Compare the bounds alignment with the `kBubbleBorderInsets`.
EXPECT_EQ(nudge_bounds.bottom_left(),
anchor_widget_bounds.bottom_left() +
gfx::Vector2d(kBubbleBorderInsets.left(),
-kBubbleBorderInsets.bottom()));
}
// Tests that the nudge is closed when the anchor widget is closed.
TEST_F(AnchoredNudgeManagerImplTest, NudgeClosedWhenAnchorWidgetClosed) {
std::unique_ptr<views::Widget> anchor_widget =
CreateTestWidget(views::Widget::InitParams::CLIENT_OWNS_WIDGET);
anchor_widget->SetBounds(
gfx::Rect(gfx::Point(100, 100), gfx::Size(300, 200)));
// Set up nudge data contents.
const std::string id("id");
auto nudge_data = CreateBaseNudgeData(id, /*anchor_view=*/nullptr);
nudge_data.anchor_widget = anchor_widget.get();
nudge_data.arrow = views::BubbleBorder::Arrow::BOTTOM_LEFT;
// `anchor_widget` exists, will anchor inside the widget.
GetAnchoredNudgeManager()->Show(nudge_data);
auto* nudge = GetShownNudge(id);
EXPECT_TRUE(nudge);
auto* nudge_widget = nudge->GetWidget();
EXPECT_TRUE(nudge_widget);
auto nudge_bounds = nudge_widget->GetWindowBoundsInScreen();
auto anchor_widget_bounds = anchor_widget->GetWindowBoundsInScreen();
// Compare the bounds alignment with the `kBubbleBorderInsets`.
EXPECT_EQ(nudge_bounds.bottom_left(),
anchor_widget_bounds.bottom_left() +
gfx::Vector2d(kBubbleBorderInsets.left(),
-kBubbleBorderInsets.bottom()));
// Close the `anchor_widget` should close the nudge as well.
anchor_widget->CloseNow();
nudge = GetShownNudge(id);
EXPECT_FALSE(nudge);
}
} // namespace ash
Codebase Browser
chromium