chromeos: Turn off displays on suspend

ui/display/chromeos/display_configurator.cc

 // Copyright 2014 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 "ui/display/chromeos/display_configurator.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
 // The delay to perform configuration after RRNotify. See the comment for
 // |configure_timer_|.
 const int kConfigureDelayMs = 500;
 
-// The delay spent before reading the display configuration after coming out of
-// suspend. While coming out of suspend the display state may be updating. This
-// is used to wait until the hardware had a chance to update the display state
-// such that we read an up to date state.
-const int kResumeDelayMs = 500;
-
 // The EDID specification marks the top bit of the manufacturer id as reserved.
 const int16_t kReservedManufacturerID = static_cast<int16_t>(1 << 15);
 
 struct DisplayState {
   DisplaySnapshot* display = nullptr;  // Not owned.
 
   // User-selected mode for the display.
   const DisplayMode* selected_mode = nullptr;
 
   // Mode used when displaying the same desktop on multiple displays.
@@ skipping 415 matching lines @@
 
 DisplayConfigurator::DisplayConfigurator()
     : state_controller_(NULL),
       mirroring_controller_(NULL),
       is_panel_fitting_enabled_(false),
       configure_display_(base::SysInfo::IsRunningOnChromeOS()),
       current_display_state_(MULTIPLE_DISPLAY_STATE_INVALID),
       current_power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       requested_display_state_(MULTIPLE_DISPLAY_STATE_INVALID),
       requested_power_state_(chromeos::DISPLAY_POWER_ALL_ON),
-      requested_power_state_change_(false),
-      requested_power_flags_(kSetDisplayPowerNoFlags),
+      config_power_state_(chromeos::DISPLAY_POWER_ALL_ON),
+      power_state_change_(false),
+      config_power_flags_(kSetDisplayPowerNoFlags),
       force_configure_(false),
       next_display_protection_client_id_(1),
       display_externally_controlled_(false),
       display_control_changing_(false),
       displays_suspended_(false),
       layout_manager_(new DisplayLayoutManagerImpl(this)),
       weak_ptr_factory_(this) {
 }
 
 DisplayConfigurator::~DisplayConfigurator() {
@@ skipping 346 matching lines @@
           *display, degamma_lut, gamma_lut, correction_matrix);
   }
 
   return false;
 }
 
 void DisplayConfigurator::PrepareForExit() {
   configure_display_ = false;
 }
 
+void DisplayConfigurator::SetDisplayPowerInternal(
+    chromeos::DisplayPowerState power_state,
+    int flags,
+    const ConfigurationCallback& callback) {
+  if (power_state == current_power_state_ &&
+      !(flags & kSetDisplayPowerForceProbe)) {
+    callback.Run(true);
+    return;
+  }
+
+  config_power_state_ = power_state;
+  power_state_change_ = true;
+  config_power_flags_ = flags;
+  queued_configuration_callbacks_.push_back(callback);
+
+  RunPendingConfiguration();
+}
+
 void DisplayConfigurator::SetDisplayPower(
     chromeos::DisplayPowerState power_state,
     int flags,
     const ConfigurationCallback& callback) {
   if (!configure_display_ || display_externally_controlled_) {
     callback.Run(false);
     return;
   }
 
   VLOG(1) << "SetDisplayPower: power_state="
           << DisplayPowerStateToString(power_state) << " flags=" << flags
           << ", configure timer="
           << (configure_timer_.IsRunning() ? "Running" : "Stopped");
-  if (power_state == requested_power_state_ &&
-      !(flags & kSetDisplayPowerForceProbe)) {
-    callback.Run(true);
-    return;
-  }
 
   requested_power_state_ = power_state;
-  requested_power_state_change_ = true;
-  requested_power_flags_ = flags;
-  queued_configuration_callbacks_.push_back(callback);
-
-  RunPendingConfiguration();
+  SetDisplayPowerInternal(requested_power_state_, flags, callback);
 }
 
 void DisplayConfigurator::SetDisplayMode(MultipleDisplayState new_state) {
   if (!configure_display_ || display_externally_controlled_)
     return;
 
   VLOG(1) << "SetDisplayMode: state="
           << MultipleDisplayStateToString(new_state);
   if (current_display_state_ == new_state) {
     // Cancel software mirroring if the state is moving from
@@ skipping 42 matching lines @@
 void DisplayConfigurator::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
 
 void DisplayConfigurator::RemoveObserver(Observer* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void DisplayConfigurator::SuspendDisplays(
     const ConfigurationCallback& callback) {
-  // If the display is off due to user inactivity and there's only a single
-  // internal display connected, switch to the all-on state before
-  // suspending.  This shouldn't be very noticeable to the user since the
-  // backlight is off at this point, and doing this lets us resume directly
-  // into the "on" state, which greatly reduces resume times.
-  if (requested_power_state_ == chromeos::DISPLAY_POWER_ALL_OFF) {
-    SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
-                    kSetDisplayPowerOnlyIfSingleInternalDisplay, callback);
-
-    // We need to make sure that the monitor configuration we just did actually
-    // completes before we return, because otherwise the X message could be
-    // racing with the HandleSuspendReadiness message.
-    native_display_delegate_->SyncWithServer();
-  } else {
-    callback.Run(true);
-  }
-
   displays_suspended_ = true;
 
   // Stop |configure_timer_| because we will force probe and configure all the
   // displays at resume time anyway.
   configure_timer_.Stop();
+
+  // Turn off the displays for suspend. This way, if we wake up for lucid sleep,
+  // the displays will not turn on (all displays should be off for lucid sleep
+  // unless explicitly requested by lucid sleep code). Use
+  // SetDisplayPowerInternal so requested_power_state_ is maintained.
+  SetDisplayPowerInternal(chromeos::DISPLAY_POWER_ALL_OFF,
+                          kSetDisplayPowerNoFlags, callback);
+
+  // We need to make sure that the monitor configuration we just did actually
+  // completes before we return.
+  native_display_delegate_->SyncWithServer();
 }
 
 void DisplayConfigurator::ResumeDisplays() {
+  chromeos::DisplayPowerState power_state = chromeos::DISPLAY_POWER_ALL_ON;
+
+  // Restore requested_power_state_ unless it's DISPLAY_POWER_ALL_OFF.
+  if (requested_power_state_ != chromeos::DISPLAY_POWER_ALL_OFF) {

[Daniel Erat, 2016/04/21 22:16:41]

can you explain this to me again (and also update this comment to explain it,
instead of just describing what the next two lines do :-P)? i didn't fully
understand it the previous time. if the user manually set the brightness to zero
before suspending, isn't that getting dropped here?

[dbasehore, 2016/04/21 22:35:10]

Might be able to get rid of this. If we call SetDisplayPower in powerd when we
turn on the backlight, that may have similar latency to setting it here. We turn
the backlight back on in powerd right after announcing resume. We may have to
resume the backlight before un-muting the audio in powerd since the audio call
blocks, though.

I'll remove if it turns out to work well.

+    power_state = requested_power_state_;
+  }
+
   displays_suspended_ = false;
-
-  configure_timer_.Start(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kResumeDelayMs),
-      base::Bind(&DisplayConfigurator::RestoreRequestedPowerStateAfterResume,
-                 base::Unretained(this)));
+  // If we aren't restoring requested_power_state_, we need to make sure we
+  // overwrite it with DISPLAY_POWER_ALL_ON, so call SetDisplayPower.
+  SetDisplayPower(power_state, kSetDisplayPowerForceProbe,

[Daniel Erat, 2016/04/21 22:16:41]

it seems weird to call the public method here. if you really want to update
requested_power_state_, why not just do that in an else block above instead of
by calling the public function for something that wasn't a user request?

[dbasehore, 2016/04/21 22:35:10]

Works for me. Will do.

+                  base::Bind(&DoNothing));
 }
 
 void DisplayConfigurator::ConfigureDisplays() {
   if (!configure_display_ || display_externally_controlled_)
     return;
 
   force_configure_ = true;
   RunPendingConfiguration();
 }
 
 void DisplayConfigurator::RunPendingConfiguration() {
   // Configuration task is currently running. Do not start a second
   // configuration.
   if (configuration_task_)
     return;
 
   if (!ShouldRunConfigurationTask()) {
     LOG(ERROR) << "Called RunPendingConfiguration without any changes"
                   " requested";
     CallAndClearQueuedCallbacks(true);
     return;
   }
 
   configuration_task_.reset(new UpdateDisplayConfigurationTask(
       native_display_delegate_.get(), layout_manager_.get(),
-      requested_display_state_, requested_power_state_, requested_power_flags_,
+      requested_display_state_, config_power_state_, config_power_flags_,
       0, force_configure_, base::Bind(&DisplayConfigurator::OnConfigured,
                                       weak_ptr_factory_.GetWeakPtr())));
   configuration_task_->set_virtual_display_snapshots(
       virtual_display_snapshots_.get());
 
   // Reset the flags before running the task; otherwise it may end up scheduling
   // another configuration.
   force_configure_ = false;
-  requested_power_flags_ = kSetDisplayPowerNoFlags;
-  requested_power_state_change_ = false;
+  config_power_flags_ = kSetDisplayPowerNoFlags;
+  power_state_change_ = false;
   requested_display_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
 
   DCHECK(in_progress_configuration_callbacks_.empty());
   in_progress_configuration_callbacks_.swap(queued_configuration_callbacks_);
 
   configuration_task_->Run();
 }
 
 void DisplayConfigurator::OnConfigured(
     bool success,
@@ skipping 19 matching lines @@
            new_display_state == MULTIPLE_DISPLAY_STATE_HEADLESS ||
            new_power_state == chromeos::DISPLAY_POWER_ALL_OFF);
 
     if (!framebuffer_size.IsEmpty())
       framebuffer_size_ = framebuffer_size;
 
     // If the requested power state hasn't changed then make sure that value
     // gets updated as well since the last requested value may have been
     // dependent on certain conditions (ie: if only the internal monitor was
     // present).
-    if (!requested_power_state_change_)
+    if (!power_state_change_)
       requested_power_state_ = new_power_state;
 
     if (old_power_state != current_power_state_)
       NotifyPowerStateObservers();
   }
 
   configuration_task_.reset();
   NotifyDisplayStateObservers(success, new_display_state);
   CallAndClearInProgressCallbacks(success);
 
@@ skipping 13 matching lines @@
 bool DisplayConfigurator::ShouldRunConfigurationTask() const {
   if (force_configure_)
     return true;
 
   // Schedule if there is a request to change the display state.
   if (requested_display_state_ != current_display_state_ &&
       requested_display_state_ != MULTIPLE_DISPLAY_STATE_INVALID)
     return true;
 
   // Schedule if there is a request to change the power state.
-  if (requested_power_state_change_)
+  if (power_state_change_)
     return true;
 
   return false;
 }
 
 void DisplayConfigurator::CallAndClearInProgressCallbacks(bool success) {
   for (const auto& callback : in_progress_configuration_callbacks_)
     callback.Run(success);
 
   in_progress_configuration_callbacks_.clear();
 }
 
 void DisplayConfigurator::CallAndClearQueuedCallbacks(bool success) {
   for (const auto& callback : queued_configuration_callbacks_)
     callback.Run(success);
 
   queued_configuration_callbacks_.clear();
 }
 
-void DisplayConfigurator::RestoreRequestedPowerStateAfterResume() {
-  // Force probing to ensure that we pick up any changes that were made while
-  // the system was suspended.
-  SetDisplayPower(requested_power_state_, kSetDisplayPowerForceProbe,
-                  base::Bind(&DoNothing));
-}
-
 void DisplayConfigurator::NotifyDisplayStateObservers(
     bool success,
     MultipleDisplayState attempted_state) {
   if (success) {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChanged(cached_displays_));
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(cached_displays_,
                                                         attempted_state));
@@ skipping 42 matching lines @@
   last_virtual_display_id_ = max_display_id & 0xff;
 
   return true;
 }
 
 bool DisplayConfigurator::IsDisplayOn() const {
   return current_power_state_ != chromeos::DISPLAY_POWER_ALL_OFF;
 }
 
 }  // namespace ui