chromeos: Add delay between screen off and lock.

chrome/browser/chromeos/policy/power_policy_browsertest.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 <string>
 
 #include "base/compiler_specific.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/power/power_api_manager.h"
@@ skipping 51 matching lines @@
   EXPECT_CALL(provider_, RegisterPolicyDomain(_, _)).Times(AnyNumber());
   BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
 }
 
 void PowerPolicyBrowserTest::SetUserPolicy(
     const std::string& user_policy_name,
     base::Value* user_policy_value) {
   PolicyMap policy_map;
   policy_map.Set(user_policy_name, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER,
                  user_policy_value);
+
+  // The lock-on-idle-suspend policy must be set in order for the
+  // screen-lock-delay policies to be honored.
+  if (user_policy_name == key::kScreenLockDelayAC ||

[Daniel Erat, 2013/05/22 17:12:34]

This feels gross; let me know if you can think of a better approach.

+      user_policy_name == key::kScreenLockDelayBattery) {
+    policy_map.Set(key::kChromeOsLockOnIdleSuspend, POLICY_LEVEL_MANDATORY,
+                   POLICY_SCOPE_USER, base::Value::CreateBooleanValue(true));
+  }
+
   provider_.UpdateChromePolicy(policy_map);
   base::RunLoop().RunUntilIdle();
 }
 
 std::string PowerPolicyBrowserTest::GetDebugString(
     const pm::PowerManagementPolicy& policy) {
   return chromeos::PowerPolicyController::GetPolicyDebugString(policy);
 }
 
 IN_PROC_BROWSER_TEST_F(PowerPolicyBrowserTest, SetPowerPolicy) {
   pm::PowerManagementPolicy original_power_management_policy =
       power_manager_client_->get_policy();
 
+  // Also save the default policy that's sent when the lock-on-idle-suspend
+  // policy is enabled, as it results in a different interpretation of the
+  // screen-lock-delay policies.
+  SetUserPolicy(key::kChromeOsLockOnIdleSuspend,
+                base::Value::CreateBooleanValue(true));
+  pm::PowerManagementPolicy original_power_management_screen_lock_policy =
+      power_manager_client_->get_policy();
+
   pm::PowerManagementPolicy power_management_policy =
       original_power_management_policy;
   power_management_policy.set_idle_action(
       pm::PowerManagementPolicy::STOP_SESSION);
   SetUserPolicy(
       key::kIdleAction,
       base::Value::CreateIntegerValue(pm::PowerManagementPolicy::STOP_SESSION));
   EXPECT_EQ(GetDebugString(power_management_policy),
             GetDebugString(power_manager_client_->get_policy()));
 
@@ skipping 24 matching lines @@
   SetUserPolicy(key::kScreenOffDelayAC, base::Value::CreateIntegerValue(7000));
   EXPECT_EQ(GetDebugString(power_management_policy),
             GetDebugString(power_manager_client_->get_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(power_manager_client_->get_policy()));
 
-  power_management_policy = original_power_management_policy;
+  power_management_policy = original_power_management_screen_lock_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(power_manager_client_->get_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(power_manager_client_->get_policy()));
@@ skipping 12 matching lines @@
   EXPECT_EQ(GetDebugString(power_management_policy),
             GetDebugString(power_manager_client_->get_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(power_manager_client_->get_policy()));
 
-  power_management_policy = original_power_management_policy;
+  power_management_policy = original_power_management_screen_lock_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(power_manager_client_->get_policy()));
 
   power_management_policy = original_power_management_policy;
   power_management_policy.set_use_audio_activity(false);
   SetUserPolicy(key::kPowerManagementUsesAudioActivity,
                 base::Value::CreateBooleanValue(false));
@@ skipping 47 matching lines @@
   SetUserPolicy(key::kAllowScreenWakeLocks,
                 base::Value::CreateBooleanValue(false));
   policy = baseline_policy;
   policy.set_idle_action(power_manager_client_->get_policy().idle_action());
   policy.set_reason(power_manager_client_->get_policy().reason());
   EXPECT_EQ(GetDebugString(policy),
             GetDebugString(power_manager_client_->get_policy()));
 }
 
 }  // namespace policy