// Copyright 2018 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/power/power_notification_controller.h"

#include <memory>

#include "ash/constants/ash_features.h"
#include "ash/constants/ash_pref_names.h"
#include "ash/constants/ash_switches.h"
#include "ash/constants/notifier_catalogs.h"
#include "ash/public/cpp/notification_utils.h"
#include "ash/resources/vector_icons/vector_icons.h"
#include "ash/shell.h"
#include "ash/strings/grit/ash_strings.h"
#include "ash/system/power/battery_notification.h"
#include "ash/system/power/battery_saver_controller.h"
#include "ash/system/power/dual_role_notification.h"
#include "base/command_line.h"
#include "base/i18n/number_formatting.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/histogram_functions.h"
#include "base/numerics/safe_conversions.h"
#include "base/strings/strcat.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/chromeos/devicetype_utils.h"
#include "ui/message_center/message_center.h"
#include "ui/message_center/public/cpp/notification.h"
#include "ui/message_center/public/cpp/notification_delegate.h"

using message_center::MessageCenter;
using message_center::Notification;

namespace ash {
namespace {

const char kNotifierPower[] = "ash.power";
constexpr base::TimeDelta kCriticalNotificationDurationUpdateInterval =
    base::Seconds(15);

// Informs the PowerNotificationController when a USB notification is closed.
class UsbNotificationDelegate : public message_center::NotificationDelegate {
 public:
  explicit UsbNotificationDelegate(PowerNotificationController* controller)
      : controller_(controller) {}

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

  // Overridden from message_center::NotificationDelegate.
  void Close(bool by_user) override {
    if (by_user) {
      controller_->NotifyUsbNotificationClosedByUser();
    }
  }

 private:
  ~UsbNotificationDelegate() override = default;

  const raw_ptr<PowerNotificationController> controller_;
};

std::string GetNotificationStateString(
    PowerNotificationController::NotificationState notification_state) {
  switch (notification_state) {
    case PowerNotificationController::NOTIFICATION_NONE:
      return "none";
    case PowerNotificationController::NOTIFICATION_BSM_ENABLING_AT_THRESHOLD:
      return "low power - battery saver opt out";
    case PowerNotificationController::NOTIFICATION_BSM_THRESHOLD_OPT_IN:
      return "low power - battery saver opt in";
    case PowerNotificationController::NOTIFICATION_GENERIC_LOW_POWER:
      return "low power";
    case PowerNotificationController::NOTIFICATION_CRITICAL:
      return "critical power";
  }
  NOTREACHED() << "Unknown state " << notification_state;
}

void LogBattery(PowerNotificationController::NotificationState state,
                double battery_percent,
                bool is_usb_charger_connected) {
  VLOG(1) << "Showing " << GetNotificationStateString(state)
          << " notification. "
          << (is_usb_charger_connected ? "USB charger is connected." : "")
          << "Battery percentage: " << battery_percent << "%.";
}

void LogBatteryForNoCharger(
    PowerNotificationController::NotificationState state,
    int remaining_minutes) {
  VLOG(1) << "Showing " << GetNotificationStateString(state)
          << " notification. No charger connected."
          << " Remaining time: " << remaining_minutes << " minutes.";
}

std::string CriticalNotificationOutcomeToString(
    PowerNotificationController::CriticalNotificationOutcome outcome) {
  switch (outcome) {
    case PowerNotificationController::CriticalNotificationOutcome::Crashed:
      return "Crashed";
    case PowerNotificationController::CriticalNotificationOutcome::
        LowBatteryShutdown:
      return "LowBatteryShutdown";
    case PowerNotificationController::CriticalNotificationOutcome::
        NotificationShown:
      return "NotificationShown";
    case PowerNotificationController::CriticalNotificationOutcome::PluggedIn:
      return "PluggedIn";
    case PowerNotificationController::CriticalNotificationOutcome::Suspended:
      return "Suspended";
    case PowerNotificationController::CriticalNotificationOutcome::UserShutdown:
      return "UserShutdown";
  }
}

// Record remaining battery time in second when notification is shown for
// critical state.
void RecordTimeToEmptyForCriticalState(base::TimeDelta remaining_time) {
  // Use the custom counts function instead of custom times so we can record in
  // seconds instead of milliseconds. The max bucket is 10 minutes.
  base::UmaHistogramCustomCounts(
      "Ash.PowerNotification.TimeToEmptyForCritialState",
      remaining_time.InSeconds(),
      /*min=*/1,
      /*exclusive_max=*/base::Minutes(10).InSeconds(),
      /*buckets=*/100);
}

// Record remaining battery time in second when the device transitions from a
// critical state to charging state upon connecting the charger.
void RecordTimeToEmptyPluggedIn(
    const std::optional<base::TimeDelta> remaining_time) {
  if (!remaining_time.has_value()) {
    return;
  }
  base::UmaHistogramCustomCounts("Ash.PowerNotification.TimeToEmptyPluggedIn",
                                 remaining_time->InSeconds(),
                                 /*min=*/0,
                                 /*exclusive_max=*/base::Hours(1).InSeconds(),
                                 /*buckets=*/100);
}

void RecordCriticalNotificationOutcome(
    PowerNotificationController::CriticalNotificationOutcome outcome,
    base::TimeDelta duration) {
  base::UmaHistogramEnumeration(
      "Ash.PowerNotification.CriticalNotificationOutcome", outcome);
  base::UmaHistogramCustomCounts(
      base::StrCat(
          {"Ash.PowerNotification.CriticalNotificationToOutcomeDuration.",
           CriticalNotificationOutcomeToString(outcome)}),
      duration.InSeconds(),
      /*min=*/0,
      /*exclusive_max=*/base::Hours(1).InSeconds(),
      /*buckets=*/100);
}

}  // namespace

const char PowerNotificationController::kUsbNotificationId[] = "usb-charger";

PowerNotificationController::PowerNotificationController(
    message_center::MessageCenter* message_center)
    : message_center_(message_center),
      battery_saver_activation_charge_percent_(
          features::kBatterySaverActivationChargePercent.Get()),
      critical_percentage_(5),
      low_power_percentage_(battery_saver_activation_charge_percent_),
      no_warning_percentage_(low_power_percentage_ + 5) {
  if (Shell::HasInstance()) {
    shell_observation_.Observe(ash::Shell::Get());
  }
  chromeos::PowerManagerClient::Get()->AddObserver(this);
  PowerStatus::Get()->AddObserver(this);

  local_state_ = Shell::Get()->local_state();
  if (local_state_ && local_state_->GetTimeDelta(
                          prefs::kCriticalStateDuration) != base::TimeDelta()) {
    // This indicates the device does not undergo a graceful shutdown last time,
    // because pref is not reset.
    RecordCriticalNotificationOutcome(
        PowerNotificationController::CriticalNotificationOutcome::Crashed,
        local_state_->GetTimeDelta(prefs::kCriticalStateDuration));
  }
  ResetCriticalNotificationTimestamp();
}

PowerNotificationController::~PowerNotificationController() {
  PowerStatus::Get()->RemoveObserver(this);
  chromeos::PowerManagerClient::Get()->RemoveObserver(this);
  message_center_->RemoveNotification(kUsbNotificationId, false);
}

// static
void PowerNotificationController::RegisterLocalStatePrefs(
    PrefRegistrySimple* registry) {
  registry->RegisterTimeDeltaPref(prefs::kCriticalStateDuration,
                                  base::TimeDelta());
}

void PowerNotificationController::SetUserOptStatus(bool status) {
  user_opt_status_ = status;
}

void PowerNotificationController::OnPowerStatusChanged() {
  bool battery_alert = UpdateNotificationState();

  // Factory testing may place the battery into unusual states.
  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
          switches::kAshHideNotificationsForFactory)) {
    return;
  }

  MaybeShowUsbChargerNotification();
  MaybeShowDualRoleNotification();

  if (battery_alert) {
    // Remove any existing notification so it's dismissed before adding a new
    // one. Otherwise we might update a "low battery" notification to "critical"
    // without it being shown again.
    battery_notification_.reset();
    battery_notification_ =
        std::make_unique<BatteryNotification>(message_center_, this);
    if (notification_state_ == NOTIFICATION_CRITICAL &&
        !PowerStatus::Get()->IsLinePowerConnected()) {
      critical_notification_shown_time_ = base::TimeTicks::Now();
      StartPeriodicUpdate();
      // Record NotificationShown outcome each time to avoid cross-metric
      // comparison; its count should be greater than or equal to the sum of
      // other outcomes.
      base::UmaHistogramEnumeration(
          "Ash.PowerNotification.CriticalNotificationOutcome",
          PowerNotificationController::CriticalNotificationOutcome::
              NotificationShown);
    }
  } else if (notification_state_ == NOTIFICATION_NONE) {
    battery_notification_.reset();
    if (PluggedInCriticalState()) {
      RecordTimeToEmptyPluggedIn(
          remaining_time_to_empty_from_critical_state_.value());
      MaybeRecordCriticalNotificationOutcome(
          PowerNotificationController::CriticalNotificationOutcome::PluggedIn,
          base::TimeTicks::Now() - critical_notification_shown_time_);
    }
  } else if (battery_notification_.get()) {
    battery_notification_->Update();
  }

  battery_was_full_ = PowerStatus::Get()->IsBatteryFull();
  usb_charger_was_connected_ = PowerStatus::Get()->IsUsbChargerConnected();
  line_power_was_connected_ = PowerStatus::Get()->IsLinePowerConnected();
  remaining_time_to_empty_from_critical_state_ =
      PowerStatus::Get()->GetBatteryTimeToEmpty();
  was_in_critical_state_ = GetNotificationState() == NOTIFICATION_CRITICAL;
}

void PowerNotificationController::SuspendImminent(
    power_manager::SuspendImminent::Reason reason) {
  MaybeRecordCriticalNotificationOutcome(
      PowerNotificationController::CriticalNotificationOutcome::Suspended,
      base::TimeTicks::Now() - critical_notification_shown_time_);
}

void PowerNotificationController::ShutdownRequested(
    power_manager::RequestShutdownReason reason) {
  if (reason ==
      power_manager::RequestShutdownReason::REQUEST_SHUTDOWN_FOR_USER) {
    MaybeRecordCriticalNotificationOutcome(
        PowerNotificationController::CriticalNotificationOutcome::UserShutdown,
        base::TimeTicks::Now() - critical_notification_shown_time_);
  }
  ResetCriticalNotificationTimestamp();
}

void PowerNotificationController::RestartRequested(
    power_manager::RequestRestartReason reason) {
  ResetCriticalNotificationTimestamp();
}

void PowerNotificationController::OnShellDestroying() {
  // User-initiated shutdowns are recorded separately in `ShutdownRequested`,
  // for powred initiated shutdown, it will be recorded in`OnShellDestroying`.
  MaybeRecordCriticalNotificationOutcome(
      PowerNotificationController::CriticalNotificationOutcome::
          LowBatteryShutdown,
      base::TimeTicks::Now() - critical_notification_shown_time_);
  shell_observation_.Reset();
}

bool PowerNotificationController::MaybeShowUsbChargerNotification() {
  const PowerStatus& status = *PowerStatus::Get();

  // We show the notification if a USB charger is connected but the battery
  // isn't full (since some ECs may choose to use a lower power rail when the
  // battery is full even when a high-power charger is connected).
  const bool show = status.IsUsbChargerConnected() && !status.IsBatteryFull();

  // Check if the notification needs to be created.
  if (show && !usb_charger_was_connected_ && !usb_notification_dismissed_) {
    bool on_battery = PowerStatus::Get()->IsBatteryPresent();
    std::unique_ptr<Notification> notification = CreateSystemNotificationPtr(
        message_center::NOTIFICATION_TYPE_SIMPLE, kUsbNotificationId,
        l10n_util::GetStringUTF16(
            on_battery ? IDS_ASH_STATUS_TRAY_LOW_POWER_CHARGER_TITLE
                       : IDS_ASH_STATUS_TRAY_LOW_POWER_ADAPTER_TITLE),
        on_battery
            ? ui::SubstituteChromeOSDeviceType(
                  IDS_ASH_STATUS_TRAY_LOW_POWER_CHARGER_MESSAGE_SHORT)
            : l10n_util::GetStringFUTF16(
                  IDS_ASH_STATUS_TRAY_LOW_POWER_ADAPTER_MESSAGE_SHORT,
                  ui::GetChromeOSDeviceName(),
                  base::FormatDouble(
                      PowerStatus::Get()->GetPreferredMinimumPower(), 0)),
        std::u16string(), GURL(),
        message_center::NotifierId(
            message_center::NotifierType::SYSTEM_COMPONENT, kNotifierPower,
            on_battery ? NotificationCatalogName::kLowPowerCharger
                       : NotificationCatalogName::kLowPowerAdapter),
        message_center::RichNotificationData(),
        new UsbNotificationDelegate(this), kNotificationLowPowerChargerIcon,
        message_center::SystemNotificationWarningLevel::WARNING);
    notification->set_pinned(on_battery);
    notification->set_never_timeout(!on_battery);
    message_center_->AddNotification(std::move(notification));
    return true;
  }

  if (!show && usb_charger_was_connected_ && !battery_was_full_) {
    // USB charger was unplugged or identified as a different type or battery
    // reached the full state while the notification was showing.
    message_center_->RemoveNotification(kUsbNotificationId, false);
    if (!status.IsLinePowerConnected()) {
      usb_notification_dismissed_ = false;
    }
    return true;
  }

  return false;
}

void PowerNotificationController::MaybeShowDualRoleNotification() {
  const PowerStatus& status = *PowerStatus::Get();
  if (!status.HasDualRoleDevices()) {
    dual_role_notification_.reset();
    return;
  }

  if (!dual_role_notification_) {
    dual_role_notification_ =
        std::make_unique<DualRoleNotification>(message_center_);
  }
  dual_role_notification_->Update();
}

std::optional<bool>
PowerNotificationController::HandleBatterySaverNotifications() {
  const PowerStatus& status = *PowerStatus::Get();

  const bool on_AC_power = status.IsMainsChargerConnected();
  const bool on_USB_power = status.IsUsbChargerConnected();
  const double rounded_battery_percent = status.GetRoundedBatteryPercent();

  const bool below_threshold =
      rounded_battery_percent <= battery_saver_activation_charge_percent_;
  const bool threshold_conditions_met =
      !on_AC_power && below_threshold && !battery_saver_triggered_;

  const bool no_notification_currently_showing =
      notification_state_ == NOTIFICATION_NONE;

  // Notification State Machine based on opt-in/out experiment arms.
  switch (features::kBatterySaverNotificationBehavior.Get()) {
    case features::kBSMAutoEnable:
      // Auto Enable when either the battery percentage is at the low power
      // threshold (~20%).
      if (threshold_conditions_met) {
        battery_saver_triggered_ = true;
        const bool was_active = PowerStatus::Get()->IsBatterySaverActive();
        Shell::Get()->battery_saver_controller()->ClearBatterySaverModeToast();

        // If user_opt_status_ is false in this branch, the user wants bsm
        // auto-enabled (or rather, hasn't explicitly opt-ed out).
        if (!user_opt_status_) {
          Shell::Get()->battery_saver_controller()->SetState(
              true, BatterySaverController::UpdateReason::kThreshold);

          // Show enable toast if previously not active, then activated, in the
          // critical percentage range.
          if (!was_active && (rounded_battery_percent <= critical_percentage_ ||
                              on_USB_power)) {
            Shell::Get()
                ->battery_saver_controller()
                ->ShowBatterySaverModeEnabledToast();
          }
        }

        // Send appropriate notification at
        // `battery_saver_activation_charge_percent_` battery percentage or
        // update the notification state if we're on USB power.
        if (no_notification_currently_showing || on_USB_power) {
          // If enabled previously or the user doesn't want it to be on
          // Send the appropriate notification.
          if (rounded_battery_percent <= critical_percentage_) {
            notification_state_ =
                PowerNotificationController::NOTIFICATION_CRITICAL;
          } else {
            notification_state_ =
                (was_active || user_opt_status_)
                    ? PowerNotificationController::
                          NOTIFICATION_GENERIC_LOW_POWER
                    : PowerNotificationController::
                          NOTIFICATION_BSM_ENABLING_AT_THRESHOLD;
          }

          // Only send a new notification is there isn't one already displayed.
          return no_notification_currently_showing;
        }
      }
      break;
    case features::kBSMOptIn:
      // Ask the user to manually enable battery saver mode at the low power
      // threshold (~20%).
      if (threshold_conditions_met) {
        battery_saver_triggered_ = true;
        const bool was_active = PowerStatus::Get()->IsBatterySaverActive();
        Shell::Get()->battery_saver_controller()->ClearBatterySaverModeToast();

        // If user_opt_status_ is true, then the user wants battery saver on.
        if (user_opt_status_) {
          Shell::Get()->battery_saver_controller()->SetState(
              true, BatterySaverController::UpdateReason::kThreshold);

          // Show enable toast if previously not active, then activated.
          if (!was_active) {
            Shell::Get()
                ->battery_saver_controller()
                ->ShowBatterySaverModeEnabledToast();
          }
        }

        // Send Opt-In Notification at
        // `battery_saver_activation_charge_percent_` battery percentage or
        // update the notification state if we're on USB power.
        if (no_notification_currently_showing || on_USB_power) {
          if (rounded_battery_percent <= critical_percentage_) {
            notification_state_ =
                PowerNotificationController::NOTIFICATION_CRITICAL;
          } else {
            notification_state_ = (was_active || user_opt_status_)
                                      ? PowerNotificationController::
                                            NOTIFICATION_GENERIC_LOW_POWER
                                      : PowerNotificationController::
                                            NOTIFICATION_BSM_THRESHOLD_OPT_IN;
          }
          return no_notification_currently_showing;
        }
      }
      break;
    default:
      break;
  }

  return std::nullopt;
}

void PowerNotificationController::MaybeRecordCriticalNotificationOutcome(
    PowerNotificationController::CriticalNotificationOutcome outcome,
    base::TimeDelta duration) {
  if (critical_notification_shown_time_ == base::TimeTicks()) {
    return;
  }

  RecordCriticalNotificationOutcome(outcome, duration);
  ResetCriticalNotificationTimestamp();
}

bool PowerNotificationController::UpdateNotificationState() {
  const PowerStatus& status = *PowerStatus::Get();
  const bool on_AC_power = status.IsMainsChargerConnected();
  const bool on_USB_power = status.IsUsbChargerConnected();

  // When charging, we clear the previous notification, and disable battery
  // saver. This means when we unplug the charger (under the threshold), we want
  // to resend the notification.
  if (on_AC_power || on_USB_power) {
    battery_saver_triggered_ = false;
  }

  // Battery Saver Notification doesn't have a time remaining text, so send
  // the notification + turn on battery saver right away.
  if (!status.IsBatteryPresent() ||
      (!IsBatterySaverAllowed() && status.IsBatteryTimeBeingCalculated()) ||
      on_AC_power) {
    notification_state_ = NOTIFICATION_NONE;
    return false;
  }

  // Send different notifications if Battery Saver flag is allowed.
  if (IsBatterySaverAllowed()) {
    const double rounded_battery_percent = status.GetRoundedBatteryPercent();
    const bool on_line_power = status.IsLinePowerConnected();

    // Reset threshold when charging and percent remaining goes above the
    // threshold.
    if ((on_AC_power || on_USB_power || on_line_power) &&
        rounded_battery_percent > battery_saver_activation_charge_percent_) {
      battery_saver_triggered_ = false;
    }

    // Check if we are supposed to send a battery saver notification.
    std::optional<bool> should_update = HandleBatterySaverNotifications();
    return should_update != std::nullopt
               ? should_update.value()
               : UpdateNotificationStateForRemainingPercentageBatterySaver();
  }

  return status.IsUsbChargerConnected()
             ? UpdateNotificationStateForRemainingPercentage()
             : UpdateNotificationStateForRemainingTime();
}

bool PowerNotificationController::UpdateNotificationStateForRemainingTime() {
  const std::optional<base::TimeDelta> remaining_time =
      PowerStatus::Get()->GetBatteryTimeToEmpty();

  // Check that powerd actually provided an estimate. It doesn't if the battery
  // current is so close to zero that the estimate would be huge.
  if (!remaining_time) {
    notification_state_ = NOTIFICATION_NONE;
    return false;
  }

  // The notification includes a rounded minutes value, so round the estimate
  // received from the power manager to match.
  const int remaining_minutes =
      base::ClampRound(*remaining_time / base::Minutes(1));

  if (remaining_minutes >= kNoWarningMinutes ||
      PowerStatus::Get()->IsBatteryFull()) {
    notification_state_ = NOTIFICATION_NONE;
    return false;
  }

  switch (notification_state_) {
    case NOTIFICATION_NONE:
      if (remaining_minutes <= kCriticalMinutes) {
        notification_state_ = NOTIFICATION_CRITICAL;
        LogBatteryForNoCharger(notification_state_, remaining_minutes);
        RecordTimeToEmptyForCriticalState(remaining_time.value());
        return true;
      }
      if (remaining_minutes <= kLowPowerMinutes) {
        notification_state_ = NOTIFICATION_BSM_THRESHOLD_OPT_IN;
        LogBatteryForNoCharger(notification_state_, remaining_minutes);
        return true;
      }
      return false;
    // Essentially Low Power Notification State.
    case NOTIFICATION_BSM_ENABLING_AT_THRESHOLD:
    case NOTIFICATION_BSM_THRESHOLD_OPT_IN:
    case NOTIFICATION_GENERIC_LOW_POWER:
      if (remaining_minutes <= kCriticalMinutes) {
        notification_state_ = NOTIFICATION_CRITICAL;
        LogBatteryForNoCharger(notification_state_, remaining_minutes);
        RecordTimeToEmptyForCriticalState(remaining_time.value());
        return true;
      }
      return false;
    case NOTIFICATION_CRITICAL:
      return false;
  }
  NOTREACHED();
}

bool PowerNotificationController::
    UpdateNotificationStateForRemainingPercentage() {
  // The notification includes a rounded percentage, so round the value received
  // from the power manager to match.
  const int remaining_percentage =
      PowerStatus::Get()->GetRoundedBatteryPercent();

  if (remaining_percentage >= kNoWarningPercentage ||
      PowerStatus::Get()->IsBatteryFull()) {
    notification_state_ = NOTIFICATION_NONE;
    return false;
  }

  switch (notification_state_) {
    case NOTIFICATION_NONE:
      if (remaining_percentage <= kCriticalPercentage) {
        notification_state_ = NOTIFICATION_CRITICAL;
        LogBattery(notification_state_, remaining_percentage, true);
        return true;
      }
      if (remaining_percentage <= kLowPowerPercentage) {
        notification_state_ = NOTIFICATION_BSM_THRESHOLD_OPT_IN;
        LogBattery(notification_state_, remaining_percentage, true);
        return true;
      }
      return false;
    case NOTIFICATION_BSM_ENABLING_AT_THRESHOLD:
    case NOTIFICATION_BSM_THRESHOLD_OPT_IN:
    case NOTIFICATION_GENERIC_LOW_POWER:
      if (remaining_percentage <= kCriticalPercentage) {
        notification_state_ = NOTIFICATION_CRITICAL;
        LogBattery(notification_state_, remaining_percentage, true);
        return true;
      }
      return false;
    case NOTIFICATION_CRITICAL:
      return false;
  }
  NOTREACHED();
}

bool PowerNotificationController::
    UpdateNotificationStateForRemainingPercentageBatterySaver() {
  const PowerStatus* status = PowerStatus::Get();
  const double rounded_battery_percent = status->GetRoundedBatteryPercent();

  if (rounded_battery_percent >= no_warning_percentage_ ||
      status->IsBatteryFull()) {
    notification_state_ = NOTIFICATION_NONE;
    return false;
  }

  switch (notification_state_) {
    case NOTIFICATION_NONE:
      if (rounded_battery_percent <= critical_percentage_) {
        notification_state_ = NOTIFICATION_CRITICAL;
        LogBattery(notification_state_, rounded_battery_percent,
                   status->IsUsbChargerConnected());
        return true;
      }
      if (rounded_battery_percent <= low_power_percentage_) {
        notification_state_ =
            features::kBatterySaverNotificationBehavior.Get() ==
                    features::kBSMAutoEnable
                ? NOTIFICATION_BSM_ENABLING_AT_THRESHOLD
                : NOTIFICATION_BSM_THRESHOLD_OPT_IN;
        LogBattery(notification_state_, rounded_battery_percent,
                   status->IsUsbChargerConnected());
        return true;
      }
      return false;
    case NOTIFICATION_BSM_ENABLING_AT_THRESHOLD:
    case NOTIFICATION_BSM_THRESHOLD_OPT_IN:
    case NOTIFICATION_GENERIC_LOW_POWER:
      if (rounded_battery_percent <= critical_percentage_) {
        notification_state_ = NOTIFICATION_CRITICAL;
        LogBattery(notification_state_, rounded_battery_percent,
                   status->IsUsbChargerConnected());
        return true;
      }
      return false;
    case NOTIFICATION_CRITICAL:
      return false;
  }
  NOTREACHED();
}

void PowerNotificationController::NotifyUsbNotificationClosedByUser() {
  usb_notification_dismissed_ = true;
}

bool PowerNotificationController::PluggedInCriticalState() {
  bool line_power_is_connected = PowerStatus::Get()->IsLinePowerConnected();
  return was_in_critical_state_ && !line_power_was_connected_ &&
         line_power_is_connected;
}

void PowerNotificationController::StartPeriodicUpdate() {
  timer_.Start(
      FROM_HERE, kCriticalNotificationDurationUpdateInterval, this,
      &PowerNotificationController::UpdateCriticalNotificationDurationPrefs);
}

void PowerNotificationController::ResetCriticalNotificationTimestamp() {
  if (timer_.IsRunning()) {
    timer_.Stop();
  }
  critical_notification_shown_time_ = base::TimeTicks();
  if (local_state_) {
    local_state_->ClearPref(prefs::kCriticalStateDuration);
  }
}

void PowerNotificationController::UpdateCriticalNotificationDurationPrefs() {
  local_state_->SetTimeDelta(
      prefs::kCriticalStateDuration,
      base::TimeTicks::Now() - critical_notification_shown_time_);
}

}  // namespace ash