// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/notifications/mac/notification_dispatcher_mojo.h"
#include <memory>
#include <optional>
#include "base/functional/bind.h"
#include "base/functional/callback.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/raw_ptr.h"
#include "base/path_service.h"
#include "base/process/process_handle.h"
#include "base/test/gmock_callback_support.h"
#include "base/test/metrics/histogram_tester.h"
#include "base/test/mock_callback.h"
#include "base/time/time.h"
#include "chrome/browser/notifications/mac/mac_notification_provider_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/notifications/notification_operation.h"
#include "chrome/services/mac_notifications/public/mojom/mac_notifications.mojom.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chrome/test/base/testing_profile_manager.h"
#include "content/public/test/browser_task_environment.h"
#include "mojo/public/cpp/bindings/pending_receiver.h"
#include "mojo/public/cpp/bindings/pending_remote.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "mojo/public/cpp/bindings/remote.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace {
const char kNotificationId[] = "notification-id";
const char kProfileId[] = "profile-id";
class MockNotificationService
: public mac_notifications::mojom::MacNotificationService {
public:
MOCK_METHOD(void,
DisplayNotification,
(mac_notifications::mojom::NotificationPtr),
(override));
MOCK_METHOD(void,
GetDisplayedNotifications,
(mac_notifications::mojom::ProfileIdentifierPtr,
const std::optional<GURL>& origin,
GetDisplayedNotificationsCallback),
(override));
MOCK_METHOD(void,
CloseNotification,
(mac_notifications::mojom::NotificationIdentifierPtr),
(override));
MOCK_METHOD(void,
CloseNotificationsForProfile,
(mac_notifications::mojom::ProfileIdentifierPtr),
(override));
MOCK_METHOD(void, CloseAllNotifications, (), (override));
MOCK_METHOD(void,
OkayToTerminateService,
(OkayToTerminateServiceCallback),
(override));
};
class MockNotificationProvider
: public mac_notifications::mojom::MacNotificationProvider {
public:
MOCK_METHOD(
void,
BindNotificationService,
(mojo::PendingReceiver<mac_notifications::mojom::MacNotificationService>,
mojo::PendingRemote<
mac_notifications::mojom::MacNotificationActionHandler>),
(override));
};
class FakeMacNotificationProviderFactory
: public MacNotificationProviderFactory,
public mac_notifications::mojom::MacNotificationProvider {
public:
explicit FakeMacNotificationProviderFactory(
base::RepeatingClosure on_disconnect)
: MacNotificationProviderFactory(
mac_notifications::NotificationStyle::kAlert),
on_disconnect_(std::move(on_disconnect)) {}
~FakeMacNotificationProviderFactory() override = default;
// MacNotificationProviderFactory:
mojo::Remote<mac_notifications::mojom::MacNotificationProvider>
LaunchProvider() override {
mojo::Remote<mac_notifications::mojom::MacNotificationProvider> remote;
provider_receiver_.Bind(remote.BindNewPipeAndPassReceiver());
provider_receiver_.set_disconnect_handler(
base::BindOnce(&FakeMacNotificationProviderFactory::Disconnect,
base::Unretained(this)));
return remote;
}
// mac_notifications::mojom::MacNotificationProvider:
void BindNotificationService(
mojo::PendingReceiver<mac_notifications::mojom::MacNotificationService>
service,
mojo::PendingRemote<
mac_notifications::mojom::MacNotificationActionHandler> handler)
override {
service_receiver_.Bind(std::move(service));
handler_remote_.Bind(std::move(handler));
}
MockNotificationService& service() { return mock_service_; }
mac_notifications::mojom::MacNotificationActionHandler* handler() {
return handler_remote_.get();
}
void Disconnect() {
handler_remote_.reset();
service_receiver_.reset();
provider_receiver_.reset();
on_disconnect_.Run();
}
bool is_service_connected() { return service_receiver_.is_bound(); }
private:
base::RepeatingClosure on_disconnect_;
mojo::Receiver<mac_notifications::mojom::MacNotificationProvider>
provider_receiver_{this};
MockNotificationService mock_service_;
mojo::Receiver<mac_notifications::mojom::MacNotificationService>
service_receiver_{&mock_service_};
mojo::Remote<mac_notifications::mojom::MacNotificationActionHandler>
handler_remote_;
};
message_center::Notification CreateNotification() {
return message_center::Notification(
message_center::NOTIFICATION_TYPE_SIMPLE, kNotificationId, u"title",
u"message", /*icon=*/ui::ImageModel(),
/*display_source=*/std::u16string(), /*origin_url=*/GURL(),
message_center::NotifierId(), message_center::RichNotificationData(),
base::MakeRefCounted<message_center::NotificationDelegate>());
}
mac_notifications::mojom::NotificationMetadataPtr CreateNotificationMetadata() {
auto profile_identifier = mac_notifications::mojom::ProfileIdentifier::New(
kProfileId, /*incognito=*/true);
auto notification_identifier =
mac_notifications::mojom::NotificationIdentifier::New(
kNotificationId, std::move(profile_identifier));
base::FilePath user_data_dir;
EXPECT_TRUE(base::PathService::Get(chrome::DIR_USER_DATA, &user_data_dir));
return mac_notifications::mojom::NotificationMetadata::New(
std::move(notification_identifier), /*notification_type=*/0,
/*origin_url=*/GURL("https://example.com"), user_data_dir.value());
}
mac_notifications::mojom::NotificationActionInfoPtr
CreateNotificationActionInfo() {
auto meta = CreateNotificationMetadata();
return mac_notifications::mojom::NotificationActionInfo::New(
std::move(meta), NotificationOperation::kClick,
/*button_index=*/-1, /*reply=*/std::nullopt);
}
} // namespace
class NotificationDispatcherMojoTest : public testing::Test {
public:
NotificationDispatcherMojoTest() = default;
~NotificationDispatcherMojoTest() override {
base::RunLoop run_loop;
ExpectDisconnect(run_loop.QuitClosure());
provider_factory_->Disconnect();
run_loop.Run();
}
// testing::Test:
void SetUp() override {
ASSERT_TRUE(testing_profile_manager_.SetUp());
profile_ = testing_profile_manager_.CreateTestingProfile("profile");
auto provider_factory =
std::make_unique<FakeMacNotificationProviderFactory>(
on_disconnect_.Get());
provider_factory_ = provider_factory.get();
// NotificationDispatcherMojo will query if it can terminate the service
// at startup. Once that finishes it should disconnect due to inactivity.
base::RunLoop run_loop;
EmulateOkayToTerminate(/*can_terminate=*/true);
ExpectDisconnect(run_loop.QuitClosure());
notification_dispatcher_ = std::make_unique<NotificationDispatcherMojo>(
std::move(provider_factory));
run_loop.Run();
}
MockNotificationService& service() { return provider_factory_->service(); }
mac_notifications::mojom::MacNotificationActionHandler* handler() {
return provider_factory_->handler();
}
protected:
void ExpectDisconnect(base::OnceClosure callback) {
EXPECT_CALL(on_disconnect_, Run())
.WillOnce(base::test::RunOnceClosure(std::move(callback)))
.WillRepeatedly(testing::DoDefault());
}
void ExpectKeepConnected() {
EXPECT_CALL(on_disconnect_, Run()).Times(0);
// Run remaining tasks to see if we get disconnected.
task_environment_.RunUntilIdle();
}
void EmulateOkayToTerminate(bool can_terminate,
base::OnceClosure callback = base::DoNothing()) {
EXPECT_CALL(service(), OkayToTerminateService)
.WillRepeatedly(testing::DoAll(
base::test::RunOnceClosure(std::move(callback)),
[can_terminate](
MockNotificationService::OkayToTerminateServiceCallback
callback) { std::move(callback).Run(can_terminate); }));
}
void DisplayNotificationSync() {
base::RunLoop run_loop;
EXPECT_CALL(service(), DisplayNotification)
.WillOnce(base::test::RunOnceClosure(run_loop.QuitClosure()));
notification_dispatcher_->DisplayNotification(
NotificationHandler::Type::WEB_PERSISTENT, profile_,
CreateNotification());
run_loop.Run();
}
content::BrowserTaskEnvironment task_environment_{
base::test::TaskEnvironment::TimeSource::MOCK_TIME};
TestingProfileManager testing_profile_manager_{
TestingBrowserProcess::GetGlobal()};
raw_ptr<Profile> profile_;
base::MockRepeatingClosure on_disconnect_;
std::unique_ptr<NotificationDispatcherMojo> notification_dispatcher_;
raw_ptr<FakeMacNotificationProviderFactory> provider_factory_ = nullptr;
};
TEST_F(NotificationDispatcherMojoTest, CloseNotificationAndDisconnect) {
DisplayNotificationSync();
base::RunLoop run_loop;
// Expect that we disconnect after closing the last notification.
ExpectDisconnect(run_loop.QuitClosure());
EXPECT_CALL(service(), CloseNotification)
.WillOnce(
[](mac_notifications::mojom::NotificationIdentifierPtr identifier) {
EXPECT_EQ(kNotificationId, identifier->id);
EXPECT_EQ(kProfileId, identifier->profile->id);
EXPECT_TRUE(identifier->profile->incognito);
});
EmulateOkayToTerminate(/*can_terminate=*/true);
notification_dispatcher_->CloseNotificationWithId(
{kNotificationId, kProfileId, /*incognito=*/true});
run_loop.Run();
}
TEST_F(NotificationDispatcherMojoTest, CloseNotificationAndKeepConnected) {
DisplayNotificationSync();
base::RunLoop run_loop;
// Expect that we continue running if there are remaining notifications.
EXPECT_CALL(service(), CloseNotification);
EmulateOkayToTerminate(/*can_terminate=*/false, run_loop.QuitClosure());
notification_dispatcher_->CloseNotificationWithId(
{kNotificationId, kProfileId, /*incognito=*/true});
run_loop.Run();
ExpectKeepConnected();
}
TEST_F(NotificationDispatcherMojoTest,
CloseThenDispatchNotificationAndKeepConnected) {
base::RunLoop run_loop;
DisplayNotificationSync();
// Expect that we continue running when showing a new notification just after
// closing the last one.
EXPECT_CALL(service(), CloseNotification);
EmulateOkayToTerminate(/*can_terminate=*/true);
notification_dispatcher_->CloseNotificationWithId(
{kNotificationId, kProfileId, /*incognito=*/true});
EXPECT_CALL(service(), DisplayNotification)
.WillOnce(base::test::RunOnceClosure(run_loop.QuitClosure()));
notification_dispatcher_->DisplayNotification(
NotificationHandler::Type::WEB_PERSISTENT, profile_,
CreateNotification());
run_loop.Run();
ExpectKeepConnected();
base::RunLoop run_loop2;
// Expect that we disconnect after closing all notifications.
ExpectDisconnect(run_loop2.QuitClosure());
EXPECT_CALL(service(), CloseAllNotifications);
notification_dispatcher_->CloseAllNotifications();
run_loop2.Run();
}
TEST_F(NotificationDispatcherMojoTest, CloseProfileNotificationsAndDisconnect) {
DisplayNotificationSync();
base::RunLoop run_loop;
// Expect that we disconnect after closing the last notification.
ExpectDisconnect(run_loop.QuitClosure());
EXPECT_CALL(service(), CloseNotificationsForProfile)
.WillOnce([](mac_notifications::mojom::ProfileIdentifierPtr profile) {
EXPECT_EQ(kProfileId, profile->id);
EXPECT_TRUE(profile->incognito);
});
EmulateOkayToTerminate(/*can_terminate=*/true);
notification_dispatcher_->CloseNotificationsWithProfileId(kProfileId,
/*incognito=*/true);
run_loop.Run();
}
TEST_F(NotificationDispatcherMojoTest, CloseAndDisconnectTiming) {
base::HistogramTester histograms;
// Show a new notification.
EXPECT_CALL(service(), DisplayNotification);
notification_dispatcher_->DisplayNotification(
NotificationHandler::Type::WEB_PERSISTENT, profile_,
CreateNotification());
// Wait for 30 seconds and close the notification.
auto delay = base::Seconds(30);
task_environment_.FastForwardBy(delay);
// Expect that we disconnect after closing the last notification.
base::RunLoop run_loop;
ExpectDisconnect(run_loop.QuitClosure());
EmulateOkayToTerminate(/*can_terminate=*/true);
EXPECT_CALL(service(), CloseNotification);
notification_dispatcher_->CloseNotificationWithId(
{kNotificationId, kProfileId, /*incognito=*/true});
// Verify that we log the runtime length and no unexpected kill.
run_loop.Run();
histograms.ExpectUniqueTimeSample("Notifications.macOS.ServiceProcessRuntime",
delay, /*expected_count=*/1);
histograms.ExpectTotalCount("Notifications.macOS.ServiceProcessKilled",
/*count=*/0);
}
TEST_F(NotificationDispatcherMojoTest, KillServiceTiming) {
base::HistogramTester histograms;
// Show a new notification.
EXPECT_CALL(service(), DisplayNotification);
notification_dispatcher_->DisplayNotification(
NotificationHandler::Type::WEB_PERSISTENT, profile_,
CreateNotification());
// Wait for 30 seconds and terminate the service.
auto delay = base::Seconds(30);
task_environment_.FastForwardBy(delay);
// Simulate a dying service process.
provider_factory_->Disconnect();
// Run remaining tasks as we can't observe the disconnect callback.
task_environment_.RunUntilIdle();
// Verify that we log the runtime length and an unexpected kill.
histograms.ExpectUniqueTimeSample("Notifications.macOS.ServiceProcessRuntime",
delay, /*expected_count=*/1);
histograms.ExpectUniqueTimeSample("Notifications.macOS.ServiceProcessKilled",
delay, /*expected_count=*/1);
}
TEST_F(NotificationDispatcherMojoTest, DidActivateNotification) {
base::HistogramTester histograms;
// Show a new notification.
EmulateOkayToTerminate(/*can_terminate=*/true);
EXPECT_CALL(service(), DisplayNotification);
notification_dispatcher_->DisplayNotification(
NotificationHandler::Type::WEB_PERSISTENT, profile_,
CreateNotification());
// Wait until the action handler has been bound.
task_environment_.RunUntilIdle();
handler()->OnNotificationAction(CreateNotificationActionInfo());
// Handling responses is async, make sure we wait for all tasks to complete.
task_environment_.RunUntilIdle();
}
TEST_F(NotificationDispatcherMojoTest, TestUnexpectedDisconnectReconnects) {
// Display a notification and verify that the service is running.
DisplayNotificationSync();
EXPECT_TRUE(provider_factory_->is_service_connected());
// Disconnect after 30 seconds while there is still a notification on screen.
task_environment_.FastForwardBy(base::Seconds(30));
provider_factory_->Disconnect();
EXPECT_FALSE(provider_factory_->is_service_connected());
// Expect the service to be restarted after a short timeout.
EmulateOkayToTerminate(/*can_terminate=*/false);
task_environment_.FastForwardBy(base::Milliseconds(500));
EXPECT_TRUE(provider_factory_->is_service_connected());
}
TEST_F(NotificationDispatcherMojoTest, TestReconnectBackoff) {
// Display a notification and verify that the service is running.
DisplayNotificationSync();
// Disconnect after 30 seconds while there is still a notification on screen.
task_environment_.FastForwardBy(base::Seconds(30));
provider_factory_->Disconnect();
// Verify the service hasn't restarted if not enough time has passed.
task_environment_.FastForwardBy(base::Milliseconds(499));
EXPECT_FALSE(provider_factory_->is_service_connected());
// Expect the service to be restarted after a short timeout.
EmulateOkayToTerminate(/*can_terminate=*/false);
task_environment_.FastForwardBy(base::Milliseconds(1));
EXPECT_TRUE(provider_factory_->is_service_connected());
// Disconnect again immediately which should double the restart timeout.
provider_factory_->Disconnect();
// Verify the service hasn't restarted if not enough time has passed.
task_environment_.FastForwardBy(base::Milliseconds(999));
EXPECT_FALSE(provider_factory_->is_service_connected());
// Expect the service to be restarted after a short timeout.
EmulateOkayToTerminate(/*can_terminate=*/false);
task_environment_.FastForwardBy(base::Milliseconds(1));
EXPECT_TRUE(provider_factory_->is_service_connected());
}
Codebase Browser
chromium