// Copyright 2014 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/notification_center/ash_message_popup_collection.h"
#include <memory>
#include <tuple>
#include <utility>
#include <vector>
#include "ash/ime/ime_controller_impl.h"
#include "ash/keyboard/ui/keyboard_ui_controller.h"
#include "ash/keyboard/ui/keyboard_util.h"
#include "ash/public/cpp/keyboard/keyboard_switches.h"
#include "ash/public/cpp/shelf_types.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/root_window_controller.h"
#include "ash/shelf/shelf.h"
#include "ash/shelf/shelf_layout_manager.h"
#include "ash/shell.h"
#include "ash/system/ime_menu/ime_menu_tray.h"
#include "ash/system/notification_center/message_center_test_util.h"
#include "ash/system/notification_center/message_popup_animation_waiter.h"
#include "ash/system/notification_center/notification_center_tray.h"
#include "ash/system/notification_center/views/ash_notification_expand_button.h"
#include "ash/system/notification_center/views/ash_notification_view.h"
#include "ash/system/phonehub/phone_hub_tray.h"
#include "ash/system/status_area_widget.h"
#include "ash/system/status_area_widget_test_helper.h"
#include "ash/system/unified/unified_slider_view.h"
#include "ash/system/unified/unified_system_tray.h"
#include "ash/system/unified/unified_system_tray_bubble.h"
#include "ash/test/ash_test_base.h"
#include "ash/wm/desks/desks_util.h"
#include "ash/wm/overview/overview_controller.h"
#include "ash/wm/tablet_mode/tablet_mode_controller.h"
#include "ash/wm/tablet_mode/tablet_mode_controller_test_api.h"
#include "base/command_line.h"
#include "base/run_loop.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/scoped_feature_list.h"
#include "base/time/time.h"
#include "chromeos/ash/components/phonehub/fake_phone_hub_manager.h"
#include "chromeos/ash/components/phonehub/feature_status.h"
#include "ui/base/ui_base_features.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/screen.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/keyboard_codes_posix.h"
#include "ui/events/test/event_generator.h"
#include "ui/gfx/animation/linear_animation.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/public/cpp/message_center_constants.h"
#include "ui/message_center/public/cpp/notification_delegate.h"
#include "ui/message_center/public/cpp/notification_types.h"
#include "ui/message_center/views/message_popup_collection.h"
#include "ui/message_center/views/message_popup_view.h"
#include "ui/message_center/views/message_view.h"
#include "ui/message_center/views/notification_control_buttons_view.h"
#include "ui/message_center/views/notification_view_base.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/textfield/textfield.h"
#include "ui/wm/core/window_util.h"
#include "url/gurl.h"
namespace ash {
namespace {
class TestMessagePopupCollection : public AshMessagePopupCollection {
public:
explicit TestMessagePopupCollection(Shelf* shelf)
: AshMessagePopupCollection(display::Screen::GetScreen(), shelf) {}
TestMessagePopupCollection(const TestMessagePopupCollection&) = delete;
TestMessagePopupCollection& operator=(const TestMessagePopupCollection&) =
delete;
~TestMessagePopupCollection() override = default;
bool popup_shown() const { return popup_shown_; }
protected:
void NotifyPopupAdded(message_center::MessagePopupView* popup) override {
AshMessagePopupCollection::NotifyPopupAdded(popup);
popup_shown_ = true;
notification_id_ = popup->message_view()->notification_id();
}
void NotifyPopupRemoved(const std::string& notification_id) override {
AshMessagePopupCollection::NotifyPopupRemoved(notification_id);
EXPECT_EQ(notification_id_, notification_id);
popup_shown_ = false;
notification_id_.clear();
}
private:
bool popup_shown_ = false;
std::string notification_id_;
};
} // namespace
class AshMessagePopupCollectionTest : public AshTestBase,
public testing::WithParamInterface<
/*IsNotifierCollisionEnabled=*/bool> {
public:
AshMessagePopupCollectionTest() = default;
AshMessagePopupCollectionTest(const AshMessagePopupCollectionTest&) = delete;
AshMessagePopupCollectionTest& operator=(
const AshMessagePopupCollectionTest&) = delete;
~AshMessagePopupCollectionTest() override = default;
void SetUp() override {
scoped_feature_list_ = std::make_unique<base::test::ScopedFeatureList>();
std::vector<base::test::FeatureRef> enabled_features;
std::vector<base::test::FeatureRef> disabled_features;
if (IsNotifierCollisionEnabled()) {
enabled_features.emplace_back(features::kNotifierCollision);
} else {
disabled_features.emplace_back(features::kNotifierCollision);
}
scoped_feature_list_->InitWithFeatures(enabled_features, disabled_features);
base::CommandLine::ForCurrentProcess()->AppendSwitch(
keyboard::switches::kEnableVirtualKeyboard);
AshTestBase::SetUp();
}
// Trigger the timeout so that shelf will show/hide immediately.
bool TriggerShelfAutoHideTimeout() {
auto* layout_manager = GetPrimaryShelf()->shelf_layout_manager();
if (!layout_manager->auto_hide_timer_.IsRunning()) {
return false;
}
layout_manager->auto_hide_timer_.FireNow();
return true;
}
void AnimateUntilIdle() {
auto* animation = GetPrimaryPopupCollection()->animation();
while (animation->is_animating()) {
animation->SetCurrentValue(1.0);
animation->End();
}
}
// TODO(b/305075031) clean up after the flag is removed.
bool IsNotifierCollisionEnabled() const { return GetParam(); }
protected:
enum Position { TOP_LEFT, TOP_RIGHT, BOTTOM_LEFT, BOTTOM_RIGHT, OUTSIDE };
AshMessagePopupCollection* GetPrimaryPopupCollection() {
return GetPrimaryNotificationCenterTray()->popup_collection();
}
void UpdateWorkArea(AshMessagePopupCollection* popup_collection,
const display::Display& display) {
popup_collection->StartObserving(display::Screen::GetScreen(), display);
// Update the layout
popup_collection->UpdateWorkArea();
}
message_center::MessagePopupView* GetLastPopUpAdded() {
return GetPrimaryPopupCollection()->last_pop_up_added_;
}
message_center::MessagePopupView* GetLastPopUpAddedForCollection(
AshMessagePopupCollection* collection) {
return collection->last_pop_up_added_;
}
Position GetPositionInDisplay(const gfx::Point& point) {
const gfx::Rect work_area =
display::Screen::GetScreen()->GetPrimaryDisplay().work_area();
const gfx::Point center_point = work_area.CenterPoint();
if (work_area.x() > point.x() || work_area.y() > point.y() ||
work_area.right() < point.x() || work_area.bottom() < point.y()) {
return OUTSIDE;
}
if (center_point.x() < point.x()) {
return (center_point.y() < point.y()) ? BOTTOM_RIGHT : TOP_RIGHT;
} else {
return (center_point.y() < point.y()) ? BOTTOM_LEFT : TOP_LEFT;
}
}
gfx::Rect GetWorkArea() { return GetPrimaryPopupCollection()->work_area_; }
std::string AddNotification(bool has_image = false,
const GURL& origin_url = GURL(),
bool has_inline_reply = false) {
std::string id = base::NumberToString(notification_id_++);
message_center::MessageCenter::Get()->AddNotification(
CreateSimpleNotification(id, has_image, origin_url, has_inline_reply));
return id;
}
phonehub::FakePhoneHubManager* phone_hub_manager() {
return &phone_hub_manager_;
}
private:
int notification_id_ = 0;
// Fake phone hub manager to show the phone hub tray. Used to test the popup
// collection when the phone hub bubble is showing.
phonehub::FakePhoneHubManager phone_hub_manager_;
std::unique_ptr<base::test::ScopedFeatureList> scoped_feature_list_;
};
INSTANTIATE_TEST_SUITE_P(All,
AshMessagePopupCollectionTest,
/*IsNotifierCollisionEnabled()=*/testing::Bool());
TEST_P(AshMessagePopupCollectionTest, ShelfAlignment) {
const gfx::Rect popup_size(0, 0, 10, 10);
UpdateDisplay("601x600");
gfx::Point popup_point;
auto* popup_collection = GetPrimaryPopupCollection();
popup_point.set_x(popup_collection->GetPopupOriginX(popup_size));
popup_point.set_y(popup_collection->GetBaseline());
EXPECT_EQ(BOTTOM_RIGHT, GetPositionInDisplay(popup_point));
EXPECT_FALSE(popup_collection->IsTopDown());
EXPECT_FALSE(popup_collection->IsFromLeft());
GetPrimaryShelf()->SetAlignment(ShelfAlignment::kRight);
popup_point.set_x(popup_collection->GetPopupOriginX(popup_size));
popup_point.set_y(popup_collection->GetBaseline());
EXPECT_EQ(BOTTOM_RIGHT, GetPositionInDisplay(popup_point));
EXPECT_FALSE(popup_collection->IsTopDown());
EXPECT_FALSE(popup_collection->IsFromLeft());
GetPrimaryShelf()->SetAlignment(ShelfAlignment::kLeft);
popup_point.set_x(popup_collection->GetPopupOriginX(popup_size));
popup_point.set_y(popup_collection->GetBaseline());
EXPECT_EQ(BOTTOM_LEFT, GetPositionInDisplay(popup_point));
EXPECT_FALSE(popup_collection->IsTopDown());
EXPECT_TRUE(popup_collection->IsFromLeft());
}
TEST_P(AshMessagePopupCollectionTest, LockScreen) {
const gfx::Rect popup_size(0, 0, 10, 10);
auto* popup_collection = GetPrimaryPopupCollection();
GetPrimaryShelf()->SetAlignment(ShelfAlignment::kLeft);
gfx::Point popup_point;
popup_point.set_x(popup_collection->GetPopupOriginX(popup_size));
popup_point.set_y(popup_collection->GetBaseline());
EXPECT_EQ(BOTTOM_LEFT, GetPositionInDisplay(popup_point));
EXPECT_FALSE(popup_collection->IsTopDown());
EXPECT_TRUE(popup_collection->IsFromLeft());
BlockUserSession(BLOCKED_BY_LOCK_SCREEN);
popup_point.set_x(popup_collection->GetPopupOriginX(popup_size));
popup_point.set_y(popup_collection->GetBaseline());
EXPECT_EQ(BOTTOM_RIGHT, GetPositionInDisplay(popup_point));
EXPECT_FALSE(popup_collection->IsTopDown());
EXPECT_FALSE(popup_collection->IsFromLeft());
}
TEST_P(AshMessagePopupCollectionTest, AutoHide) {
const gfx::Rect popup_size(0, 0, 10, 10);
UpdateDisplay("601x600");
auto* popup_collection = GetPrimaryPopupCollection();
int origin_x = popup_collection->GetPopupOriginX(popup_size);
int shelf_show_baseline = popup_collection->GetBaseline();
// Create a window, otherwise autohide doesn't work.
std::unique_ptr<views::Widget> widget = CreateTestWidget(
views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
Shelf* shelf = GetPrimaryShelf();
shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
EXPECT_EQ(origin_x, popup_collection->GetPopupOriginX(popup_size));
// The baseline when shelf shows should be less than when it hides.
int shelf_hide_baseline = popup_collection->GetBaseline();
EXPECT_LT(shelf_show_baseline, shelf_hide_baseline);
// Tests that popup baseline changes when shelf shows/hides.
// Move down the mouse to show shelf. Popup should move up.
ui::test::EventGenerator* generator = GetEventGenerator();
gfx::Rect display_bounds =
display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
generator->MoveMouseTo(display_bounds.bottom_center());
ASSERT_TRUE(TriggerShelfAutoHideTimeout());
ASSERT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
EXPECT_EQ(shelf_show_baseline, popup_collection->GetBaseline());
// Move the mouse away to hide shelf. Popup should move down.
generator->MoveMouseTo(0, 0);
ASSERT_TRUE(TriggerShelfAutoHideTimeout());
ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
EXPECT_EQ(shelf_hide_baseline, popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest, DisplayResize) {
const gfx::Rect popup_size(0, 0, 10, 10);
UpdateDisplay("601x600");
auto* popup_collection = GetPrimaryPopupCollection();
int origin_x = popup_collection->GetPopupOriginX(popup_size);
int baseline = popup_collection->GetBaseline();
UpdateDisplay("801x800");
EXPECT_LT(origin_x, popup_collection->GetPopupOriginX(popup_size));
EXPECT_LT(baseline, popup_collection->GetBaseline());
UpdateDisplay("500x400");
EXPECT_GT(origin_x, popup_collection->GetPopupOriginX(popup_size));
EXPECT_GT(baseline, popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest, DockedMode) {
const gfx::Rect popup_size(0, 0, 10, 10);
UpdateDisplay("601x600");
auto* popup_collection = GetPrimaryPopupCollection();
int origin_x = popup_collection->GetPopupOriginX(popup_size);
int baseline = popup_collection->GetBaseline();
// Emulate the docked mode; enter to an extended mode, then invoke
// OnNativeDisplaysChanged() with the info for the secondary display only.
UpdateDisplay("601x600,801x800");
std::vector<display::ManagedDisplayInfo> new_info;
new_info.push_back(display_manager()->GetDisplayInfo(
display_manager()->GetDisplayAt(1u).id()));
display_manager()->OnNativeDisplaysChanged(new_info);
EXPECT_LT(origin_x, popup_collection->GetPopupOriginX(popup_size));
EXPECT_LT(baseline, popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest, Extended) {
UpdateDisplay("601x600,801x800");
display::Display second_display = GetSecondaryDisplay();
Shelf* second_shelf =
Shell::GetRootWindowControllerWithDisplayId(second_display.id())->shelf();
AshMessagePopupCollection for_2nd_display(display::Screen::GetScreen(),
second_shelf);
UpdateWorkArea(&for_2nd_display, second_display);
// Make sure that the popup position on the secondary display is
// positioned correctly.
EXPECT_LT(1300, for_2nd_display.GetPopupOriginX(gfx::Rect(0, 0, 10, 10)));
EXPECT_LT(700, for_2nd_display.GetBaseline());
}
// TODO(b/301625873): Fix notification pop-up dismissal on full-screen activated
// with multiple displays. The unit test is passing but the behavior it is
// testing does not work in production.
TEST_P(AshMessagePopupCollectionTest, DISABLED_MixedFullscreenNone) {
UpdateDisplay("601x600,801x800");
Shelf* shelf1 = GetPrimaryShelf();
TestMessagePopupCollection collection1(shelf1);
UpdateWorkArea(&collection1, GetPrimaryDisplay());
Shelf* shelf2 =
Shell::GetRootWindowControllerWithDisplayId(GetSecondaryDisplay().id())
->shelf();
TestMessagePopupCollection collection2(shelf2);
UpdateWorkArea(&collection2, GetSecondaryDisplay());
// No fullscreens, both receive notification.
std::unique_ptr<views::Widget> widget1 =
CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
widget1->SetFullscreen(false);
AddNotification();
EXPECT_TRUE(collection1.popup_shown());
EXPECT_TRUE(collection2.popup_shown());
// Set screen 1 to fullscreen, popup closes on screen 1, stays on screen 2.
widget1->SetFullscreen(true);
EXPECT_FALSE(collection1.popup_shown());
EXPECT_TRUE(collection2.popup_shown());
}
// TODO(b/301625873): Fix notification pop-up dismissal on full-screen activated
// with multiple displays. The unit test is passing but the behavior it is
// testing does not work in production.
TEST_P(AshMessagePopupCollectionTest, DISABLED_MixedFullscreenSome) {
UpdateDisplay("601x600,801x800");
Shelf* shelf1 = GetPrimaryShelf();
TestMessagePopupCollection collection1(shelf1);
UpdateWorkArea(&collection1, GetPrimaryDisplay());
Shelf* shelf2 =
Shell::GetRootWindowControllerWithDisplayId(GetSecondaryDisplay().id())
->shelf();
TestMessagePopupCollection collection2(shelf2);
UpdateWorkArea(&collection2, GetSecondaryDisplay());
// One fullscreen, non-fullscreen receives notification.
std::unique_ptr<views::Widget> widget =
CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
widget->SetFullscreen(true);
AddNotification();
EXPECT_FALSE(collection1.popup_shown());
EXPECT_TRUE(collection2.popup_shown());
// Fullscreen toggles, notification now on both.
widget->SetFullscreen(false);
EXPECT_TRUE(collection1.popup_shown());
EXPECT_TRUE(collection2.popup_shown());
}
// TODO(b/301625873): Fix notification pop-up dismissal on full-screen activated
// with multiple displays. The unit test is passing but the behavior it is
// testing does not work in production.
TEST_P(AshMessagePopupCollectionTest, DISABLED_MixedFullscreenAll) {
UpdateDisplay("601x600,801x800");
Shelf* shelf1 = GetPrimaryShelf();
TestMessagePopupCollection collection1(shelf1);
UpdateWorkArea(&collection1, GetPrimaryDisplay());
Shelf* shelf2 =
Shell::GetRootWindowControllerWithDisplayId(GetSecondaryDisplay().id())
->shelf();
TestMessagePopupCollection collection2(shelf2);
UpdateWorkArea(&collection2, GetSecondaryDisplay());
std::unique_ptr<views::Widget> widget1 =
CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
std::unique_ptr<views::Widget> widget2 = CreateTestWidget(
views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
desks_util::GetActiveDeskContainerId(), gfx::Rect(700, 0, 50, 50));
// Both fullscreen, no notifications.
widget1->SetFullscreen(true);
widget2->SetFullscreen(true);
AddNotification();
EXPECT_FALSE(collection1.popup_shown());
EXPECT_FALSE(collection2.popup_shown());
// Toggle 1, then the other.
widget1->SetFullscreen(false);
EXPECT_TRUE(collection1.popup_shown());
EXPECT_FALSE(collection2.popup_shown());
widget2->SetFullscreen(false);
EXPECT_TRUE(collection1.popup_shown());
EXPECT_TRUE(collection2.popup_shown());
}
TEST_P(AshMessagePopupCollectionTest, PopupCollectionOriginX) {
display_manager()->SetUnifiedDesktopEnabled(true);
UpdateDisplay("601x600,801x800");
EXPECT_GT(600, GetPrimaryPopupCollection()->GetPopupOriginX(
gfx::Rect(0, 0, 10, 10)));
}
// Tests that when the keyboard is showing that notifications appear above it,
// and that they return to normal once the keyboard is gone.
TEST_P(AshMessagePopupCollectionTest, KeyboardShowing) {
ASSERT_TRUE(keyboard::IsKeyboardEnabled());
ASSERT_TRUE(
keyboard::KeyboardUIController::Get()->IsKeyboardOverscrollEnabled());
UpdateDisplay("601x600");
auto* popup_collection = GetPrimaryPopupCollection();
int baseline = popup_collection->GetBaseline();
Shelf* shelf = GetPrimaryShelf();
gfx::Rect keyboard_bounds(0, 300, 601, 300);
shelf->SetVirtualKeyboardBoundsForTesting(keyboard_bounds);
int keyboard_baseline = popup_collection->GetBaseline();
EXPECT_NE(baseline, keyboard_baseline);
EXPECT_GT(keyboard_bounds.y(), keyboard_baseline);
shelf->SetVirtualKeyboardBoundsForTesting(gfx::Rect());
EXPECT_EQ(baseline, popup_collection->GetBaseline());
}
// Tests that notification bubble baseline is correct when entering and exiting
// overview with a full screen window.
TEST_P(AshMessagePopupCollectionTest, BaselineInOverview) {
UpdateDisplay("800x600");
ASSERT_TRUE(GetPrimaryShelf()->IsHorizontalAlignment());
ASSERT_EQ(SHELF_VISIBLE, GetPrimaryShelf()->GetVisibilityState());
auto* popup_collection = GetPrimaryPopupCollection();
const int baseline_with_visible_shelf = popup_collection->GetBaseline();
std::unique_ptr<views::Widget> widget =
CreateTestWidget(views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET);
widget->SetFullscreen(true);
ASSERT_EQ(SHELF_HIDDEN, GetPrimaryShelf()->GetVisibilityState());
const int baseline_with_hidden_shelf = popup_collection->GetBaseline();
EXPECT_NE(baseline_with_visible_shelf, baseline_with_hidden_shelf);
auto* overview_controller = OverviewController::Get();
EnterOverview();
EXPECT_TRUE(overview_controller->InOverviewSession());
const int baseline_in_overview = popup_collection->GetBaseline();
EXPECT_EQ(baseline_in_overview, baseline_with_visible_shelf);
ExitOverview();
EXPECT_FALSE(overview_controller->InOverviewSession());
const int baseline_no_overview = popup_collection->GetBaseline();
EXPECT_EQ(baseline_no_overview, baseline_with_hidden_shelf);
}
class NotificationDestructingNotificationDelegate
: public message_center::NotificationDelegate {
public:
NotificationDestructingNotificationDelegate() = default;
NotificationDestructingNotificationDelegate(
const NotificationDestructingNotificationDelegate&) = delete;
NotificationDestructingNotificationDelegate& operator=(
const NotificationDestructingNotificationDelegate&) = delete;
private:
~NotificationDestructingNotificationDelegate() override = default;
// NotificationObserver:
void Click(const std::optional<int>& button_index,
const std::optional<std::u16string>& reply) override {
// Show the UnifiedSystemTrayBubble, which will force all popups to be
// destroyed.
Shell::Get()
->GetPrimaryRootWindowController()
->GetStatusAreaWidget()
->notification_center_tray()
->ShowBubble();
}
};
// Regression test for crbug/1316656. Tests that pressing a button resulting in
// the notification popup getting destroyed does not crash.
TEST_P(AshMessagePopupCollectionTest, PopupDestroyedDuringClick) {
// Create a Notification popup with 1 action button.
message_center::RichNotificationData notification_data;
std::u16string button_text = u"BUTTON_TEXT";
notification_data.buttons.emplace_back(button_text);
auto to_be_destroyed_notification(
std::make_unique<message_center::Notification>(
message_center::NOTIFICATION_TYPE_SIMPLE, "id1",
u"Test Web Notification", u"Notification message body.",
ui::ImageModel(), u"www.test.org", GURL(),
message_center::NotifierId(), notification_data,
new NotificationDestructingNotificationDelegate()));
message_center::MessageCenter::Get()->AddNotification(
std::move(to_be_destroyed_notification));
EXPECT_TRUE(GetLastPopUpAdded());
// Get the view for the button added earlier.
auto* message_view = GetLastPopUpAdded()->message_view();
auto* action_button =
message_view
->GetViewByID(
message_center::NotificationViewBase::ViewId::kActionButtonsRow)
->children()[0]
.get();
EXPECT_EQ(static_cast<views::LabelButton*>(action_button)->GetText(),
button_text);
// Click the action button.
// `NotificationDestructingNotificationDelegate::Click()` will destroy the
// popup during `NotificationViewBase::ActionButtonPressed()`. There should be
// no crash.
auto* event_generator = GetEventGenerator();
event_generator->MoveMouseTo(
action_button->GetBoundsInScreen().CenterPoint());
event_generator->ClickLeftButton();
// Wait for animation to end.
MessagePopupAnimationWaiter(GetPrimaryPopupCollection()).Wait();
EXPECT_FALSE(GetLastPopUpAdded());
}
// Tests that notification popup baseline is correct when entering and exiting
// tablet mode in a full screen window.
TEST_P(AshMessagePopupCollectionTest, BaselineUpdates_InTabletMode) {
UpdateDisplay("800x600");
ASSERT_TRUE(GetPrimaryShelf()->IsHorizontalAlignment());
auto* popup_collection = GetPrimaryPopupCollection();
// Baseline is higher than the top of the shelf in clamshell mode.
EXPECT_GT(GetPrimaryShelf()->GetShelfBoundsInScreen().y(),
popup_collection->GetBaseline());
auto* tablet_mode_controller = Shell::Get()->tablet_mode_controller();
// Baseline is higher than the top of the shelf after entering tablet mode.
tablet_mode_controller->SetEnabledForTest(true);
EXPECT_TRUE(display::Screen::GetScreen()->InTabletMode());
EXPECT_GT(GetPrimaryShelf()->GetShelfBoundsInScreen().y(),
popup_collection->GetBaseline());
// Baseline is higher than the top of the shelf after exiting tablet mode.
tablet_mode_controller->SetEnabledForTest(false);
EXPECT_FALSE(display::Screen::GetScreen()->InTabletMode());
EXPECT_GT(GetPrimaryShelf()->GetShelfBoundsInScreen().y(),
popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest, BaselineUpdates_InAppMode) {
UpdateDisplay("800x600");
ASSERT_TRUE(GetPrimaryShelf()->IsHorizontalAlignment());
auto* popup_collection = GetPrimaryPopupCollection();
// Enable tablet mode without an open window.
auto* tablet_mode_controller = Shell::Get()->tablet_mode_controller();
tablet_mode_controller->SetEnabledForTest(true);
EXPECT_TRUE(display::Screen::GetScreen()->InTabletMode());
auto previous_popup_collection_bottom =
popup_collection->popup_collection_bounds().bottom();
EXPECT_EQ(ShelfBackgroundType::kHomeLauncher,
GetPrimaryShelf()->shelf_layout_manager()->shelf_background_type());
// Enter app mode by showing a window, pop-up collection bottom should update
// its bounds to be lower down the screen than before.
std::unique_ptr<aura::Window> window(
AshTestBase::CreateTestWindow(gfx::Rect(0, 0, 400, 400)));
EXPECT_GT(popup_collection->popup_collection_bounds().bottom(),
previous_popup_collection_bottom);
EXPECT_EQ(ShelfBackgroundType::kInApp,
GetPrimaryShelf()->shelf_layout_manager()->shelf_background_type());
// Exit app mode by hiding the window, popup collection bottom should return
// to its previous value.
window->Hide();
EXPECT_EQ(popup_collection->popup_collection_bounds().bottom(),
previous_popup_collection_bottom);
EXPECT_EQ(ShelfBackgroundType::kHomeLauncher,
GetPrimaryShelf()->shelf_layout_manager()->shelf_background_type());
}
TEST_P(AshMessagePopupCollectionTest, BaselineUpdates_OnSliderShown) {
auto* popup_collection = GetPrimaryPopupCollection();
auto* system_tray = GetPrimaryUnifiedSystemTray();
int previous_baseline = popup_collection->GetBaseline();
// Add a notification.
AddNotification();
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
// Show a volume slider bubble, baseline should be updated if notifier
// collision is enabled.
system_tray->ShowVolumeSliderBubble();
auto* slider_view = system_tray->GetSliderView();
ASSERT_TRUE(slider_view);
if (IsNotifierCollisionEnabled()) {
// The added popup should appear on top of the slider bubble, separated by
// a padding of `kMarginBetweenPopups`.
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
EXPECT_EQ(slider_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if notifier collision is disabled.
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
}
// Baseline returns to previous value when the slider bubble is closed.
system_tray->CloseSecondaryBubbles();
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest,
BaselineUpdates_OnSliderShownWithAutoHideShelf) {
// Create a window, otherwise autohide doesn't work.
Shelf* shelf = GetPrimaryShelf();
std::unique_ptr<views::Widget> widget = CreateTestWidget(
views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
AddNotification();
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
auto* system_tray = GetPrimaryUnifiedSystemTray();
system_tray->ShowVolumeSliderBubble();
auto* slider_view = system_tray->GetSliderView();
ASSERT_TRUE(slider_view);
int shelf_hide_popup_bottom = popup->GetBoundsInScreen().bottom();
if (IsNotifierCollisionEnabled()) {
// On hidden shelf, the added popup should appear on top of the slider
// bubble, separated by a padding of `kMarginBetweenPopups`.
EXPECT_EQ(shelf_hide_popup_bottom + message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
}
// Move mouse to the shelf to make it show.
ui::test::EventGenerator* generator = GetEventGenerator();
gfx::Rect display_bounds =
display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
generator->MoveMouseTo(display_bounds.bottom_center());
ASSERT_TRUE(TriggerShelfAutoHideTimeout());
ASSERT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
// Popup should move up when shelf is shown.
int shelf_show_popup_bottom = popup->GetBoundsInScreen().bottom();
EXPECT_GT(shelf_hide_popup_bottom, shelf_show_popup_bottom);
if (IsNotifierCollisionEnabled()) {
// Should still be on top of slider view.
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
}
// Move the mouse away to hide the shelf. The shelf should hide now and the
// popup is adjusted correctly.
generator->MoveMouseTo(0, 0);
ASSERT_TRUE(TriggerShelfAutoHideTimeout());
ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
// Popup should move down and still on top of slider view.
EXPECT_EQ(shelf_hide_popup_bottom, popup->GetBoundsInScreen().bottom());
if (IsNotifierCollisionEnabled()) {
// Should still be on top of slider view.
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
}
}
// Tests that `TrayBubbleView` elements (e.g. Quick Settings) and popups
// are placed on top of each other based on which was shown most recently.
TEST_P(AshMessagePopupCollectionTest, PopupsAndTrayBubbleViewsZOrdering) {
// Add a notification popup.
AddNotification();
auto* popup = GetLastPopUpAdded();
EXPECT_TRUE(popup);
// Opening Quick Settings makes its bubble show in front of the previously
// shown notification pop-up.
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
auto* bubble_native_view =
unified_system_tray->bubble()->GetBubbleWidget()->GetNativeView();
EXPECT_FALSE(popup->GetWidget()->IsStackedAbove(bubble_native_view));
// Adding another popup moves Quick Settings to the back, bringing all popups
// to the top level, showing them in front of the Quick Settings bubble.
AddNotification();
// Wait until the notification popup shows.
MessagePopupAnimationWaiter(GetPrimaryPopupCollection()).Wait();
EXPECT_TRUE(popup->GetWidget()->IsStackedAbove(bubble_native_view));
}
TEST_P(AshMessagePopupCollectionTest, BaselineUpdates_OnTrayBubbleShown) {
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
// Show a corner anchored shelf pod bubble. Baseline should update if notifier
// collision is enabled.
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
// Attempt showing a notification when Quick Settings is open.
AddNotification();
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
auto* bubble_widget = unified_system_tray->bubble()->GetBubbleWidget();
auto* bubble_view = unified_system_tray->bubble()->GetBubbleView();
if (IsNotifierCollisionEnabled()) {
// The added popup should appear on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
EXPECT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// Change the bubble height.
auto bubble_bounds = bubble_widget->GetWindowBoundsInScreen();
bubble_widget->SetBounds(gfx::Rect(bubble_bounds.x(), bubble_bounds.y() + 20,
bubble_bounds.width(),
bubble_bounds.height() - 20));
if (IsNotifierCollisionEnabled()) {
// The baseline for the popup should be adjusted based on the new bubble
// height.
EXPECT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// When bubble is closed, no offset should be set.
// NOTE: We use `CloseNow()` here instead of calling `CloseBubble()` on
// `unified_system_tray` to avoid the delay in the message loop happen in
// `Widget::Close()`.
bubble_widget->CloseNow();
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
// The popup is adjusted to be at the baseline without the offset.
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest,
BaselineUpdates_OnTrayBubbleShownWithAutoHideShelf) {
// Create a window, otherwise autohide doesn't work.
Shelf* shelf = GetPrimaryShelf();
std::unique_ptr<views::Widget> widget = CreateTestWidget(
views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
shelf->SetAutoHideBehavior(ShelfAutoHideBehavior::kAlways);
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
// Move mouse to the shelf to make it show.
ui::test::EventGenerator* generator = GetEventGenerator();
gfx::Rect display_bounds =
display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
generator->MoveMouseTo(display_bounds.bottom_center());
ASSERT_TRUE(TriggerShelfAutoHideTimeout());
ASSERT_EQ(SHELF_AUTO_HIDE_SHOWN, shelf->GetAutoHideState());
// Test showing a bubble with the shelf showing in auto-hide state.
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
AddNotification();
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
if (IsNotifierCollisionEnabled()) {
// The added popup should appears on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
}
int old_popup_bottom = popup->GetBoundsInScreen().bottom();
// Click on the screen corner to hide the shelf and the bubble. The shelf
// should hide now and the popup is adjusted correctly to the baseline.
generator->MoveMouseTo(0, 0);
generator->ClickLeftButton();
base::RunLoop().RunUntilIdle();
ASSERT_EQ(SHELF_AUTO_HIDE_HIDDEN, shelf->GetAutoHideState());
// The popup is moved down to be at the baseline without the offset.
EXPECT_LT(old_popup_bottom, popup->GetBoundsInScreen().bottom());
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// Tests that the baseline will not be adjusted when a tray bubble that is not
// anchored to the shelf corner opens (i.e. the IME tray bubble).
TEST_P(AshMessagePopupCollectionTest,
BaselineDoesNotUpdate_OnNonAnchoredTrayBubbleShown) {
Shell::Get()->ime_controller()->ShowImeMenuOnShelf(true);
auto* ime_tray =
StatusAreaWidgetTestHelper::GetStatusAreaWidget()->ime_menu_tray();
ASSERT_TRUE(ime_tray->GetVisible());
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
ime_tray->ShowBubble();
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
ime_tray->GetBubbleWidget()->CloseNow();
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
}
TEST_P(AshMessagePopupCollectionTest,
BaselineUpdates_OnTrayBubbleShownWithMultiDisplay) {
UpdateDisplay("801x800,801x800");
display::Display second_display = GetSecondaryDisplay();
Shelf* second_shelf =
Shell::GetRootWindowControllerWithDisplayId(second_display.id())->shelf();
AshMessagePopupCollection secondary_popup_collection(
display::Screen::GetScreen(), second_shelf);
UpdateWorkArea(&secondary_popup_collection, second_display);
auto* primary_popup_collection = GetPrimaryPopupCollection();
int previous_primary_baseline = primary_popup_collection->GetBaseline();
int previous_secondary_baseline = secondary_popup_collection.GetBaseline();
// Add a notification popup.
AddNotification();
auto* primary_popup = GetLastPopUpAdded();
auto* secondary_popup =
GetLastPopUpAddedForCollection(&secondary_popup_collection);
EXPECT_TRUE(primary_popup);
EXPECT_TRUE(secondary_popup);
// Open primary system tray bubble.
auto* primary_system_tray = GetPrimaryUnifiedSystemTray();
LeftClickOn(primary_system_tray);
if (IsNotifierCollisionEnabled()) {
// The primary popup collection should update the baseline and the secondary
// one should reset.
auto* primary_bubble_view = primary_system_tray->bubble()->GetBubbleView();
EXPECT_EQ(
primary_bubble_view->height() + message_center::kMarginBetweenPopups,
previous_primary_baseline - primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
primary_system_tray->GetBubbleBoundsInScreen().y());
EXPECT_EQ(previous_secondary_baseline,
secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom(),
secondary_popup_collection.GetBaseline());
} else {
// The popup on both display should stay the same if the feature is
// disabled.
EXPECT_EQ(previous_primary_baseline,
primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom(),
primary_popup_collection->GetBaseline());
EXPECT_EQ(previous_secondary_baseline,
secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom(),
secondary_popup_collection.GetBaseline());
}
// Open secondary system tray bubble.
auto* secondary_system_tray =
second_shelf->GetStatusAreaWidget()->unified_system_tray();
LeftClickOn(secondary_system_tray);
if (IsNotifierCollisionEnabled()) {
// The secondary popup collection should update the baseline and the primary
// one should reset.
EXPECT_EQ(previous_primary_baseline,
primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom(),
primary_popup_collection->GetBaseline());
auto* secondary_bubble_view =
secondary_system_tray->bubble()->GetBubbleView();
EXPECT_EQ(
secondary_bubble_view->height() + message_center::kMarginBetweenPopups,
previous_secondary_baseline - secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
secondary_system_tray->GetBubbleBoundsInScreen().y());
} else {
// The popup on both display should stay the same if the feature is
// disabled.
EXPECT_EQ(previous_primary_baseline,
primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom(),
primary_popup_collection->GetBaseline());
EXPECT_EQ(previous_secondary_baseline,
secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom(),
secondary_popup_collection.GetBaseline());
}
}
TEST_P(AshMessagePopupCollectionTest, HistogramRecordedForShelfPodBubble) {
using SurfaceType = AshMessagePopupCollection::NotifierCollisionSurfaceType;
base::HistogramTester histogram_tester;
const std::string popup_count_histogram_name =
"Ash.NotificationPopup.OnTopOfSurfacesPopupCount";
const std::string surface_type_histogram_name =
"Ash.NotificationPopup.OnTopOfSurfacesType";
AddNotification();
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
if (IsNotifierCollisionEnabled()) {
// The popup should appear on top of the bubble and histogram is recorded.
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 1, 1);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kShelfPodBubble, 1);
} else {
// The popup stays the same if the feature is disabled.
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 1, 0);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kShelfPodBubble, 0);
}
// Add another notification. Histogram should also be recorded with the
// correct bucket for 2 notifications.
AddNotification();
AnimateUntilIdle();
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 2,
IsNotifierCollisionEnabled() ? 1 : 0);
// Close and re-open the bubble. Histogram should be recorded again.
auto* bubble_widget = unified_system_tray->bubble()->GetBubbleWidget();
bubble_widget->CloseNow();
unified_system_tray->ShowBubble();
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 2,
IsNotifierCollisionEnabled() ? 2 : 0);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kShelfPodBubble,
IsNotifierCollisionEnabled() ? 2 : 0);
}
TEST_P(AshMessagePopupCollectionTest, HistogramRecordedForSliderAndHotseat) {
using SurfaceType = AshMessagePopupCollection::NotifierCollisionSurfaceType;
base::HistogramTester histogram_tester;
const std::string popup_count_histogram_name =
"Ash.NotificationPopup.OnTopOfSurfacesPopupCount";
const std::string surface_type_histogram_name =
"Ash.NotificationPopup.OnTopOfSurfacesType";
AddNotification();
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowVolumeSliderBubble();
if (IsNotifierCollisionEnabled()) {
// The popup should appear on top of the bubble and histogram is recorded.
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 1, 1);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kSliderBubble, 1);
} else {
// The popup stays the same if the feature is disabled.
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 1, 0);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kSliderBubble, 0);
}
TabletModeControllerTestApi().EnterTabletMode();
std::unique_ptr<aura::Window> window =
CreateTestWindow(gfx::Rect(0, 0, 400, 400));
wm::ActivateWindow(window.get());
ASSERT_EQ(HotseatState::kHidden,
GetPrimaryShelf()->shelf_layout_manager()->hotseat_state());
// Dragging up to show the hotseat.
gfx::Rect display_bounds =
display::Screen::GetScreen()->GetPrimaryDisplay().bounds();
const gfx::Point start = display_bounds.bottom_center();
const gfx::Point end = start + gfx::Vector2d(0, -80);
GetEventGenerator()->GestureScrollSequence(
start, end, /*duration=*/base::Milliseconds(100),
/*steps=*/4);
ASSERT_EQ(HotseatState::kExtended,
GetPrimaryShelf()->shelf_layout_manager()->hotseat_state());
// Histogram should be recorded accordingly to the adjusted baseline.
if (IsNotifierCollisionEnabled()) {
histogram_tester.ExpectBucketCount(
surface_type_histogram_name,
SurfaceType::kSliderBubbleAndExtendedHotseat, 1);
} else {
histogram_tester.ExpectBucketCount(
surface_type_histogram_name,
SurfaceType::kSliderBubbleAndExtendedHotseat, 0);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kExtendedHotseat, 1);
}
unified_system_tray->CloseSecondaryBubbles();
if (IsNotifierCollisionEnabled()) {
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kExtendedHotseat, 1);
}
}
TEST_P(AshMessagePopupCollectionTest, HistogramNotRecordedWhenAllPopupsClosed) {
if (!IsNotifierCollisionEnabled()) {
return;
}
using SurfaceType = AshMessagePopupCollection::NotifierCollisionSurfaceType;
base::HistogramTester histogram_tester;
const std::string popup_count_histogram_name =
"Ash.NotificationPopup.OnTopOfSurfacesPopupCount";
const std::string surface_type_histogram_name =
"Ash.NotificationPopup.OnTopOfSurfacesType";
UpdateDisplay("801x800");
AddNotification(/*has_image=*/true);
ASSERT_TRUE(GetLastPopUpAdded());
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
// Histogram is recorded when open the bubble.
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 1, 1);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kShelfPodBubble, 1);
// Increase the bubble height so that there's not enough space to display the
// popups on top of it. Note that this only works with screen height of 800
// (set above), and the test might fail if we change the height of bubble
// width or notification width in the future.
auto* bubble_widget = unified_system_tray->bubble()->GetBubbleWidget();
auto bubble_bounds = bubble_widget->GetWindowBoundsInScreen();
bubble_widget->SetBounds(gfx::Rect(bubble_bounds.x(), bubble_bounds.y() - 100,
bubble_bounds.width(),
bubble_bounds.height() + 100));
ASSERT_FALSE(GetLastPopUpAdded());
// Histogram should not be recorded in this case.
histogram_tester.ExpectBucketCount(popup_count_histogram_name, 1, 1);
histogram_tester.ExpectBucketCount(surface_type_histogram_name,
SurfaceType::kShelfPodBubble, 1);
}
TEST_P(AshMessagePopupCollectionTest, NotificationAddedOnTrayBubbleOpen) {
UpdateDisplay("801x600");
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
// Show a tray bubble.
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
auto* bubble_view = unified_system_tray->bubble()->GetBubbleView();
// Add a notification with a tray bubble open.
AddNotification();
auto* popup1 = GetLastPopUpAdded();
if (IsNotifierCollisionEnabled()) {
// The added popup should appears on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
ASSERT_EQ(popup1->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
ASSERT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup1->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// Add more popup so that there's not enough space to display the popup above
// the tray bubble. Note that this only works with screen height of 600 (set
// above), and the test might fail if we change the height of bubble width or
// notification width in the future.
auto id2 = AddNotification();
auto id3 = AddNotification();
AnimateUntilIdle();
// The baseline should still be the same when there's notification added.
if (IsNotifierCollisionEnabled()) {
// The added popup should appears on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
EXPECT_EQ(popup1->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
EXPECT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup1->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// Popup 2 should be right above the first one.
auto* popup2 = popup_collection->GetPopupViewForNotificationID(id2);
ASSERT_TRUE(popup2);
EXPECT_EQ(popup2->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
popup1->GetBoundsInScreen().y());
if (IsNotifierCollisionEnabled()) {
// Popup for the third notification should not be displayed since there's
// not enough space.
EXPECT_FALSE(popup_collection->GetPopupViewForNotificationID(id3));
} else {
// The popup is still displayed if the feature is disabled.
EXPECT_TRUE(popup_collection->GetPopupViewForNotificationID(id3));
}
}
TEST_P(AshMessagePopupCollectionTest, NotificationUpdatedOnTrayBubbleOpen) {
UpdateDisplay("801x600");
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
auto* bubble_view = unified_system_tray->bubble()->GetBubbleView();
AddNotification();
auto* popup1 = GetLastPopUpAdded();
if (IsNotifierCollisionEnabled()) {
// The added popup should appears on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
ASSERT_EQ(popup1->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
ASSERT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup1->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// Add a second popup, it should be on top of the first one and baseline
// offset should stay the same.
auto id2 = AddNotification();
AnimateUntilIdle();
auto* popup2 = popup_collection->GetPopupViewForNotificationID(id2);
EXPECT_EQ(popup2->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
popup1->GetBoundsInScreen().y());
// Update the notification to have an image now, which increases the height of
// the notification and make it not fit above the tray bubble anymore. In this
// case, all the notifications should move down to make room for the change.
// Note that this only works with screen height of 600 (set above), and the
// test might fail if we change the height of bubble width or notification
// width in the future.
message_center::MessageCenter::Get()->UpdateNotification(
id2, CreateSimpleNotification(id2, /*has_image=*/true));
popup2 = popup_collection->GetPopupViewForNotificationID(id2);
AnimateUntilIdle();
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup1->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
EXPECT_EQ(popup2->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
popup1->GetBoundsInScreen().y());
}
// Tests that a corner anchored shelf pod bubble closes when the popup
// collection height expands and it needs more space for it to be displayed.
TEST_P(AshMessagePopupCollectionTest,
BubbleCloses_OnPopupExpandedUsedAvailableSpace) {
UpdateDisplay("801x800");
AddNotification(/*has_image=*/true);
auto* popup1 = GetLastPopUpAdded();
auto id2 = AddNotification();
AnimateUntilIdle();
auto* popup_collection = GetPrimaryPopupCollection();
auto* popup2 = popup_collection->GetPopupViewForNotificationID(id2);
int previous_baseline = popup_collection->GetBaseline();
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
if (IsNotifierCollisionEnabled()) {
// The added popup should appears on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
ASSERT_EQ(popup1->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup1->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
return;
}
EXPECT_EQ(popup2->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
popup1->GetBoundsInScreen().y());
LeftClickOn(static_cast<AshNotificationView*>(popup1->message_view())
->expand_button_for_test());
// Since the space left on the screen above the bubble is not enough to
// display the popup collection when the popup is expanded, the bubble will be
// closed to make room for it and we move down the baseline. Note that this
// only works with screen height of 800 (set above), and the test might fail
// if we change the height of the bubble or notification in the future.
EXPECT_FALSE(unified_system_tray->bubble());
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
}
// Tests that popups will be closed when a tray bubble visibility or bounds
// change and there is not enough space for the popups to be displayed.
TEST_P(AshMessagePopupCollectionTest,
PopupsClose_OnBubbleHeightChangedUsedAvailableSpace) {
UpdateDisplay("801x800");
AddNotification(/*has_image=*/true);
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
auto* bubble_widget = unified_system_tray->bubble()->GetBubbleWidget();
auto* bubble_view = unified_system_tray->bubble()->GetBubbleView();
if (IsNotifierCollisionEnabled()) {
// The added popup should appears on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups`.
ASSERT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
unified_system_tray->GetBubbleBoundsInScreen().y());
ASSERT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// The popup collection height before the bubble height is increased.
int previous_popup_collection_height =
popup_collection->popup_collection_bounds().height();
// Increase the bubble height so that there's not enough space to display the
// popups on top of it. Note that this only works with screen height of 800
// (set above), and the test might fail if we change the height of bubble
// width or notification width in the future.
auto bubble_bounds = bubble_widget->GetWindowBoundsInScreen();
bubble_widget->SetBounds(gfx::Rect(bubble_bounds.x(), bubble_bounds.y() - 100,
bubble_bounds.width(),
bubble_bounds.height() + 100));
if (IsNotifierCollisionEnabled()) {
// Since there was not enough space to display the popup, all popups should
// be closed and will go to the notification center tray.
EXPECT_GT(previous_popup_collection_height,
popup_collection->GetBaseline());
EXPECT_FALSE(GetLastPopUpAdded());
} else {
EXPECT_TRUE(GetLastPopUpAdded());
}
}
// Tests that when a shelf pod bubble other than the main status area bubbles
// (e.g. phone hub) is shown and a slider appears, the popup will be on top of
// the shelf pod bubble, not the slider.
TEST_P(AshMessagePopupCollectionTest,
BaselineUpdates_OnTrayBubbleAndSliderShown) {
UpdateDisplay("1001x900");
auto* popup_collection = GetPrimaryPopupCollection();
int previous_baseline = popup_collection->GetBaseline();
phone_hub_manager()->fake_feature_status_provider()->SetStatus(
phonehub::FeatureStatus::kEnabledAndConnected);
auto* phone_hub_tray =
GetPrimaryShelf()->status_area_widget()->phone_hub_tray();
phone_hub_tray->SetPhoneHubManager(phone_hub_manager());
ASSERT_TRUE(phone_hub_tray->GetVisible());
phone_hub_tray->ShowBubble();
auto* system_tray = GetPrimaryUnifiedSystemTray();
system_tray->ShowVolumeSliderBubble();
auto* slider_view = system_tray->GetSliderView();
ASSERT_TRUE(slider_view);
AddNotification(/*has_image=*/true);
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
auto* bubble_view = phone_hub_tray->GetBubbleView();
auto* bubble_widget = phone_hub_tray->GetBubbleWidget();
if (IsNotifierCollisionEnabled()) {
// The added popup should appear on top of the tray bubble, separated by a
// padding of `kMarginBetweenPopups` (not on top of the slider).
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
bubble_view->GetBoundsInScreen().y());
ASSERT_EQ(bubble_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if the feature is disabled.
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
}
// Close the phone hub bubble. Popup should sit above slider.
bubble_widget->CloseNow();
if (IsNotifierCollisionEnabled()) {
EXPECT_EQ(popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
EXPECT_EQ(slider_view->height() + message_center::kMarginBetweenPopups,
previous_baseline - popup_collection->GetBaseline());
} else {
// The popup stays the same if notifier collision is disabled.
EXPECT_EQ(popup->GetBoundsInScreen().bottom(),
popup_collection->GetBaseline());
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
}
// Close the slider. Popup should go back to original baseline.
system_tray->CloseSecondaryBubbles();
EXPECT_EQ(previous_baseline, popup_collection->GetBaseline());
}
// b/293660273
TEST_P(AshMessagePopupCollectionTest,
BaselineUpdates_OnSliderShownWithMultiDisplay) {
UpdateDisplay("0+0-801x800,0+800-801x800");
display::Display second_display = GetSecondaryDisplay();
AshMessagePopupCollection secondary_popup_collection(
display::Screen::GetScreen(),
Shell::GetRootWindowControllerWithDisplayId(second_display.id())
->shelf());
UpdateWorkArea(&secondary_popup_collection, second_display);
auto* primary_popup_collection = GetPrimaryPopupCollection();
int previous_primary_baseline = primary_popup_collection->GetBaseline();
int previous_secondary_baseline = secondary_popup_collection.GetBaseline();
// Add a notification popup.
AddNotification();
auto* primary_popup = GetLastPopUpAdded();
auto* secondary_popup =
GetLastPopUpAddedForCollection(&secondary_popup_collection);
EXPECT_TRUE(primary_popup);
EXPECT_TRUE(secondary_popup);
// Show a slider on the primary display only.
auto* primary_system_tray = GetPrimaryUnifiedSystemTray();
primary_system_tray->ShowVolumeSliderBubble();
auto* slider_view = primary_system_tray->GetSliderView();
ASSERT_TRUE(slider_view);
if (IsNotifierCollisionEnabled()) {
// Popup on primary display should move up, and popup on secondary display
// stay the same.
EXPECT_EQ(
slider_view->height() + message_center::kMarginBetweenPopups,
previous_primary_baseline - primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
EXPECT_EQ(previous_secondary_baseline,
secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom(),
secondary_popup_collection.GetBaseline());
} else {
// The popup on both display should stay the same if the feature is
// disabled.
EXPECT_EQ(previous_primary_baseline,
primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom(),
primary_popup_collection->GetBaseline());
EXPECT_EQ(previous_secondary_baseline,
secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom(),
secondary_popup_collection.GetBaseline());
}
// Show a slider on the secondary display.
auto* secondary_system_tray =
StatusAreaWidgetTestHelper::GetSecondaryStatusAreaWidget()
->unified_system_tray();
secondary_system_tray->ShowVolumeSliderBubble();
auto* secondary_slider_view = secondary_system_tray->GetSliderView();
ASSERT_TRUE(secondary_slider_view);
if (IsNotifierCollisionEnabled()) {
// Popup on both displays should move up since there are sliders on both
// displays.
EXPECT_EQ(
slider_view->height() + message_center::kMarginBetweenPopups,
previous_primary_baseline - primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
slider_view->GetBoundsInScreen().y());
EXPECT_EQ(
secondary_slider_view->height() + message_center::kMarginBetweenPopups,
previous_secondary_baseline - secondary_popup_collection.GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom() +
message_center::kMarginBetweenPopups,
secondary_slider_view->GetBoundsInScreen().y());
} else {
// The popup on both display should stay the same if the feature is
// disabled.
EXPECT_EQ(previous_primary_baseline,
primary_popup_collection->GetBaseline());
EXPECT_EQ(primary_popup->GetBoundsInScreen().bottom(),
primary_popup_collection->GetBaseline());
EXPECT_EQ(previous_secondary_baseline,
secondary_popup_collection.GetBaseline());
EXPECT_EQ(secondary_popup->GetBoundsInScreen().bottom(),
secondary_popup_collection.GetBaseline());
}
}
// b/291988617
TEST_P(AshMessagePopupCollectionTest, QsBubbleNotCloseWhenPopupClose) {
// Skip since b/291988617 only happens when both features are enabled.
if (!IsNotifierCollisionEnabled()) {
return;
}
// Create a window to simulate the step from b/291988617.
std::unique_ptr<views::Widget> widget = CreateTestWidget(
views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET, nullptr,
desks_util::GetActiveDeskContainerId(), gfx::Rect(0, 0, 50, 50));
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
auto id = AddNotification();
auto* popup_collection = GetPrimaryPopupCollection();
auto* popup = popup_collection->GetPopupViewForNotificationID(id);
ASSERT_TRUE(unified_system_tray->bubble());
ASSERT_TRUE(popup);
AnimateUntilIdle();
// Click the notification close button, the popup should disappear. However,
// the bubble show still remain open.
LeftClickOn(static_cast<AshNotificationView*>(popup->message_view())
->control_buttons_view_for_test()
->close_button());
AnimateUntilIdle();
EXPECT_FALSE(popup_collection->GetPopupViewForNotificationID(id));
EXPECT_TRUE(unified_system_tray->bubble());
}
// Same as the above test. But now test with a bubble created by
// `TrayBubbleWrapper` instead of the QS bubble. We will use Phone Hub bubble in
// this case.
TEST_P(AshMessagePopupCollectionTest, BubbleNotCloseWhenPopupClose) {
// Skip since b/291988617 only happens when both features are enabled.
if (!IsNotifierCollisionEnabled()) {
return;
}
// Update display so that notification fit on top of phone hub bubble.
UpdateDisplay("1001x900");
phone_hub_manager()->fake_feature_status_provider()->SetStatus(
phonehub::FeatureStatus::kEnabledAndConnected);
auto* phone_hub_tray =
GetPrimaryShelf()->status_area_widget()->phone_hub_tray();
phone_hub_tray->SetPhoneHubManager(phone_hub_manager());
ASSERT_TRUE(phone_hub_tray->GetVisible());
phone_hub_tray->ShowBubble();
auto id = AddNotification();
auto* popup_collection = GetPrimaryPopupCollection();
auto* popup = popup_collection->GetPopupViewForNotificationID(id);
ASSERT_TRUE(phone_hub_tray->GetBubbleView());
ASSERT_TRUE(popup);
AnimateUntilIdle();
// Click the notification close button, the popup should disappear. However,
// the bubble show still remain open.
LeftClickOn(static_cast<AshNotificationView*>(popup->message_view())
->control_buttons_view_for_test()
->close_button());
AnimateUntilIdle();
EXPECT_FALSE(popup_collection->GetPopupViewForNotificationID(id));
EXPECT_TRUE(phone_hub_tray->GetBubbleView());
}
// For b/346641561
TEST_P(AshMessagePopupCollectionTest, InlineReplyTextfield) {
if (!IsNotifierCollisionEnabled()) {
GTEST_SKIP() << "Popup notifications does not show when notifier collision "
"is enabled";
}
auto* unified_system_tray = GetPrimaryUnifiedSystemTray();
unified_system_tray->ShowBubble();
// Attempt showing a notification when Quick Settings is open.
AddNotification(/*has_image=*/false,
/*origin_url=*/GURL(),
/*has_inline_reply=*/true);
auto* popup = GetLastPopUpAdded();
ASSERT_TRUE(popup);
AnimateUntilIdle();
auto* message_view =
static_cast<AshNotificationView*>(GetLastPopUpAdded()->message_view());
ASSERT_TRUE(message_view);
LeftClickOn(message_view->GetActionButtonsForTest().front());
auto* textfield = message_view->GetInlineReplyForTest()->textfield();
EXPECT_TRUE(textfield->GetVisible());
EXPECT_TRUE(textfield->HasFocus());
PressAndReleaseKey(ui::VKEY_A, ui::EF_NONE);
PressAndReleaseKey(ui::VKEY_A, ui::EF_NONE);
// Make sure that inline reply textfield can receive keyboard events.
EXPECT_EQ(u"aa", textfield->GetText());
}
class AshMessagePopupCollectionMockTimeTest : public ash::AshTestBase {
public:
AshMessagePopupCollectionMockTimeTest()
: AshTestBase(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {}
AshMessagePopupCollectionMockTimeTest(
const AshMessagePopupCollectionMockTimeTest&) = delete;
AshMessagePopupCollectionMockTimeTest& operator=(
const AshMessagePopupCollectionMockTimeTest&) = delete;
~AshMessagePopupCollectionMockTimeTest() override = default;
};
TEST_F(AshMessagePopupCollectionMockTimeTest, PopupTimeouts) {
base::test::ScopedFeatureList feature_list;
feature_list.InitAndEnableFeature(
::features::kNotificationsIgnoreRequireInteraction);
auto* popup_collection =
GetPrimaryNotificationCenterTray()->popup_collection();
auto* message_center = message_center::MessageCenter::Get();
std::string id = "0";
auto notification_priorities = {
message_center::DEFAULT_PRIORITY, message_center::HIGH_PRIORITY,
message_center::MAX_PRIORITY, message_center::SYSTEM_PRIORITY};
// Make sure all notification popups below `SYSTEM_PRIORITY` are dismissed
// after `kAutocloseShortDelaySeconds` seconds. Also, make sure
// `SYSTEM_PRIORITY` notifications are dismissed after
// `kAutocloseCrosHighPriorityDelaySeconds`.
for (auto priority : notification_priorities) {
auto notification = CreateSimpleNotification(id);
notification->set_priority(priority);
if (priority == message_center::SYSTEM_PRIORITY) {
notification->SetSystemPriority();
}
message_center->AddNotification(std::move(notification));
EXPECT_TRUE(popup_collection->GetPopupViewForNotificationID(id));
int timeout = priority == message_center::SYSTEM_PRIORITY
? message_center::kAutocloseCrosHighPriorityDelaySeconds
: message_center::kAutocloseShortDelaySeconds;
task_environment()->FastForwardBy(base::Seconds(timeout - 1));
base::RunLoop().RunUntilIdle();
EXPECT_TRUE(popup_collection->GetPopupViewForNotificationID(id));
task_environment()->FastForwardBy(base::Seconds(timeout));
base::RunLoop().RunUntilIdle();
EXPECT_FALSE(popup_collection->GetPopupViewForNotificationID(id));
message_center->RemoveNotification(id,
/*by_user=*/false);
}
}
} // namespace ash
Codebase Browser
chromium