| // Copyright 2022 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/metrics/power/power_metrics.h" |
| |
| #include <string> |
| |
| #include "base/metrics/histogram_functions.h" |
| #include "base/strings/strcat.h" |
| #include "chrome/browser/metrics/power/process_metrics_recorder_util.h" |
| #include "chrome/browser/performance_manager/public/user_tuning/battery_saver_mode_manager.h" |
| |
| namespace { |
| |
| constexpr const char* kBatteryDischargeRateMilliwattsHistogramName = |
| "Power.BatteryDischargeRateMilliwatts6"; |
| constexpr const char* kBatteryDischargeRateRelativeHistogramName = |
| "Power.BatteryDischargeRateRelative5"; |
| constexpr const char* kBatteryDischargeModeHistogramName = |
| "Power.BatteryDischargeMode5"; |
| #if BUILDFLAG(IS_WIN) |
| constexpr const char* kHasPreciseBatteryDischargeGranularity = |
| "Power.HasPreciseBatteryDischargeGranularity"; |
| constexpr const char* kBatteryDischargeRatePreciseMilliwattsHistogramName = |
| "Power.BatteryDischargeRatePreciseMilliwatts"; |
| constexpr const char* kBatteryDischargeRateMilliwattsTenMinutesHistogramName = |
| "Power.BatteryDischargeRateMilliwatts6.TenMinutes"; |
| constexpr const char* kBatteryDischargeModeTenMinutesHistogramName = |
| "Power.BatteryDischargeMode5.TenMinutes"; |
| #endif // BUILDFLAG(IS_WIN) |
| |
| } // namespace |
| |
| void ReportAggregatedProcessMetricsHistograms( |
| const ProcessMonitor::Metrics& aggregated_process_metrics, |
| const std::vector<const char*>& suffixes) { |
| for (const char* suffix : suffixes) { |
| std::string complete_suffix = base::StrCat({"Total", suffix}); |
| RecordProcessHistograms(complete_suffix.c_str(), |
| aggregated_process_metrics); |
| } |
| } |
| |
| int64_t CalculateDischargeRateMilliwatts( |
| const base::BatteryLevelProvider::BatteryState& previous_battery_state, |
| const base::BatteryLevelProvider::BatteryState& new_battery_state, |
| base::TimeDelta interval_duration) { |
| DCHECK(previous_battery_state.charge_unit.has_value()); |
| DCHECK(new_battery_state.charge_unit.has_value()); |
| DCHECK_EQ(previous_battery_state.charge_unit.value(), |
| new_battery_state.charge_unit.value()); |
| |
| const int64_t discharge_capacity = |
| (new_battery_state.full_charged_capacity.value() - |
| new_battery_state.current_capacity.value()) - |
| (previous_battery_state.full_charged_capacity.value() - |
| previous_battery_state.current_capacity.value()); |
| |
| const int64_t discharge_capacity_mwh = [&]() -> int64_t { |
| if (new_battery_state.charge_unit.value() == |
| base::BatteryLevelProvider::BatteryLevelUnit::kMWh) { |
| return discharge_capacity; |
| } |
| |
| DCHECK_EQ(new_battery_state.charge_unit.value(), |
| base::BatteryLevelProvider::BatteryLevelUnit::kMAh); |
| const uint64_t average_mv = (previous_battery_state.voltage_mv.value() + |
| new_battery_state.voltage_mv.value()) / |
| 2; |
| return discharge_capacity * average_mv / 1000; |
| }(); |
| |
| // The capacity is in mWh. Divide by hours to get mW. Note that there is no |
| // InHoursF() method. |
| const double interval_duration_in_hours = |
| interval_duration.InSecondsF() / base::Time::kSecondsPerHour; |
| |
| return discharge_capacity_mwh / interval_duration_in_hours; |
| } |
| |
| int64_t CalculateDischargeRateRelative( |
| const base::BatteryLevelProvider::BatteryState& previous_battery_state, |
| const base::BatteryLevelProvider::BatteryState& new_battery_state, |
| base::TimeDelta interval_duration) { |
| // The battery discharge rate is reported per minute with 1/10000 of full |
| // charge resolution. |
| static constexpr int64_t kDischargeRateFactor = 10000; |
| |
| const double previous_level = |
| static_cast<double>(previous_battery_state.current_capacity.value()) / |
| previous_battery_state.full_charged_capacity.value(); |
| const double new_level = |
| static_cast<double>(new_battery_state.current_capacity.value()) / |
| new_battery_state.full_charged_capacity.value(); |
| |
| const double interval_duration_in_minutes = |
| interval_duration.InSecondsF() / base::Time::kSecondsPerMinute; |
| |
| return (previous_level - new_level) * kDischargeRateFactor / |
| interval_duration_in_minutes; |
| } |
| |
| BatteryDischarge GetBatteryDischargeDuringInterval( |
| const std::optional<base::BatteryLevelProvider::BatteryState>& |
| previous_battery_state, |
| const std::optional<base::BatteryLevelProvider::BatteryState>& |
| new_battery_state, |
| base::TimeDelta interval_duration) { |
| if (!previous_battery_state.has_value() || !new_battery_state.has_value()) { |
| return {BatteryDischargeMode::kRetrievalError, std::nullopt}; |
| } |
| if (previous_battery_state->is_external_power_connected != |
| new_battery_state->is_external_power_connected || |
| previous_battery_state->battery_count != |
| new_battery_state->battery_count) { |
| return {BatteryDischargeMode::kStateChanged, std::nullopt}; |
| } |
| if (new_battery_state->battery_count == 0) { |
| return {BatteryDischargeMode::kNoBattery, std::nullopt}; |
| } |
| if (new_battery_state->is_external_power_connected) { |
| return {BatteryDischargeMode::kPluggedIn, std::nullopt}; |
| } |
| if (new_battery_state->battery_count > 1) { |
| return {BatteryDischargeMode::kMultipleBatteries, std::nullopt}; |
| } |
| if ((previous_battery_state->charge_unit == |
| base::BatteryLevelProvider::BatteryLevelUnit::kRelative) || |
| (new_battery_state->charge_unit == |
| base::BatteryLevelProvider::BatteryLevelUnit::kRelative)) { |
| return {BatteryDischargeMode::kInsufficientResolution, std::nullopt}; |
| } |
| |
| // TODO(crbug.com/40756364): Change CHECK to DCHECK in October 2022 after |
| // verifying that there are no crash reports. |
| CHECK(previous_battery_state->current_capacity.has_value()); |
| CHECK(previous_battery_state->full_charged_capacity.has_value()); |
| CHECK(new_battery_state->current_capacity.has_value()); |
| CHECK(new_battery_state->full_charged_capacity.has_value()); |
| |
| #if BUILDFLAG(IS_MAC) |
| // On MacOS, empirical evidence has shown that right after a full charge, the |
| // current capacity stays equal to the maximum capacity for several minutes, |
| // despite the fact that power was definitely consumed. Reporting a zero |
| // discharge rate for this duration would be misleading. |
| if (previous_battery_state->current_capacity == |
| previous_battery_state->full_charged_capacity) { |
| return {BatteryDischargeMode::kMacFullyCharged, std::nullopt}; |
| } |
| #endif |
| |
| if (previous_battery_state->full_charged_capacity.value() == 0 || |
| new_battery_state->full_charged_capacity.value() == 0) { |
| return {BatteryDischargeMode::kFullChargedCapacityIsZero, std::nullopt}; |
| } |
| |
| const auto discharge_rate_mw = CalculateDischargeRateMilliwatts( |
| *previous_battery_state, *new_battery_state, interval_duration); |
| |
| #if BUILDFLAG(IS_WIN) |
| // The maximum granularity allowed for the following battery discharge value. |
| // The bell curve of the battery discharge rate starts at 1000 mW. This |
| // correspond to a discharge amount of 1000/60 ~ 17 mWh every 1 minute |
| // interval. |
| static const int64_t kMaximumGranularityInMilliwattHours = 17; |
| std::optional<int64_t> discharge_rate_with_precise_granularity; |
| if (previous_battery_state->battery_discharge_granularity.has_value() && |
| previous_battery_state->battery_discharge_granularity.value() <= |
| kMaximumGranularityInMilliwattHours && |
| new_battery_state->battery_discharge_granularity.has_value() && |
| new_battery_state->battery_discharge_granularity.value() <= |
| kMaximumGranularityInMilliwattHours) { |
| discharge_rate_with_precise_granularity = discharge_rate_mw; |
| } |
| #endif // BUILDFLAG(IS_WIN) |
| |
| const auto discharge_rate_relative = CalculateDischargeRateRelative( |
| *previous_battery_state, *new_battery_state, interval_duration); |
| |
| if (discharge_rate_relative < 0 || discharge_rate_mw < 0) { |
| return {BatteryDischargeMode::kBatteryLevelIncreased, std::nullopt}; |
| } |
| return { |
| .mode = BatteryDischargeMode::kDischarging, |
| .rate_milliwatts = discharge_rate_mw, |
| #if BUILDFLAG(IS_WIN) |
| .rate_milliwatts_with_precise_granularity = |
| discharge_rate_with_precise_granularity, |
| #endif |
| .rate_relative = discharge_rate_relative |
| }; |
| } |
| |
| void ReportBatteryHistograms( |
| base::TimeDelta interval_duration, |
| BatteryDischarge battery_discharge, |
| bool is_initial_interval, |
| const std::vector<const char*>& scenario_suffixes) { |
| #if BUILDFLAG(IS_WIN) |
| base::UmaHistogramBoolean( |
| kHasPreciseBatteryDischargeGranularity, |
| battery_discharge.rate_milliwatts_with_precise_granularity.has_value()); |
| #endif // BUILDFLAG(IS_WIN) |
| |
| bool battery_saver_enabled = |
| performance_manager::user_tuning::BatterySaverModeManager:: |
| GetInstance() && |
| performance_manager::user_tuning::BatterySaverModeManager::GetInstance() |
| ->IsBatterySaverActive(); |
| |
| const char* interval_type_suffixes[] = { |
| "", is_initial_interval ? ".Initial" : ".Periodic"}; |
| const char* battery_saver_suffixes[] = {"", battery_saver_enabled |
| ? ".BatterySaverEnabled" |
| : ".BatterySaverDisabled"}; |
| for (const char* scenario_suffix : scenario_suffixes) { |
| for (const char* interval_type_suffix : interval_type_suffixes) { |
| base::UmaHistogramEnumeration( |
| base::StrCat({kBatteryDischargeModeHistogramName, scenario_suffix, |
| interval_type_suffix}), |
| battery_discharge.mode); |
| for (const char* battery_saver_suffix : battery_saver_suffixes) { |
| if (battery_discharge.mode == BatteryDischargeMode::kDischarging) { |
| DCHECK(battery_discharge.rate_milliwatts.has_value()); |
| base::UmaHistogramCounts100000( |
| base::StrCat({kBatteryDischargeRateMilliwattsHistogramName, |
| scenario_suffix, interval_type_suffix, |
| battery_saver_suffix}), |
| *battery_discharge.rate_milliwatts); |
| #if BUILDFLAG(IS_WIN) |
| if (battery_discharge.rate_milliwatts_with_precise_granularity) { |
| base::UmaHistogramCounts100000( |
| base::StrCat( |
| {kBatteryDischargeRatePreciseMilliwattsHistogramName, |
| scenario_suffix, interval_type_suffix, |
| battery_saver_suffix}), |
| *battery_discharge.rate_milliwatts_with_precise_granularity); |
| } |
| #endif // BUILDFLAG(IS_WIN) |
| DCHECK(battery_discharge.rate_relative.has_value()); |
| base::UmaHistogramCounts1000( |
| base::StrCat({kBatteryDischargeRateRelativeHistogramName, |
| scenario_suffix, interval_type_suffix, |
| battery_saver_suffix}), |
| *battery_discharge.rate_relative); |
| } |
| } |
| } |
| } |
| } |
| |
| #if BUILDFLAG(IS_WIN) |
| void ReportBatteryHistogramsTenMinutesInterval( |
| base::TimeDelta interval_duration, |
| BatteryDischarge battery_discharge) { |
| base::UmaHistogramEnumeration(kBatteryDischargeModeTenMinutesHistogramName, |
| battery_discharge.mode); |
| if (battery_discharge.mode == BatteryDischargeMode::kDischarging) { |
| DCHECK(battery_discharge.rate_milliwatts.has_value()); |
| base::UmaHistogramCounts100000( |
| kBatteryDischargeRateMilliwattsTenMinutesHistogramName, |
| *battery_discharge.rate_milliwatts); |
| } |
| } |
| #endif // BUILDFLAG(IS_WIN) |
