// 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/ash/extensions/file_manager/system_notification_manager.h"
#include <optional>
#include <string>
#include "ash/components/arc/arc_prefs.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/webui/file_manager/file_manager_ui.h"
#include "ash/webui/settings/public/constants/routes.mojom.h"
#include "base/functional/bind.h"
#include "base/functional/callback_forward.h"
#include "base/functional/callback_helpers.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_refptr.h"
#include "base/metrics/histogram_macros.h"
#include "base/notreached.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/strcat.h"
#include "base/strings/utf_string_conversions.h"
#include "base/types/cxx23_to_underlying.h"
#include "chrome/browser/ash/drive/file_system_util.h"
#include "chrome/browser/ash/extensions/file_manager/drivefs_event_router.h"
#include "chrome/browser/ash/file_manager/fileapi_util.h"
#include "chrome/browser/ash/file_manager/io_task.h"
#include "chrome/browser/ash/file_manager/io_task_controller.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/policy/dlp/dialogs/files_policy_dialog.h"
#include "chrome/browser/ash/policy/dlp/files_policy_notification_manager.h"
#include "chrome/browser/ash/policy/dlp/files_policy_notification_manager_factory.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/ui/settings_window_manager_chromeos.h"
#include "chrome/common/extensions/api/file_manager_private.h"
#include "chrome/grit/generated_resources.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/browser/browser_thread.h"
#include "extensions/browser/extension_event_histogram_value.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/strings/grit/ui_chromeos_strings.h"
#include "ui/message_center/public/cpp/notification.h"
namespace file_manager {
namespace {
namespace fmp = extensions::api::file_manager_private;
using base::BindRepeating;
using base::MakeRefCounted;
using base::RepeatingClosure;
using base::UTF8ToUTF16;
using extensions::Event;
using file_manager::io_task::IOTaskController;
using file_manager::io_task::IOTaskId;
using file_manager::io_task::OperationType;
using file_manager::io_task::ProgressStatus;
using file_manager::util::GetDisplayablePath;
using fmp::MountCompletedEvent;
using fmp::ToString;
using l10n_util::GetStringFUTF16;
using l10n_util::GetStringUTF16;
using message_center::ButtonInfo;
using message_center::HandleNotificationClickDelegate;
using message_center::Notification;
using message_center::NotificationDelegate;
using message_center::NotifierId;
using message_center::RichNotificationData;
using message_center::SystemNotificationWarningLevel;
using NotificationPtr = std::unique_ptr<Notification>;
using DelegatePtr = scoped_refptr<NotificationDelegate>;
using OperationID = storage::FileSystemOperationRunner::OperationID;
using FileSystemContextPtr = scoped_refptr<storage::FileSystemContext>;
using enum extensions::events::HistogramValue;
using enum message_center::NotificationType;
void CancelCopyOnIOThread(FileSystemContextPtr file_system_context,
OperationID operation_id) {
file_system_context->operation_runner()->Cancel(
operation_id, base::BindOnce([](base::File::Error error) {
DLOG_IF(WARNING, error != base::File::FILE_OK)
<< "Failed to cancel copy: " << error;
}));
}
constexpr char kSwaFileOperationPrefix[] = "swa-file-operation-";
bool NotificationIdToOperationId(const std::string& notification_id,
OperationID* operation_id) {
*operation_id = 0;
std::string id_string;
if (base::RemoveChars(notification_id, kSwaFileOperationPrefix, &id_string)) {
if (base::StringToUint64(id_string, operation_id)) {
return true;
}
}
return false;
}
void RecordDeviceNotificationMetric(DeviceNotificationUmaType type) {
UMA_HISTOGRAM_ENUMERATION(kNotificationShowHistogramName, type);
}
void RecordDeviceNotificationUserActionMetric(
DeviceNotificationUserActionUmaType type) {
UMA_HISTOGRAM_ENUMERATION(kNotificationUserActionHistogramName, type);
}
std::u16string GetIOTaskMessage(Profile* profile,
const ProgressStatus& status) {
int single_file_message_id;
int multiple_file_message_id;
// Display special copy to help users understand that pasting files to "My
// Drive" does not mean that they are immediately synced.
drive::DriveIntegrationService* const service =
drive::util::GetIntegrationServiceByProfile(profile);
bool is_destination_drive =
service && service->GetMountPointPath().IsParent(
status.GetDestinationFolder().path());
switch (status.type) {
case OperationType::kCopy:
if (is_destination_drive) {
single_file_message_id = IDS_FILE_BROWSER_PREPARING_FILE_NAME_MY_DRIVE;
multiple_file_message_id = IDS_FILE_BROWSER_PREPARING_ITEMS_MY_DRIVE;
} else {
single_file_message_id = IDS_FILE_BROWSER_COPY_FILE_NAME;
multiple_file_message_id = IDS_FILE_BROWSER_COPY_ITEMS_REMAINING;
}
break;
case OperationType::kMove:
if (is_destination_drive) {
single_file_message_id = IDS_FILE_BROWSER_PREPARING_FILE_NAME_MY_DRIVE;
multiple_file_message_id = IDS_FILE_BROWSER_PREPARING_ITEMS_MY_DRIVE;
} else {
single_file_message_id = IDS_FILE_BROWSER_MOVE_FILE_NAME;
multiple_file_message_id = IDS_FILE_BROWSER_MOVE_ITEMS_REMAINING;
}
break;
case OperationType::kDelete:
single_file_message_id = IDS_FILE_BROWSER_DELETE_FILE_NAME;
multiple_file_message_id = IDS_FILE_BROWSER_DELETE_ITEMS_REMAINING;
break;
case OperationType::kExtract:
single_file_message_id = IDS_FILE_BROWSER_EXTRACT_FILE_NAME;
multiple_file_message_id = IDS_FILE_BROWSER_EXTRACT_ITEMS_REMAINING;
break;
case OperationType::kZip:
single_file_message_id = IDS_FILE_BROWSER_ZIP_FILE_NAME;
multiple_file_message_id = IDS_FILE_BROWSER_ZIP_ITEMS_REMAINING;
break;
case OperationType::kRestoreToDestination:
single_file_message_id = IDS_FILE_BROWSER_RESTORING_FROM_TRASH_FILE_NAME;
multiple_file_message_id =
IDS_FILE_BROWSER_RESTORING_FROM_TRASH_ITEMS_REMAINING;
break;
case OperationType::kTrash:
single_file_message_id = IDS_FILE_BROWSER_MOVE_TO_TRASH_FILE_NAME;
multiple_file_message_id = IDS_FILE_BROWSER_MOVE_TO_TRASH_ITEMS_REMAINING;
break;
case OperationType::kEmptyTrash:
case OperationType::kRestore:
default:
NOTREACHED_IN_MIGRATION() << "Unexpected operation type " << status.type;
return u"Unknown operation type";
}
if (status.sources.size() > 1) {
return GetStringFUTF16(multiple_file_message_id,
base::NumberToString16(status.sources.size()));
}
return GetStringFUTF16(
single_file_message_id,
UTF8ToUTF16(GetDisplayablePath(profile, status.sources.back().url)
.value_or(base::FilePath())
.BaseName()
.value()));
}
} // namespace
std::string GetNotificationId(io_task::IOTaskId task_id) {
return base::StrCat({kSwaFileOperationPrefix, base::NumberToString(task_id)});
}
NotificationPtr CreateSystemNotification(
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message,
DelegatePtr delegate,
message_center::RichNotificationData optional_fields) {
return ash::CreateSystemNotificationPtr(
NOTIFICATION_TYPE_SIMPLE, notification_id, title, message,
GetStringUTF16(IDS_FILEMANAGER_APP_NAME), GURL(), NotifierId(),
optional_fields, std::move(delegate), ash::kFolderIcon,
SystemNotificationWarningLevel::NORMAL);
}
NotificationPtr CreateSystemNotification(const std::string& notification_id,
int title_id,
int message_id,
DelegatePtr delegate) {
return CreateSystemNotification(notification_id, GetStringUTF16(title_id),
GetStringUTF16(message_id),
std::move(delegate));
}
NotificationPtr CreateSystemNotification(
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message,
const RepeatingClosure& click_callback) {
return CreateSystemNotification(
notification_id, title, message,
MakeRefCounted<HandleNotificationClickDelegate>(click_callback));
}
SystemNotificationManager::SystemNotificationManager(Profile* profile)
: profile_(profile), app_name_(GetStringUTF16(IDS_FILEMANAGER_APP_NAME)) {}
SystemNotificationManager::~SystemNotificationManager() = default;
bool SystemNotificationManager::DoFilesSwaWindowsExist() {
return ash::file_manager::FileManagerUI::GetNumInstances() != 0;
}
NotificationPtr SystemNotificationManager::CreateNotification(
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message) {
return CreateSystemNotification(
notification_id, title, message,
BindRepeating(&SystemNotificationManager::Dismiss,
weak_ptr_factory_.GetWeakPtr(), notification_id));
}
NotificationPtr SystemNotificationManager::CreateNotification(
const std::string& notification_id,
int title_id,
int message_id) {
return CreateNotification(notification_id, GetStringUTF16(title_id),
GetStringUTF16(message_id));
}
void SystemNotificationManager::HandleProgressClick(
const std::string& notification_id,
std::optional<int> button_index) {
if (button_index) {
// Cancel the copy operation.
FileSystemContextPtr file_system_context =
util::GetFileManagerFileSystemContext(profile_);
OperationID operation_id;
if (NotificationIdToOperationId(notification_id, &operation_id)) {
content::GetIOThreadTaskRunner({})->PostTask(
FROM_HERE, base::BindOnce(&CancelCopyOnIOThread, file_system_context,
operation_id));
}
}
}
NotificationPtr SystemNotificationManager::CreateProgressNotification(
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message,
int progress) {
RichNotificationData rich_data;
rich_data.progress = progress;
rich_data.progress_status = message;
return ash::CreateSystemNotificationPtr(
NOTIFICATION_TYPE_PROGRESS, notification_id, title, message, app_name_,
GURL(), NotifierId(), rich_data,
MakeRefCounted<HandleNotificationClickDelegate>(
BindRepeating(&SystemNotificationManager::HandleProgressClick,
weak_ptr_factory_.GetWeakPtr(), notification_id)),
ash::kFolderIcon, SystemNotificationWarningLevel::NORMAL);
}
NotificationPtr SystemNotificationManager::CreateIOTaskProgressNotification(
IOTaskId task_id,
const std::string& notification_id,
const std::u16string& title,
const std::u16string& message,
const bool paused,
int progress) {
RichNotificationData rich_data;
rich_data.progress = progress;
rich_data.progress_status = message;
// Button click delegate to handle the state::PAUSED IOTask case, where the
// user [X] closes this system notification, but did not press its buttons.
// In that case, default behavior is to auto-click button 1.
// TODO(b/255264604): ask UX here, which button should be the default?
class IOTaskProgressNotificationClickDelegate
: public HandleNotificationClickDelegate {
public:
IOTaskProgressNotificationClickDelegate(const ButtonClickCallback& callback,
bool paused)
: HandleNotificationClickDelegate(callback), paused_(paused) {}
void Close(bool by_user) override {
if (paused_ && by_user) { // Click button at index 1.
HandleNotificationClickDelegate::Click(1, {});
}
}
protected:
~IOTaskProgressNotificationClickDelegate() override = default;
private:
bool paused_; // True if the IOTask is in state::PAUSED.
};
auto notification_click_handler = BindRepeating(
&SystemNotificationManager::HandleIOTaskProgressNotificationClick,
weak_ptr_factory_.GetWeakPtr(), task_id, notification_id, paused);
auto notification = ash::CreateSystemNotificationPtr(
NOTIFICATION_TYPE_PROGRESS, notification_id, title, message, app_name_,
GURL(), NotifierId(), rich_data,
MakeRefCounted<IOTaskProgressNotificationClickDelegate>(
std::move(notification_click_handler), paused),
ash::kFolderIcon, SystemNotificationWarningLevel::NORMAL);
std::vector<ButtonInfo> notification_buttons;
// Add "Cancel" button.
notification_buttons.emplace_back(
GetStringUTF16(IDS_FILE_BROWSER_CANCEL_LABEL));
if (paused) { // For paused tasks, add "Open Files app" button.
notification_buttons.emplace_back(
GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_BUTTON_LABEL));
}
notification->set_buttons(notification_buttons);
return notification;
}
void SystemNotificationManager::HandleIOTaskProgressNotificationClick(
IOTaskId task_id,
const std::string& notification_id,
const bool paused,
std::optional<int> button_index) {
if (!button_index.has_value()) {
return;
}
if (button_index.value() == 0) {
CancelTask(task_id);
}
if (paused && button_index.value() == 1) {
platform_util::ShowItemInFolder(
profile_, file_manager::util::GetMyFilesFolderForProfile(profile_));
Dismiss(notification_id);
}
}
void SystemNotificationManager::Dismiss(const std::string& notification_id) {
GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
notification_id);
}
static const char kDeviceFailNotificationId[] = "swa-device-fail-id";
void SystemNotificationManager::HandleDeviceEvent(
const fmp::DeviceEvent& event) {
NotificationPtr notification;
const std::string id = ToString(event.type);
switch (event.type) {
case fmp::DeviceEventType::kDisabled:
notification =
CreateNotification(id, IDS_REMOVABLE_DEVICE_DETECTION_TITLE,
IDS_EXTERNAL_STORAGE_DISABLED_MESSAGE);
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_EXTERNAL_STORAGE_DISABLED);
break;
case fmp::DeviceEventType::kRemoved:
// Hide device fail & storage disabled notifications.
GetNotificationDisplayService()->Close(
NotificationHandler::Type::TRANSIENT, kDeviceFailNotificationId);
GetNotificationDisplayService()->Close(
NotificationHandler::Type::TRANSIENT,
ToString(fmp::DeviceEventType::kDisabled));
// Remove the device from the mount status map.
mount_status_.erase(event.device_path);
break;
case fmp::DeviceEventType::kHardUnplugged:
notification = CreateNotification(id, IDS_DEVICE_HARD_UNPLUGGED_TITLE,
IDS_DEVICE_HARD_UNPLUGGED_MESSAGE);
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_HARD_UNPLUGGED);
break;
case fmp::DeviceEventType::kFormatStart:
notification = CreateNotification(
id,
GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_DIALOG_TITLE,
UTF8ToUTF16(event.device_label)),
GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_PROGRESS_MESSAGE,
UTF8ToUTF16(event.device_label)));
RecordDeviceNotificationMetric(DeviceNotificationUmaType::FORMAT_START);
break;
case fmp::DeviceEventType::kFormatSuccess:
case fmp::DeviceEventType::kFormatFail:
case fmp::DeviceEventType::kPartitionFail: {
// Hide the formatting notification.
GetNotificationDisplayService()->Close(
NotificationHandler::Type::TRANSIENT,
ToString(fmp::DeviceEventType::kFormatStart));
std::u16string message;
if (event.type == fmp::DeviceEventType::kFormatSuccess) {
message = GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_SUCCESS_MESSAGE,
UTF8ToUTF16(event.device_label));
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::FORMAT_SUCCESS);
} else {
message = GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_FAILURE_MESSAGE,
UTF8ToUTF16(event.device_label));
RecordDeviceNotificationMetric(
event.type == fmp::DeviceEventType::kFormatFail
? DeviceNotificationUmaType::FORMAT_FAIL
: DeviceNotificationUmaType::PARTITION_FAIL);
}
notification = CreateNotification(
id,
GetStringFUTF16(IDS_FILE_BROWSER_FORMAT_DIALOG_TITLE,
UTF8ToUTF16(event.device_label)),
std::move(message));
break;
}
case fmp::DeviceEventType::kPartitionStart:
case fmp::DeviceEventType::kPartitionSuccess:
// No-op.
break;
case fmp::DeviceEventType::kRenameFail:
notification =
CreateNotification(id, IDS_RENAMING_OF_DEVICE_FAILED_TITLE,
IDS_RENAMING_OF_DEVICE_FINISHED_FAILURE_MESSAGE);
RecordDeviceNotificationMetric(DeviceNotificationUmaType::RENAME_FAIL);
break;
case fmp::DeviceEventType::kNone:
case fmp::DeviceEventType::kRenameStart:
case fmp::DeviceEventType::kRenameSuccess:
default:
VLOG(1) << "No notification for device event " << id;
break;
}
if (notification) {
GetNotificationDisplayService()->Display(
NotificationHandler::Type::TRANSIENT, *notification,
/*metadata=*/nullptr);
}
}
static const char kBulkPinningNotificationId[] = "drive-bulk-pinning-error";
void SystemNotificationManager::HandleBulkPinningNotificationClick() {
chrome::SettingsWindowManager::GetInstance()->ShowOSSettings(
profile_, chromeos::settings::mojom::kGoogleDriveSubpagePath);
GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
kBulkPinningNotificationId);
}
NotificationPtr SystemNotificationManager::MakeBulkPinningErrorNotification(
const Event& event) {
// Parse the event args as a bulk-pinning progress struct.
DCHECK(!event.event_args.empty());
auto progress = fmp::BulkPinProgress::FromValue(event.event_args[0]);
if (!progress) {
LOG(ERROR) << "Cannot parse BulkPinProgress from " << event.event_args[0];
return nullptr;
}
// Remember the bulk-pinning stage.
using enum BulkPinStage;
const BulkPinStage old_stage = bulk_pin_stage_;
bulk_pin_stage_ = progress->stage;
if (!progress->should_pin) {
return nullptr;
}
if (old_stage != BulkPinStage::kListingFiles &&
old_stage != BulkPinStage::kSyncing) {
return nullptr;
}
// Check the bulk-pinning stage.
switch (bulk_pin_stage_) {
case BulkPinStage::kNone:
case BulkPinStage::kStopped:
case BulkPinStage::kPausedOffline:
case BulkPinStage::kPausedBatterySaver:
case BulkPinStage::kGettingFreeSpace:
case BulkPinStage::kListingFiles:
case BulkPinStage::kSyncing:
case BulkPinStage::kSuccess:
return nullptr;
case BulkPinStage::kNotEnoughSpace:
case BulkPinStage::kCannotGetFreeSpace:
case BulkPinStage::kCannotListFiles:
case BulkPinStage::kCannotEnableDocsOffline:
break;
}
VLOG(1) << "Creating bulk-pinning error notification";
int title_id, message_id;
if (bulk_pin_stage_ == BulkPinStage::kNotEnoughSpace) {
if (progress->emptied_queue) {
title_id = IDS_FILE_BROWSER_DRIVE_SYNC_TURNED_OFF_TITLE;
message_id =
IDS_FILE_BROWSER_BULK_PINNING_NOT_ENOUGH_SPACE_NOTIFICATION_2;
} else {
title_id = IDS_FILE_BROWSER_DRIVE_SYNC_ERROR_TITLE;
message_id = IDS_FILE_BROWSER_BULK_PINNING_NOT_ENOUGH_SPACE_NOTIFICATION;
}
} else {
title_id = IDS_FILE_BROWSER_DRIVE_SYNC_TURNED_OFF_TITLE;
message_id = IDS_FILE_BROWSER_BULK_PINNING_ERROR;
}
NotificationPtr notification = CreateSystemNotification(
kBulkPinningNotificationId, GetStringUTF16(title_id),
GetStringUTF16(message_id),
BindRepeating(
&SystemNotificationManager::HandleBulkPinningNotificationClick,
weak_ptr_factory_.GetWeakPtr()));
return notification;
}
NotificationPtr SystemNotificationManager::MakeDriveSyncErrorNotification(
const Event& event) {
DCHECK(!event.event_args.empty());
auto sync_error = fmp::DriveSyncErrorEvent::FromValue(event.event_args[0]);
if (!sync_error) {
LOG(ERROR) << "Cannot parse DriveSyncErrorEvent from "
<< event.event_args[0];
return nullptr;
}
const std::u16string title =
GetStringUTF16(IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL);
const std::string id = ToString(sync_error->type);
const GURL file_url(sync_error->file_url);
switch (sync_error->type) {
case fmp::DriveSyncErrorType::kDeleteWithoutPermission:
return CreateNotification(
id, title,
GetStringFUTF16(IDS_FILE_BROWSER_SYNC_DELETE_WITHOUT_PERMISSION_ERROR,
util::GetDisplayableFileName16(file_url)));
case fmp::DriveSyncErrorType::kServiceUnavailable:
return CreateNotification(
id, IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL,
IDS_FILE_BROWSER_SYNC_SERVICE_UNAVAILABLE_ERROR);
case fmp::DriveSyncErrorType::kNoServerSpace:
return CreateNotification(
id, title, GetStringUTF16(IDS_FILE_BROWSER_SYNC_NO_SERVER_SPACE));
case fmp::DriveSyncErrorType::kNoServerSpaceOrganization:
return CreateNotification(
id, title,
GetStringUTF16(IDS_FILE_BROWSER_SYNC_NO_SERVER_SPACE_ORGANIZATION));
case fmp::DriveSyncErrorType::kNoLocalSpace:
return CreateNotification(id, IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL,
IDS_FILE_BROWSER_DRIVE_OUT_OF_SPACE_HEADER);
case fmp::DriveSyncErrorType::kMisc:
return CreateNotification(
id, title,
GetStringFUTF16(IDS_FILE_BROWSER_SYNC_MISC_ERROR,
util::GetDisplayableFileName16(file_url)));
case fmp::DriveSyncErrorType::kNoSharedDriveSpace:
if (!sync_error->shared_drive.has_value()) {
DLOG(WARNING) << "No shared drive provided for error notification";
return nullptr;
}
return CreateNotification(
id, title,
GetStringFUTF16(IDS_FILE_BROWSER_SYNC_ERROR_SHARED_DRIVE_OUT_OF_SPACE,
UTF8ToUTF16(sync_error->shared_drive.value())));
case fmp::DriveSyncErrorType::kNone:
break;
}
LOG(ERROR) << "Unexpected Drive sync error: "
<< base::to_underlying(sync_error->type);
return nullptr;
}
static const char kDriveDialogId[] = "swa-drive-confirm-dialog";
void SystemNotificationManager::HandleDriveDialogClick(
std::optional<int> button_index) {
drivefs::mojom::DialogResult result = drivefs::mojom::DialogResult::kDismiss;
if (button_index) {
if (button_index.value() == 1) {
result = drivefs::mojom::DialogResult::kAccept;
} else {
result = drivefs::mojom::DialogResult::kReject;
}
}
// Send the dialog result to the callback stored in DriveFS on dialog
// creation.
if (drivefs_event_router_) {
drivefs_event_router_->OnDialogResult(result);
}
GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
kDriveDialogId);
}
NotificationPtr SystemNotificationManager::MakeDriveConfirmDialogNotification(
const Event& event) {
DCHECK(!event.event_args.empty());
auto dialog_event =
fmp::DriveConfirmDialogEvent::FromValue(event.event_args[0]);
if (!dialog_event) {
LOG(ERROR) << "Cannot parse DriveConfirmDialogEvent from "
<< event.event_args[0];
return nullptr;
}
NotificationPtr notification = CreateSystemNotification(
kDriveDialogId, IDS_FILE_BROWSER_DRIVE_DIRECTORY_LABEL,
IDS_FILE_BROWSER_OFFLINE_ENABLE_MESSAGE,
MakeRefCounted<HandleNotificationClickDelegate>(
BindRepeating(&SystemNotificationManager::HandleDriveDialogClick,
weak_ptr_factory_.GetWeakPtr())));
std::vector<ButtonInfo> buttons;
buttons.emplace_back(GetStringUTF16(IDS_FILE_BROWSER_OFFLINE_ENABLE_REJECT));
buttons.emplace_back(GetStringUTF16(IDS_FILE_BROWSER_OFFLINE_ENABLE_ACCEPT));
notification->set_buttons(buttons);
return notification;
}
void SystemNotificationManager::HandleEvent(const Event& event) {
if (event.event_args.empty()) {
DLOG(WARNING) << "Ignored empty Event {name: " << event.event_name
<< ", histogram_value: " << event.histogram_value << "}";
return;
}
// For some events we always display a system notification regardless of if
// there are any SWA windows open.
bool force_as_system_notification = false;
NotificationPtr notification;
switch (event.histogram_value) {
case FILE_MANAGER_PRIVATE_ON_DRIVE_SYNC_ERROR:
notification = MakeDriveSyncErrorNotification(event);
break;
case FILE_MANAGER_PRIVATE_ON_DRIVE_CONFIRM_DIALOG:
notification = MakeDriveConfirmDialogNotification(event);
force_as_system_notification = true;
break;
case FILE_MANAGER_PRIVATE_ON_BULK_PIN_PROGRESS:
notification = MakeBulkPinningErrorNotification(event);
force_as_system_notification = true;
break;
default:
VLOG(1) << "Ignored Event {name: " << event.event_name
<< ", histogram_value: " << event.histogram_value
<< ", args: " << event.event_args << "}";
return;
}
if (!notification) {
return;
}
// Check if we need to remove any progress notification when there
// are active SWA windows.
if (!force_as_system_notification && DoFilesSwaWindowsExist()) {
GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
notification->id());
return;
}
GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
*notification, nullptr);
}
void SystemNotificationManager::HandleIOTaskProgress(
const ProgressStatus& status) {
std::string id = GetNotificationId(status.task_id);
// If there are any SWA windows open, remove the IOTask progress from system
// notifications.
if (!status.show_notification || DoFilesSwaWindowsExist()) {
Dismiss(id);
return;
}
// If there's a warning or security error, show a data protection
// notification.
if (status.HasWarning() || status.HasPolicyError()) {
policy::FilesPolicyNotificationManager* manager =
policy::FilesPolicyNotificationManagerFactory::GetForBrowserContext(
profile_);
if (!manager) {
LOG(ERROR) << "No FilesPolicyNotificationManager instantiated,"
"can't show policy dialog for task_id "
<< status.task_id;
return;
}
Dismiss(id);
manager->ShowFilesPolicyNotification(id, status);
return;
}
// If the task is currently in the scanning state, show a data protection
// progress notification.
if (status.IsScanning()) {
Dismiss(id);
NotificationPtr notification =
MakeDataProtectionPolicyProgressNotification(id, status);
GetNotificationDisplayService()->Display(
NotificationHandler::Type::TRANSIENT, *notification,
/*metadata=*/nullptr);
return;
}
// If the IOTask state has completed, remove the IOTask progress from system
// notifications.
if (status.IsCompleted()) {
Dismiss(id);
return;
}
// From here state is kQueued, kInProgress, or kPaused.
const bool paused = status.IsPaused();
std::u16string title;
std::u16string message;
if (!paused) {
title = app_name_;
message = GetIOTaskMessage(profile_, status);
} else {
title = GetIOTaskMessage(profile_, status);
int message_id = IDS_FILE_BROWSER_CONFLICT_DIALOG_MESSAGE;
if (status.pause_params.conflict_params.has_value() &&
status.pause_params.conflict_params->conflict_is_directory) {
message_id = IDS_FILE_BROWSER_CONFLICT_DIALOG_FOLDER_MESSAGE;
}
auto& item_name = status.pause_params.conflict_params->conflict_name;
message = GetStringFUTF16(message_id, UTF8ToUTF16(item_name));
}
int progress = 0;
if (status.total_bytes > 0) {
progress = status.bytes_transferred * 100.0 / status.total_bytes;
}
NotificationPtr notification = CreateIOTaskProgressNotification(
status.task_id, id, title, message, paused, progress);
GetNotificationDisplayService()->Display(NotificationHandler::Type::TRANSIENT,
*notification,
/*metadata=*/nullptr);
}
constexpr char kRemovableNotificationId[] = "swa-removable-device-id";
void SystemNotificationManager::HandleRemovableNotificationClick(
const std::string& path,
const std::vector<DeviceNotificationUserActionUmaType>&
uma_types_for_buttons,
std::optional<int> button_index) {
if (button_index) {
if (button_index.value() == 0) {
base::FilePath volume_root(path);
platform_util::ShowItemInFolder(profile_, volume_root);
} else {
chrome::SettingsWindowManager::GetInstance()->ShowOSSettings(
profile_, chromeos::settings::mojom::kExternalStorageSubpagePath);
}
if (base::checked_cast<size_t>(button_index.value()) <
uma_types_for_buttons.size()) {
RecordDeviceNotificationUserActionMetric(
uma_types_for_buttons.at(button_index.value()));
}
}
GetNotificationDisplayService()->Close(NotificationHandler::Type::TRANSIENT,
kRemovableNotificationId);
}
void SystemNotificationManager::HandleDataProtectionPolicyNotificationClick(
RepeatingClosure proceed_callback,
RepeatingClosure cancel_callback,
std::optional<int> button_index) {
if (!button_index.has_value()) {
return;
}
if (button_index.value() == 0) {
proceed_callback.Run();
}
if (button_index.value() == 1 && cancel_callback) {
cancel_callback.Run();
}
}
NotificationPtr SystemNotificationManager::MakeMountErrorNotification(
MountCompletedEvent& event,
const Volume& volume) {
const auto it = mount_status_.find(volume.storage_device_path().value());
if (it == mount_status_.end()) {
return nullptr;
}
const std::u16string title =
GetStringUTF16(IDS_REMOVABLE_DEVICE_DETECTION_TITLE);
std::u16string message;
std::vector<ButtonInfo> buttons;
std::vector<DeviceNotificationUserActionUmaType> uma_types_for_buttons;
switch (it->second) {
// We have either an unsupported or unknown filesystem on the mount.
case MOUNT_STATUS_ONLY_PARENT_ERROR:
case MOUNT_STATUS_CHILD_ERROR:
if (event.status == fmp::MountError::kUnsupportedFilesystem) {
if (volume.drive_label().empty()) {
message = GetStringUTF16(IDS_DEVICE_UNSUPPORTED_DEFAULT_MESSAGE);
} else {
message = GetStringFUTF16(IDS_DEVICE_UNSUPPORTED_MESSAGE,
UTF8ToUTF16(volume.drive_label()));
}
RecordDeviceNotificationMetric(DeviceNotificationUmaType::DEVICE_FAIL);
} else {
if (volume.drive_label().empty()) {
message = GetStringUTF16(IDS_DEVICE_UNKNOWN_DEFAULT_MESSAGE);
} else {
message = GetStringFUTF16(IDS_DEVICE_UNKNOWN_MESSAGE,
UTF8ToUTF16(volume.drive_label()));
}
if (!volume.is_read_only()) {
// Give a format device button on the notification.
buttons.emplace_back(GetStringUTF16(IDS_DEVICE_UNKNOWN_BUTTON_LABEL));
uma_types_for_buttons.push_back(
DeviceNotificationUserActionUmaType::OPEN_MEDIA_DEVICE_FAIL);
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_FAIL_UNKNOWN);
} else {
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_FAIL_UNKNOWN_READONLY);
}
}
break;
// We have a multi-partition device for which at least one mount
// failed.
case MOUNT_STATUS_MULTIPART_ERROR:
if (volume.drive_label().empty()) {
message =
GetStringUTF16(IDS_MULTIPART_DEVICE_UNSUPPORTED_DEFAULT_MESSAGE);
} else {
message = GetStringFUTF16(IDS_MULTIPART_DEVICE_UNSUPPORTED_MESSAGE,
UTF8ToUTF16(volume.drive_label()));
}
RecordDeviceNotificationMetric(DeviceNotificationUmaType::DEVICE_FAIL);
break;
case MOUNT_STATUS_NO_RESULT:
case MOUNT_STATUS_SUCCESS:
default:
VLOG(1) << "Unhandled mount status " << it->second;
return nullptr;
}
NotificationPtr notification = CreateSystemNotification(
kDeviceFailNotificationId, title, message,
MakeRefCounted<HandleNotificationClickDelegate>(BindRepeating(
&SystemNotificationManager::HandleRemovableNotificationClick,
weak_ptr_factory_.GetWeakPtr(), volume.mount_path().value(),
uma_types_for_buttons)));
DCHECK_EQ(buttons.size(), uma_types_for_buttons.size());
notification->set_buttons(buttons);
return notification;
}
SystemNotificationManagerMountStatus
SystemNotificationManager::UpdateDeviceMountStatus(MountCompletedEvent& event,
const Volume& volume) {
SystemNotificationManagerMountStatus status = MOUNT_STATUS_NO_RESULT;
const std::string& device_path = volume.storage_device_path().value();
auto device_mount_status = mount_status_.find(device_path);
if (device_mount_status == mount_status_.end()) {
status = MOUNT_STATUS_NO_RESULT;
} else {
status = device_mount_status->second;
}
switch (status) {
case MOUNT_STATUS_MULTIPART_ERROR:
// Do nothing, status has already been detected.
break;
case MOUNT_STATUS_ONLY_PARENT_ERROR:
if (!volume.is_parent()) {
// Hide Device Fail notification.
GetNotificationDisplayService()->Close(
NotificationHandler::Type::TRANSIENT, kDeviceFailNotificationId);
}
[[fallthrough]];
case MOUNT_STATUS_NO_RESULT:
if (event.status == fmp::MountError::kSuccess) {
status = MOUNT_STATUS_SUCCESS;
} else if (event.volume_metadata.is_parent_device) {
status = MOUNT_STATUS_ONLY_PARENT_ERROR;
} else {
status = MOUNT_STATUS_CHILD_ERROR;
}
break;
case MOUNT_STATUS_SUCCESS:
case MOUNT_STATUS_CHILD_ERROR:
if (status == MOUNT_STATUS_SUCCESS &&
event.status == fmp::MountError::kSuccess) {
status = MOUNT_STATUS_SUCCESS;
} else {
// Multi partition device with at least one partition in error.
status = MOUNT_STATUS_MULTIPART_ERROR;
}
break;
}
mount_status_[device_path] = status;
return status;
}
NotificationPtr SystemNotificationManager::MakeRemovableNotification(
MountCompletedEvent& event,
const Volume& volume) {
NotificationPtr notification;
if (event.status == fmp::MountError::kSuccess) {
bool show_settings_button = false;
std::u16string title = GetStringUTF16(IDS_REMOVABLE_DEVICE_DETECTION_TITLE);
std::u16string message;
std::vector<DeviceNotificationUserActionUmaType> uma_types_for_buttons;
if (volume.is_read_only() && !volume.is_read_only_removable_device()) {
message = GetStringUTF16(
IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE_READONLY_POLICY);
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_NAVIGATION_READONLY_POLICY);
uma_types_for_buttons.push_back(
DeviceNotificationUserActionUmaType::OPEN_MEDIA_DEVICE_NAVIGATION);
} else {
const PrefService* const service = profile_->GetPrefs();
DCHECK(service);
bool arc_enabled = service->GetBoolean(arc::prefs::kArcEnabled);
bool arc_removable_media_access_enabled =
service->GetBoolean(arc::prefs::kArcHasAccessToRemovableMedia);
if (!arc_enabled) {
message = GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE);
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_NAVIGATION);
uma_types_for_buttons.push_back(
DeviceNotificationUserActionUmaType::OPEN_MEDIA_DEVICE_NAVIGATION);
} else if (arc_removable_media_access_enabled) {
message = base::StrCat(
{GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE), u" ",
GetStringUTF16(
IDS_REMOVABLE_DEVICE_PLAY_STORE_APPS_HAVE_ACCESS_MESSAGE)});
show_settings_button = true;
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_NAVIGATION_APPS_HAVE_ACCESS);
uma_types_for_buttons.insert(uma_types_for_buttons.end(),
{DeviceNotificationUserActionUmaType::
OPEN_MEDIA_DEVICE_NAVIGATION_ARC,
DeviceNotificationUserActionUmaType::
OPEN_SETTINGS_FOR_ARC_STORAGE});
} else {
message = base::StrCat(
{GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_MESSAGE), u" ",
GetStringUTF16(
IDS_REMOVABLE_DEVICE_ALLOW_PLAY_STORE_ACCESS_MESSAGE)});
show_settings_button = true;
RecordDeviceNotificationMetric(
DeviceNotificationUmaType::DEVICE_NAVIGATION_ALLOW_APP_ACCESS);
uma_types_for_buttons.insert(uma_types_for_buttons.end(),
{DeviceNotificationUserActionUmaType::
OPEN_MEDIA_DEVICE_NAVIGATION_ARC,
DeviceNotificationUserActionUmaType::
OPEN_SETTINGS_FOR_ARC_STORAGE});
}
}
notification = CreateSystemNotification(
kRemovableNotificationId, title, message,
MakeRefCounted<HandleNotificationClickDelegate>(BindRepeating(
&SystemNotificationManager::HandleRemovableNotificationClick,
weak_ptr_factory_.GetWeakPtr(), volume.mount_path().value(),
uma_types_for_buttons)));
std::vector<ButtonInfo> notification_buttons;
notification_buttons.emplace_back(
GetStringUTF16(IDS_REMOVABLE_DEVICE_NAVIGATION_BUTTON_LABEL));
if (show_settings_button) {
notification_buttons.emplace_back(
GetStringUTF16(IDS_REMOVABLE_DEVICE_OPEN_SETTTINGS_BUTTON_LABEL));
}
DCHECK_EQ(notification_buttons.size(), uma_types_for_buttons.size());
notification->set_buttons(notification_buttons);
}
if (volume.device_type() != ash::DeviceType::kUnknown &&
!volume.storage_device_path().empty()) {
if (UpdateDeviceMountStatus(event, volume) != MOUNT_STATUS_SUCCESS) {
notification = MakeMountErrorNotification(event, volume);
}
}
return notification;
}
NotificationPtr
SystemNotificationManager::MakeDataProtectionPolicyProgressNotification(
const std::string& notification_id,
const ProgressStatus& status) {
std::u16string message =
status.sources.size() > 1
? GetStringUTF16(IDS_FILE_BROWSER_SCANNING_LABEL_PLURAL)
: GetStringUTF16(IDS_FILE_BROWSER_SCANNING_LABEL);
int progress = status.sources_scanned * 100.0 / status.sources.size();
return CreateIOTaskProgressNotification(status.task_id, notification_id,
app_name_, message, /*paused=*/false,
progress);
}
void SystemNotificationManager::ShowDataProtectionPolicyDialog(
IOTaskId task_id,
policy::FilesDialogType type) {
policy::FilesPolicyNotificationManager* manager =
policy::FilesPolicyNotificationManagerFactory::GetForBrowserContext(
profile_);
if (!manager) {
LOG(ERROR) << "No FilesPolicyNotificationManager instantiated,"
"can't show policy dialog for task_id "
<< task_id;
return;
}
manager->ShowDialog(task_id, type);
}
void SystemNotificationManager::CancelTask(IOTaskId task_id) {
if (io_task_controller_) {
io_task_controller_->Cancel(task_id);
} else {
LOG(ERROR) << "No TaskController, can't cancel task_id: " << task_id;
}
}
void SystemNotificationManager::ResumeTask(IOTaskId task_id,
policy::Policy policy) {
if (io_task_controller_) {
io_task::ResumeParams params;
params.policy_params->type = policy;
io_task_controller_->Resume(task_id, std::move(params));
} else {
LOG(ERROR) << "No TaskController, can't resume task_id: " << task_id;
}
}
void SystemNotificationManager::HandleMountCompletedEvent(
MountCompletedEvent& event,
const Volume& volume) {
NotificationPtr notification;
switch (event.event_type) {
case fmp::MountCompletedEventType::kMount:
if (event.should_notify) {
notification = MakeRemovableNotification(event, volume);
}
break;
case fmp::MountCompletedEventType::kUnmount:
GetNotificationDisplayService()->Close(
NotificationHandler::Type::TRANSIENT, kRemovableNotificationId);
if (volume.device_type() != ash::DeviceType::kUnknown &&
!volume.storage_device_path().empty()) {
UpdateDeviceMountStatus(event, volume);
}
break;
case fmp::MountCompletedEventType::kNone:
default:
VLOG(1) << "Unexpected mount event "
<< base::to_underlying(event.event_type);
break;
}
if (notification) {
GetNotificationDisplayService()->Display(
NotificationHandler::Type::TRANSIENT, *notification,
/*metadata=*/nullptr);
}
}
NotificationDisplayService*
SystemNotificationManager::GetNotificationDisplayService() {
return NotificationDisplayServiceFactory::GetForProfile(profile_);
}
void SystemNotificationManager::SetDriveFSEventRouter(
DriveFsEventRouter* drivefs_event_router) {
drivefs_event_router_ = drivefs_event_router;
}
void SystemNotificationManager::SetIOTaskController(
IOTaskController* io_task_controller) {
io_task_controller_ = io_task_controller;
}
} // namespace file_manager
Codebase Browser
chromium