chromeos: Move default power management policy into Chrome.

chromeos/dbus/power_policy_controller_unittest.cc

 // Copyright (c) 2013 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 "chromeos/dbus/power_policy_controller.h"
 
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/testing_pref_service.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/mock_dbus_thread_manager.h"
 #include "chromeos/dbus/mock_power_manager_client.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::SaveArg;
 
 namespace chromeos {
 
 class PowerPolicyControllerTest : public testing::Test {
  public:
   PowerPolicyControllerTest() {}
   virtual ~PowerPolicyControllerTest() {}
 
   virtual void SetUp() OVERRIDE {
     dbus_manager_ = new MockDBusThreadManager;
     DBusThreadManager::InitializeForTesting(dbus_manager_);  // Takes ownership.
     power_client_ = dbus_manager_->mock_power_manager_client();
     EXPECT_CALL(*power_client_, SetPolicy(_))
         .WillRepeatedly(SaveArg<0>(&last_policy_));
 
     policy_controller_ = dbus_manager_->GetPowerPolicyController();
 
-    // TODO(derat): Write what looks like it will be a ridiculously large
-    // amount of code to register prefs so that UpdatePolicyFromPrefs() can
-    // be tested.
+    prefs_.registry()->RegisterIntegerPref(kAcScreenDimDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kAcScreenOffDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kAcScreenLockDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kAcIdleWarningDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kAcIdleDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kBatteryScreenDimDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kBatteryScreenOffDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kBatteryScreenLockDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kBatteryIdleWarningDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kBatteryIdleDelay, 0);
+    prefs_.registry()->RegisterIntegerPref(kIdleAction, 0);
+    prefs_.registry()->RegisterIntegerPref(kLidClosedAction, 0);
+    prefs_.registry()->RegisterBooleanPref(kUseAudioActivity, false);
+    prefs_.registry()->RegisterBooleanPref(kUseVideoActivity, false);
+    prefs_.registry()->RegisterBooleanPref(kEnableScreenLock, false);
+    prefs_.registry()->RegisterDoublePref(kPresentationIdleDelayFactor, 0.0);
   }
 
   virtual void TearDown() OVERRIDE {
     DBusThreadManager::Shutdown();
   }
 
  protected:
+  // Names for various prefs.
+  static const char kAcScreenDimDelay[];
+  static const char kAcScreenOffDelay[];
+  static const char kAcScreenLockDelay[];
+  static const char kAcIdleWarningDelay[];
+  static const char kAcIdleDelay[];
+  static const char kBatteryScreenDimDelay[];
+  static const char kBatteryScreenOffDelay[];
+  static const char kBatteryScreenLockDelay[];
+  static const char kBatteryIdleWarningDelay[];
+  static const char kBatteryIdleDelay[];
+  static const char kIdleAction[];
+  static const char kLidClosedAction[];
+  static const char kUseAudioActivity[];
+  static const char kUseVideoActivity[];
+  static const char kEnableScreenLock[];
+  static const char kPresentationIdleDelayFactor[];
+
+  void InitControllerPrefs() {
+    PowerPolicyController::PrefNames names;
+    names.ac_screen_dim_delay_ms = kAcScreenDimDelay;
+    names.ac_screen_off_delay_ms = kAcScreenOffDelay;
+    names.ac_screen_lock_delay_ms =kAcScreenLockDelay;

[bartfab (slow), 2013/04/17 11:51:12]

Nit: Space after =

[Daniel Erat, 2013/04/18 03:59:16]

n/a

+    names.ac_idle_warning_delay_ms = kAcIdleWarningDelay;
+    names.ac_idle_delay_ms = kAcIdleDelay;
+    names.battery_screen_dim_delay_ms = kBatteryScreenDimDelay;
+    names.battery_screen_off_delay_ms = kBatteryScreenOffDelay;
+    names.battery_screen_lock_delay_ms = kBatteryScreenLockDelay;
+    names.battery_idle_warning_delay_ms = kBatteryIdleWarningDelay;
+    names.battery_idle_delay_ms = kBatteryIdleDelay;
+    names.idle_action = kIdleAction;
+    names.lid_closed_action = kLidClosedAction;
+    names.use_audio_activity = kUseAudioActivity;
+    names.use_video_activity = kUseVideoActivity;
+    names.enable_screen_lock = kEnableScreenLock;
+    names.presentation_idle_delay_factor = kPresentationIdleDelayFactor;
+    policy_controller_->InitPrefs(&prefs_, names);
+  }
+
   MockDBusThreadManager* dbus_manager_;  // Not owned.
   MockPowerManagerClient* power_client_;  // Not owned.
   PowerPolicyController* policy_controller_;  // Not owned.
 
+  TestingPrefServiceSimple prefs_;
+
   power_manager::PowerManagementPolicy last_policy_;
 };
 
+const char PowerPolicyControllerTest::kAcScreenDimDelay[] = "a_dim";
+const char PowerPolicyControllerTest::kAcScreenOffDelay[] = "a_off";
+const char PowerPolicyControllerTest::kAcScreenLockDelay[] = "a_lock";
+const char PowerPolicyControllerTest::kAcIdleWarningDelay[] = "a_warning";
+const char PowerPolicyControllerTest::kAcIdleDelay[] = "a_idle";
+const char PowerPolicyControllerTest::kBatteryScreenDimDelay[] = "b_dim";
+const char PowerPolicyControllerTest::kBatteryScreenOffDelay[] = "b_off";
+const char PowerPolicyControllerTest::kBatteryScreenLockDelay[] = "b_lock";
+const char PowerPolicyControllerTest::kBatteryIdleWarningDelay[] = "b_warning";
+const char PowerPolicyControllerTest::kBatteryIdleDelay[] = "b_idle";
+const char PowerPolicyControllerTest::kIdleAction[] = "idle_action";
+const char PowerPolicyControllerTest::kLidClosedAction[] = "lid_closed_action";
+const char PowerPolicyControllerTest::kUseAudioActivity[] = "use_audio";
+const char PowerPolicyControllerTest::kUseVideoActivity[] = "use_video";
+const char PowerPolicyControllerTest::kEnableScreenLock[] = "enable_lock";
+const char PowerPolicyControllerTest::kPresentationIdleDelayFactor[] =
+    "presentation_idle_delay_factor";
+
+TEST_F(PowerPolicyControllerTest, Prefs) {
+  prefs_.SetInteger(kAcScreenDimDelay, 600000);
+  prefs_.SetInteger(kAcScreenOffDelay, 660000);
+  prefs_.SetInteger(kAcIdleDelay, 720000);
+  prefs_.SetInteger(kBatteryScreenDimDelay, 300000);
+  prefs_.SetInteger(kBatteryScreenOffDelay, 360000);
+  prefs_.SetInteger(kBatteryIdleDelay, 420000);
+  prefs_.SetInteger(kIdleAction, PowerPolicyController::ACTION_SUSPEND);
+  prefs_.SetInteger(kLidClosedAction, PowerPolicyController::ACTION_SHUT_DOWN);
+  prefs_.SetBoolean(kUseAudioActivity, true);
+  prefs_.SetBoolean(kUseVideoActivity, true);
+  prefs_.SetBoolean(kEnableScreenLock, false);
+  prefs_.SetDouble(kPresentationIdleDelayFactor, 2.0);
+  InitControllerPrefs();
+
+  power_manager::PowerManagementPolicy expected_policy;
+  expected_policy.mutable_ac_delays()->set_screen_dim_ms(600000);
+  expected_policy.mutable_ac_delays()->set_screen_off_ms(660000);
+  expected_policy.mutable_ac_delays()->set_screen_lock_ms(0);
+  expected_policy.mutable_ac_delays()->set_idle_warning_ms(0);
+  expected_policy.mutable_ac_delays()->set_idle_ms(720000);
+  expected_policy.mutable_battery_delays()->set_screen_dim_ms(300000);
+  expected_policy.mutable_battery_delays()->set_screen_off_ms(360000);
+  expected_policy.mutable_battery_delays()->set_screen_lock_ms(0);
+  expected_policy.mutable_battery_delays()->set_idle_warning_ms(0);
+  expected_policy.mutable_battery_delays()->set_idle_ms(420000);
+  expected_policy.set_idle_action(
+      power_manager::PowerManagementPolicy_Action_SUSPEND);
+  expected_policy.set_lid_closed_action(
+      power_manager::PowerManagementPolicy_Action_SHUT_DOWN);
+  expected_policy.set_use_audio_activity(true);
+  expected_policy.set_use_video_activity(true);
+  expected_policy.set_presentation_idle_delay_factor(2.0);
+  EXPECT_EQ(expected_policy.SerializeAsString(),
+            last_policy_.SerializeAsString());
+
+  // Change some prefs and check that an updated policy is sent.
+  prefs_.SetInteger(kAcIdleWarningDelay, 700000);
+  prefs_.SetInteger(kBatteryIdleWarningDelay, 400000);
+  prefs_.SetInteger(kLidClosedAction, PowerPolicyController::ACTION_SUSPEND);
+  expected_policy.mutable_ac_delays()->set_idle_warning_ms(700000);
+  expected_policy.mutable_battery_delays()->set_idle_warning_ms(400000);
+  expected_policy.set_lid_closed_action(
+      power_manager::PowerManagementPolicy_Action_SUSPEND);
+  EXPECT_EQ(expected_policy.SerializeAsString(),
+            last_policy_.SerializeAsString());
+
+  // The enable-screen-lock pref should force the screen-lock delays to
+  // match the screen-off delays.
+  prefs_.SetBoolean(kEnableScreenLock, true);
+  expected_policy.mutable_ac_delays()->set_screen_lock_ms(660000);
+  expected_policy.mutable_battery_delays()->set_screen_lock_ms(360000);
+  EXPECT_EQ(expected_policy.SerializeAsString(),
+            last_policy_.SerializeAsString());
+
+  // If the screen-lock-delay prefs are set to lower values than the
+  // screen-off delays, the lock prefs should take precedence.
+  prefs_.SetInteger(kAcScreenLockDelay, 70000);
+  prefs_.SetInteger(kBatteryScreenLockDelay, 60000);
+  expected_policy.mutable_ac_delays()->set_screen_lock_ms(70000);
+  expected_policy.mutable_battery_delays()->set_screen_lock_ms(60000);
+  EXPECT_EQ(expected_policy.SerializeAsString(),
+            last_policy_.SerializeAsString());
+}
+
 TEST_F(PowerPolicyControllerTest, Blocks) {
   const char kSuspendBlockReason[] = "suspend";
   const int suspend_id =
       policy_controller_->AddSuspendBlock(kSuspendBlockReason);
   power_manager::PowerManagementPolicy expected_policy;
   expected_policy.set_idle_action(
       power_manager::PowerManagementPolicy_Action_DO_NOTHING);
   expected_policy.set_reason(kSuspendBlockReason);
   EXPECT_EQ(expected_policy.SerializeAsString(),
             last_policy_.SerializeAsString());
@@ skipping 14 matching lines @@
   EXPECT_EQ(expected_policy.SerializeAsString(),
             last_policy_.SerializeAsString());
 
   policy_controller_->RemoveBlock(screen_id);
   expected_policy.Clear();
   EXPECT_EQ(expected_policy.SerializeAsString(),
             last_policy_.SerializeAsString());
 }
 
 }  // namespace chromeos