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 40 matching lines @@
     case PowerPolicyController::ACTION_DO_NOTHING:
       return power_manager::PowerManagementPolicy_Action_DO_NOTHING;
     default:
       NOTREACHED() << "Unhandled action " << action;
       return power_manager::PowerManagementPolicy_Action_DO_NOTHING;
   }
 }
 
 }  // namespace
 
+const int PowerPolicyController::kScreenLockAfterOffDelayMs = 10000;

[bartfab (slow), 2013/05/31 17:39:07]

Should we make this a tunable pref? Ad if so, should it be tunable for AC and
battery separately?

On the one hand, I see little value in yet another tunable. On the other hand,
we have made everything else adjustable. This is the only hard-coded constant.
And ironically, it has been the offset between screen-off and screen-lock that
has caused us the most headaches. Maybe we should make it tunable so that we can
tweak it easier in the future or even let admins control it in enterprise cases?

[Daniel Erat, 2013/06/01 03:19:43]

No, I don't think that this should be a pref.

- Admins would have no need to set this unless they wanted the gap between
screen-off and screen-lock to be longer than ten seconds. They can already set
the lock delays.
- A constant is as easy for us to tweak as a pref's default value.
- There's no benefit to making this a pref before we have a need to make it
tunable -- it's easy to replace a constant with a pref later.

+
 // -1 is interpreted as "unset" by powerd, resulting in powerd's default
 // delays being used instead.  There are no similarly-interpreted values
 // for the other fields, unfortunately (but the constructor-assigned values
 // will only reach powerd if Chrome messes up and forgets to override them
 // with the pref-assigned values).
 PowerPolicyController::PrefValues::PrefValues()
     : ac_screen_dim_delay_ms(-1),
       ac_screen_off_delay_ms(-1),
       ac_screen_lock_delay_ms(-1),
       ac_idle_warning_delay_ms(-1),
@@ skipping 69 matching lines @@
   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_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.
+  // If screen-locking is enabled, ensure that the screen is locked soon
+  // after it's turned off due to user inactivity.
+  int64 lock_ms = delays->screen_off_ms() + kScreenLockAfterOffDelayMs;
   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->screen_lock_ms() <= 0 || lock_ms < delays->screen_lock_ms()) &&
+      lock_ms < delays->idle_ms())
+    delays->set_screen_lock_ms(lock_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_idle_warning_ms(values.battery_idle_warning_delay_ms);
   delays->set_idle_ms(values.battery_idle_delay_ms);
+
+  lock_ms = delays->screen_off_ms() + kScreenLockAfterOffDelayMs;
   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->screen_lock_ms() <= 0 || lock_ms < delays->screen_lock_ms()) &&
+      lock_ms < delays->idle_ms())
+    delays->set_screen_lock_ms(lock_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 67 matching lines @@
   if (!reason.empty())
     policy.set_reason(reason);
   client_->SetPolicy(policy);
 }
 
 void PowerPolicyController::SendEmptyPolicy() {
   client_->SetPolicy(power_manager::PowerManagementPolicy());
 }
 
 }  // namespace chromeos