chromeos: Add delay between screen off and lock.

chromeos/dbus/power_policy_controller.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/format_macros.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 125 matching lines @@
   manager_ = NULL;
 }
 
 void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
   prefs_policy_.Clear();
 
   power_manager::PowerManagementPolicy::Delays* delays =
       prefs_policy_.mutable_ac_delays();
   delays->set_screen_dim_ms(values.ac_screen_dim_delay_ms);
   delays->set_screen_off_ms(values.ac_screen_off_delay_ms);
-  delays->set_screen_lock_ms(values.ac_screen_lock_delay_ms);
+  delays->set_screen_lock_ms(
+      values.enable_screen_lock ? values.ac_screen_lock_delay_ms : 0);

[Mattias Nissler (ping if slow), 2013/05/31 13:22:46]

This would become:

if (values.ac_screen_lock_delay_ms > 0) {
  delays->set_screen_lock_ms(values.ac_screen_lock_delay_ms);
} else if (values.enable_screen_lock) {
  delays->set_screen_lock_ms(values.ac_screen_off_delay_ms + 10000);
}

[bartfab (slow), 2013/05/31 13:35:59]

Actually, I think we would want to use the minimum of the two values (if both
are configured). The idea of the |screen_lock_delay_ms| pref was that the admin
could set it to any value desired, without worrying about whether
|screen_lock_delay| is enabled, is longer or is shorter than
|screen_lock_delay_ms|.

If |screen_lock_delay_ms| is set by the admin, the screen should always lock at
that point at the latest.

[bartfab (slow), 2013/05/31 13:37:32]

Let me try that again, hopefully without confusing pref names this time:

Actually, I think we would want to use the minimum of the two values (if
both are configured). The idea of the |screen_lock_delay_ms| pref was
that the admin could set it to any value desired, without worrying about
whether |screen_off_delay_ms| is enabled, is longer or is shorter than
|screen_lock_delay_ms|.

If |screen_lock_delay_ms| is set by the admin, the screen should always
lock at that point at the latest. 

[Daniel Erat, 2013/05/31 13:41:58]

Yes, I agree. Like Mattias suggested, I'll just retain the existing blocks of
code but add a constant to the screen-off delays. See #1 in
http://crbug.com/239486#2.

   delays->set_idle_warning_ms(values.ac_idle_warning_delay_ms);
   delays->set_idle_ms(values.ac_idle_delay_ms);
 
-  // If screen-locking is enabled, ensure that the screen is locked when
-  // it's turned off due to user inactivity.

[Mattias Nissler (ping if slow), 2013/05/31 13:22:46]

I guess we want to retain this block.

-  if (values.enable_screen_lock && delays->screen_off_ms() > 0 &&
-      (delays->screen_lock_ms() <= 0 ||
-       delays->screen_off_ms() < delays->screen_lock_ms())) {
-    delays->set_screen_lock_ms(delays->screen_off_ms());
-  }
-
   delays = prefs_policy_.mutable_battery_delays();
   delays->set_screen_dim_ms(values.battery_screen_dim_delay_ms);
   delays->set_screen_off_ms(values.battery_screen_off_delay_ms);
-  delays->set_screen_lock_ms(values.battery_screen_lock_delay_ms);
+  delays->set_screen_lock_ms(
+      values.enable_screen_lock ? values.battery_screen_lock_delay_ms : 0);

[Mattias Nissler (ping if slow), 2013/05/31 13:22:46]

same for battery obviously.

   delays->set_idle_warning_ms(values.battery_idle_warning_delay_ms);
   delays->set_idle_ms(values.battery_idle_delay_ms);
-  if (values.enable_screen_lock && delays->screen_off_ms() > 0 &&
-      (delays->screen_lock_ms() <= 0 ||
-       delays->screen_off_ms() < delays->screen_lock_ms())) {
-    delays->set_screen_lock_ms(delays->screen_off_ms());
-  }
 
   prefs_policy_.set_idle_action(GetProtoAction(values.idle_action));
   prefs_policy_.set_lid_closed_action(GetProtoAction(values.lid_closed_action));
   prefs_policy_.set_use_audio_activity(values.use_audio_activity);
   prefs_policy_.set_use_video_activity(values.use_video_activity);
   prefs_policy_.set_presentation_idle_delay_factor(
       values.presentation_idle_delay_factor);
   prefs_policy_.set_user_activity_screen_dim_delay_factor(
       values.user_activity_screen_dim_delay_factor);
 
@@ skipping 37 matching lines @@
 void PowerPolicyController::SendCurrentPolicy() {
   std::string reason;
 
   power_manager::PowerManagementPolicy policy = prefs_policy_;
   if (prefs_were_set_)
     reason = "Prefs";
 
   if (honor_screen_wake_locks_ && !screen_wake_locks_.empty()) {
     policy.mutable_ac_delays()->set_screen_dim_ms(0);
     policy.mutable_ac_delays()->set_screen_off_ms(0);
+    policy.mutable_ac_delays()->set_screen_lock_ms(0);
     policy.mutable_battery_delays()->set_screen_dim_ms(0);
     policy.mutable_battery_delays()->set_screen_off_ms(0);
+    policy.mutable_battery_delays()->set_screen_lock_ms(0);
   }
 
   if ((!screen_wake_locks_.empty() || !system_wake_locks_.empty()) &&
       (!policy.has_idle_action() || policy.idle_action() ==
        power_manager::PowerManagementPolicy_Action_SUSPEND)) {
     policy.set_idle_action(
         power_manager::PowerManagementPolicy_Action_DO_NOTHING);
   }
 
   for (WakeLockMap::const_iterator it = screen_wake_locks_.begin();
        it != screen_wake_locks_.end(); ++it) {
     reason += (reason.empty() ? "" : ", ") + it->second;
   }
   for (WakeLockMap::const_iterator it = system_wake_locks_.begin();
        it != system_wake_locks_.end(); ++it) {
     reason += (reason.empty() ? "" : ", ") + it->second;
   }
 
   if (!reason.empty())
     policy.set_reason(reason);
   client_->SetPolicy(policy);
 }
 
 void PowerPolicyController::SendEmptyPolicy() {
   client_->SetPolicy(power_manager::PowerManagementPolicy());
 }
 
 }  // namespace chromeos