chromeos: Add pref for automated brightness increases.

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/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 70 matching lines @@
       battery_idle_action(ACTION_SUSPEND),
       lid_closed_action(ACTION_SUSPEND),
       use_audio_activity(true),
       use_video_activity(true),
       ac_brightness_percent(-1.0),
       battery_brightness_percent(-1.0),
       allow_screen_wake_locks(true),
       enable_auto_screen_lock(false),
       presentation_screen_dim_delay_factor(1.0),
       user_activity_screen_dim_delay_factor(1.0),
-      wait_for_initial_user_activity(false) {}
+      wait_for_initial_user_activity(false),
+      force_nonzero_brightness_for_user_activity(true) {}
 
 // 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_ac_idle_action())
@@ skipping 19 matching lines @@
         policy.presentation_screen_dim_delay_factor());
   }
   if (policy.has_user_activity_screen_dim_delay_factor()) {
     str += base::StringPrintf("user_activity_screen_dim_delay_factor=%f ",
         policy.user_activity_screen_dim_delay_factor());
   }
   if (policy.has_wait_for_initial_user_activity()) {
     str += base::StringPrintf("wait_for_initial_user_activity=%d ",
         policy.wait_for_initial_user_activity());
   }
+  if (policy.has_force_nonzero_brightness_for_user_activity()) {
+    str += base::StringPrintf("force_nonzero_brightness_for_user_activity=%d ",
+        policy.force_nonzero_brightness_for_user_activity());
+  }
   if (policy.has_reason())
     str += base::StringPrintf("reason=\"%s\" ", policy.reason().c_str());
   base::TrimWhitespace(str, base::TRIM_TRAILING, &str);
   return str;
 }
 
 // static
 void PowerPolicyController::Initialize(PowerManagerClient* client) {
   DCHECK(!IsInitialized());
   g_power_policy_controller = new PowerPolicyController(client);
@@ skipping 62 matching lines @@
   if (values.battery_brightness_percent >= 0.0) {
     prefs_policy_.set_battery_brightness_percent(
         values.battery_brightness_percent);
   }
   prefs_policy_.set_presentation_screen_dim_delay_factor(
       values.presentation_screen_dim_delay_factor);
   prefs_policy_.set_user_activity_screen_dim_delay_factor(
       values.user_activity_screen_dim_delay_factor);
   prefs_policy_.set_wait_for_initial_user_activity(
       values.wait_for_initial_user_activity);
+  prefs_policy_.set_force_nonzero_brightness_for_user_activity(
+      values.force_nonzero_brightness_for_user_activity);
 
   honor_screen_wake_locks_ = values.allow_screen_wake_locks;
 
   prefs_were_set_ = true;
   SendCurrentPolicy();
 }
 
 int PowerPolicyController::AddScreenWakeLock(const std::string& reason) {
   int id = next_wake_lock_id_++;
   screen_wake_locks_[id] = reason;
@@ skipping 69 matching lines @@
        it != system_wake_locks_.end(); ++it) {
     reason += (reason.empty() ? "" : ", ") + it->second;
   }
 
   if (!reason.empty())
     policy.set_reason(reason);
   client_->SetPolicy(policy);
 }
 
 }  // namespace chromeos