From 768e1fdb8fe23d2ebf312496931034efc2f22708 Mon Sep 17 00:00:00 2001 From: Anthony Vallee-Dubois Date: Tue, 9 Aug 2022 18:07:54 +0000 Subject: [PATCH] Introduce UserPerformanceTuningManager MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This CL introduces a new component that manages the state of User Controlled Performance features, and surfaces signals related to them so that UI can decide when and what to display. This CL also moves the existing High Efficiency and Battery Saver Mode behaviors to this new component. A follow up will finish implementing the different signals and expose the manager to other code. Design Doc: go/uv-performance-bsm-manager Bug: 1348590 Change-Id: I51158c3e262d649c331c5f5db36a7bd996a11f09 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3817866 Reviewed-by: Francois Pierre Doray Commit-Queue: Anthony Vallée-Dubois Cr-Commit-Position: refs/heads/main@{#1033113} --- chrome/browser/BUILD.gn | 4 +- ...er_main_extra_parts_performance_manager.cc | 8 +- ...ser_main_extra_parts_performance_manager.h | 9 +- .../high_efficiency_mode_policy_helper.cc | 66 --------- .../high_efficiency_mode_policy_helper.h | 27 ---- .../high_efficiency_mode_policy_unittest.cc | 1 - .../user_performance_tuning_manager.cc | 134 ++++++++++++++++++ .../user_performance_tuning_manager.h | 94 ++++++++++++ ...ser_performance_tuning_manager_unittest.cc | 98 +++++++++++++ chrome/test/BUILD.gn | 1 + 10 files changed, 338 insertions(+), 104 deletions(-) delete mode 100644 chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.cc delete mode 100644 chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h create mode 100644 chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.cc create mode 100644 chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h create mode 100644 chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager_unittest.cc diff --git a/chrome/browser/BUILD.gn b/chrome/browser/BUILD.gn index 40589835781a0..3679db75810ce 100644 --- a/chrome/browser/BUILD.gn +++ b/chrome/browser/BUILD.gn @@ -4033,14 +4033,14 @@ static_library("browser") { "performance_manager/policies/background_tab_loading_policy_helpers.h", "performance_manager/policies/high_efficiency_mode_policy.cc", "performance_manager/policies/high_efficiency_mode_policy.h", - "performance_manager/policies/high_efficiency_mode_policy_helper.cc", - "performance_manager/policies/high_efficiency_mode_policy_helper.h", "performance_manager/policies/page_discarding_helper.cc", "performance_manager/policies/page_discarding_helper.h", "performance_manager/policies/urgent_page_discarding_policy.cc", "performance_manager/policies/urgent_page_discarding_policy.h", "performance_manager/user_tuning/profile_discard_opt_out_list_helper.cc", "performance_manager/user_tuning/profile_discard_opt_out_list_helper.h", + "performance_manager/user_tuning/user_performance_tuning_manager.cc", + "performance_manager/user_tuning/user_performance_tuning_manager.h", "permissions/attestation_permission_request.cc", "permissions/attestation_permission_request.h", "policy/browsing_history_policy_handler.cc", diff --git a/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.cc b/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.cc index fa0fcfcedca7a..918c451383d94 100644 --- a/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.cc +++ b/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.cc @@ -49,10 +49,10 @@ #if !BUILDFLAG(IS_ANDROID) #include "chrome/browser/performance_manager/mechanisms/page_freezer.h" #include "chrome/browser/performance_manager/policies/high_efficiency_mode_policy.h" -#include "chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h" #include "chrome/browser/performance_manager/policies/page_discarding_helper.h" #include "chrome/browser/performance_manager/policies/page_freezing_policy.h" #include "chrome/browser/performance_manager/policies/urgent_page_discarding_policy.h" +#include "chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h" #include "chrome/browser/tab_contents/form_interaction_tab_helper.h" #include "components/performance_manager/graph/policies/bfcache_policy.h" #endif // !BUILDFLAG(IS_ANDROID) @@ -211,8 +211,8 @@ void ChromeBrowserMainExtraPartsPerformanceManager::PreMainMessageLoopRun() { performance_manager::features::kHighEfficiencyModeAvailable) || base::FeatureList::IsEnabled( performance_manager::features::kBatterySaverModeAvailable)) { - high_efficiency_mode_policy_helper_ = std::make_unique< - performance_manager::policies::HighEfficiencyModePolicyHelper>( + user_performance_tuning_manager_ = std::make_unique< + performance_manager::user_tuning::UserPerformanceTuningManager>( g_browser_process->local_state()); } #endif @@ -235,7 +235,7 @@ void ChromeBrowserMainExtraPartsPerformanceManager::PostMainMessageLoopRun() { page_load_metrics_observer_.reset(); #if !BUILDFLAG(IS_ANDROID) - high_efficiency_mode_policy_helper_.reset(); + user_performance_tuning_manager_.reset(); profile_discard_opt_out_list_helper_.reset(); #endif diff --git a/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.h b/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.h index 14f3d873cd819..7b7594a178ba8 100644 --- a/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.h +++ b/chrome/browser/performance_manager/chrome_browser_main_extra_parts_performance_manager.h @@ -34,8 +34,8 @@ class PerformanceManagerLifetime; class ExtensionWatcher; #endif -namespace policies { -class HighEfficiencyModePolicyHelper; +namespace user_tuning { +class UserPerformanceTuningManager; } namespace user_tuning { @@ -115,8 +115,9 @@ class ChromeBrowserMainExtraPartsPerformanceManager #endif #if !BUILDFLAG(IS_ANDROID) - std::unique_ptr - high_efficiency_mode_policy_helper_; + std::unique_ptr< + performance_manager::user_tuning::UserPerformanceTuningManager> + user_performance_tuning_manager_; std::unique_ptr< performance_manager::user_tuning::ProfileDiscardOptOutListHelper> profile_discard_opt_out_list_helper_; diff --git a/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.cc b/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.cc deleted file mode 100644 index fee70e4a5eee2..0000000000000 --- a/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.cc +++ /dev/null @@ -1,66 +0,0 @@ -// Copyright 2022 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h" - -#include "base/feature_list.h" -#include "chrome/browser/performance_manager/policies/high_efficiency_mode_policy.h" -#include "components/performance_manager/public/features.h" -#include "components/performance_manager/public/performance_manager.h" -#include "components/performance_manager/public/user_tuning/prefs.h" -#include "components/prefs/pref_service.h" -#include "content/public/browser/frame_rate_throttling.h" - -namespace performance_manager::policies { - -HighEfficiencyModePolicyHelper::HighEfficiencyModePolicyHelper( - PrefService* local_state) { - pref_change_registrar_.Init(local_state); - - if (base::FeatureList::IsEnabled( - performance_manager::features::kHighEfficiencyModeAvailable)) { - pref_change_registrar_.Add( - performance_manager::user_tuning::prefs::kHighEfficiencyModeEnabled, - base::BindRepeating( - &HighEfficiencyModePolicyHelper::OnHighEfficiencyModeChanged, - base::Unretained(this))); - // Make sure the initial state of the pref is passed on to the policy. - OnHighEfficiencyModeChanged(); - } - - if (base::FeatureList::IsEnabled( - performance_manager::features::kBatterySaverModeAvailable)) { - pref_change_registrar_.Add( - performance_manager::user_tuning::prefs::kBatterySaverModeEnabled, - base::BindRepeating( - &HighEfficiencyModePolicyHelper::OnBatterySaverModeChanged, - base::Unretained(this))); - OnBatterySaverModeChanged(); - } -} - -void HighEfficiencyModePolicyHelper::OnHighEfficiencyModeChanged() { - bool enabled = pref_change_registrar_.prefs()->GetBoolean( - performance_manager::user_tuning::prefs::kHighEfficiencyModeEnabled); - performance_manager::PerformanceManager::CallOnGraph( - FROM_HERE, base::BindOnce( - [](bool enabled, performance_manager::Graph* graph) { - HighEfficiencyModePolicy::GetInstance() - ->OnHighEfficiencyModeChanged(enabled); - }, - enabled)); -} - -void HighEfficiencyModePolicyHelper::OnBatterySaverModeChanged() { - bool enabled = pref_change_registrar_.prefs()->GetBoolean( - performance_manager::user_tuning::prefs::kBatterySaverModeEnabled); - - if (enabled) { - content::StartThrottlingAllFrameSinks(base::Hertz(30)); - } else { - content::StopThrottlingAllFrameSinks(); - } -} - -} // namespace performance_manager::policies diff --git a/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h b/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h deleted file mode 100644 index 5c7220df3f1bb..0000000000000 --- a/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h +++ /dev/null @@ -1,27 +0,0 @@ -// Copyright 2022 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#ifndef CHROME_BROWSER_PERFORMANCE_MANAGER_POLICIES_HIGH_EFFICIENCY_MODE_POLICY_HELPER_H_ -#define CHROME_BROWSER_PERFORMANCE_MANAGER_POLICIES_HIGH_EFFICIENCY_MODE_POLICY_HELPER_H_ - -#include "components/prefs/pref_change_registrar.h" - -class PrefService; - -namespace performance_manager::policies { - -class HighEfficiencyModePolicyHelper { - public: - explicit HighEfficiencyModePolicyHelper(PrefService* local_state); - - private: - void OnHighEfficiencyModeChanged(); - void OnBatterySaverModeChanged(); - - PrefChangeRegistrar pref_change_registrar_; -}; - -} // namespace performance_manager::policies - -#endif // CHROME_BROWSER_PERFORMANCE_MANAGER_POLICIES_HIGH_EFFICIENCY_MODE_POLICY_HELPER_H_ diff --git a/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_unittest.cc b/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_unittest.cc index ba2157ae5f181..a1249ab409851 100644 --- a/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_unittest.cc +++ b/chrome/browser/performance_manager/policies/high_efficiency_mode_policy_unittest.cc @@ -7,7 +7,6 @@ #include "base/test/scoped_feature_list.h" #include "base/test/task_environment.h" #include "base/time/time.h" -#include "chrome/browser/performance_manager/policies/high_efficiency_mode_policy_helper.h" #include "chrome/browser/performance_manager/test_support/page_discarding_utils.h" #include "components/performance_manager/public/features.h" #include "components/performance_manager/public/user_tuning/prefs.h" diff --git a/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.cc b/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.cc new file mode 100644 index 0000000000000..4cdeea92ca694 --- /dev/null +++ b/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.cc @@ -0,0 +1,134 @@ +// Copyright 2022 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h" + +#include "base/feature_list.h" +#include "chrome/browser/performance_manager/policies/high_efficiency_mode_policy.h" +#include "components/performance_manager/public/features.h" +#include "components/performance_manager/public/performance_manager.h" +#include "components/performance_manager/public/user_tuning/prefs.h" +#include "components/prefs/pref_service.h" +#include "content/public/browser/frame_rate_throttling.h" + +namespace performance_manager::user_tuning { +namespace { + +class FrameThrottlingDelegateImpl + : public performance_manager::user_tuning::UserPerformanceTuningManager:: + FrameThrottlingDelegate { + public: + void StartThrottlingAllFrameSinks() override { + content::StartThrottlingAllFrameSinks(base::Hertz(30)); + } + + void StopThrottlingAllFrameSinks() override { + content::StopThrottlingAllFrameSinks(); + } + + ~FrameThrottlingDelegateImpl() override = default; +}; + +} // namespace + +UserPerformanceTuningManager::UserPerformanceTuningManager( + PrefService* local_state, + std::unique_ptr frame_throttling_delegate) + : frame_throttling_delegate_( + frame_throttling_delegate + ? std::move(frame_throttling_delegate) + : std::make_unique()) { + pref_change_registrar_.Init(local_state); + + if (base::FeatureList::IsEnabled( + performance_manager::features::kHighEfficiencyModeAvailable)) { + pref_change_registrar_.Add( + performance_manager::user_tuning::prefs::kHighEfficiencyModeEnabled, + base::BindRepeating( + &UserPerformanceTuningManager::OnHighEfficiencyModePrefChanged, + base::Unretained(this))); + // Make sure the initial state of the pref is passed on to the policy. + OnHighEfficiencyModePrefChanged(); + } + + if (base::FeatureList::IsEnabled( + performance_manager::features::kBatterySaverModeAvailable)) { + pref_change_registrar_.Add( + performance_manager::user_tuning::prefs::kBatterySaverModeEnabled, + base::BindRepeating( + &UserPerformanceTuningManager::OnBatterySaverModePrefChanged, + base::Unretained(this))); + OnBatterySaverModePrefChanged(); + } +} + +UserPerformanceTuningManager::~UserPerformanceTuningManager() = default; + +void UserPerformanceTuningManager::AddObserver(Observer* o) { + observers_.AddObserver(o); +} + +void UserPerformanceTuningManager::RemoveObserver(Observer* o) { + observers_.RemoveObserver(o); +} + +bool UserPerformanceTuningManager::DeviceHasBattery() const { + // TODO(crbug.com/1348590): Check platform-specific APIs to return whether + // this device has a battery. + return true; +} + +void UserPerformanceTuningManager::SetTemporaryBatterySaver(bool enabled) { + // Setting the temporary mode to its current state is a no-op. + if (temporary_battery_saver_enabled_ == enabled) + return; + + temporary_battery_saver_enabled_ = enabled; + UpdateBatterySaverModeState(); +} + +bool UserPerformanceTuningManager::IsBatterySaverActive() const { + return battery_saver_mode_enabled_; +} + +void UserPerformanceTuningManager::OnHighEfficiencyModePrefChanged() { + bool enabled = pref_change_registrar_.prefs()->GetBoolean( + performance_manager::user_tuning::prefs::kHighEfficiencyModeEnabled); + performance_manager::PerformanceManager::CallOnGraph( + FROM_HERE, base::BindOnce( + [](bool enabled, performance_manager::Graph* graph) { + policies::HighEfficiencyModePolicy::GetInstance() + ->OnHighEfficiencyModeChanged(enabled); + }, + enabled)); +} + +void UserPerformanceTuningManager::OnBatterySaverModePrefChanged() { + UpdateBatterySaverModeState(); +} + +void UserPerformanceTuningManager::UpdateBatterySaverModeState() { + bool pref_enabled = pref_change_registrar_.prefs()->GetBoolean( + performance_manager::user_tuning::prefs::kBatterySaverModeEnabled); + + bool previously_enabled = battery_saver_mode_enabled_; + battery_saver_mode_enabled_ = + pref_enabled || temporary_battery_saver_enabled_; + + // Don't change throttling or notify observers if the mode didn't change. + if (previously_enabled == battery_saver_mode_enabled_) + return; + + if (battery_saver_mode_enabled_) { + frame_throttling_delegate_->StartThrottlingAllFrameSinks(); + } else { + frame_throttling_delegate_->StopThrottlingAllFrameSinks(); + } + + for (auto& obs : observers_) { + obs.OnBatterySaverModeChanged(battery_saver_mode_enabled_); + } +} + +} // namespace performance_manager::user_tuning diff --git a/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h b/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h new file mode 100644 index 0000000000000..47014aa8f6083 --- /dev/null +++ b/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h @@ -0,0 +1,94 @@ +// Copyright 2022 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef CHROME_BROWSER_PERFORMANCE_MANAGER_USER_TUNING_USER_PERFORMANCE_TUNING_MANAGER_H_ +#define CHROME_BROWSER_PERFORMANCE_MANAGER_USER_TUNING_USER_PERFORMANCE_TUNING_MANAGER_H_ + +#include "base/observer_list.h" +#include "base/observer_list_types.h" +#include "components/prefs/pref_change_registrar.h" + +class PrefService; + +namespace performance_manager::user_tuning { + +class UserPerformanceTuningManager { + public: + class FrameThrottlingDelegate { + public: + virtual void StartThrottlingAllFrameSinks() = 0; + virtual void StopThrottlingAllFrameSinks() = 0; + + virtual ~FrameThrottlingDelegate() = default; + }; + + class Observer : public base::CheckedObserver { + public: + // Raised when the battery saver mode interventions are activated or + // deactivated + virtual void OnBatterySaverModeChanged(bool is_active) = 0; + + // Raised when the device is plugged in or unplugged + // Can be used by the UI to show a promo if BSM isn't configured to be + // enabled when on battery power. + virtual void OnExternalPowerConnectedChanged( + bool external_power_connected) = 0; + + // Raised when the battery has reached the X% threshold + // Can be used by the UI to show a promo if BSM isn't configured to be + // enabled when on battery power under a certain threshold. + virtual void OnBatteryThresholdReached() = 0; + + // Raised when the total memory footprint reaches X%. + // Can be used by the UI to show a promo + virtual void OnMemoryThresholdReached() = 0; + + // Raised when the tab count reaches X. + // Can be used by the UI to show a promo + virtual void OnTabCountThresholdReached() = 0; + + // Raised when the count of janky intervals reaches X. + // Can be used by the UI to show a promo + virtual void OnJankThresholdReached() = 0; + }; + + explicit UserPerformanceTuningManager( + PrefService* local_state, + std::unique_ptr frame_throttling_delegate = + nullptr); + ~UserPerformanceTuningManager(); + + void AddObserver(Observer* o); + void RemoveObserver(Observer* o); + + // Returns true if the device is a portable device that can run on battery + // power, false otherwise. + bool DeviceHasBattery() const; + + // Called to enable or disable the temporary battery saver mode. + void SetTemporaryBatterySaver(bool enabled); + + // Returns true if Battery Saver Mode interventions are active. If any state + // transitions cause an observer notification, this is guaranteed to reflect + // the *new* value when the observers are notified so the UI layer can make + // decisions based on the most up-to-date state. + bool IsBatterySaverActive() const; + + private: + void OnHighEfficiencyModePrefChanged(); + void OnBatterySaverModePrefChanged(); + + void UpdateBatterySaverModeState(); + + bool battery_saver_mode_enabled_ = false; + bool temporary_battery_saver_enabled_ = false; + std::unique_ptr frame_throttling_delegate_; + + PrefChangeRegistrar pref_change_registrar_; + base::ObserverList observers_; +}; + +} // namespace performance_manager::user_tuning + +#endif // CHROME_BROWSER_PERFORMANCE_MANAGER_USER_TUNING_USER_PERFORMANCE_TUNING_MANAGER_H_ diff --git a/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager_unittest.cc b/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager_unittest.cc new file mode 100644 index 0000000000000..8fd99fa0d00f3 --- /dev/null +++ b/chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager_unittest.cc @@ -0,0 +1,98 @@ +// Copyright 2022 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "chrome/browser/performance_manager/user_tuning/user_performance_tuning_manager.h" + +#include "base/test/scoped_feature_list.h" +#include "components/performance_manager/public/features.h" +#include "components/performance_manager/public/user_tuning/prefs.h" +#include "components/prefs/testing_pref_service.h" +#include "testing/gtest/include/gtest/gtest.h" + +namespace performance_manager::user_tuning { + +class FakeFrameThrottlingDelegate + : public UserPerformanceTuningManager::FrameThrottlingDelegate { + public: + void StartThrottlingAllFrameSinks() override { *throttling_enabled_ = true; } + void StopThrottlingAllFrameSinks() override { *throttling_enabled_ = false; } + + explicit FakeFrameThrottlingDelegate(bool* throttling_enabled) + : throttling_enabled_(throttling_enabled) {} + ~FakeFrameThrottlingDelegate() override = default; + + bool* throttling_enabled_; +}; + +class UserPerformanceTuningManagerTest : public testing::Test { + public: + void SetUp() override { + feature_list_.InitAndEnableFeature( + performance_manager::features::kBatterySaverModeAvailable); + + performance_manager::user_tuning::prefs::RegisterLocalStatePrefs( + local_state_.registry()); + } + + TestingPrefServiceSimple local_state_; + base::test::ScopedFeatureList feature_list_; +}; + +TEST_F(UserPerformanceTuningManagerTest, TemporaryBatterySaver) { + bool throttling_enabled = false; + UserPerformanceTuningManager manager( + &local_state_, + std::make_unique(&throttling_enabled)); + EXPECT_FALSE(manager.IsBatterySaverActive()); + EXPECT_FALSE(throttling_enabled); + + manager.SetTemporaryBatterySaver(true); + EXPECT_TRUE(manager.IsBatterySaverActive()); + EXPECT_TRUE(throttling_enabled); + + manager.SetTemporaryBatterySaver(false); + EXPECT_FALSE(manager.IsBatterySaverActive()); + EXPECT_FALSE(throttling_enabled); +} + +TEST_F(UserPerformanceTuningManagerTest, BatterySaverModePref) { + bool throttling_enabled = false; + UserPerformanceTuningManager manager( + &local_state_, + std::make_unique(&throttling_enabled)); + EXPECT_FALSE(manager.IsBatterySaverActive()); + EXPECT_FALSE(throttling_enabled); + + local_state_.SetBoolean( + performance_manager::user_tuning::prefs::kBatterySaverModeEnabled, true); + EXPECT_TRUE(manager.IsBatterySaverActive()); + EXPECT_TRUE(throttling_enabled); + + local_state_.SetBoolean( + performance_manager::user_tuning::prefs::kBatterySaverModeEnabled, false); + EXPECT_FALSE(manager.IsBatterySaverActive()); + EXPECT_FALSE(throttling_enabled); +} + +TEST_F(UserPerformanceTuningManagerTest, PrefSupersedesTemporary) { + bool throttling_enabled = false; + UserPerformanceTuningManager manager( + &local_state_, + std::make_unique(&throttling_enabled)); + + local_state_.SetBoolean( + performance_manager::user_tuning::prefs::kBatterySaverModeEnabled, true); + EXPECT_TRUE(manager.IsBatterySaverActive()); + EXPECT_TRUE(throttling_enabled); + + manager.SetTemporaryBatterySaver(true); + EXPECT_TRUE(manager.IsBatterySaverActive()); + EXPECT_TRUE(throttling_enabled); + + manager.SetTemporaryBatterySaver(false); + EXPECT_TRUE(manager.IsBatterySaverActive()); + EXPECT_TRUE(throttling_enabled); +} + +} // namespace performance_manager::user_tuning diff --git a/chrome/test/BUILD.gn b/chrome/test/BUILD.gn index 6ce67fc6f18fd..b720f7b30f98d 100644 --- a/chrome/test/BUILD.gn +++ b/chrome/test/BUILD.gn @@ -6873,6 +6873,7 @@ test("unit_tests") { "../browser/performance_manager/policies/high_efficiency_mode_policy_unittest.cc", "../browser/performance_manager/policies/page_discarding_helper_unittest.cc", "../browser/performance_manager/policies/urgent_page_discarding_policy_unittest.cc", + "../browser/performance_manager/user_tuning/user_performance_tuning_manager_unittest.cc", ] sources += [