On resume perform a delayed call to SetDisplayPower()

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/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/time/time.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/types/chromeos/display_mode.h"
 #include "ui/display/types/chromeos/display_snapshot.h"
 #include "ui/display/types/chromeos/native_display_delegate.h"
 
 namespace ui {
 
 namespace {
 
 typedef std::vector<const DisplayMode*> DisplayModeList;
 
-// The delay to perform configuration after RRNotify.  See the comment
-// in |Dispatch()|.
+// 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;
+
 // Returns a string describing |state|.
 std::string DisplayPowerStateToString(chromeos::DisplayPowerState state) {
   switch (state) {
     case chromeos::DISPLAY_POWER_ALL_ON:
       return "ALL_ON";
     case chromeos::DISPLAY_POWER_ALL_OFF:
       return "ALL_OFF";
     case chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON:
       return "INTERNAL_OFF_EXTERNAL_ON";
     case chromeos::DISPLAY_POWER_INTERNAL_ON_EXTERNAL_OFF:
@@ skipping 43 matching lines @@
     if (display_power)
       (*display_power)[i] = on;
     if (on)
       num_on_displays++;
   }
   return num_on_displays;
 }
 
 }  // namespace
 
+
+const int DisplayConfigurator::kSetDisplayPowerNoFlags = 0;
+const int DisplayConfigurator::kSetDisplayPowerForceProbe = 1 << 0;
+const int
+DisplayConfigurator::kSetDisplayPowerOnlyIfSingleInternalDisplay = 1 << 1;
+
 DisplayConfigurator::DisplayState::DisplayState()
     : display(NULL),
       touch_device_id(0),
       selected_mode(NULL),
       mirror_mode(NULL) {}
 
 bool DisplayConfigurator::TestApi::TriggerConfigureTimeout() {
-  if (configurator_->configure_timer_.get() &&
-      configurator_->configure_timer_->IsRunning()) {
-    configurator_->configure_timer_.reset();
-    configurator_->ConfigureDisplays();
+  if (configurator_->configure_timer_.IsRunning()) {
+    configurator_->configure_timer_.user_task().Run();
+    configurator_->configure_timer_.Stop();
     return true;
   } else {
     return false;
   }
 }
 
 // static
 const DisplayMode* DisplayConfigurator::FindDisplayModeMatchingSize(
     const DisplaySnapshot& display,
     const gfx::Size& size) {
@@ skipping 317 matching lines @@
 
 bool DisplayConfigurator::SetDisplayPower(
     chromeos::DisplayPowerState power_state,
     int flags) {
   if (!configure_display_)
     return false;
 
   VLOG(1) << "SetDisplayPower: power_state="
           << DisplayPowerStateToString(power_state) << " flags=" << flags
           << ", configure timer="
-          << ((configure_timer_.get() && configure_timer_->IsRunning()) ?
-                  "Running" : "Stopped");
+          << (configure_timer_.IsRunning() ? "Running" : "Stopped");
   if (power_state == power_state_ && !(flags & kSetDisplayPowerForceProbe))
     return true;
 
   native_display_delegate_->GrabServer();
   UpdateCachedDisplays();
 
   const MultipleDisplayState new_state = ChooseDisplayState(power_state);
   bool attempted_change = false;
   bool success = false;
 
@@ skipping 40 matching lines @@
       EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
   native_display_delegate_->UngrabServer();
 
   NotifyObservers(success, new_state);
   return success;
 }
 
 void DisplayConfigurator::OnConfigurationChanged() {
   // Configure displays with |kConfigureDelayMs| delay,
   // so that time-consuming ConfigureDisplays() won't be called multiple times.
-  if (configure_timer_.get()) {
-    configure_timer_->Reset();
+  if (configure_timer_.IsRunning()) {
+    // Note: when the timer is running it is possible that a different task
+    // (SetDisplayPower()) is scheduled. In these cases, prefer the already
+    // scheduled task to ConfigureDisplays() since ConfigureDisplays() performs
+    // only basic configuration while SetDisplayPower() will perform additional
+    // operations.
+    configure_timer_.Reset();
   } else {
-    configure_timer_.reset(new base::OneShotTimer<DisplayConfigurator>());
-    configure_timer_->Start(
+    configure_timer_.Start(
         FROM_HERE,
         base::TimeDelta::FromMilliseconds(kConfigureDelayMs),
         this,
         &DisplayConfigurator::ConfigureDisplays);
   }
 }
 
 void DisplayConfigurator::AddObserver(Observer* observer) {
   observers_.AddObserver(observer);
 }
@@ skipping 15 matching lines @@
     // 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() {
   // Force probing to ensure that we pick up any changes that were made
   // while the system was suspended.
-  SetDisplayPower(power_state_, kSetDisplayPowerForceProbe);
+  configure_timer_.Start(
+      FROM_HERE,
+      base::TimeDelta::FromMilliseconds(kResumeDelayMs),
+      base::Bind(base::IgnoreResult(&DisplayConfigurator::SetDisplayPower),
+                 base::Unretained(this),
+                 power_state_,
+                 kSetDisplayPowerForceProbe));
 }
 
 void DisplayConfigurator::UpdateCachedDisplays() {
   std::vector<DisplaySnapshot*> snapshots =
       native_display_delegate_->GetDisplays();
 
   cached_displays_.clear();
   for (size_t i = 0; i < snapshots.size(); ++i) {
     DisplayState display_state;
     display_state.display = snapshots[i];
@@ skipping 127 matching lines @@
         external_display->mirror_mode = *external_it;
         return true;  // Mirror mode created.
       }
     }
   }
 
   return false;
 }
 
 void DisplayConfigurator::ConfigureDisplays() {
-  configure_timer_.reset();
-
   if (!configure_display_)
     return;
 
   native_display_delegate_->GrabServer();
   UpdateCachedDisplays();
   const MultipleDisplayState new_state = ChooseDisplayState(power_state_);
   const bool success =
       EnterStateOrFallBackToSoftwareMirroring(new_state, power_state_);
   native_display_delegate_->UngrabServer();
 
@@ skipping 238 matching lines @@
         return state_controller_->GetStateForDisplayIds(display_ids);
       }
     }
     default:
       NOTREACHED();
   }
   return MULTIPLE_DISPLAY_STATE_INVALID;
 }
 
 }  // namespace ui