chromeos: Notify observers after display power changes.

chromeos/display/output_configurator_unittest.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 <cstdarg>
 #include <map>
 #include <string>
 #include <vector>
@@ skipping 174 matching lines @@
   std::vector<OutputConfigurator::OutputSnapshot> outputs_;
 
   std::string actions_;
 
   // Return value returned by ConfigureCrtc().
   bool configure_crtc_result_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
+class TestObserver : public OutputConfigurator::Observer {
+ public:
+  explicit TestObserver(OutputConfigurator* configurator)
+      : configurator_(configurator) {
+    Reset();
+    configurator_->AddObserver(this);
+  }
+  virtual ~TestObserver() {
+    configurator_->RemoveObserver(this);
+  }
+
+  int num_changes() const { return num_changes_; }
+  int num_failures() const { return num_failures_; }
+  std::vector<OutputConfigurator::OutputSnapshot> latest_outputs() const {
+    return latest_outputs_;
+  }
+  OutputState latest_failed_state() const { return latest_failed_state_; }
+
+  void Reset() {
+    num_changes_ = 0;
+    num_failures_ = 0;
+    latest_outputs_.clear();
+    latest_failed_state_ = STATE_INVALID;
+  }
+
+  // OutputConfigurator::Observer overrides:
+  virtual void OnDisplayModeChanged(
+      const std::vector<OutputConfigurator::OutputSnapshot>& outputs) OVERRIDE {
+    num_changes_++;
+    latest_outputs_ = outputs;
+  }
+
+  virtual void OnDisplayModeChangeFailed(OutputState failed_new_state)
+      OVERRIDE {
+    num_failures_++;
+    latest_failed_state_ = failed_new_state;
+  }
+
+ private:
+  OutputConfigurator* configurator_;  // Not owned.
+
+  // Number of times that OnDisplayMode*() has been called.
+  int num_changes_;
+  int num_failures_;
+
+  // Parameters most recently passed to OnDisplayMode*().
+  std::vector<OutputConfigurator::OutputSnapshot> latest_outputs_;
+  OutputState latest_failed_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestObserver);
+};
+
 class TestStateController : public OutputConfigurator::StateController {
  public:
   TestStateController() : state_(STATE_DUAL_EXTENDED) {}
   virtual ~TestStateController() {}
 
   void set_state(OutputState state) { state_ = state; }
 
   // OutputConfigurator::StateController overrides:
   virtual OutputState GetStateForDisplayIds(
       const std::vector<int64>& outputs) const OVERRIDE { return state_; }
@@ skipping 26 matching lines @@
 
  private:
   bool software_mirroring_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMirroringController);
 };
 
 class OutputConfiguratorTest : public testing::Test {
  public:
   OutputConfiguratorTest()
-      : test_api_(&configurator_, TestDelegate::kXRandREventBase) {}
+      : observer_(&configurator_),
+        test_api_(&configurator_, TestDelegate::kXRandREventBase) {}
   virtual ~OutputConfiguratorTest() {}
 
   virtual void SetUp() OVERRIDE {
     delegate_ = new TestDelegate();
     configurator_.SetDelegateForTesting(
         scoped_ptr<OutputConfigurator::Delegate>(delegate_));
     configurator_.set_state_controller(&state_controller_);
     configurator_.set_mirroring_controller(&mirroring_controller_);
 
     OutputConfigurator::ModeInfo small_mode_info;
@@ skipping 88 matching lines @@
                           GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                                         outputs_[0].output).c_str(),
                           kForceDPMS, kUngrab, kProjectingOff, NULL),
               delegate_->GetActionsAndClear());
   }
 
   base::MessageLoop message_loop_;
   TestStateController state_controller_;
   TestMirroringController mirroring_controller_;
   OutputConfigurator configurator_;
+  TestObserver observer_;
   TestDelegate* delegate_;  // not owned
   OutputConfigurator::TestApi test_api_;
 
   OutputConfigurator::OutputSnapshot outputs_[2];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OutputConfiguratorTest);
 };
 
 }  // namespace
 
 TEST_F(OutputConfiguratorTest, ConnectSecondOutput) {
   InitWithSingleOutput();
 
   // Connect a second output and check that the configurator enters
   // extended mode.
+  observer_.Reset();
   state_controller_.set_state(STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   const int kDualHeight =
       kSmallModeHeight + OutputConfigurator::kVerticalGap + kBigModeHeight;
   EXPECT_EQ(JoinActions(kUpdateXRandR, kGrab,
                         GetFramebufferAction(kBigModeWidth, kDualHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0,
                             kSmallModeHeight + OutputConfigurator::kVerticalGap,
                             kBigModeId, outputs_[1].output).c_str(),
                         kUngrab, kProjectingOn, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
+  observer_.Reset();
   EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kSmallModeWidth, kSmallModeHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, kSmallModeId,
                             outputs_[1].output).c_str(),
                         kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
+  observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(JoinActions(kUpdateXRandR, kGrab,
                         GetFramebufferAction(kSmallModeWidth, kSmallModeHeight,
                             outputs_[0].crtc, 0).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         kUngrab, kProjectingOff, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Software Mirroring
   DisableNativeMirroring();
   state_controller_.set_state(STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   EXPECT_EQ(JoinActions(kUpdateXRandR, kGrab,
                         GetFramebufferAction(kBigModeWidth, kDualHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0,
                             kSmallModeHeight + OutputConfigurator::kVerticalGap,
                             kBigModeId, outputs_[1].output).c_str(),
                         kUngrab, kProjectingOn, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
 
+  observer_.Reset();
+  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
+  EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), delegate_->GetActionsAndClear());
+  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
+  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
+
+  // Setting STATE_DUAL_MIRROR should try to reconfigure.
+  observer_.Reset();
+  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_EQ(JoinActions(NULL), delegate_->GetActionsAndClear());
+  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
+
+  // Set back to software mirror mode.
+  observer_.Reset();
   EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
-
-  // Setting STATE_DUAL_MIRROR should try to reconfigure
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
-  EXPECT_EQ(JoinActions(NULL), delegate_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
-
-  // Set back to software mirror mode.
-  EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
-  EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL),
-            delegate_->GetActionsAndClear());
-  EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
-  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
+  observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(JoinActions(kUpdateXRandR, kGrab,
                         GetFramebufferAction(kSmallModeWidth, kSmallModeHeight,
                             outputs_[0].crtc, 0).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         kUngrab, kProjectingOff, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(OutputConfiguratorTest, SetDisplayPower) {
   InitWithSingleOutput();
 
   state_controller_.set_state(STATE_DUAL_MIRROR);
+  observer_.Reset();
   UpdateOutputs(2, true);
   EXPECT_EQ(JoinActions(kUpdateXRandR, kGrab,
                         GetFramebufferAction(kSmallModeWidth, kSmallModeHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, kSmallModeId,
                             outputs_[1].output).c_str(),
                         kUngrab, kProjectingOn, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
+  observer_.Reset();
   configurator_.SetDisplayPower(DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kBigModeWidth, kBigModeHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, 0,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, kBigModeId,
                             outputs_[1].output).c_str(),
                         kForceDPMS, kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_SINGLE, configurator_.output_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(DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kSmallModeWidth, kSmallModeHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, 0,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, 0,
                             outputs_[1].output).c_str(),
                         kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
+  observer_.Reset();
   configurator_.SetDisplayPower(DISPLAY_POWER_ALL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kSmallModeWidth, kSmallModeHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, kSmallModeId,
                             outputs_[1].output).c_str(),
                         kForceDPMS, kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_DUAL_MIRROR, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Software Mirroring
   DisableNativeMirroring();
   state_controller_.set_state(STATE_DUAL_MIRROR);
+  observer_.Reset();
   UpdateOutputs(2, true);
   const int kDualHeight =
       kSmallModeHeight + OutputConfigurator::kVerticalGap + kBigModeHeight;
   EXPECT_EQ(JoinActions(kUpdateXRandR, kGrab,
                         GetFramebufferAction(kBigModeWidth, kDualHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0,
                             kSmallModeHeight + OutputConfigurator::kVerticalGap,
                             kBigModeId, outputs_[1].output).c_str(),
                         kUngrab, kProjectingOn, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Turning off the internal display should switch the external display to
   // its native mode.
+  observer_.Reset();
   configurator_.SetDisplayPower(DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kBigModeWidth, kBigModeHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, 0,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, kBigModeId,
                             outputs_[1].output).c_str(),
                         kForceDPMS, kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_SINGLE, configurator_.output_state());
   EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  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(DISPLAY_POWER_ALL_OFF,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kBigModeWidth, kDualHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, 0,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0,
                             kSmallModeHeight + OutputConfigurator::kVerticalGap,
                             0, outputs_[1].output).c_str(),
                         kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_EQ(1, observer_.num_changes());
 
   // Turn all displays on and check that mirroring is still used.
+  observer_.Reset();
   configurator_.SetDisplayPower(DISPLAY_POWER_ALL_ON,
                                 OutputConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(JoinActions(kGrab,
                         GetFramebufferAction(kBigModeWidth, kDualHeight,
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0,
                             kSmallModeHeight + OutputConfigurator::kVerticalGap,
                             kBigModeId, outputs_[1].output).c_str(),
                         kForceDPMS, kUngrab, NULL),
             delegate_->GetActionsAndClear());
   EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
   EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
-
+  EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(OutputConfiguratorTest, 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.
   configurator_.SuspendDisplays();
   EXPECT_EQ(kNoActions, delegate_->GetActionsAndClear());
@@ skipping 128 matching lines @@
                             outputs_[1].output).c_str(),
                         kForceDPMS, kUngrab, kProjectingOn, NULL),
             delegate_->GetActionsAndClear());
 }
 
 TEST_F(OutputConfiguratorTest, InvalidOutputStates) {
   UpdateOutputs(0, false);
   EXPECT_EQ(kNoActions, delegate_->GetActionsAndClear());
   configurator_.Init(false);
   configurator_.Start(0);
+  observer_.Reset();
   EXPECT_TRUE(configurator_.SetDisplayMode(STATE_HEADLESS));
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_SINGLE));
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_EQ(1, observer_.num_changes());
+  EXPECT_EQ(3, observer_.num_failures());
 
   UpdateOutputs(1, true);
+  observer_.Reset();
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_HEADLESS));
   EXPECT_TRUE(configurator_.SetDisplayMode(STATE_SINGLE));
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_EQ(1, observer_.num_changes());
+  EXPECT_EQ(3, observer_.num_failures());
 
   state_controller_.set_state(STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
+  observer_.Reset();
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_HEADLESS));
   EXPECT_FALSE(configurator_.SetDisplayMode(STATE_SINGLE));
   EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_MIRROR));
   EXPECT_TRUE(configurator_.SetDisplayMode(STATE_DUAL_EXTENDED));
+  EXPECT_EQ(2, observer_.num_changes());
+  EXPECT_EQ(2, observer_.num_failures());
 }
 
 TEST_F(OutputConfiguratorTest, GetOutputStateForDisplaysWithoutId) {
   outputs_[0].has_display_id = false;
   UpdateOutputs(2, false);
   configurator_.Init(false);
   state_controller_.set_state(STATE_DUAL_MIRROR);
   configurator_.Start(0);
   EXPECT_EQ(STATE_DUAL_EXTENDED, configurator_.output_state());
 }
@@ skipping 97 matching lines @@
                             outputs_[0].crtc, outputs_[1].crtc).c_str(),
                         GetCrtcAction(outputs_[0].crtc, 0, 0, kSmallModeId,
                             outputs_[0].output).c_str(),
                         GetCrtcAction(outputs_[1].crtc, 0, 0, kSmallModeId,
                             outputs_[1].output).c_str(),
                         kUngrab, kProjectingOn, NULL),
             delegate_->GetActionsAndClear());
 }
 
 }  // namespace chromeos