chromeos: Notify observers after display power changes.

chromeos/display/output_configurator.cc

 // Copyright (c) 2012 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/display/output_configurator.h"
 
 #include <X11/Xlib.h>
 #include <X11/extensions/Xrandr.h>
 #include <X11/extensions/XInput2.h>
 
@@ skipping 195 matching lines @@
   if (!configure_display_)
     return;
 
   delegate_->GrabServer();
   delegate_->InitXRandRExtension(&xrandr_event_base_);
 
   std::vector<OutputSnapshot> outputs =
       delegate_->GetOutputs(state_controller_);
   if (outputs.size() > 1 && background_color_argb)
     delegate_->SetBackgroundColor(background_color_argb);
-  EnterStateOrFallBackToSoftwareMirroring(
-      GetOutputState(outputs, power_state_), power_state_, outputs);
+  const OutputState new_state = GetOutputState(outputs, power_state_);
+  const bool success = EnterStateOrFallBackToSoftwareMirroring(
+      new_state, power_state_, outputs);
 
   // Force the DPMS on chrome startup as the driver doesn't always detect
   // that all displays are on when signing out.
   delegate_->ForceDPMSOn();
   delegate_->UngrabServer();
   delegate_->SendProjectingStateToPowerManager(IsProjecting(outputs));
-  NotifyOnDisplayChanged();
+  NotifyObservers(success, new_state);
 }
 
 void OutputConfigurator::Stop() {
   configure_display_ = false;
 }
 
 bool OutputConfigurator::SetDisplayPower(DisplayPowerState power_state,
                                          int flags) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayPower: power_state="
           << DisplayPowerStateToString(power_state) << " flags=" << flags;
   if (power_state == power_state_ && !(flags & kSetDisplayPowerForceProbe))
     return true;
 
   delegate_->GrabServer();
   std::vector<OutputSnapshot> outputs =
       delegate_->GetOutputs(state_controller_);
 
+  const OutputState new_state = GetOutputState(outputs, power_state);
+  bool attempted_change = false;
+  bool success = false;
+
   bool only_if_single_internal_display =
       flags & kSetDisplayPowerOnlyIfSingleInternalDisplay;
   bool single_internal_display = outputs.size() == 1 && outputs[0].is_internal;
-  if ((single_internal_display || !only_if_single_internal_display) &&
-      EnterStateOrFallBackToSoftwareMirroring(
-          GetOutputState(outputs, power_state), power_state, outputs)) {
-    if (power_state != DISPLAY_POWER_ALL_OFF)  {
+  if (single_internal_display || !only_if_single_internal_display) {
+    if (EnterStateOrFallBackToSoftwareMirroring(
+            new_state, power_state, outputs)) {

[oshima, 2013/08/16 16:19:14]

success = EnterState...;
if (success && power_state_ != DISPLAY_POWER_ALL_OFF)
   delegate_->FoceDPRMSOn();

[Daniel Erat, 2013/08/16 16:42:16]

Done.

       // Force the DPMS on since the driver doesn't always detect that it
       // should turn on. This is needed when coming back from idle suspend.
-      delegate_->ForceDPMSOn();
+      if (power_state != DISPLAY_POWER_ALL_OFF)
+        delegate_->ForceDPMSOn();
+      success = true;
     }
+    attempted_change = true;
   }
 
   delegate_->UngrabServer();
+  if (attempted_change)
+    NotifyObservers(success, new_state);
   return true;
 }
 
 bool OutputConfigurator::SetDisplayMode(OutputState new_state) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayMode: state=" << OutputStateToString(new_state);
   if (output_state_ == new_state) {
     // Cancel software mirroring if the state is moving from
     // STATE_DUAL_EXTENDED to STATE_DUAL_EXTENDED.
     if (mirroring_controller_ && new_state == STATE_DUAL_EXTENDED)
       mirroring_controller_->SetSoftwareMirroring(false);
-    NotifyOnDisplayChanged();
+    NotifyObservers(true, new_state);
     return true;
   }
 
   delegate_->GrabServer();
   std::vector<OutputSnapshot> outputs =
       delegate_->GetOutputs(state_controller_);
-  bool success = EnterStateOrFallBackToSoftwareMirroring(
+  const bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_, outputs);
   delegate_->UngrabServer();
 
-  if (success) {
-    NotifyOnDisplayChanged();
-  } else {
-    FOR_EACH_OBSERVER(
-        Observer, observers_, OnDisplayModeChangeFailed(new_state));
-  }
+  NotifyObservers(success, new_state);
   return success;
 }
 
 bool OutputConfigurator::Dispatch(const base::NativeEvent& event) {
   if (!configure_display_)
     return true;
 
   if (event->type - xrandr_event_base_ == RRScreenChangeNotify) {
     VLOG(1) << "Received RRScreenChangeNotify event";
     delegate_->UpdateXRandRConfiguration(event);
@@ skipping 106 matching lines @@
         &OutputConfigurator::ConfigureOutputs);
   }
 }
 
 void OutputConfigurator::ConfigureOutputs() {
   configure_timer_.reset();
 
   delegate_->GrabServer();
   std::vector<OutputSnapshot> outputs =
       delegate_->GetOutputs(state_controller_);
-  OutputState new_state = GetOutputState(outputs, power_state_);
-  bool success = EnterStateOrFallBackToSoftwareMirroring(
+  const OutputState new_state = GetOutputState(outputs, power_state_);
+  const bool success = EnterStateOrFallBackToSoftwareMirroring(
       new_state, power_state_, outputs);
   delegate_->UngrabServer();
 
-  if (success) {
-    NotifyOnDisplayChanged();
-  } else {
-    FOR_EACH_OBSERVER(
-        Observer, observers_, OnDisplayModeChangeFailed(new_state));
-  }
+  NotifyObservers(success, new_state);
   delegate_->SendProjectingStateToPowerManager(IsProjecting(outputs));
 }
 
-void OutputConfigurator::NotifyOnDisplayChanged() {
-  FOR_EACH_OBSERVER(Observer, observers_,
-                    OnDisplayModeChanged(cached_outputs_));
+void OutputConfigurator::NotifyObservers(bool success,
+                                         OutputState attempted_state) {
+  if (success) {
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnDisplayModeChanged(cached_outputs_));
+  } else {
+    FOR_EACH_OBSERVER(Observer, observers_,
+                      OnDisplayModeChangeFailed(attempted_state));
+  }
 }
 
 bool OutputConfigurator::EnterStateOrFallBackToSoftwareMirroring(
     OutputState output_state,
     DisplayPowerState power_state,
     const std::vector<OutputSnapshot>& outputs) {
   bool success = EnterState(output_state, power_state, outputs);
   if (mirroring_controller_) {
     bool enable_software_mirroring = false;
     if (!success && output_state == STATE_DUAL_MIRROR) {
@@ skipping 244 matching lines @@
   float width_ratio = static_cast<float>(mirror_mode_info->width) /
       static_cast<float>(native_mode_info->width);
   float height_ratio = static_cast<float>(mirror_mode_info->height) /
       static_cast<float>(native_mode_info->height);
 
   area_ratio = width_ratio * height_ratio;
   return area_ratio;
 }
 
 }  // namespace chromeos