chromeos: Move default power management policy into Chrome.

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/values.h"
+#include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 
 namespace chromeos {
 
 namespace {
 
-// If |pref|, a PrefService::Preference containing an integer, has been
-// explicitly set to 0 or a positive value, assigns it to |proto_field|, a
-// int32 field in |proto|, a google::protobuf::MessageLite*.  If |proto|
-// was updated, |got_prefs|, a bool*, is set to true; otherwise it is left
-// unchanged.
-#define SET_DELAY_FROM_PREF(pref, proto_field, proto, got_prefs)               \
+// Appends a description of |field|, a field within |delays|, a
+// power_manager::PowerManagementPolicy::Delays object, to |str|, an
+// std::string, if the field is set.  |name| is a char* describing the
+// field.
+#define APPEND_DELAY(str, delays, field, name)                                 \
     {                                                                          \
-      int value = GetIntPrefValue(pref);                                       \
-      if (value >= 0) {                                                        \
-        (proto)->set_##proto_field(value);                                     \
-        *got_prefs = true;                                                     \
-      }                                                                        \
+      if (delays.has_##field())                                                \
+        str += base::StringPrintf(name "=%" PRId64 " ", delays.field());       \
     }
 
-// Similar to SET_DELAY_FROM_PREF() but sets a
-// power_manager::PowerManagementPolicy_Action field instead.
-#define SET_ACTION_FROM_PREF(pref, proto_field, proto, got_prefs)              \
+// Appends descriptions of all of the set delays in |delays|, a
+// power_manager::PowerManagementPolicy::Delays object, to |str|, an
+// std::string.  |prefix| should be a char* containing either "ac" or
+// "battery".
+#define APPEND_DELAYS(str, delays, prefix)                                     \
     {                                                                          \
-      int value = GetIntPrefValue(pref);                                       \
-      if (value >= 0) {                                                        \
-        (proto)->set_##proto_field(                                            \
-            static_cast<power_manager::PowerManagementPolicy_Action>(value));  \
-        *got_prefs = true;                                                     \
-      }                                                                        \
+      APPEND_DELAY(str, delays, screen_dim_ms, prefix "_screen_dim_ms");       \
+      APPEND_DELAY(str, delays, screen_off_ms, prefix "_screen_off_ms");       \
+      APPEND_DELAY(str, delays, screen_lock_ms, prefix "_screen_lock_ms");     \
+      APPEND_DELAY(str, delays, idle_warning_ms, prefix "_idle_warning_ms");   \
+      APPEND_DELAY(str, delays, idle_ms, prefix "_idle_ms");                   \
     }
 
-// If |pref|, a PrefService::Preference containing a bool, has been set,
-// assigns it to |proto_field|, a bool field in |proto|, a
-// google::protobuf::MessageLite*.  If |proto| was updated, |got_prefs|, a
-// bool*, is set to true; otherwise it is left unchanged.
-#define SET_BOOL_FROM_PREF(pref, proto_field, proto, got_prefs)                \
-    if (!pref.IsDefaultValue()) {                                              \
-      bool value = false;                                                      \
-      if (pref.GetValue()->GetAsBoolean(&value)) {                             \
-        (proto)->set_##proto_field(value);                                     \
-        *got_prefs = true;                                                     \
-      } else {                                                                 \
-        LOG(DFATAL) << pref.name() << " pref has non-boolean value";           \
-      }                                                                        \
-    }
-
-// Returns a zero or positive integer value from |pref|.  Returns -1 if the
-// pref is unset and logs an error if it's set to a negative value.
-int GetIntPrefValue(const PrefService::Preference& pref) {
-  if (pref.IsDefaultValue())
-    return -1;
-
-  int value = -1;
-  if (!pref.GetValue()->GetAsInteger(&value)) {
-    LOG(DFATAL) << pref.name() << " pref has non-integer value";
-    return -1;
-  }
-
-  if (value < 0)
-    LOG(WARNING) << pref.name() << " pref has negative value";
-  return value;
-}
-
 // Returns the power_manager::PowerManagementPolicy_Action value
 // corresponding to |action|.
 power_manager::PowerManagementPolicy_Action GetProtoAction(
     PowerPolicyController::Action action) {
   switch (action) {
     case PowerPolicyController::ACTION_SUSPEND:
       return power_manager::PowerManagementPolicy_Action_SUSPEND;
     case PowerPolicyController::ACTION_STOP_SESSION:
       return power_manager::PowerManagementPolicy_Action_STOP_SESSION;
     case PowerPolicyController::ACTION_SHUT_DOWN:
       return power_manager::PowerManagementPolicy_Action_SHUT_DOWN;
     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
 
+// -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),
+      ac_idle_delay_ms(-1),
+      battery_screen_dim_delay_ms(-1),
+      battery_screen_off_delay_ms(-1),
+      battery_screen_lock_delay_ms(-1),
+      battery_idle_warning_delay_ms(-1),
+      battery_idle_delay_ms(-1),
+      idle_action(ACTION_SUSPEND),
+      lid_closed_action(ACTION_SUSPEND),
+      use_audio_activity(true),
+      use_video_activity(true),
+      enable_screen_lock(false),
+      presentation_idle_delay_factor(2.0) {}
+
+// static
+std::string PowerPolicyController::GetPolicyDebugString(
+    const power_manager::PowerManagementPolicy& policy) {
+  std::string str;
+  if (policy.has_ac_delays())
+    APPEND_DELAYS(str, policy.ac_delays(), "ac");
+  if (policy.has_battery_delays())
+    APPEND_DELAYS(str, policy.battery_delays(), "battery");
+  if (policy.has_idle_action())
+    str += base::StringPrintf("idle=%d ", policy.idle_action());
+  if (policy.has_lid_closed_action())
+    str += base::StringPrintf("lid_closed=%d ", policy.lid_closed_action());
+  if (policy.has_use_audio_activity())
+    str += base::StringPrintf("use_audio=%d ", policy.use_audio_activity());
+  if (policy.has_use_video_activity())
+    str += base::StringPrintf("use_video=%d ", policy.use_audio_activity());
+  if (policy.has_presentation_idle_delay_factor()) {
+    str += base::StringPrintf("presentation_idle_delay_factor=%f ",
+        policy.presentation_idle_delay_factor());
+  }
+  if (policy.has_reason())
+    str += base::StringPrintf("reason=\"%s\" ", policy.reason().c_str());
+  TrimWhitespace(str, TRIM_TRAILING, &str);
+  return str;
+}
+
 PowerPolicyController::PowerPolicyController(DBusThreadManager* manager,
                                              PowerManagerClient* client)
     : manager_(manager),
       client_(client),
       prefs_were_set_(false),
       next_block_id_(1) {
   manager_->AddObserver(this);
   client_->AddObserver(this);
-  SendEmptyPolicy();
+  SendCurrentPolicy();
 }
 
 PowerPolicyController::~PowerPolicyController() {
   // The power manager's policy is reset before this point, in
   // OnDBusThreadManagerDestroying().  At the time that
   // PowerPolicyController is destroyed, PowerManagerClient's D-Bus proxy
   // to the power manager is already gone.
   client_->RemoveObserver(this);
   client_ = NULL;
   manager_->RemoveObserver(this);
   manager_ = NULL;
 }
 
-void PowerPolicyController::UpdatePolicyFromPrefs(
-    const PrefService::Preference& ac_screen_dim_delay_ms_pref,
-    const PrefService::Preference& ac_screen_off_delay_ms_pref,
-    const PrefService::Preference& ac_screen_lock_delay_ms_pref,
-    const PrefService::Preference& ac_idle_warning_delay_ms_pref,
-    const PrefService::Preference& ac_idle_delay_ms_pref,
-    const PrefService::Preference& battery_screen_dim_delay_ms_pref,
-    const PrefService::Preference& battery_screen_off_delay_ms_pref,
-    const PrefService::Preference& battery_screen_lock_delay_ms_pref,
-    const PrefService::Preference& battery_idle_warning_delay_ms_pref,
-    const PrefService::Preference& battery_idle_delay_ms_pref,
-    const PrefService::Preference& idle_action_pref,
-    const PrefService::Preference& lid_closed_action_pref,
-    const PrefService::Preference& use_audio_activity_pref,
-    const PrefService::Preference& use_video_activity_pref,
-    const PrefService::Preference& presentation_idle_delay_factor_pref) {
+void PowerPolicyController::ApplyPrefs(const PrefValues& values) {
   prefs_policy_.Clear();
-  bool got_prefs = false;
 
   power_manager::PowerManagementPolicy::Delays* delays =
       prefs_policy_.mutable_ac_delays();
-  SET_DELAY_FROM_PREF(
-      ac_screen_dim_delay_ms_pref, screen_dim_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(
-      ac_screen_off_delay_ms_pref, screen_off_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(
-      ac_screen_lock_delay_ms_pref, screen_lock_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(
-      ac_idle_warning_delay_ms_pref, idle_warning_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(ac_idle_delay_ms_pref, idle_ms, delays, &got_prefs);
+  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 (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();
-  SET_DELAY_FROM_PREF(
-      battery_screen_dim_delay_ms_pref, screen_dim_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(
-      battery_screen_off_delay_ms_pref, screen_off_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(
-      battery_screen_lock_delay_ms_pref, screen_lock_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(
-      battery_idle_warning_delay_ms_pref, idle_warning_ms, delays, &got_prefs);
-  SET_DELAY_FROM_PREF(battery_idle_delay_ms_pref, idle_ms, delays, &got_prefs);
-
-  SET_ACTION_FROM_PREF(
-      idle_action_pref, idle_action, &prefs_policy_, &got_prefs);
-  SET_ACTION_FROM_PREF(
-      lid_closed_action_pref, lid_closed_action, &prefs_policy_, &got_prefs);
-
-  SET_BOOL_FROM_PREF(
-      use_audio_activity_pref, use_audio_activity, &prefs_policy_, &got_prefs);
-  SET_BOOL_FROM_PREF(
-      use_video_activity_pref, use_video_activity, &prefs_policy_, &got_prefs);
-
-  if (!presentation_idle_delay_factor_pref.IsDefaultValue()) {
-    double value = 0.0;
-    if (presentation_idle_delay_factor_pref.GetValue()->GetAsDouble(&value)) {
-      prefs_policy_.set_presentation_idle_delay_factor(value);
-      got_prefs = true;
-    } else {
-      LOG(DFATAL) << presentation_idle_delay_factor_pref.name()
-                  << " pref has non-double value";
-    }
+  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);
+  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_were_set_ = got_prefs;
+  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_were_set_ = true;
   SendCurrentPolicy();
 }
 
 int PowerPolicyController::AddScreenBlock(const std::string& reason) {
   int id = next_block_id_++;
   screen_blocks_[id] = reason;
   SendCurrentPolicy();
   return id;
 }
 
@@ skipping 54 matching lines @@
   if (!reason.empty())
     policy.set_reason(reason);
   client_->SetPolicy(policy);
 }
 
 void PowerPolicyController::SendEmptyPolicy() {
   client_->SetPolicy(power_manager::PowerManagementPolicy());
 }
 
 }  // namespace chromeos