Make SetDisplayPower() take a callback to signal completion

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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
@@ skipping 14 matching lines @@
 // 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;
 
+void DoNothing(bool status) {
+}
+
 }  // namespace
 
 
 const int DisplayConfigurator::kSetDisplayPowerNoFlags = 0;
 const int DisplayConfigurator::kSetDisplayPowerForceProbe = 1 << 0;
 const int
 DisplayConfigurator::kSetDisplayPowerOnlyIfSingleInternalDisplay = 1 << 1;
 
 DisplayConfigurator::DisplayState::DisplayState()
     : display(NULL),
@@ skipping 408 matching lines @@
       force_configure_(false),
       next_display_protection_client_id_(1),
       display_externally_controlled_(false),
       layout_manager_(new DisplayLayoutManagerImpl(this)),
       weak_ptr_factory_(this) {
 }
 
 DisplayConfigurator::~DisplayConfigurator() {
   if (native_display_delegate_)
     native_display_delegate_->RemoveObserver(this);
+
+  CallAndClearPendingCallbacks(false);
+  CallAndClearQueuedCallbacks(false);
 }
 
 void DisplayConfigurator::SetDelegateForTesting(
     scoped_ptr<NativeDisplayDelegate> display_delegate) {
   DCHECK(!native_display_delegate_);
 
   native_display_delegate_ = display_delegate.Pass();
   configure_display_ = true;
 }
 
@@ skipping 279 matching lines @@
 
   return false;
 }
 
 void DisplayConfigurator::PrepareForExit() {
   configure_display_ = false;
 }
 
 void DisplayConfigurator::SetDisplayPower(
     chromeos::DisplayPowerState power_state,
-    int flags) {
-  if (!configure_display_ || display_externally_controlled_)
+    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))
+      !(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();
 }
 
 void DisplayConfigurator::SetDisplayMode(MultipleDisplayState new_state) {
   if (!configure_display_ || display_externally_controlled_)
     return;
 
   VLOG(1) << "SetDisplayMode: state="
           << MultipleDisplayStateToString(new_state);
@@ skipping 42 matching lines @@
 }
 
 void DisplayConfigurator::SuspendDisplays() {
   // 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);
+                    kSetDisplayPowerOnlyIfSingleInternalDisplay,
+                    base::Bind(&DoNothing));
 
     // 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();
   }
 }
 
 void DisplayConfigurator::ResumeDisplays() {
   configure_timer_.Start(
@@ skipping 13 matching lines @@
 
 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_,
       0, force_configure_, base::Bind(&DisplayConfigurator::OnConfigured,
                                       weak_ptr_factory_.GetWeakPtr())));
 
   // 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;
   requested_display_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
 
+  DCHECK(pending_configuration_callbacks_.empty());
+  pending_configuration_callbacks_.swap(queued_configuration_callbacks_);
+
   configuration_task_->Run();
 }
 
 void DisplayConfigurator::OnConfigured(
     bool success,
     const std::vector<DisplayState>& displays,
     const gfx::Size& framebuffer_size,
     MultipleDisplayState new_display_state,
     chromeos::DisplayPowerState new_power_state) {
   VLOG(1) << "OnConfigured: success=" << success << " new_display_state="
           << MultipleDisplayStateToString(new_display_state)
           << " new_power_state=" << DisplayPowerStateToString(new_power_state);
 
   cached_displays_ = displays;
   if (success) {
     current_display_state_ = new_display_state;
     current_power_state_ = new_power_state;
     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_)
       requested_power_state_ = new_power_state;
   }
 
   configuration_task_.reset();
   NotifyObservers(success, new_display_state);
+  CallAndClearPendingCallbacks(success);
 
   if (success && !configure_timer_.IsRunning() &&
       ShouldRunConfigurationTask()) {
     configure_timer_.Start(FROM_HERE,
                            base::TimeDelta::FromMilliseconds(kConfigureDelayMs),
                            this, &DisplayConfigurator::RunPendingConfiguration);
+  } else {
+    // If a new configuration task isn't scheduled respond to all queued
+    // callbacks (for example if requested state is current state).
+    if (!configure_timer_.IsRunning())
+      CallAndClearQueuedCallbacks(success);
   }
 }
 
 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_)
     return true;
 
   return false;
 }
 
+void DisplayConfigurator::CallAndClearPendingCallbacks(bool success) {
+  for (const auto& callback : pending_configuration_callbacks_)
+    callback.Run(success);
+
+  pending_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);
+  SetDisplayPower(requested_power_state_, kSetDisplayPowerForceProbe,
+                  base::Bind(&DoNothing));
 }
 
 void DisplayConfigurator::NotifyObservers(
     bool success,
     MultipleDisplayState attempted_state) {
   if (success) {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChanged(cached_displays_));
   } else {
     FOR_EACH_OBSERVER(
         Observer, observers_, OnDisplayModeChangeFailed(attempted_state));
   }
 }
 
 }  // namespace ui