Add browser test for Chrome OS power management policies

This CL adds a test which verifies that changes to enterprise policies
controlling power management cause updated settings to be sent to the
power management backend. The backend daemon's behavior is covered by
separate tests.

BUG=161267
TEST=browser test PowerPolicyBrowserTest.SetPowerPolicy

Review URL: https://codereview.chromium.org/12212132

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@182720 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 207 insertions, 0 deletions

diff --git a/chrome/browser/policy/power_policy_browsertest.cc b/chrome/browser/policy/power_policy_browsertest.cc
new file mode 100644
index 0000000..e9256f9
--- /dev/null
+++ b/chrome/browser/policy/power_policy_browsertest.cc
@@ -0,0 +1,207 @@
+// 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 <string>
+
+#include "base/compiler_specific.h"
+#include "base/run_loop.h"
+#include "base/values.h"
+#include "chrome/browser/policy/browser_policy_connector.h"
+#include "chrome/browser/policy/mock_configuration_policy_provider.h"
+#include "chrome/browser/policy/policy_map.h"
+#include "chrome/browser/policy/policy_types.h"
+#include "chrome/test/base/in_process_browser_test.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 "chromeos/dbus/mock_session_manager_client.h"
+#include "chromeos/dbus/power_manager/policy.pb.h"
+#include "policy/policy_constants.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace policy {
+
+namespace {
+
+using ::testing::AnyNumber;
+using ::testing::AtLeast;
+using ::testing::Mock;
+using ::testing::Return;
+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();
+  return actual.SerializeAsString() == expected.SerializeAsString();
+}
+
+}  // namespace
+
+class PowerPolicyBrowserTest : public InProcessBrowserTest {
+ protected:
+  // InProcessBrowserTest:
+  virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
+
+  void SetUserPolicyAndVerifyPowerManagementPolicy(
+      const std::string& user_policy_name,
+      base::Value* user_policy_value,
+      const pm::PowerManagementPolicy& power_management_policy);
+
+  chromeos::MockPowerManagerClient* power_manager_client_;
+
+ private:
+  MockConfigurationPolicyProvider provider_;
+};
+
+void PowerPolicyBrowserTest::SetUpInProcessBrowserTestFixture() {
+  chromeos::MockDBusThreadManager* dbus_thread_manager =
+      new chromeos::MockDBusThreadManager;
+  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_, RegisterPolicyNamespace(_, _)).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(
+    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));
+  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_);
+}
+
+IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
+  pm::PowerManagementPolicy power_management_policy;
+
+  power_management_policy.set_idle_action(
+      pm::PowerManagementPolicy::STOP_SESSION);
+  SetUserPolicyAndVerifyPowerManagementPolicy(
+      key::kIdleAction,
+      base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION),
+      power_management_policy);
+
+  power_management_policy.Clear();
+  power_management_policy.set_lid_closed_action(
+      pm::PowerManagementPolicy::STOP_SESSION);
+  SetUserPolicyAndVerifyPowerManagementPolicy(
+      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_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_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();
+  power_management_policy.set_use_audio_activity(false);
+  SetUserPolicyAndVerifyPowerManagementPolicy(
+      key::kPowerManagementUsesAudioActivity,
+      base::Value::CreateBooleanValue(false),
+      power_management_policy);
+
+  power_management_policy.Clear();
+  power_management_policy.set_use_video_activity(false);
+  SetUserPolicyAndVerifyPowerManagementPolicy(
+      key::kPowerManagementUsesVideoActivity,
+      base::Value::CreateBooleanValue(false),
+      power_management_policy);
+
+  power_management_policy.Clear();
+  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());
+}
+
+}  // namespace policy