| // 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 "content/browser/android/battery_metrics.h" | |
| #include "base/android/application_status_listener.h" | |
| #include "base/feature_list.h" | |
| #include "base/functional/bind.h" | |
| #include "base/logging.h" | |
| #include "base/metrics/histogram.h" | |
| #include "base/metrics/histogram_base.h" | |
| #include "base/metrics/histogram_functions.h" | |
| #include "base/metrics/histogram_macros.h" | |
| #include "base/no_destructor.h" | |
| #include "base/power_monitor/energy_monitor_android.h" | |
| #include "base/power_monitor/power_monitor.h" | |
| #include "base/strings/strcat.h" | |
| #include "base/task/sequenced_task_runner.h" | |
| #include "base/task/thread_pool.h" | |
| #include "base/time/time.h" | |
| #include "base/trace_event/application_state_proto_android.h" | |
| #include "base/trace_event/trace_event.h" | |
| #include "base/trace_event/typed_macros.h" | |
| #include "base/tracing/protos/chrome_track_event.pbzero.h" | |
| #include "content/browser/web_contents/web_contents_impl.h" | |
| #include "content/public/browser/browser_thread.h" | |
| #include "third_party/blink/public/mojom/webpreferences/web_preferences.mojom.h" | |
| namespace content { | |
| namespace { | |
| using ScenarioScope = performance_scenarios::ScenarioScope; | |
| using LoadingScenario = performance_scenarios::LoadingScenario; | |
| using InputScenario = performance_scenarios::InputScenario; | |
| using Subsystem = AndroidBatteryMetrics::EnergyConsumedTracker::Subsystem; | |
| perfetto::protos::pbzero::DeviceThermalState ToTraceEnum( | |
| base::PowerThermalObserver::DeviceThermalState state) { | |
| switch (state) { | |
| case base::PowerThermalObserver::DeviceThermalState::kUnknown: | |
| return perfetto::protos::pbzero::DEVICE_THERMAL_STATE_UNKNOWN; | |
| case base::PowerThermalObserver::DeviceThermalState::kNominal: | |
| return perfetto::protos::pbzero::DEVICE_THERMAL_STATE_NOMINAL; | |
| case base::PowerThermalObserver::DeviceThermalState::kFair: | |
| return perfetto::protos::pbzero::DEVICE_THERMAL_STATE_FAIR; | |
| case base::PowerThermalObserver::DeviceThermalState::kSerious: | |
| return perfetto::protos::pbzero::DEVICE_THERMAL_STATE_SERIOUS; | |
| case base::PowerThermalObserver::DeviceThermalState::kCritical: | |
| return perfetto::protos::pbzero::DEVICE_THERMAL_STATE_CRITICAL; | |
| } | |
| } | |
| std::string GetLoadingScenarioSuffix(std::optional<LoadingScenario> scenario) { | |
| // LINT.IfChange(LoadingScenarioSuffix) | |
| if (!scenario.has_value()) { | |
| return "UnknownLoadingScenario"; | |
| } | |
| switch (*scenario) { | |
| case LoadingScenario::kFocusedPageLoading: | |
| return "FocusedPageLoading"; | |
| case LoadingScenario::kVisiblePageLoading: | |
| return "VisiblePageLoading"; | |
| case LoadingScenario::kBackgroundPageLoading: | |
| return "BackgroundPageLoading"; | |
| case LoadingScenario::kNoPageLoading: | |
| return "NoPageLoading"; | |
| } | |
| // LINT.ThenChange(/tools/metrics/histograms/metadata/power/histograms.xml:LoadingScenarioSuffix) | |
| NOTREACHED(); | |
| } | |
| std::string GetInputScenarioSuffix(std::optional<InputScenario> scenario) { | |
| // LINT.IfChange(InputScenarioSuffix) | |
| if (!scenario.has_value()) { | |
| return "UnknownInputScenario"; | |
| } | |
| switch (*scenario) { | |
| case InputScenario::kScroll: | |
| return "Scroll"; | |
| case InputScenario::kTap: | |
| return "Tap"; | |
| case InputScenario::kTyping: | |
| return "Typing"; | |
| case InputScenario::kNoInput: | |
| return "NoInput"; | |
| } | |
| // LINT.ThenChange(/tools/metrics/histograms/metadata/power/histograms.xml:InputScenarioSuffix) | |
| NOTREACHED(); | |
| } | |
| std::string GetSubsystemSuffix(Subsystem subsystem) { | |
| // LINT.IfChange(SubsystemSuffix) | |
| switch (subsystem) { | |
| case Subsystem::kCpu: | |
| return "Cpu"; | |
| case Subsystem::kGpu: | |
| return "Gpu"; | |
| case Subsystem::kDisplay: | |
| return "Display"; | |
| case Subsystem::kOther: | |
| return "Other"; | |
| } | |
| // LINT.ThenChange(/tools/metrics/histograms/metadata/power/histograms.xml:SubsystemSuffix) | |
| NOTREACHED(); | |
| } | |
| Subsystem ClassifyConsumer(std::string_view consumer) { | |
| if (consumer.find("CPU") != std::string::npos) { | |
| return Subsystem::kCpu; | |
| } | |
| if (consumer.find("GPU") != std::string::npos) { | |
| return Subsystem::kGpu; | |
| } | |
| if (consumer.find("DISPLAY") != std::string::npos) { | |
| return Subsystem::kDisplay; | |
| } | |
| return Subsystem::kOther; | |
| } | |
| base::flat_map<Subsystem, int64_t> AttributePowerMonitorReadingsToSubsystems( | |
| const std::vector<base::android::PowerMonitorReading>& readings) { | |
| base::flat_map<Subsystem, int64_t> energy_per_subsystem; | |
| for (const auto& reading : readings) { | |
| energy_per_subsystem[ClassifyConsumer(reading.consumer)] += | |
| reading.total_energy; | |
| } | |
| return energy_per_subsystem; | |
| } | |
| void ReportPerSubsystemEnergyDeltas( | |
| const std::vector<AndroidBatteryMetrics::EnergyConsumedTracker::Delta>& | |
| energy_deltas, | |
| const std::string& base_histogram_name) { | |
| // If there're no energy deltas for any subsystem, there's an error in the | |
| // latest or the previous reading. Do not report any metrics. | |
| if (energy_deltas.empty()) { | |
| return; | |
| } | |
| int64_t total_energy_consumed_mwh = 0; | |
| for (const auto& delta : energy_deltas) { | |
| total_energy_consumed_mwh += delta.energy_consumed_mwh; | |
| base::UmaHistogramCounts100000( | |
| base::StrCat( | |
| {base_histogram_name, ".", GetSubsystemSuffix(delta.subsystem)}), | |
| delta.energy_consumed_mwh); | |
| } | |
| base::UmaHistogramCounts100000(base_histogram_name, | |
| total_energy_consumed_mwh); | |
| } | |
| void Report30SecondDrain( | |
| int capacity_consumed, | |
| const std::vector<AndroidBatteryMetrics::EnergyConsumedTracker::Delta>& | |
| energy_deltas, | |
| bool is_exclusive_measurement, | |
| const std::string& scenario) { | |
| // Drain over the last 30 seconds in uAh. We assume a max current of 10A which | |
| // translates to a little under 100mAh capacity drain over 30 seconds. | |
| UMA_HISTOGRAM_COUNTS_100000("Power.ForegroundBatteryDrain.30Seconds", | |
| capacity_consumed); | |
| base::UmaHistogramCounts100000( | |
| std::string("Power.ForegroundBatteryDrainPerScenario.30Seconds.") + | |
| scenario, | |
| capacity_consumed); | |
| ReportPerSubsystemEnergyDeltas( | |
| energy_deltas, | |
| std::string("Power.ForegroundEnergyConsumedPerScenario.30Seconds.") + | |
| scenario); | |
| // Record a separate metric for power drain that was completely observed while | |
| // we were the foreground app. This avoids attributing power draw from other | |
| // apps to us. | |
| if (is_exclusive_measurement) { | |
| UMA_HISTOGRAM_COUNTS_100000( | |
| "Power.ForegroundBatteryDrain.30Seconds.Exclusive", capacity_consumed); | |
| base::UmaHistogramCounts100000( | |
| std::string( | |
| "Power.ForegroundBatteryDrainPerScenario.30Seconds.Exclusive.") + | |
| scenario, | |
| capacity_consumed); | |
| ReportPerSubsystemEnergyDeltas( | |
| energy_deltas, | |
| std::string( | |
| "Power.ForegroundEnergyConsumedPerScenario.30Seconds.Exclusive.") + | |
| scenario); | |
| } | |
| } | |
| base::HistogramBase* GetAvgBatteryDrainHistogram(const char* suffix) { | |
| static constexpr char kAvgDrainHistogramPrefix[] = | |
| "Power.ForegroundBatteryDrain.30SecondsAvg2"; | |
| return base::Histogram::FactoryGet( | |
| std::string(kAvgDrainHistogramPrefix) + suffix, 1, 100000, 50, | |
| base::HistogramBase::kUmaTargetedHistogramFlag); | |
| } | |
| // Dark mode histograms are reported on the UI thread, because they depend on | |
| // the current darkening state of the web contents -- which we can only inspect | |
| // on the UI thread. | |
| void ReportDarkModeDrains(int capacity_consumed_avg, | |
| bool is_exclusive_measurement, | |
| int num_sampling_periods) { | |
| size_t no_darkening_count = 0, user_agent_darkening_count = 0, | |
| web_page_or_user_agent_darkening_count = 0, | |
| web_page_darkening_count = 0; | |
| auto all_webcontents = WebContentsImpl::GetAllWebContents(); | |
| auto total_webcontents_count = all_webcontents.size(); | |
| for (WebContentsImpl* wc : all_webcontents) { | |
| auto dark_theme = wc->GetOrCreateWebPreferences().preferred_color_scheme == | |
| blink::mojom::PreferredColorScheme::kDark; | |
| auto force_dark = wc->GetOrCreateWebPreferences().force_dark_mode_enabled; | |
| if (force_dark) { | |
| if (dark_theme) { | |
| web_page_or_user_agent_darkening_count++; | |
| } else { | |
| user_agent_darkening_count++; | |
| } | |
| } else { | |
| if (dark_theme) { | |
| web_page_darkening_count++; | |
| } else { | |
| no_darkening_count++; | |
| } | |
| } | |
| } | |
| base::HistogramBase* dark_mode_histogram = nullptr; | |
| base::HistogramBase* exclusive_dark_mode_histogram = nullptr; | |
| if (user_agent_darkening_count + web_page_or_user_agent_darkening_count == | |
| total_webcontents_count) { | |
| // All WebContents have at least user-agent darkening. | |
| dark_mode_histogram = GetAvgBatteryDrainHistogram(".ForcedDarkMode"); | |
| exclusive_dark_mode_histogram = | |
| GetAvgBatteryDrainHistogram(".Exclusive.ForcedDarkMode"); | |
| } else if (web_page_darkening_count == total_webcontents_count) { | |
| // All WebContents have only web page darkening. | |
| dark_mode_histogram = GetAvgBatteryDrainHistogram(".DarkMode"); | |
| exclusive_dark_mode_histogram = | |
| GetAvgBatteryDrainHistogram(".Exclusive.DarkMode"); | |
| } else if (no_darkening_count == total_webcontents_count) { | |
| // None of the WebContents have any darkening. | |
| dark_mode_histogram = GetAvgBatteryDrainHistogram(".LightMode"); | |
| exclusive_dark_mode_histogram = | |
| GetAvgBatteryDrainHistogram(".Exclusive.LightMode"); | |
| } else { | |
| // Some WebContents have some kind of darkening and some might not have any. | |
| dark_mode_histogram = GetAvgBatteryDrainHistogram(".MixedMode"); | |
| exclusive_dark_mode_histogram = | |
| GetAvgBatteryDrainHistogram(".Exclusive.MixedMode"); | |
| } | |
| CHECK(dark_mode_histogram, base::NotFatalUntil::M159); | |
| CHECK(exclusive_dark_mode_histogram, base::NotFatalUntil::M159); | |
| dark_mode_histogram->AddCount(capacity_consumed_avg, num_sampling_periods); | |
| if (is_exclusive_measurement) { | |
| exclusive_dark_mode_histogram->AddCount(capacity_consumed_avg, | |
| num_sampling_periods); | |
| } | |
| } | |
| void ReportAveragedDrain(int capacity_consumed, | |
| bool is_exclusive_measurement, | |
| int num_sampling_periods) { | |
| // Averaged drain over 30 second intervals in uAh. We assume a max current of | |
| // 10A which translates to a little under 100mAh capacity drain over 30 | |
| // seconds. | |
| auto capacity_consumed_avg = capacity_consumed / num_sampling_periods; | |
| GetAvgBatteryDrainHistogram("")->AddCount(capacity_consumed_avg, | |
| num_sampling_periods); | |
| if (is_exclusive_measurement) { | |
| GetAvgBatteryDrainHistogram(".Exclusive") | |
| ->AddCount(capacity_consumed_avg, num_sampling_periods); | |
| } | |
| GetUIThreadTaskRunner({base::TaskPriority::BEST_EFFORT}) | |
| ->PostTask( | |
| FROM_HERE, | |
| base::BindOnce(&ReportDarkModeDrains, capacity_consumed_avg, | |
| is_exclusive_measurement, num_sampling_periods)); | |
| } | |
| } // namespace | |
| // static | |
| constexpr base::TimeDelta AndroidBatteryMetrics::kMetricsInterval; | |
| // static | |
| void AndroidBatteryMetrics::CreateInstance() { | |
| static base::NoDestructor<AndroidBatteryMetrics> instance; | |
| } | |
| AndroidBatteryMetrics::AndroidBatteryMetrics() | |
| : task_runner_(base::ThreadPool::CreateSequencedTaskRunner( | |
| {base::TaskPriority::BEST_EFFORT, | |
| base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})) { | |
| DETACH_FROM_SEQUENCE(sequence_checker_); | |
| task_runner_->PostTask( | |
| FROM_HERE, base::BindOnce(&AndroidBatteryMetrics::InitializeOnSequence, | |
| base::Unretained(this))); | |
| } | |
| AndroidBatteryMetrics::~AndroidBatteryMetrics() { | |
| // Never called, this is a no-destruct singleton. | |
| NOTREACHED(); | |
| } | |
| void AndroidBatteryMetrics::InitializeOnSequence() { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| auto* power_monitor = base::PowerMonitor::GetInstance(); | |
| battery_power_status_ = | |
| power_monitor->AddPowerStateObserverAndReturnBatteryPowerStatus(this); | |
| power_monitor->AddPowerThermalObserver(this); | |
| // The observer is never removed because this class uses base::NoDestructor. | |
| content::ProcessPriorityTracker::GetInstance()->AddObserver(this); | |
| // TODO(b/339859756): Update this call to take into account the unknown battery | |
| // status. | |
| UpdateMetricsEnabled(); | |
| } | |
| void AndroidBatteryMetrics::TryObservePerformanceScenarios() { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| if (is_observing_performance_scenarios_) { | |
| return; | |
| } | |
| // We're using ScenarioScope::kGlobal because we're interested in the overall | |
| // app state, not just the current process. | |
| if (auto observer_list = | |
| performance_scenarios::PerformanceScenarioObserverList::GetForScope( | |
| ScenarioScope::kGlobal)) { | |
| is_observing_performance_scenarios_ = true; | |
| performance_scenario_tracker_.UpdateLoadingScenario( | |
| performance_scenarios::GetLoadingScenario(ScenarioScope::kGlobal) | |
| ->load(std::memory_order_relaxed)); | |
| performance_scenario_tracker_.UpdateInputScenario( | |
| performance_scenarios::GetInputScenario(ScenarioScope::kGlobal) | |
| ->load(std::memory_order_relaxed)); | |
| observer_list->AddObserver(this); | |
| } | |
| } | |
| void AndroidBatteryMetrics::OnPriorityChanged( | |
| base::Process::Priority priority) { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| app_foregrounded_ = (priority != base::Process::Priority::kBestEffort); | |
| UpdateMetricsEnabled(); | |
| } | |
| void AndroidBatteryMetrics::OnBatteryPowerStatusChange( | |
| base::PowerStateObserver::BatteryPowerStatus battery_power_status) { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| battery_power_status_ = battery_power_status; | |
| UpdateMetricsEnabled(); | |
| } | |
| void AndroidBatteryMetrics::OnLoadingScenarioChanged( | |
| ScenarioScope scope, | |
| LoadingScenario old_scenario, | |
| LoadingScenario new_scenario) { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| performance_scenario_tracker_.UpdateLoadingScenario(new_scenario); | |
| } | |
| void AndroidBatteryMetrics::OnInputScenarioChanged(ScenarioScope scope, | |
| InputScenario old_scenario, | |
| InputScenario new_scenario) { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| performance_scenario_tracker_.UpdateInputScenario(new_scenario); | |
| } | |
| void AndroidBatteryMetrics::OnThermalStateChange(DeviceThermalState new_state) { | |
| TRACE_EVENT_INSTANT( | |
| "base.power", "OnThermalStateChange", perfetto::Track::Global(0), | |
| [&](perfetto::EventContext ctx) { | |
| auto* event = ctx.event<perfetto::protos::pbzero::ChromeTrackEvent>(); | |
| event->set_chrome_application_state_info()->set_application_state( | |
| base::trace_event::ApplicationStateToTraceEnum( | |
| base::android::ApplicationStatusListener::GetState())); | |
| event->set_device_thermal_state(ToTraceEnum(new_state)); | |
| }); | |
| } | |
| void AndroidBatteryMetrics::OnSpeedLimitChange(int speed_limit) {} | |
| void AndroidBatteryMetrics::UpdateMetricsEnabled() { | |
| DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_); | |
| TryObservePerformanceScenarios(); | |
| // We want to attribute battery drain to chromium while the embedding app is | |
| // visible. Battery drain will only be reflected in remaining battery capacity | |
| // when the device is not on a charger. | |
| bool should_be_enabled = | |
| app_foregrounded_ && | |
| (battery_power_status_ == | |
| PowerStateObserver::BatteryPowerStatus::kBatteryPower); | |
| if (should_be_enabled && !metrics_timer_.IsRunning()) { | |
| // Capture first capacity measurement and enable the repeating timer. | |
| last_remaining_capacity_uah_ = base::android::GetRemainingBatteryCapacity(); | |
| energy_consumed_tracker_.UpdatePowerMonitorReadings( | |
| base::android::GetTotalEnergyConsumed()); | |
| skipped_timers_ = 0; | |
| observed_capacity_drops_ = 0; | |
| performance_scenario_tracker_.UseLatestScenarios(); | |
| metrics_timer_.Start( | |
| FROM_HERE, kMetricsInterval, | |
| base::BindRepeating(&AndroidBatteryMetrics::CaptureAndReportMetrics, | |
| base::Unretained(this), | |
| /*disabling=*/false)); | |
| } else if (!should_be_enabled && metrics_timer_.IsRunning()) { | |
| // Capture one last measurement before disabling the timer. | |
| CaptureAndReportMetrics(/*disabling=*/true); | |
| metrics_timer_.Stop(); | |
| } | |
| } | |
| void AndroidBatteryMetrics::CaptureAndReportMetrics(bool disabling) { | |
| int remaining_capacity_uah = base::android::GetRemainingBatteryCapacity(); | |
| const auto power_monitor_readings = base::android::GetTotalEnergyConsumed(); | |
| std::vector<EnergyConsumedTracker::Delta> energy_deltas; | |
| // The underlying API has throttling (in which case the old value is reported | |
| // again, but no errors), so if we call this method because the battery state | |
| // is changing rather than by timer, the deltas are likely to be | |
| // (misleadingly) 0. Let's not report such values. | |
| if (!disabling) { | |
| energy_deltas = energy_consumed_tracker_.GetDeltas(power_monitor_readings); | |
| } | |
| energy_consumed_tracker_.UpdatePowerMonitorReadings(power_monitor_readings); | |
| const std::string scenario = performance_scenario_tracker_.GetMetricSuffix(); | |
| performance_scenario_tracker_.UseLatestScenarios(); | |
| if (remaining_capacity_uah >= last_remaining_capacity_uah_) { | |
| // No change in battery capacity, or it increased. The latter could happen | |
| // if we detected the switch off battery power to a charger late, or if the | |
| // device reports bogus values. We don't change last_remaining_capacity_uah_ | |
| // here to avoid overreporting in case of fluctuating values. | |
| skipped_timers_++; | |
| Report30SecondDrain(0, energy_deltas, IsMeasuringDrainExclusively(), | |
| scenario); | |
| if (disabling) { | |
| // Disabling the timer, but without a change in capacity counter -- We | |
| // should still emit values for the elapsed time intervals into the | |
| // average histograms. We exclude exclusive metrics here, because these | |
| // metrics exclude the measurements before the first capacity drop and | |
| // after the last drop. Member fields will be reset when tracking | |
| // is resumed after foregrounding again later. | |
| ReportAveragedDrain(0, /*is_exclusive_measurement=*/false, | |
| skipped_timers_); | |
| } | |
| return; | |
| } | |
| observed_capacity_drops_++; | |
| // Report the consumed capacity delta over the last 30 seconds. | |
| int capacity_consumed = last_remaining_capacity_uah_ - remaining_capacity_uah; | |
| Report30SecondDrain(capacity_consumed, energy_deltas, | |
| IsMeasuringDrainExclusively(), scenario); | |
| // Also record drain over 30 second intervals, but averaged since the last | |
| // time we recorded an increase (or started recording samples). Because the | |
| // underlying battery capacity counter is often low-resolution (usually | |
| // between .5 and 50 mAh), it may only increment after multiple sampling | |
| // points. For example, a 20 mAh drop over two successive periods of 30 | |
| // seconds will be reported as two samples of 10 mAh. | |
| ReportAveragedDrain(capacity_consumed, IsMeasuringDrainExclusively(), | |
| skipped_timers_ + 1); | |
| // Also track the total capacity consumed in a single-bucket-histogram, | |
| // emitting one sample for every 100 uAh drained. | |
| static constexpr base::Histogram::Sample32 kSampleFactor = 100; | |
| UMA_HISTOGRAM_SCALED_EXACT_LINEAR("Power.ForegroundBatteryDrain", | |
| /*sample=*/1, capacity_consumed, | |
| /*sample_max=*/1, kSampleFactor); | |
| if (IsMeasuringDrainExclusively()) { | |
| UMA_HISTOGRAM_SCALED_EXACT_LINEAR("Power.ForegroundBatteryDrain.Exclusive", | |
| /*sample=*/1, capacity_consumed, | |
| /*sample_max=*/1, kSampleFactor); | |
| } | |
| last_remaining_capacity_uah_ = remaining_capacity_uah; | |
| skipped_timers_ = 0; | |
| } | |
| bool AndroidBatteryMetrics::IsMeasuringDrainExclusively() const { | |
| return observed_capacity_drops_ >= 2; | |
| } | |
| void AndroidBatteryMetrics::PerformanceScenarioTracker::UpdateLoadingScenario( | |
| performance_scenarios::LoadingScenario new_scenario) { | |
| latest_loading_scenario_ = new_scenario; | |
| if (loading_scenario_to_report_.value_or(LoadingScenario::kNoPageLoading) <= | |
| new_scenario) { | |
| loading_scenario_to_report_ = new_scenario; | |
| } | |
| } | |
| void AndroidBatteryMetrics::PerformanceScenarioTracker::UpdateInputScenario( | |
| performance_scenarios::InputScenario new_scenario) { | |
| latest_input_scenario_ = new_scenario; | |
| if (input_scenario_to_report_.value_or(InputScenario::kNoInput) <= | |
| new_scenario) { | |
| input_scenario_to_report_ = new_scenario; | |
| } | |
| } | |
| std::string AndroidBatteryMetrics::PerformanceScenarioTracker::GetMetricSuffix() | |
| const { | |
| return GetLoadingScenarioSuffix(loading_scenario_to_report_) + "_" + | |
| GetInputScenarioSuffix(input_scenario_to_report_); | |
| } | |
| void AndroidBatteryMetrics::PerformanceScenarioTracker::UseLatestScenarios() { | |
| loading_scenario_to_report_ = latest_loading_scenario_; | |
| input_scenario_to_report_ = latest_input_scenario_; | |
| } | |
| AndroidBatteryMetrics::EnergyConsumedTracker::EnergyConsumedTracker() = default; | |
| AndroidBatteryMetrics::EnergyConsumedTracker::~EnergyConsumedTracker() = | |
| default; | |
| void AndroidBatteryMetrics::EnergyConsumedTracker::UpdatePowerMonitorReadings( | |
| const std::vector<base::android::PowerMonitorReading>& readings) { | |
| last_total_energy_uws_ = AttributePowerMonitorReadingsToSubsystems(readings); | |
| } | |
| std::vector<AndroidBatteryMetrics::EnergyConsumedTracker::Delta> | |
| AndroidBatteryMetrics::EnergyConsumedTracker::GetDeltas( | |
| const std::vector<base::android::PowerMonitorReading>& readings) const { | |
| base::flat_map<Subsystem, int64_t> total_energy_uws = | |
| AttributePowerMonitorReadingsToSubsystems(readings); | |
| std::vector<Delta> deltas; | |
| for (const auto& [subsystem, energy_uws] : total_energy_uws) { | |
| // 0 total energy means an error, in which case we can't report the detla. | |
| if (energy_uws == 0) { | |
| continue; | |
| } | |
| auto it = last_total_energy_uws_.find(subsystem); | |
| if (it == last_total_energy_uws_.end() || it->second == 0) { | |
| continue; | |
| } | |
| int64_t delta_mwh = | |
| std::max(static_cast<int64_t>(0), (energy_uws - it->second) / 3600); | |
| deltas.push_back({subsystem, delta_mwh}); | |
| } | |
| return deltas; | |
| } | |
| } // namespace content |