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 456 matching lines @@
       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),
       pending_power_state_(chromeos::DISPLAY_POWER_ALL_ON),
       has_pending_power_state_(false),
       pending_power_flags_(kSetDisplayPowerNoFlags),
       force_configure_(false),
+      configure_cached_displays_(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() {
   if (native_display_delegate_)
@@ skipping 121 matching lines @@
   DCHECK(native_display_delegate_);
   native_display_delegate_->Initialize();
 
   // ForceInitialConfigure should be the first configuration so there shouldn't
   // be anything scheduled.
   DCHECK(!configuration_task_);
 
   configuration_task_.reset(new UpdateDisplayConfigurationTask(
       native_display_delegate_.get(), layout_manager_.get(),
       requested_display_state_, requested_power_state_,
-      kSetDisplayPowerForceProbe, background_color_argb, true,
+      kSetDisplayPowerForceProbe, background_color_argb, true, false,
       base::Bind(&DisplayConfigurator::OnConfigured,
                  weak_ptr_factory_.GetWeakPtr())));
   configuration_task_->Run();
 }
 
 DisplayConfigurator::ContentProtectionClientId
 DisplayConfigurator::RegisterContentProtectionClient() {
   if (!configure_display_ || display_externally_controlled_)
     return kInvalidClientId;
 
@@ skipping 206 matching lines @@
   return false;
 }
 
 void DisplayConfigurator::PrepareForExit() {
   configure_display_ = false;
 }
 
 void DisplayConfigurator::SetDisplayPowerInternal(
     chromeos::DisplayPowerState power_state,
     int flags,
+    bool configure_cached_displays,
     const ConfigurationCallback& callback) {
   if (power_state == current_power_state_ &&
       !(flags & kSetDisplayPowerForceProbe)) {
     callback.Run(true);
     return;
   }
 
   pending_power_state_ = power_state;
   has_pending_power_state_ = true;
   pending_power_flags_ = flags;
+  configure_cached_displays_ = configure_cached_displays;
   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");
 
   requested_power_state_ = power_state;
-  SetDisplayPowerInternal(requested_power_state_, flags, callback);
+  SetDisplayPowerInternal(requested_power_state_, flags, false, 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 58 matching lines @@
 
   // 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);
+                          kSetDisplayPowerNoFlags, false, 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() {
   if (!configure_display_ || display_externally_controlled_)
     return;
 
   displays_suspended_ = false;
+  configure_cached_displays_ = true;
 
   // If requested_power_state_ is ALL_OFF due to idle suspend, powerd will turn
   // the display power on when it enables the backlight.
-  SetDisplayPower(requested_power_state_, kSetDisplayPowerNoFlags,
-                  base::Bind(&DoNothing));
+  SetDisplayPowerInternal(requested_power_state_, kSetDisplayPowerNoFlags, true,
+                          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_, pending_power_state_, pending_power_flags_,
-      0, force_configure_, base::Bind(&DisplayConfigurator::OnConfigured,
-                                      weak_ptr_factory_.GetWeakPtr())));
+      0, force_configure_, configure_cached_displays_,
+      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;
+  configure_cached_displays_ = false;
   pending_power_flags_ = kSetDisplayPowerNoFlags;
   has_pending_power_state_ = 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();
 }
 
@@ skipping 137 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