Fix HDCP in mirror mode.

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 <stdint.h>
 
 #include <cmath>
 #include <cstdarg>
@@ skipping 358 matching lines @@
 class TestMirroringController
     : public DisplayConfigurator::SoftwareMirroringController {
  public:
   TestMirroringController() : software_mirroring_enabled_(false) {}
   virtual ~TestMirroringController() {}
 
   virtual void SetSoftwareMirroring(bool enabled) OVERRIDE {
     software_mirroring_enabled_ = enabled;
   }
 
-  bool software_mirroring_enabled() const {
+  virtual bool SoftwareMirroringEnabled() const OVERRIDE {
     return software_mirroring_enabled_;
   }
 
  private:
   bool software_mirroring_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestMirroringController);
 };
 
 class DisplayConfiguratorTest : public testing::Test {
@@ skipping 195 matching lines @@
           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,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   observer_.Reset();
   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
               .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,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
   observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Get rid of shared modes to force software mirroring.
   outputs_[1].set_modes(std::vector<const DisplayMode*>(1, &big_mode_));
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED);
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                &outputs_[0],
                                &outputs_[1]).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,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
 
   observer_.Reset();
   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
-  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Setting MULTIPLE_DISPLAY_STATE_DUAL_MIRROR should try to reconfigure.
   observer_.Reset();
   EXPECT_TRUE(
       configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED));
   EXPECT_EQ(JoinActions(NULL), log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Set back to software mirror mode.
   observer_.Reset();
   EXPECT_TRUE(configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR));
   EXPECT_EQ(JoinActions(kGrab, kUngrab, NULL), log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
-  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Disconnect the second output.
   observer_.Reset();
   UpdateOutputs(1, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), &outputs_[0], NULL).c_str(),
           GetCrtcAction(outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 }
 
 TEST_F(DisplayConfiguratorTest, SetDisplayPower) {
   InitWithSingleOutput();
 
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
               .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,
           NULL),
       log_->GetActionsAndClear());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  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();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
@@ skipping 17 matching lines @@
   EXPECT_EQ(
       JoinActions(kGrab,
                   GetFramebufferAction(
                       small_mode_.size(), &outputs_[0], &outputs_[1]).c_str(),
                   GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
                   GetCrtcAction(outputs_[1], NULL, gfx::Point(0, 0)).c_str(),
                   kUngrab,
                   NULL),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  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);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(small_mode_.size(), &outputs_[0], &outputs_[1])
               .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,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
   EXPECT_EQ(1, observer_.num_changes());
 
   // Get rid of shared modes to force software mirroring.
   outputs_[1].set_modes(std::vector<const DisplayMode*>(1, &big_mode_));
   state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
   observer_.Reset();
   UpdateOutputs(2, true);
   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],
                                &outputs_[1]).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,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
-  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  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();
   configurator_.SetDisplayPower(
       chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
       DisplayConfigurator::kSetDisplayPowerNoFlags);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(big_mode_.size(), &outputs_[0], &outputs_[1])
               .c_str(),
           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
           kForceDPMS,
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_SINGLE, configurator_.display_state());
-  EXPECT_FALSE(mirroring_controller_.software_mirroring_enabled());
+  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);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                &outputs_[0],
                                &outputs_[1]).c_str(),
           GetCrtcAction(outputs_[0], NULL, gfx::Point(0, 0)).c_str(),
           GetCrtcAction(outputs_[1],
                         NULL,
                         gfx::Point(0,
                                    small_mode_.size().height() +
                                        DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
-  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  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);
   EXPECT_EQ(
       JoinActions(
           kGrab,
           GetFramebufferAction(gfx::Size(big_mode_.size().width(), kDualHeight),
                                &outputs_[0],
                                &outputs_[1]).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,
           NULL),
       log_->GetActionsAndClear());
   EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_EXTENDED,
             configurator_.display_state());
-  EXPECT_TRUE(mirroring_controller_.software_mirroring_enabled());
+  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.
   configurator_.SuspendDisplays();
@@ skipping 484 matching lines @@
                         gfx::Point(0,
                                    modes[0]->size().height() +
                                        DisplayConfigurator::kVerticalGap))
               .c_str(),
           kUngrab,
           NULL),
       log_->GetActionsAndClear());
 }
 
 }  // namespace ui