chromeos/dbus/power_policy_controller_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/dbus/power_policy_controller.h"
   6
   7 #include "base/memory/scoped_ptr.h"
   8 #include "chromeos/dbus/dbus_thread_manager.h"
   9 #include "chromeos/dbus/fake_dbus_thread_manager.h"
  10 #include "chromeos/dbus/fake_power_manager_client.h"
  11 #include "testing/gmock/include/gmock/gmock.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 using ::testing::_;
  15 using ::testing::SaveArg;
  16
  17 namespace chromeos {
  18
  19 class PowerPolicyControllerTest : public testing::Test {
  20  public:
  21   PowerPolicyControllerTest() {}
  22   virtual ~PowerPolicyControllerTest() {}
  23
  24   virtual void SetUp() OVERRIDE {
  25     dbus_manager_ = new FakeDBusThreadManager;
  26     fake_power_client_ = new FakePowerManagerClient;
  27     dbus_manager_->SetPowerManagerClient(
  28         scoped_ptr<PowerManagerClient>(fake_power_client_));
  29     DBusThreadManager::InitializeForTesting(dbus_manager_);  // Takes ownership.
  30
  31     policy_controller_.reset(new PowerPolicyController);
  32     policy_controller_->Init(dbus_manager_);
  33   }
  34
  35   virtual void TearDown() OVERRIDE {
  36     policy_controller_.reset();
  37     DBusThreadManager::Shutdown();
  38   }
  39
  40  protected:
  41   FakeDBusThreadManager* dbus_manager_;  // Not owned.
  42   FakePowerManagerClient* fake_power_client_;
  43   scoped_ptr<PowerPolicyController> policy_controller_;
  44 };
  45
  46 TEST_F(PowerPolicyControllerTest, Prefs) {
  47   PowerPolicyController::PrefValues prefs;
  48   prefs.ac_screen_dim_delay_ms = 600000;
  49   prefs.ac_screen_off_delay_ms = 660000;
  50   prefs.ac_idle_delay_ms = 720000;
  51   prefs.battery_screen_dim_delay_ms = 300000;
  52   prefs.battery_screen_off_delay_ms = 360000;
  53   prefs.battery_idle_delay_ms = 420000;
  54   prefs.ac_idle_action = PowerPolicyController::ACTION_SUSPEND;
  55   prefs.battery_idle_action = PowerPolicyController::ACTION_STOP_SESSION;
  56   prefs.lid_closed_action = PowerPolicyController::ACTION_SHUT_DOWN;
  57   prefs.use_audio_activity = true;
  58   prefs.use_video_activity = true;
  59   prefs.ac_brightness_percent = 87.0;
  60   prefs.battery_brightness_percent = 43.0;
  61   prefs.enable_auto_screen_lock = false;
  62   prefs.presentation_screen_dim_delay_factor = 3.0;
  63   prefs.user_activity_screen_dim_delay_factor = 2.0;
  64   prefs.wait_for_initial_user_activity = true;
  65   policy_controller_->ApplyPrefs(prefs);
  66
  67   power_manager::PowerManagementPolicy expected_policy;
  68   expected_policy.mutable_ac_delays()->set_screen_dim_ms(600000);
  69   expected_policy.mutable_ac_delays()->set_screen_off_ms(660000);
  70   expected_policy.mutable_ac_delays()->set_screen_lock_ms(-1);
  71   expected_policy.mutable_ac_delays()->set_idle_warning_ms(-1);
  72   expected_policy.mutable_ac_delays()->set_idle_ms(720000);
  73   expected_policy.mutable_battery_delays()->set_screen_dim_ms(300000);
  74   expected_policy.mutable_battery_delays()->set_screen_off_ms(360000);
  75   expected_policy.mutable_battery_delays()->set_screen_lock_ms(-1);
  76   expected_policy.mutable_battery_delays()->set_idle_warning_ms(-1);
  77   expected_policy.mutable_battery_delays()->set_idle_ms(420000);
  78   expected_policy.set_ac_idle_action(
  79       power_manager::PowerManagementPolicy_Action_SUSPEND);
  80   expected_policy.set_battery_idle_action(
  81       power_manager::PowerManagementPolicy_Action_STOP_SESSION);
  82   expected_policy.set_lid_closed_action(
  83       power_manager::PowerManagementPolicy_Action_SHUT_DOWN);
  84   expected_policy.set_use_audio_activity(true);
  85   expected_policy.set_use_video_activity(true);
  86   expected_policy.set_ac_brightness_percent(87.0);
  87   expected_policy.set_battery_brightness_percent(43.0);
  88   expected_policy.set_presentation_screen_dim_delay_factor(3.0);
  89   expected_policy.set_user_activity_screen_dim_delay_factor(2.0);
  90   expected_policy.set_wait_for_initial_user_activity(true);
  91   expected_policy.set_reason("Prefs");
  92   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
  93             PowerPolicyController::GetPolicyDebugString(
  94                 fake_power_client_->policy()));
  95
  96   // Change some prefs and check that an updated policy is sent.
  97   prefs.ac_idle_warning_delay_ms = 700000;
  98   prefs.battery_idle_warning_delay_ms = 400000;
  99   prefs.lid_closed_action = PowerPolicyController::ACTION_SUSPEND;
 100   prefs.ac_brightness_percent = -1.0;
 101   policy_controller_->ApplyPrefs(prefs);
 102   expected_policy.mutable_ac_delays()->set_idle_warning_ms(700000);
 103   expected_policy.mutable_battery_delays()->set_idle_warning_ms(400000);
 104   expected_policy.set_lid_closed_action(
 105       power_manager::PowerManagementPolicy_Action_SUSPEND);
 106   expected_policy.clear_ac_brightness_percent();
 107   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 108             PowerPolicyController::GetPolicyDebugString(
 109                 fake_power_client_->policy()));
 110
 111   // The enable-auto-screen-lock pref should force the screen-lock delays to
 112   // match the screen-off delays plus a constant value.
 113   prefs.enable_auto_screen_lock = true;
 114   policy_controller_->ApplyPrefs(prefs);
 115   expected_policy.mutable_ac_delays()->set_screen_lock_ms(
 116       660000 + PowerPolicyController::kScreenLockAfterOffDelayMs);
 117   expected_policy.mutable_battery_delays()->set_screen_lock_ms(
 118       360000 + PowerPolicyController::kScreenLockAfterOffDelayMs);
 119   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 120             PowerPolicyController::GetPolicyDebugString(
 121                 fake_power_client_->policy()));
 122
 123   // If the screen-lock-delay prefs are set to lower values than the
 124   // screen-off delays plus the constant, the lock prefs should take
 125   // precedence.
 126   prefs.ac_screen_lock_delay_ms = 70000;
 127   prefs.battery_screen_lock_delay_ms = 60000;
 128   policy_controller_->ApplyPrefs(prefs);
 129   expected_policy.mutable_ac_delays()->set_screen_lock_ms(70000);
 130   expected_policy.mutable_battery_delays()->set_screen_lock_ms(60000);
 131   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 132             PowerPolicyController::GetPolicyDebugString(
 133                 fake_power_client_->policy()));
 134
 135   // If the artificial screen-lock delays would exceed the idle delay, they
 136   // shouldn't be set -- the power manager would ignore them since the
 137   // idle action should lock the screen in this case.
 138   prefs.ac_screen_off_delay_ms = prefs.ac_idle_delay_ms - 1;
 139   prefs.battery_screen_off_delay_ms = prefs.battery_idle_delay_ms - 1;
 140   prefs.ac_screen_lock_delay_ms = -1;
 141   prefs.battery_screen_lock_delay_ms = -1;
 142   policy_controller_->ApplyPrefs(prefs);
 143   expected_policy.mutable_ac_delays()->set_screen_off_ms(
 144       prefs.ac_screen_off_delay_ms);
 145   expected_policy.mutable_battery_delays()->set_screen_off_ms(
 146       prefs.battery_screen_off_delay_ms);
 147   expected_policy.mutable_ac_delays()->set_screen_lock_ms(-1);
 148   expected_policy.mutable_battery_delays()->set_screen_lock_ms(-1);
 149   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 150             PowerPolicyController::GetPolicyDebugString(
 151                 fake_power_client_->policy()));
 152
 153   // Set the "allow screen wake locks" pref to false.  The system should be
 154   // prevented from suspending due to user inactivity on AC power but the
 155   // pref-supplied screen-related delays should be left untouched.
 156   prefs.allow_screen_wake_locks = false;
 157   policy_controller_->ApplyPrefs(prefs);
 158   policy_controller_->AddScreenWakeLock("Screen");
 159   expected_policy.set_ac_idle_action(
 160       power_manager::PowerManagementPolicy_Action_DO_NOTHING);
 161   expected_policy.set_reason("Prefs, Screen");
 162   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 163             PowerPolicyController::GetPolicyDebugString(
 164                 fake_power_client_->policy()));
 165 }
 166
 167 TEST_F(PowerPolicyControllerTest, WakeLocks) {
 168   const char kSystemWakeLockReason[] = "system";
 169   const int system_id =
 170       policy_controller_->AddSystemWakeLock(kSystemWakeLockReason);
 171   power_manager::PowerManagementPolicy expected_policy;
 172   expected_policy.set_ac_idle_action(
 173       power_manager::PowerManagementPolicy_Action_DO_NOTHING);
 174   expected_policy.set_battery_idle_action(
 175       power_manager::PowerManagementPolicy_Action_DO_NOTHING);
 176   expected_policy.set_reason(kSystemWakeLockReason);
 177   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 178             PowerPolicyController::GetPolicyDebugString(
 179                 fake_power_client_->policy()));
 180
 181   const char kScreenWakeLockReason[] = "screen";
 182   const int screen_id = policy_controller_->AddScreenWakeLock(
 183       kScreenWakeLockReason);
 184   expected_policy.mutable_ac_delays()->set_screen_dim_ms(0);
 185   expected_policy.mutable_ac_delays()->set_screen_off_ms(0);
 186   expected_policy.mutable_ac_delays()->set_screen_lock_ms(0);
 187   expected_policy.mutable_battery_delays()->set_screen_dim_ms(0);
 188   expected_policy.mutable_battery_delays()->set_screen_off_ms(0);
 189   expected_policy.mutable_battery_delays()->set_screen_lock_ms(0);
 190   expected_policy.set_reason(
 191       std::string(kScreenWakeLockReason) + ", " + kSystemWakeLockReason);
 192   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 193             PowerPolicyController::GetPolicyDebugString(
 194                 fake_power_client_->policy()));
 195
 196   policy_controller_->RemoveWakeLock(system_id);
 197   expected_policy.set_reason(kScreenWakeLockReason);
 198   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 199             PowerPolicyController::GetPolicyDebugString(
 200                 fake_power_client_->policy()));
 201
 202   policy_controller_->RemoveWakeLock(screen_id);
 203   expected_policy.Clear();
 204   EXPECT_EQ(PowerPolicyController::GetPolicyDebugString(expected_policy),
 205             PowerPolicyController::GetPolicyDebugString(
 206                 fake_power_client_->policy()));
 207 }
 208
 209 TEST_F(PowerPolicyControllerTest, AvoidSendingEmptyPolicies) {
 210   // Check that empty policies aren't sent when PowerPolicyController is created
 211   // or destroyed.
 212   EXPECT_EQ(0, fake_power_client_->num_set_policy_calls());
 213   policy_controller_.reset();
 214   EXPECT_EQ(0, fake_power_client_->num_set_policy_calls());
 215 }
 216
 217 }  // namespace chromeos