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;  // 10 sec.
+
 // -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 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