Delay display configuration after waking up from suspend with multi displays

ui/display/chromeos/display_configurator_unittest.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 <stdint.h>
 
 #include "base/macros.h"
@@ skipping 15 matching lines @@
 int64_t kDisplayIds[3] = {123, 456, 789};
 
 std::unique_ptr<ui::DisplayMode> MakeDisplayMode(int width,
                                                  int height,
                                                  bool is_interlaced,
                                                  float refresh_rate) {
   return base::MakeUnique<ui::DisplayMode>(gfx::Size(width, height),
                                            is_interlaced, refresh_rate);
 }
 
+enum CallbackResult {
+  CALLBACK_FAILURE,
+  CALLBACK_SUCCESS,
+  CALLBACK_NOT_CALLED,
+};
+
+// Expected immediate configurations should be done without any delays.
+constexpr base::TimeDelta kNoDelay = base::TimeDelta::FromMilliseconds(0);
+
+// The expected configuration delay when resuming from suspend while in 2+
+// display mode.
+constexpr base::TimeDelta kLongDelay = base::TimeDelta::FromMilliseconds(
+    DisplayConfigurator::kResumeConfigureMultiDisplayDelayMs);
+
 class TestObserver : public DisplayConfigurator::Observer {
  public:
   explicit TestObserver(DisplayConfigurator* configurator)
       : configurator_(configurator) {
     Reset();
     configurator_->AddObserver(this);
   }
   ~TestObserver() override { configurator_->RemoveObserver(this); }
 
   int num_changes() const { return num_changes_; }
@@ skipping 76 matching lines @@
   bool SoftwareMirroringEnabled() const override {
     return software_mirroring_enabled_;
   }
 
  private:
   bool software_mirroring_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMirroringController);
 };
 
+// Abstracts waiting for the display configuration to be completed and getting
+// the time it took to complete.
+class ConfigurationWaiter {
+ public:
+  ConfigurationWaiter(DisplayConfigurator::TestApi* test_api)
+      : on_configured_callback_(base::Bind(&ConfigurationWaiter::OnConfigured,
+                                           base::Unretained(this))),
+        test_api_(test_api),
+        callback_result_(CALLBACK_NOT_CALLED) {}
+
+  ~ConfigurationWaiter() = default;
+
+  const DisplayConfigurator::ConfigurationCallback& on_configuration_callback()
+      const {
+    return on_configured_callback_;
+  }
+
+  CallbackResult callback_result() const { return callback_result_; }
+
+  void Reset() {
+    callback_result_ = CALLBACK_NOT_CALLED;
+  }
+
+  // Simulates waiting for the next configuration. If an async task is pending,
+  // runs it and returns base::TimeDelta(). Otherwise, triggers the
+  // configuration timer and returns its delay. If the timer wasn't running,
+  // returns base::TimeDelta::Max().
+  base::TimeDelta Wait() WARN_UNUSED_RESULT {
+    base::RunLoop().RunUntilIdle();
+    if (callback_result_ != CALLBACK_NOT_CALLED)
+      return base::TimeDelta();
+
+    const base::TimeDelta delay = test_api_->GetConfigureDelay();
+    if (!test_api_->TriggerConfigureTimeout())
+      return base::TimeDelta::Max();
+
+    return delay;
+  }
+
+ private:
+  void OnConfigured(bool status) {
+    CHECK_EQ(callback_result_, CALLBACK_NOT_CALLED);
+    callback_result_ = status ? CALLBACK_SUCCESS : CALLBACK_FAILURE;
+  }
+
+  // Passed with configuration requests to run OnConfigured().
+  const DisplayConfigurator::ConfigurationCallback on_configured_callback_;
+
+  DisplayConfigurator::TestApi* test_api_;  // Not owned.
+
+  // The status of the display configuration.
+  CallbackResult callback_result_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConfigurationWaiter);
+};
+
 class DisplayConfiguratorTest : public testing::Test {
  public:
-  enum CallbackResult {
-    CALLBACK_FAILURE,
-    CALLBACK_SUCCESS,
-    CALLBACK_NOT_CALLED,
-  };
-
   DisplayConfiguratorTest()
       : small_mode_(gfx::Size(1366, 768), false, 60.0f),
         big_mode_(gfx::Size(2560, 1600), false, 60.0f),
         observer_(&configurator_),
         test_api_(&configurator_),
+        config_waiter_(&test_api_),
         enable_content_protection_status_(0),
         enable_content_protection_call_count_(0),
         query_content_protection_call_count_(0),
-        callback_result_(CALLBACK_NOT_CALLED),
         display_control_result_(CALLBACK_NOT_CALLED) {}
   ~DisplayConfiguratorTest() override {}
 
   void SetUp() override {
     log_.reset(new ActionLogger());
 
     native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
     configurator_.SetDelegateForTesting(
         std::unique_ptr<NativeDisplayDelegate>(native_display_delegate_));
 
@@ skipping 21 matching lines @@
                       .SetId(kDisplayIds[2])
                       .SetNativeMode(small_mode_.Clone())
                       .SetCurrentMode(small_mode_.Clone())
                       .SetType(DISPLAY_CONNECTION_TYPE_HDMI)
                       .SetIsAspectPerservingScaling(true)
                       .Build();
 
     UpdateOutputs(2, false);
   }
 
-  void OnConfiguredCallback(bool status) {
-    callback_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
-  }
-
   void OnDisplayControlUpdated(bool status) {
     display_control_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
   }
 
   void EnableContentProtectionCallback(bool status) {
     enable_content_protection_status_ = status;
     enable_content_protection_call_count_++;
   }
 
   void QueryContentProtectionCallback(
@@ skipping 40 matching lines @@
     EXPECT_EQ(
         JoinActions(
             kInitXRandR, kGrab,
             GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
                 .c_str(),
             GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
             kForceDPMS, kUngrab, nullptr),
         log_->GetActionsAndClear());
   }
 
-  CallbackResult PopCallbackResult() {
-    CallbackResult result = callback_result_;
-    callback_result_ = CALLBACK_NOT_CALLED;
-    return result;
-  }
-
   CallbackResult PopDisplayControlResult() {
     CallbackResult result = display_control_result_;
     display_control_result_ = CALLBACK_NOT_CALLED;
     return result;
   }
 
   base::MessageLoop message_loop_;
   TestStateController state_controller_;
   TestMirroringController mirroring_controller_;
   DisplayConfigurator configurator_;
   TestObserver observer_;
   std::unique_ptr<ActionLogger> log_;
   TestNativeDisplayDelegate* native_display_delegate_;  // not owned
   DisplayConfigurator::TestApi test_api_;
-
+  ConfigurationWaiter config_waiter_;
   bool enable_content_protection_status_;
   int enable_content_protection_call_count_;
   DisplayConfigurator::QueryProtectionResponse
       query_content_protection_response_;
   int query_content_protection_call_count_;
 
   std::unique_ptr<DisplaySnapshot> outputs_[3];
 
-  CallbackResult callback_result_;
   CallbackResult display_control_result_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
 };
 
 }  // namespace
 
 TEST_F(DisplayConfiguratorTest, FindDisplayModeMatchingSize) {
   std::unique_ptr<ui::DisplaySnapshot> output =
@@ skipping 356 matching lines @@
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
   observer_.Reset();
+  config_waiter_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+      config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(big_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
   // to the mirrored size.
   observer_.Reset();
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
   observer_.Reset();
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
@@ skipping 29 matching lines @@
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
   observer_.Reset();
+  config_waiter_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+      config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(big_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
   EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // When all displays are turned off, the framebuffer should switch back
   // to the extended + software mirroring.
   observer_.Reset();
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                outputs_[0].get(), outputs_[1].get())
               .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
   observer_.Reset();
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                outputs_[0].get(), outputs_[1].get())
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
   EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(DisplayConfiguratorTest, SuspendAndResume) {
   InitWithSingleOutput();
 
   // No preparation is needed before suspending when the display is already
   // on.  The configurator should still reprobe on resume in case a display
   // was connected while suspended.
   const gfx::Size framebuffer_size = configurator_.framebuffer_size();
   DCHECK(!framebuffer_size.IsEmpty());
-  configurator_.SuspendDisplays(base::Bind(
-      &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(framebuffer_size.ToString(),
             configurator_.framebuffer_size().ToString());
   EXPECT_EQ(JoinActions(
                 kGrab, GetFramebufferAction(small_mode_.size(),
                                             outputs_[0].get(), nullptr)
                            .c_str(),
                 GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
                 kUngrab, kSync, nullptr),
             log_->GetActionsAndClear());
+
+  // No resume delay in single display mode.
+  config_waiter_.Reset();
   configurator_.ResumeDisplays();
+  // The timer should not be running.
+  EXPECT_EQ(base::TimeDelta::Max(), config_waiter_.Wait());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Now turn the display off before suspending and check that the
   // configurator turns it back on and syncs with the server.
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(JoinActions(
                 kGrab, GetFramebufferAction(small_mode_.size(),
                                             outputs_[0].get(), nullptr)
                            .c_str(),
                 GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
                 kUngrab, nullptr),
             log_->GetActionsAndClear());
 
-  configurator_.SuspendDisplays(base::Bind(
-      &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(kSync, log_->GetActionsAndClear());
 
+  config_waiter_.Reset();
   configurator_.ResumeDisplays();
+  // The timer should not be running.
+  EXPECT_EQ(base::TimeDelta::Max(), config_waiter_.Wait());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
-  configurator_.SuspendDisplays(base::Bind(
-      &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  // No delay in suspend.
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_OFF,
+            configurator_.current_power_state());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
   EXPECT_EQ(kSync, log_->GetActionsAndClear());
 
   // If a display is disconnected while suspended, the configurator should
-  // pick up the change and only turn on the internal display.
+  // pick up the change and only turn on the internal display. The should be
+  // a longer configuration delay when we set the displays back to on.
   UpdateOutputs(1, false);
+  config_waiter_.Reset();
   configurator_.ResumeDisplays();
+  // Since we were in dual display mirror mode before suspend, the timer should
+  // be running with kMinLongDelayMs.
+  EXPECT_EQ(kLongDelay, test_api_.GetConfigureDelay());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
+  EXPECT_EQ(CALLBACK_NOT_CALLED, config_waiter_.callback_result());

[Daniel Erat, 2016/10/31 21:27:54]

nit: it doesn't look like you passed the callback between the last call to
Reset() and this point, so this is probably unnecessary.

[afakhry, 2016/11/01 00:21:25]

Done.

+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(CALLBACK_NOT_CALLED, config_waiter_.callback_result());
+  EXPECT_EQ(kLongDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, Headless) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   Init(false);
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
   configurator_.ForceInitialConfigure(0);
   EXPECT_EQ(JoinActions(kInitXRandR, kGrab, kForceDPMS, kUngrab, nullptr),
             log_->GetActionsAndClear());
 
   // Not much should happen when the display power state is changed while
   // no displays are connected.
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(JoinActions(kGrab, kUngrab, nullptr), log_->GetActionsAndClear());
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(JoinActions(kGrab, kForceDPMS, kUngrab, nullptr),
             log_->GetActionsAndClear());
 
   // Connect an external display and check that it's configured correctly.
   outputs_[0] = display::FakeDisplaySnapshot::Builder()
                     .SetId(kDisplayIds[0])
                     .SetNativeMode(big_mode_.Clone())
                     .SetCurrentMode(big_mode_.Clone())
                     .AddMode(small_mode_.Clone())
                     .SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
@@ skipping 223 matching lines @@
             log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, DoNotConfigureWithSuspendedDisplays) {
   InitWithSingleOutput();
 
   // The DisplayConfigurator may occasionally receive OnConfigurationChanged()
   // after the displays have been suspended.  This event should be ignored since
   // the DisplayConfigurator will force a probe and reconfiguration of displays
   // at resume time.
-  configurator_.SuspendDisplays(base::Bind(
-      &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(JoinActions(
                 kGrab, GetFramebufferAction(small_mode_.size(),
                                             outputs_[0].get(), nullptr)
                            .c_str(),
                 GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
                 kUngrab, kSync, nullptr),
             log_->GetActionsAndClear());
 
   // The configuration timer should not be started when the displays
   // are suspended.
   configurator_.OnConfigurationChanged();
   EXPECT_FALSE(test_api_.TriggerConfigureTimeout());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // Calls to SetDisplayPower should do nothing if the power state doesn't
   // change.
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   UpdateOutputs(2, false);
   configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // The DisplayConfigurator should do nothing at resume time if there is no
   // state change.
+  config_waiter_.Reset();
   UpdateOutputs(1, false);
   configurator_.ResumeDisplays();
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
   // If a configuration task is pending when the displays are suspended, that
   // task should not run either and the timer should be stopped. The displays
   // should be turned off by suspend.
   configurator_.OnConfigurationChanged();
-  configurator_.SuspendDisplays(base::Bind(
-      &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(JoinActions(
                 kGrab, GetFramebufferAction(small_mode_.size(),
                                             outputs_[0].get(), nullptr)
                            .c_str(),
                 GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
                 kUngrab, kSync, nullptr),
             log_->GetActionsAndClear());
-
   EXPECT_FALSE(test_api_.TriggerConfigureTimeout());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
 
+  config_waiter_.Reset();
   configurator_.ResumeDisplays();
+  // The timer should not be running.
+  EXPECT_EQ(base::TimeDelta::Max(), config_waiter_.Wait());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
@@ skipping 210 matching lines @@
 // so they can be reused later: http://crosbug.com/p/31571
 TEST_F(DisplayConfiguratorTest, SaveDisplayPowerStateOnConfigFailure) {
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
 
   // Turn off the internal display, simulating docked mode.
+  config_waiter_.Reset();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+      config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
   log_->GetActionsAndClear();
 
   // Make all subsequent configuration requests fail and try to turn the
   // internal display back on.
+  config_waiter_.Reset();
   native_display_delegate_->set_max_configurable_pixels(1);
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_FAILURE, PopCallbackResult());
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_FAILURE, config_waiter_.callback_result());
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(1, observer_.num_failures());
   log_->GetActionsAndClear();
 
   // Simulate the external display getting disconnected and check that the
   // internal display is turned on (i.e. DISPLAY_POWER_ALL_ON is used) rather
   // than the earlier DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON state.
   native_display_delegate_->set_max_configurable_pixels(0);
   UpdateOutputs(1, true);
   EXPECT_EQ(
@@ skipping 14 matching lines @@
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
 
   // Turn off the internal display, simulating docked mode.
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+      config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(big_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Suspend and resume the system. Resuming should restore the previous power
   // state and force a probe. Suspend should turn off the displays since an
   // external monitor is connected.
-  configurator_.SuspendDisplays(base::Bind(
-      &DisplayConfiguratorTest::OnConfiguredCallback, base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
           kUngrab, kSync, nullptr),
       log_->GetActionsAndClear());
 
   // Before the task runs, exit docked mode.
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(3, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
                                       outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS, kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Check that the display states are not changed after resuming.
+  config_waiter_.Reset();
+  // Since we are in dual display mode, a configuration task is scheduled after
+  // kMinLongDelayMs delay.
   configurator_.ResumeDisplays();
+  EXPECT_EQ(kLongDelay, test_api_.GetConfigureDelay());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
+            configurator_.current_power_state());
   EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
+  // Now trigger that delayed configuration.
+  EXPECT_EQ(kLongDelay, config_waiter_.Wait());
+  EXPECT_EQ(
+      JoinActions(
+          kGrab, GetFramebufferAction(small_mode_.size(), outputs_[0].get(),
+                                      outputs_[1].get())
+                     .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kUngrab, nullptr),
+      log_->GetActionsAndClear());
 }
 
 TEST_F(DisplayConfiguratorTest, ExternalControl) {
   InitWithSingleOutput();
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
   configurator_.RelinquishControl(
       base::Bind(&DisplayConfiguratorTest::OnDisplayControlUpdated,
                  base::Unretained(this)));
   EXPECT_EQ(CALLBACK_SUCCESS, PopDisplayControlResult());
   EXPECT_EQ(JoinActions(kRelinquishDisplayControl, nullptr),
@@ skipping 16 matching lines @@
        SetDisplayPowerWhilePendingConfigurationTaskRunning) {
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
 
   native_display_delegate_->set_run_async(true);
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(CALLBACK_NOT_CALLED, config_waiter_.callback_result());
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
 
-  EXPECT_EQ(CALLBACK_NOT_CALLED, PopCallbackResult());
-  base::RunLoop().RunUntilIdle();
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  EXPECT_EQ(CALLBACK_NOT_CALLED, config_waiter_.callback_result());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(1, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
 
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                outputs_[0].get(), outputs_[1].get())
               .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
-  EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
+  config_waiter_.Reset();
+  EXPECT_EQ(base::TimeDelta::FromMilliseconds(
+      DisplayConfigurator::kConfigureDelayMs), config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_NOT_CALLED, config_waiter_.callback_result());
   base::RunLoop().RunUntilIdle();

[Daniel Erat, 2016/10/31 21:27:54]

what's the reason for calling RunUntilIdle() directly here instead of
config_waiter_.Wait()?

[afakhry, 2016/11/01 00:21:25]

We can still use Wait() with the same result. base::RunLoop().RunUntilIdle()
seemed to clearly show that this is an async task that will invoke the
OnConfigured() callback, and that the confgig timer is not involved.

For consistency, I returned back to Wait().

-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(2, observer_.num_changes());
   EXPECT_EQ(0, observer_.num_failures());
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                outputs_[0].get(), outputs_[1].get())
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
@@ skipping 10 matching lines @@
   // Start out with two displays in extended mode.
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   Init(false);
   configurator_.ForceInitialConfigure(0);
   log_->GetActionsAndClear();
   observer_.Reset();
 
   // Fail display configuration.
   native_display_delegate_->set_max_configurable_pixels(-1);
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-
-  EXPECT_EQ(CALLBACK_FAILURE, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_FAILURE, config_waiter_.callback_result());
   EXPECT_EQ(0, observer_.num_changes());
   EXPECT_EQ(1, observer_.num_failures());
 
   const int kDualHeight = small_mode_.size().height() +
                           DisplayConfigurator::kVerticalGap +
                           big_mode_.size().height();
 
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                outputs_[0].get(), outputs_[1].get())
               .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // This configuration should trigger a display configuration since the
   // previous configuration failed.
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
 
   EXPECT_EQ(0, observer_.num_changes());
   EXPECT_EQ(2, observer_.num_failures());
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                outputs_[0].get(), outputs_[1].get())
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
@@ skipping 65 matching lines @@
           GetCrtcAction(
               *outputs_[2], &small_mode_,
               gfx::Point(0, small_mode_.size().height() +
                                 big_mode_.size().height() +
                                 2 * DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
   // Verify that turning the power off works.
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_OFF,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_OFF,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kTripleHeight),
                      outputs_[0].get(), outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], nullptr,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           GetCrtcAction(
               *outputs_[2], nullptr,
               gfx::Point(0, small_mode_.size().height() +
                                 big_mode_.size().height() +
                                 2 * DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 
-  configurator_.SetDisplayPower(
-      chromeos::DISPLAY_POWER_ALL_ON,
-      DisplayConfigurator::kSetDisplayPowerNoFlags,
-      base::Bind(&DisplayConfiguratorTest::OnConfiguredCallback,
-                 base::Unretained(this)));
-
-  EXPECT_EQ(CALLBACK_SUCCESS, PopCallbackResult());
+  config_waiter_.Reset();
+  configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
+                                DisplayConfigurator::kSetDisplayPowerNoFlags,
+                                config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
   EXPECT_EQ(
       JoinActions(
           kGrab, GetFramebufferAction(
                      gfx::Size(big_mode_.size().width(), kTripleHeight),
                      outputs_[0].get(), outputs_[1].get())
                      .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
@@ skipping 19 matching lines @@
               .c_str(),
           GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(*outputs_[1], &big_mode_,
                         gfx::Point(0, small_mode_.size().height() +
                                           DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab, nullptr),
       log_->GetActionsAndClear());
 }
 
+// Tests the suspend and resume behavior when in dual or multi display modes.
+TEST_F(DisplayConfiguratorTest, SuspendResumeWithMultipleDisplays) {
+  InitWithSingleOutput();
+  state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
+  observer_.Reset();
+  UpdateOutputs(2, true);
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
+            configurator_.display_state());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
+  EXPECT_EQ(1, observer_.num_changes());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
+            configurator_.current_power_state());
+  const int kDualHeight = small_mode_.size().height() +
+                          DisplayConfigurator::kVerticalGap +
+                          big_mode_.size().height();
+  EXPECT_EQ(
+      JoinActions(
+          kGrab,
+          GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
+                               outputs_[0].get(), outputs_[1].get())
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, nullptr),
+      log_->GetActionsAndClear());
+
+  // Suspending displays should result in an immediate configuration without
+  // delays, even in dual display mode.
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_OFF,
+            configurator_.current_power_state());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
+            configurator_.display_state());
+  EXPECT_EQ(
+      JoinActions(
+          kGrab,
+          GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
+                               outputs_[0].get(), outputs_[1].get())
+              .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, kSync, nullptr),
+      log_->GetActionsAndClear());
+
+  // Resuming from suspend with dual displays. Configuration should be done
+  // after a long delay. Afterwards, we should still expect to be in a dual
+  // display mode.
+  config_waiter_.Reset();
+  configurator_.ResumeDisplays();
+  EXPECT_EQ(kLongDelay, config_waiter_.Wait());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
+            configurator_.current_power_state());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
+            configurator_.display_state());
+  EXPECT_EQ(
+      JoinActions(
+          kGrab,
+          GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
+                               outputs_[0].get(), outputs_[1].get())
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], &big_mode_,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kForceDPMS, kUngrab, nullptr),
+      log_->GetActionsAndClear());
+
+  // Suspend displays and disconnect one of them while in suspend.
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
+            configurator_.display_state());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_OFF,
+            configurator_.current_power_state());
+  EXPECT_EQ(
+      JoinActions(
+          kGrab,
+          GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
+                               outputs_[0].get(), outputs_[1].get())
+              .c_str(),
+          GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
+          GetCrtcAction(*outputs_[1], nullptr,
+                        gfx::Point(0, small_mode_.size().height() +
+                                          DisplayConfigurator::kVerticalGap))
+              .c_str(),
+          kUngrab, kSync, nullptr),
+      log_->GetActionsAndClear());
+  UpdateOutputs(1, false);
+  EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
+
+  // Now resume, and expect that we'll still have a long delay since we were in
+  // dual mode before suspend. The configurator should pick up the change and
+  // detect that we are in single display mode now.
+  config_waiter_.Reset();
+  configurator_.ResumeDisplays();
+  EXPECT_EQ(kLongDelay, config_waiter_.Wait());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
+            configurator_.current_power_state());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
+  EXPECT_EQ(
+      JoinActions(
+          kGrab,
+          GetFramebufferAction(small_mode_.size(), outputs_[0].get(), nullptr)
+              .c_str(),
+          GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
+          kForceDPMS, kUngrab, nullptr),
+      log_->GetActionsAndClear());
+
+  // Verify that the above is the exact same behavior for 3+ displays.
+  UpdateOutputs(3, true);
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
+            configurator_.display_state());
+
+  // Suspend.
+  config_waiter_.Reset();
+  configurator_.SuspendDisplays(config_waiter_.on_configuration_callback());
+  EXPECT_EQ(kNoDelay, config_waiter_.Wait());
+  EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
+            configurator_.display_state());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_OFF,
+            configurator_.current_power_state());
+
+  // Resume and expect the correct delay.
+  config_waiter_.Reset();
+  configurator_.ResumeDisplays();
+  EXPECT_EQ(kLongDelay, config_waiter_.Wait());
+  EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_ON,
+            configurator_.current_power_state());
+  EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
+            configurator_.display_state());
+}
+
 }  // namespace test
 }  // namespace ui