ash / display / resolution_notification_controller.cc [blame]

// Copyright 2013 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/display/resolution_notification_controller.h"

#include <utility>

#include "ash/display/display_change_dialog.h"
#include "ash/display/display_util.h"
#include "ash/public/cpp/notification_utils.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/session/session_controller_impl.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/system/screen_layout_observer.h"
#include "base/functional/bind.h"
#include "base/strings/utf_string_conversions.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/display/display_features.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/manager/managed_display_info.h"
#include "ui/display/util/display_util.h"

namespace ash {

struct ResolutionNotificationController::ResolutionChangeInfo {
  ResolutionChangeInfo(int64_t display_id,
                       const display::ManagedDisplayMode& old_resolution,
                       const display::ManagedDisplayMode& new_resolution,
                       base::OnceClosure accept_callback);

  ResolutionChangeInfo(const ResolutionChangeInfo&) = delete;
  ResolutionChangeInfo& operator=(const ResolutionChangeInfo&) = delete;

  ~ResolutionChangeInfo();

  // The id of the display where the resolution change happens.
  const int64_t display_id;

  // The resolution before the change.
  display::ManagedDisplayMode old_resolution;

  // The requested resolution. Note that this may be different from
  // |current_resolution| which is the actual resolution set.
  display::ManagedDisplayMode new_resolution;

  // The actual resolution after the change.
  display::ManagedDisplayMode current_resolution;

  // The callback when accept is chosen.
  base::OnceClosure accept_callback;
};

ResolutionNotificationController::ResolutionChangeInfo::ResolutionChangeInfo(
    int64_t display_id,
    const display::ManagedDisplayMode& old_resolution,
    const display::ManagedDisplayMode& new_resolution,
    base::OnceClosure accept_callback)
    : display_id(display_id),
      old_resolution(old_resolution),
      new_resolution(new_resolution),
      accept_callback(std::move(accept_callback)) {}

ResolutionNotificationController::ResolutionChangeInfo::
    ~ResolutionChangeInfo() = default;

ResolutionNotificationController::ResolutionNotificationController() {
  Shell::Get()->display_manager()->AddDisplayManagerObserver(this);
}

ResolutionNotificationController::~ResolutionNotificationController() {
  Shell::Get()->display_manager()->RemoveDisplayManagerObserver(this);
}

bool ResolutionNotificationController::PrepareNotificationAndSetDisplayMode(
    int64_t display_id,
    const display::ManagedDisplayMode& old_resolution,
    const display::ManagedDisplayMode& new_resolution,
    crosapi::mojom::DisplayConfigSource source,
    base::OnceClosure accept_callback) {
  Shell::Get()->screen_layout_observer()->SetDisplayChangedFromSettingsUI(
      display_id);
  display::DisplayManager* const display_manager =
      Shell::Get()->display_manager();
  if (source == crosapi::mojom::DisplayConfigSource::kPolicy ||
      display::IsInternalDisplayId(display_id)) {
    // We don't show notifications to confirm/revert the resolution change in
    // the case of an internal display or policy-forced changes.
    return display_manager->SetDisplayMode(display_id, new_resolution);
  }

  // If multiple resolution changes are invoked for the same display,
  // the original resolution for the first resolution change has to be used
  // instead of the specified |old_resolution|.
  display::ManagedDisplayMode original_resolution;
  if (change_info_ && change_info_->display_id == display_id) {
    DCHECK_EQ(change_info_->new_resolution.size(), old_resolution.size());
    original_resolution = change_info_->old_resolution;
  }

  if (change_info_ && change_info_->display_id != display_id) {
    // Preparing the notification for a new resolution change of another display
    // before the previous one was accepted. We decided that it's safer to
    // revert the previous resolution change since the user didn't explicitly
    // accept it, and we have no way of knowing for sure that it worked.
    RevertResolutionChange(false /* display_was_removed */);
  }

  change_info_ = std::make_unique<ResolutionChangeInfo>(
      display_id, old_resolution, new_resolution, std::move(accept_callback));
  if (!original_resolution.size().IsEmpty()) {
    change_info_->old_resolution = original_resolution;
  }

  if (!display_manager->SetDisplayMode(display_id, new_resolution)) {
    // Discard the prepared notification data since we failed to set the new
    // resolution.
    change_info_.reset();
    return false;
  }

  return true;
}

bool ResolutionNotificationController::ShouldShowDisplayChangeDialog() const {
  return change_info_ && Shell::Get()->session_controller()->login_status() !=
                             LoginStatus::KIOSK_APP;
}

void ResolutionNotificationController::CreateOrReplaceModalDialog() {
  if (confirmation_dialog_) {
    confirmation_dialog_->GetWidget()->CloseNow();
  }

  if (!ShouldShowDisplayChangeDialog()) {
    return;
  }

  const std::u16string display_name =
      base::UTF8ToUTF16(Shell::Get()->display_manager()->GetDisplayNameForId(
          change_info_->display_id));
  const std::u16string actual_display_size =
      base::UTF8ToUTF16(change_info_->current_resolution.size().ToString());
  const std::u16string requested_display_size =
      base::UTF8ToUTF16(change_info_->new_resolution.size().ToString());

  std::u16string dialog_title =
      l10n_util::GetStringUTF16(IDS_ASH_RESOLUTION_CHANGE_DIALOG_TITLE);

  // Construct the timeout message, leaving a placeholder for the countdown
  // timer so that the string does not need to be completely rebuilt every
  // timer tick.
  constexpr char16_t kTimeoutPlaceHolder[] = u"$1";

  std::u16string timeout_message_with_placeholder;
  if (display::features::IsListAllDisplayModesEnabled()) {
    const std::u16string actual_refresh_rate = ConvertRefreshRateToString16(
        change_info_->current_resolution.refresh_rate());
    const std::u16string requested_refresh_rate = ConvertRefreshRateToString16(
        change_info_->new_resolution.refresh_rate());

    const bool no_fallback = actual_display_size == requested_display_size &&
                             actual_refresh_rate == requested_refresh_rate;

    dialog_title =
        no_fallback
            ? l10n_util::GetStringUTF16(
                  IDS_ASH_RESOLUTION_REFRESH_CHANGE_DIALOG_TITLE_SUCCESS)
            : l10n_util::GetStringUTF16(
                  IDS_ASH_RESOLUTION_REFRESH_CHANGE_DIALOG_TITLE_FALLBACK);

    timeout_message_with_placeholder =
        no_fallback ? l10n_util::GetStringFUTF16(
                          IDS_ASH_RESOLUTION_REFRESH_CHANGE_DIALOG_CHANGED_NEW,
                          display_name, actual_display_size,
                          actual_refresh_rate, kTimeoutPlaceHolder)
                    : l10n_util::GetStringFUTF16(
                          IDS_ASH_RESOLUTION_REFRESH_CHANGE_DIALOG_FALLBACK_NEW,
                          {display_name, actual_display_size,
                           actual_refresh_rate, requested_display_size,
                           requested_refresh_rate, kTimeoutPlaceHolder},
                          /*offsets=*/nullptr);

  } else {
    timeout_message_with_placeholder =
        actual_display_size == requested_display_size
            ? l10n_util::GetStringFUTF16(
                  IDS_ASH_RESOLUTION_CHANGE_DIALOG_CHANGED, display_name,
                  actual_display_size, kTimeoutPlaceHolder)
            : l10n_util::GetStringFUTF16(
                  IDS_ASH_RESOLUTION_CHANGE_DIALOG_FALLBACK, display_name,
                  requested_display_size, actual_display_size,
                  kTimeoutPlaceHolder);
  }

  DisplayChangeDialog* dialog = new DisplayChangeDialog(
      std::move(dialog_title), std::move(timeout_message_with_placeholder),
      base::BindOnce(&ResolutionNotificationController::AcceptResolutionChange,
                     weak_factory_.GetWeakPtr()),
      base::BindOnce(&ResolutionNotificationController::RevertResolutionChange,
                     weak_factory_.GetWeakPtr()));
  confirmation_dialog_ = dialog->GetWeakPtr();
}

void ResolutionNotificationController::AcceptResolutionChange() {
  if (!change_info_) {
    return;
  }
  base::OnceClosure callback = std::move(change_info_->accept_callback);
  change_info_.reset();
  std::move(callback).Run();
}

void ResolutionNotificationController::RevertResolutionChange(
    bool display_was_removed) {
  if (!change_info_) {
    return;
  }
  const int64_t display_id = change_info_->display_id;
  display::ManagedDisplayMode old_resolution = change_info_->old_resolution;
  change_info_.reset();
  Shell::Get()->screen_layout_observer()->SetDisplayChangedFromSettingsUI(
      display_id);
  if (display_was_removed) {
    // If display was removed then we are inside the stack of
    // DisplayManager::UpdateDisplaysWith(), and we need to update the selected
    // mode of this removed display without reentering again into
    // UpdateDisplaysWith() because this can cause a crash. crbug.com/709722.
    Shell::Get()->display_manager()->SetSelectedModeForDisplayId(
        display_id, old_resolution);
  } else {
    Shell::Get()->display_manager()->SetDisplayMode(display_id, old_resolution);
  }
}

void ResolutionNotificationController::OnDisplaysRemoved(
    const display::Displays& removed_displays) {
  for (const auto& display : removed_displays) {
    if (change_info_ && change_info_->display_id == display.id()) {
      if (confirmation_dialog_) {
        // Use CloseWithReason rather than CloseNow to make sure the screen
        // doesn't stay dimmed after the widget is closed. b/288485093.
        confirmation_dialog_->GetWidget()->CloseWithReason(
            views::Widget::ClosedReason::kLostFocus);
      }
      RevertResolutionChange(/*display_was_removed=*/true);
      break;
    }
  }
}

void ResolutionNotificationController::OnDidApplyDisplayChanges() {
  if (!change_info_) {
    return;
  }

  display::ManagedDisplayMode mode;
  if (Shell::Get()->display_manager()->GetActiveModeForDisplayId(
          change_info_->display_id, &mode)) {
    change_info_->current_resolution = mode;
  }

  CreateOrReplaceModalDialog();
}

}  // namespace ash