// Copyright 2020 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/notification_platform_bridge_lacros.h"
#include <algorithm>
#include <optional>
#include <utility>
#include "base/check.h"
#include "base/memory/raw_ptr.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "chrome/browser/notifications/notification_platform_bridge_delegate.h"
#include "chrome/browser/themes/theme_service.h"
#include "chrome/browser/themes/theme_service_factory.h"
#include "chromeos/crosapi/mojom/message_center.mojom.h"
#include "chromeos/crosapi/mojom/notification.mojom-shared.h"
#include "chromeos/crosapi/mojom/notification.mojom.h"
#include "mojo/public/cpp/bindings/receiver.h"
#include "ui/color/color_provider.h"
#include "ui/color/color_provider_manager.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/message_center/public/cpp/notification_types.h"
#include "ui/native_theme/native_theme.h"
namespace {
crosapi::mojom::NotificationType ToMojo(message_center::NotificationType type) {
switch (type) {
case message_center::NOTIFICATION_TYPE_SIMPLE:
case message_center::DEPRECATED_NOTIFICATION_TYPE_BASE_FORMAT:
return crosapi::mojom::NotificationType::kSimple;
case message_center::NOTIFICATION_TYPE_IMAGE:
return crosapi::mojom::NotificationType::kImage;
case message_center::NOTIFICATION_TYPE_MULTIPLE:
return crosapi::mojom::NotificationType::kList;
case message_center::NOTIFICATION_TYPE_PROGRESS:
return crosapi::mojom::NotificationType::kProgress;
case message_center::NOTIFICATION_TYPE_CUSTOM:
// TYPE_CUSTOM exists only within ash.
NOTREACHED_IN_MIGRATION();
return crosapi::mojom::NotificationType::kSimple;
case message_center::NOTIFICATION_TYPE_CONVERSATION:
// TYPE_CONVERSATION is not currently supported for Lacros.
NOTREACHED_IN_MIGRATION();
return crosapi::mojom::NotificationType::kSimple;
}
}
crosapi::mojom::NotifierType ToMojo(message_center::NotifierType type) {
switch (type) {
case message_center::NotifierType::APPLICATION:
return crosapi::mojom::NotifierType::kApplication;
case message_center::NotifierType::ARC_APPLICATION:
return crosapi::mojom::NotifierType::kArcApplication;
case message_center::NotifierType::WEB_PAGE:
return crosapi::mojom::NotifierType::kWebPage;
case message_center::NotifierType::SYSTEM_COMPONENT:
return crosapi::mojom::NotifierType::kSystemComponent;
case message_center::NotifierType::CROSTINI_APPLICATION:
return crosapi::mojom::NotifierType::kCrostiniApplication;
case message_center::NotifierType::PHONE_HUB:
return crosapi::mojom::NotifierType::kPhoneHub;
}
}
crosapi::mojom::FullscreenVisibility ToMojo(
message_center::FullscreenVisibility visibility) {
switch (visibility) {
case message_center::FullscreenVisibility::NONE:
return crosapi::mojom::FullscreenVisibility::kNone;
case message_center::FullscreenVisibility::OVER_USER:
return crosapi::mojom::FullscreenVisibility::kOverUser;
}
}
crosapi::mojom::SettingsButtonHandler ToMojo(
message_center::SettingsButtonHandler settings_button_handler) {
switch (settings_button_handler) {
case message_center::SettingsButtonHandler::NONE:
return crosapi::mojom::SettingsButtonHandler::kNone;
case message_center::SettingsButtonHandler::INLINE:
return crosapi::mojom::SettingsButtonHandler::kInline;
case message_center::SettingsButtonHandler::DELEGATE:
return crosapi::mojom::SettingsButtonHandler::kDelegate;
}
}
crosapi::mojom::NotificationPtr ToMojo(
const message_center::Notification& notification,
const ui::ColorProvider* color_provider) {
auto mojo_note = crosapi::mojom::Notification::New();
mojo_note->type = ToMojo(notification.type());
mojo_note->id = notification.id();
mojo_note->title = notification.title();
mojo_note->message = notification.message();
mojo_note->display_source = notification.display_source();
mojo_note->origin_url = notification.origin_url();
if (!notification.icon().IsEmpty())
mojo_note->icon = notification.icon().Rasterize(color_provider);
mojo_note->priority = std::clamp(notification.priority(), -2, 2);
mojo_note->require_interaction = notification.never_timeout();
mojo_note->timestamp = notification.timestamp();
if (!notification.image().IsEmpty())
mojo_note->image = notification.image().AsImageSkia();
if (!notification.small_image().IsEmpty()) {
mojo_note->badge = notification.small_image().AsImageSkia();
mojo_note->badge_needs_additional_masking_has_value = true;
mojo_note->badge_needs_additional_masking =
notification.small_image_needs_additional_masking();
}
for (const auto& item : notification.items()) {
auto mojo_item = crosapi::mojom::NotificationItem::New();
mojo_item->title = item.title();
mojo_item->message = item.message();
mojo_note->items.push_back(std::move(mojo_item));
}
mojo_note->progress = std::clamp(notification.progress(), -1, 100);
mojo_note->progress_status = notification.progress_status();
for (const auto& button : notification.buttons()) {
auto mojo_button = crosapi::mojom::ButtonInfo::New();
mojo_button->title = button.title;
mojo_button->placeholder = button.placeholder;
mojo_note->buttons.push_back(std::move(mojo_button));
}
mojo_note->pinned = notification.pinned();
mojo_note->renotify = notification.renotify();
mojo_note->silent = notification.silent();
mojo_note->accessible_name = notification.accessible_name();
mojo_note->fullscreen_visibility =
ToMojo(notification.fullscreen_visibility());
if (notification.accent_color_id().has_value()) {
// Colors have to be resolved in lacros since color ids are not guaranteed
// to be stable across the process boundary.
mojo_note->accent_color =
color_provider->GetColor(*notification.accent_color_id());
} else {
// TODO(b/308208767): Remove when this isn't used anymore.
mojo_note->accent_color = notification.accent_color();
}
mojo_note->notifier_id = crosapi::mojom::NotifierId::New();
mojo_note->notifier_id->type = ToMojo(notification.notifier_id().type);
mojo_note->notifier_id->id = notification.notifier_id().id;
mojo_note->notifier_id->url = notification.notifier_id().url;
mojo_note->notifier_id->title = notification.notifier_id().title;
mojo_note->notifier_id->profile_id = notification.notifier_id().profile_id;
const std::optional<base::FilePath>& image_path =
notification.rich_notification_data().image_path;
if (image_path.has_value()) {
mojo_note->image_path = image_path;
}
mojo_note->settings_button_handler =
ToMojo(notification.rich_notification_data().settings_button_handler);
return mojo_note;
}
} // namespace
// Keeps track of notifications being displayed in the remote message center.
class NotificationPlatformBridgeLacros::RemoteNotificationDelegate
: public crosapi::mojom::NotificationDelegate {
public:
RemoteNotificationDelegate(
const std::string& notification_id,
NotificationPlatformBridgeDelegate* bridge_delegate,
base::WeakPtr<NotificationPlatformBridgeLacros> owner)
: notification_id_(notification_id),
bridge_delegate_(bridge_delegate),
owner_(owner) {
DCHECK(!notification_id_.empty());
DCHECK(bridge_delegate_);
DCHECK(owner_);
}
RemoteNotificationDelegate(const RemoteNotificationDelegate&) = delete;
RemoteNotificationDelegate& operator=(const RemoteNotificationDelegate&) =
delete;
~RemoteNotificationDelegate() override = default;
mojo::PendingRemote<crosapi::mojom::NotificationDelegate>
BindNotificationDelegate() {
return receiver_.BindNewPipeAndPassRemoteWithVersion();
}
// crosapi::mojom::NotificationDelegate:
void OnNotificationClosed(bool by_user) override {
bridge_delegate_->HandleNotificationClosed(notification_id_, by_user);
if (owner_)
owner_->OnRemoteNotificationClosed(notification_id_);
// NOTE: |this| is deleted.
}
void OnNotificationClicked() override {
bridge_delegate_->HandleNotificationClicked(notification_id_);
}
void OnNotificationButtonClicked(
uint32_t button_index,
const std::optional<::std::u16string>& reply) override {
bridge_delegate_->HandleNotificationButtonClicked(
notification_id_, base::checked_cast<int>(button_index), reply);
}
void OnNotificationSettingsButtonClicked() override {
bridge_delegate_->HandleNotificationSettingsButtonClicked(notification_id_);
}
void OnNotificationDisabled() override {
bridge_delegate_->DisableNotification(notification_id_);
}
private:
const std::string notification_id_;
const raw_ptr<NotificationPlatformBridgeDelegate> bridge_delegate_;
base::WeakPtr<NotificationPlatformBridgeLacros> owner_;
mojo::Receiver<crosapi::mojom::NotificationDelegate> receiver_{this};
};
NotificationPlatformBridgeLacros::NotificationPlatformBridgeLacros(
NotificationPlatformBridgeDelegate* delegate,
mojo::Remote<crosapi::mojom::MessageCenter>* message_center_remote)
: bridge_delegate_(delegate),
message_center_remote_(message_center_remote) {
DCHECK(bridge_delegate_);
}
NotificationPlatformBridgeLacros::~NotificationPlatformBridgeLacros() = default;
void NotificationPlatformBridgeLacros::Display(
NotificationHandler::Type notification_type,
Profile* profile,
const message_center::Notification& notification,
std::unique_ptr<NotificationCommon::Metadata> metadata) {
if (!message_center_remote_)
return;
// |profile| is ignored because Profile management is handled in
// NotificationPlatformBridgeChromeOs, which includes a profile ID as part of
// the notification ID. Lacros does not support Chrome OS multi-signin, so we
// don't need to handle inactive user notification blockers in ash.
auto pending_notification = std::make_unique<RemoteNotificationDelegate>(
notification.id(), bridge_delegate_, weak_factory_.GetWeakPtr());
// Display the notification, or update an existing one with the same ID.
// `profile` may be null for e.g. system notifications.
const auto* const color_provider =
profile
? ThemeServiceFactory::GetForProfile(profile)->GetColorProvider()
: ui::ColorProviderManager::Get().GetColorProviderFor(
ui::NativeTheme::GetInstanceForNativeUi()->GetColorProviderKey(
nullptr));
(*message_center_remote_)
->DisplayNotification(ToMojo(notification, color_provider),
pending_notification->BindNotificationDelegate());
remote_notifications_[notification.id()] = std::move(pending_notification);
}
void NotificationPlatformBridgeLacros::Close(
Profile* profile,
const std::string& notification_id) {
if (!message_center_remote_)
return;
(*message_center_remote_)->CloseNotification(notification_id);
// |remote_notifications_| is cleaned up after the remote notification closes
// and notifies us via the delegate.
}
void NotificationPlatformBridgeLacros::GetDisplayed(
Profile* profile,
GetDisplayedNotificationsCallback callback) const {
NOTIMPLEMENTED();
std::move(callback).Run(/*notification_ids=*/{}, /*supports_sync=*/false);
}
void NotificationPlatformBridgeLacros::GetDisplayedForOrigin(
Profile* profile,
const GURL& origin,
GetDisplayedNotificationsCallback callback) const {
NOTIMPLEMENTED();
std::move(callback).Run(/*notification_ids=*/{}, /*supports_sync=*/false);
}
void NotificationPlatformBridgeLacros::SetReadyCallback(
NotificationBridgeReadyCallback callback) {
// Always return success even if |message_center_remote_| is not valid as we
// don't have another way of displaying notifications on ChromeOS via Lacros.
std::move(callback).Run(/*success=*/true);
}
void NotificationPlatformBridgeLacros::DisplayServiceShutDown(
Profile* profile) {
remote_notifications_.clear();
}
void NotificationPlatformBridgeLacros::OnRemoteNotificationClosed(
const std::string& id) {
remote_notifications_.erase(id);
}
Codebase Browser
chromium