chromeos: Move default power management policy into Chrome.

chrome/browser/chromeos/policy/power_policy_browsertest.cc

Index: chrome/browser/chromeos/policy/power_policy_browsertest.cc
diff --git a/chrome/browser/chromeos/policy/power_policy_browsertest.cc b/chrome/browser/chromeos/policy/power_policy_browsertest.cc
index 93d33f97a549f4bb6a368d99292f2deeb6847e4d..9387a789ef5840923d061551bc208db3854ac032 100644
--- a/chrome/browser/chromeos/policy/power_policy_browsertest.cc
+++ b/chrome/browser/chromeos/policy/power_policy_browsertest.cc
@@ -18,6 +18,7 @@
 #include "chromeos/dbus/mock_session_manager_client.h"
 #include "chromeos/dbus/mock_update_engine_client.h"
 #include "chromeos/dbus/power_manager/policy.pb.h"
+#include "chromeos/dbus/power_policy_controller.h"
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ -29,28 +30,11 @@ using ::testing::AnyNumber;
 using ::testing::AtLeast;
 using ::testing::Mock;
 using ::testing::Return;
+using ::testing::SaveArg;
 using ::testing::_;
 
 namespace pm = power_manager;
 
-MATCHER_P(PowerManagementPolicyMatches, expected_power_management_policy,
-          std::string(negation ? "matches" : "does not match") +
-              "the expected power management policy") {
-  // A power management policy without an |ac_delays| message is equivalent to
-  // a power management policy with an empty |ac_delays| message but their
-  // serializations are different. To simplify the equality check, ensure that
-  // the expected and actual power management policies both have an |ac_delays|
-  // message. The same applies to the |battery_delays| message.
-  pm::PowerManagementPolicy expected(expected_power_management_policy);
-  expected.mutable_ac_delays();
-  expected.mutable_battery_delays();
-  pm::PowerManagementPolicy actual(arg);
-  actual.mutable_ac_delays();
-  actual.mutable_battery_delays();
-  actual.clear_reason();
-  return actual.SerializeAsString() == expected.SerializeAsString();
-}
-
 }  // namespace
 
 class PowerPolicyBrowserTest : public InProcessBrowserTest {
@@ -58,13 +42,18 @@ class PowerPolicyBrowserTest : public InProcessBrowserTest {
   // InProcessBrowserTest:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
 
-  void SetUserPolicyAndVerifyPowerManagementPolicy(
-      const std::string& user_policy_name,
-      base::Value* user_policy_value,
-      const pm::PowerManagementPolicy& power_management_policy);
+  // Sets |user_policy_name| to |user_policy_value|.
+  void SetUserPolicy(const std::string& user_policy_name,
+                     base::Value* user_policy_value);
+
+  // Returns a string describing |policy|.
+  std::string GetDebugString(const pm::PowerManagementPolicy& policy);
 
   chromeos::MockPowerManagerClient* power_manager_client_;
 
+  // Last PowerManagementPolicy sent by |power_manager_client_|.
+  pm::PowerManagementPolicy last_power_management_policy_;
+
  private:
   MockConfigurationPolicyProvider provider_;
 };
@@ -72,152 +61,151 @@ class PowerPolicyBrowserTest : public InProcessBrowserTest {
 void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() {
   chromeos::MockDBusThreadManager* dbus_thread_manager =
       new chromeos::MockDBusThreadManager;
+  power_manager_client_ = dbus_thread_manager->mock_power_manager_client();
+
+  // Capture the PowerManagementPolicy that's sent before tests start
+  // making changes to the user policy.
+  EXPECT_CALL(*power_manager_client_, SetPolicy(_))
+      .WillRepeatedly(SaveArg<0>(&last_power_management_policy_));
+
+  // Ignore uninteresting calls.
+  EXPECT_CALL(*power_manager_client_, AddObserver(_))
+      .Times(AnyNumber());
+  EXPECT_CALL(*power_manager_client_, RemoveObserver(_))
+      .Times(AnyNumber());
+
   chromeos::DBusThreadManager::InitializeForTesting(dbus_thread_manager);
   EXPECT_CALL(*dbus_thread_manager->mock_session_manager_client(),
               RetrieveUserPolicy(_));
-  power_manager_client_ = dbus_thread_manager->mock_power_manager_client();
   EXPECT_CALL(provider_, IsInitializationComplete(_))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(provider_, RegisterPolicyDomain(_, _)).Times(AnyNumber());
   BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
 }
 
-// Verify that setting |user_policy_name| to |user_policy_value| causes the
-// updated |power_management_policy| to be sent to the power management backend.
-void PowerPolicyBrowserTest::SetUserPolicyAndVerifyPowerManagementPolicy(
+void PowerPolicyBrowserTest::SetUserPolicy(
     const std::string& user_policy_name,
-    base::Value* user_policy_value,
-    const pm::PowerManagementPolicy& power_management_policy) {
-  // Setting the user policy causes a notification which triggers an update to
-  // the backend. If other policies had been set before, they will get unset,
-  // causing additional notifications and triggering duplicate updates to the
-  // backend. Hence, expect one or more updates.
-  EXPECT_CALL(*power_manager_client_,
-              SetPolicy(PowerManagementPolicyMatches(power_management_policy)))
-      .Times(AtLeast(1));
+    base::Value* user_policy_value) {
   PolicyMap policy_map;
   policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  user_policy_value);
   provider_.UpdateChromePolicy(policy_map);
   base::RunLoop().RunUntilIdle();
-  Mock::VerifyAndClearExpectations(power_manager_client_);
+}
+
+std::string PowerPolicyBrowserTest::GetDebugString(
+    const pm::PowerManagementPolicy& policy) {
+  return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
 }
 
 IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
-  pm::PowerManagementPolicy power_management_policy;
+  pm::PowerManagementPolicy original_power_management_policy =
+      last_power_management_policy_;
 
+  pm::PowerManagementPolicy power_management_policy =
+      original_power_management_policy;
   power_management_policy.set_idle_action(
       pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
+  SetUserPolicy(
       key::kIdleAction,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION),
-      power_management_policy);
+      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
 
-  power_management_policy.Clear();
+  power_management_policy = original_power_management_policy;
   power_management_policy.set_lid_closed_action(
       pm::PowerManagementPolicy::STOP_SESSION);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
+  SetUserPolicy(
       key::kLidCloseAction,
-      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_ac_delays()->set_idle_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kIdleDelayAC,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kIdleWarningDelayAC,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_ac_delays()->set_screen_off_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kScreenOffDelayAC,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kScreenDimDelayAC,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kScreenLockDelayAC,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_battery_delays()->set_idle_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kIdleDelayBattery,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kIdleWarningDelayBattery,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_battery_delays()->set_screen_off_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kScreenOffDelayBattery,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kScreenDimDelayBattery,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
-  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(900000);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kScreenLockDelayBattery,
-      base::Value::CreateIntegerValue(900000),
-      power_management_policy);
-
-  power_management_policy.Clear();
+      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_ac_delays()->set_idle_ms(9000);
+  SetUserPolicy(key::kIdleDelayAC, base::Value::CreateIntegerValue(9000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_ac_delays()->set_idle_warning_ms(8000);
+  SetUserPolicy(key::kIdleWarningDelayAC,
+                base::Value::CreateIntegerValue(8000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_ac_delays()->set_screen_off_ms(7000);
+  SetUserPolicy(key::kScreenOffDelayAC, base::Value::CreateIntegerValue(7000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_ac_delays()->set_screen_dim_ms(5000);
+  SetUserPolicy(key::kScreenDimDelayAC, base::Value::CreateIntegerValue(5000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_ac_delays()->set_screen_lock_ms(6000);
+  SetUserPolicy(key::kScreenLockDelayAC, base::Value::CreateIntegerValue(6000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_battery_delays()->set_idle_ms(5000);
+  SetUserPolicy(key::kIdleDelayBattery, base::Value::CreateIntegerValue(5000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_battery_delays()->set_idle_warning_ms(4000);
+  SetUserPolicy(key::kIdleWarningDelayBattery,
+                base::Value::CreateIntegerValue(4000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_battery_delays()->set_screen_off_ms(3000);
+  SetUserPolicy(key::kScreenOffDelayBattery,
+                base::Value::CreateIntegerValue(3000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_battery_delays()->set_screen_dim_ms(1000);
+  SetUserPolicy(key::kScreenDimDelayBattery,
+                base::Value::CreateIntegerValue(1000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
+  power_management_policy.mutable_battery_delays()->set_screen_lock_ms(2000);
+  SetUserPolicy(key::kScreenLockDelayBattery,
+                base::Value::CreateIntegerValue(2000));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
+
+  power_management_policy = original_power_management_policy;
   power_management_policy.set_use_audio_activity(false);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kPowerManagementUsesAudioActivity,
-      base::Value::CreateBooleanValue(false),
-      power_management_policy);
+  SetUserPolicy(key::kPowerManagementUsesAudioActivity,
+                base::Value::CreateBooleanValue(false));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
 
-  power_management_policy.Clear();
+  power_management_policy = original_power_management_policy;
   power_management_policy.set_use_video_activity(false);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kPowerManagementUsesVideoActivity,
-      base::Value::CreateBooleanValue(false),
-      power_management_policy);
+  SetUserPolicy(key::kPowerManagementUsesVideoActivity,
+                base::Value::CreateBooleanValue(false));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
 
-  power_management_policy.Clear();
+  power_management_policy = original_power_management_policy;
   power_management_policy.set_presentation_idle_delay_factor(3.0);
-  SetUserPolicyAndVerifyPowerManagementPolicy(
-      key::kPresentationIdleDelayScale,
-      base::Value::CreateIntegerValue(300),
-      power_management_policy);
-
-  // During teardown, an empty power management policy should be sent to the
-  // backend.
-  power_management_policy.Clear();
-  EXPECT_CALL(*power_manager_client_, SetPolicy(
-      PowerManagementPolicyMatches(power_management_policy)));
-  EXPECT_CALL(*power_manager_client_, RemoveObserver(_)).Times(AnyNumber());
+  SetUserPolicy(key::kPresentationIdleDelayScale,
+                base::Value::CreateIntegerValue(300));
+  EXPECT_EQ(GetDebugString(power_management_policy),
+            GetDebugString(last_power_management_policy_));
 }
 
 }  // namespace policy