blob: cde72cc6654edae736c3f5449e0802ff388dbfe8 [file] [log] [blame]
// 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/manager/display_configurator.h"
#include <stddef.h>
#include <stdint.h>
#include "base/command_line.h"
#include "base/macros.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "chromeos/chromeos_switches.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/display/manager/fake_display_snapshot.h"
#include "ui/display/manager/test/action_logger_util.h"
#include "ui/display/manager/test/test_native_display_delegate.h"
#include "ui/display/util/display_util.h"
namespace display {
namespace test {
namespace {
constexpr int64_t kDisplayIds[3] = {123, 456, 789};
std::unique_ptr<DisplayMode> MakeDisplayMode(int width,
int height,
bool is_interlaced,
float refresh_rate) {
return std::make_unique<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_; }
int num_failures() const { return num_failures_; }
const DisplayConfigurator::DisplayStateList& latest_outputs() const {
return latest_outputs_;
}
MultipleDisplayState latest_failed_state() const {
return latest_failed_state_;
}
void Reset() {
num_changes_ = 0;
num_failures_ = 0;
latest_outputs_.clear();
latest_failed_state_ = MULTIPLE_DISPLAY_STATE_INVALID;
}
// DisplayConfigurator::Observer overrides:
void OnDisplayModeChanged(
const DisplayConfigurator::DisplayStateList& outputs) override {
num_changes_++;
latest_outputs_ = outputs;
}
void OnDisplayModeChangeFailed(
const DisplayConfigurator::DisplayStateList& outputs,
MultipleDisplayState failed_new_state) override {
num_failures_++;
latest_failed_state_ = failed_new_state;
}
private:
DisplayConfigurator* configurator_; // Not owned.
// Number of times that OnDisplayMode*() has been called.
int num_changes_;
int num_failures_;
// Parameters most recently passed to OnDisplayMode*().
DisplayConfigurator::DisplayStateList latest_outputs_;
MultipleDisplayState latest_failed_state_;
DISALLOW_COPY_AND_ASSIGN(TestObserver);
};
class TestStateController : public DisplayConfigurator::StateController {
public:
TestStateController() : state_(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED) {}
~TestStateController() override {}
void set_state(MultipleDisplayState state) { state_ = state; }
// DisplayConfigurator::StateController overrides:
MultipleDisplayState GetStateForDisplayIds(
const DisplayConfigurator::DisplayStateList& outputs) override {
return state_;
}
bool GetResolutionForDisplayId(int64_t display_id,
gfx::Size* size) const override {
return false;
}
private:
MultipleDisplayState state_;
DISALLOW_COPY_AND_ASSIGN(TestStateController);
};
class TestMirroringController
: public DisplayConfigurator::SoftwareMirroringController {
public:
TestMirroringController() : software_mirroring_enabled_(false) {}
~TestMirroringController() override {}
void SetSoftwareMirroring(bool enabled) override {
software_mirroring_enabled_ = enabled;
}
bool SoftwareMirroringEnabled() const override {
return software_mirroring_enabled_;
}
bool IsSoftwareMirroringEnforced() const override { return false; }
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:
explicit 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:
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_),
set_content_protection_status_(false),
set_content_protection_call_count_(0),
query_content_protection_response_success_(false),
query_content_protection_response_link_mask_(0),
query_content_protection_response_protection_mask_(0),
query_content_protection_call_count_(0),
display_control_result_(CALLBACK_NOT_CALLED) {}
~DisplayConfiguratorTest() override {}
void SetUp() override {
log_.reset(new ActionLogger());
// Force system compositor mode to simulate on-device configurator behavior.
base::CommandLine::ForCurrentProcess()->AppendSwitch(
chromeos::switches::kForceSystemCompositorMode);
native_display_delegate_ = new TestNativeDisplayDelegate(log_.get());
configurator_.SetDelegateForTesting(
std::unique_ptr<NativeDisplayDelegate>(native_display_delegate_));
configurator_.set_state_controller(&state_controller_);
configurator_.set_mirroring_controller(&mirroring_controller_);
outputs_[0] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.SetNativeMode(small_mode_.Clone())
.SetCurrentMode(small_mode_.Clone())
.SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
.SetIsAspectPerservingScaling(true)
.Build();
outputs_[1] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[1])
.SetNativeMode(big_mode_.Clone())
.SetCurrentMode(big_mode_.Clone())
.AddMode(small_mode_.Clone())
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetIsAspectPerservingScaling(true)
.Build();
outputs_[2] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[2])
.SetNativeMode(small_mode_.Clone())
.SetCurrentMode(small_mode_.Clone())
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetIsAspectPerservingScaling(true)
.Build();
UpdateOutputs(2, false);
}
void OnDisplayControlUpdated(bool status) {
display_control_result_ = (status ? CALLBACK_SUCCESS : CALLBACK_FAILURE);
}
void SetContentProtectionCallback(bool status) {
set_content_protection_status_ = status;
set_content_protection_call_count_++;
}
void QueryContentProtectionCallback(bool success,
uint32_t link_mask,
uint32_t protection_mask) {
query_content_protection_response_success_ = success;
query_content_protection_response_link_mask_ = link_mask;
query_content_protection_response_protection_mask_ = protection_mask;
query_content_protection_call_count_++;
}
// Predefined modes that can be used by outputs.
const DisplayMode small_mode_;
const DisplayMode big_mode_;
protected:
// Configures |native_display_delegate_| to return the first |num_outputs|
// entries from
// |outputs_|. If |send_events| is true, also sends screen-change and
// output-change events to |configurator_| and triggers the configure
// timeout if one was scheduled.
void UpdateOutputs(size_t num_outputs, bool send_events) {
ASSERT_LE(num_outputs, arraysize(outputs_));
std::vector<DisplaySnapshot*> outputs;
for (size_t i = 0; i < num_outputs; ++i)
outputs.push_back(outputs_[i].get());
native_display_delegate_->set_outputs(outputs);
if (send_events) {
configurator_.OnConfigurationChanged();
EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
}
}
void Init(bool panel_fitting_enabled) {
configurator_.Init(nullptr, panel_fitting_enabled);
}
// Initializes |configurator_| with a single internal display.
void InitWithSingleOutput() {
UpdateOutputs(1, false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
configurator_.Init(nullptr, false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
configurator_.ForceInitialConfigure();
EXPECT_EQ(
JoinActions(
kInit,
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
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 set_content_protection_status_;
int set_content_protection_call_count_;
bool query_content_protection_response_success_;
uint32_t query_content_protection_response_link_mask_;
uint32_t query_content_protection_response_protection_mask_;
int query_content_protection_call_count_;
std::unique_ptr<DisplaySnapshot> outputs_[3];
CallbackResult display_control_result_;
private:
DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorTest);
};
} // namespace
TEST_F(DisplayConfiguratorTest, FindDisplayModeMatchingSize) {
std::unique_ptr<DisplaySnapshot> output =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0))
.SetNativeMode(MakeDisplayMode(1920, 1200, false, 50.0))
// Different rates.
.AddMode(MakeDisplayMode(1920, 1080, false, 30.0))
.AddMode(MakeDisplayMode(1920, 1080, false, 50.0))
.AddMode(MakeDisplayMode(1920, 1080, false, 40.0))
.AddMode(MakeDisplayMode(1920, 1080, false, 0.0))
// Interlaced vs non-interlaced.
.AddMode(MakeDisplayMode(1280, 720, true, 60.0))
.AddMode(MakeDisplayMode(1280, 720, false, 40.0))
// Interlaced only.
.AddMode(MakeDisplayMode(1024, 768, true, 0.0))
.AddMode(MakeDisplayMode(1024, 768, true, 40.0))
.AddMode(MakeDisplayMode(1024, 768, true, 60.0))
// Mixed.
.AddMode(MakeDisplayMode(1024, 600, true, 60.0))
.AddMode(MakeDisplayMode(1024, 600, false, 40.0))
.AddMode(MakeDisplayMode(1024, 600, false, 50.0))
// Just one interlaced mode.
.AddMode(MakeDisplayMode(640, 480, true, 60.0))
// Refresh rate not available.
.AddMode(MakeDisplayMode(320, 200, false, 0.0))
.Build();
const std::vector<std::unique_ptr<const DisplayMode>>& modes =
output->modes();
// Should pick native over highest refresh rate.
EXPECT_EQ(modes[1].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(1920, 1200)));
// Should pick highest refresh rate.
EXPECT_EQ(modes[3].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(1920, 1080)));
// Should pick non-interlaced mode.
EXPECT_EQ(modes[7].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(1280, 720)));
// Interlaced only. Should pick one with the highest refresh rate in
// interlaced mode.
EXPECT_EQ(modes[10].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(1024, 768)));
// Mixed: Should pick one with the highest refresh rate in
// interlaced mode.
EXPECT_EQ(modes[13].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(1024, 600)));
// Just one interlaced mode.
EXPECT_EQ(modes[14].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(640, 480)));
// Refresh rate not available.
EXPECT_EQ(modes[15].get(), DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(320, 200)));
// No mode found.
EXPECT_EQ(nullptr, DisplayConfigurator::FindDisplayModeMatchingSize(
*output, gfx::Size(1440, 900)));
}
TEST_F(DisplayConfiguratorTest, ConnectSecondOutput) {
InitWithSingleOutput();
// Connect a second output and check that the configurator enters
// extended mode.
observer_.Reset();
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
UpdateOutputs(2, true);
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
// Disconnect the second output.
observer_.Reset();
UpdateOutputs(1, true);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
// Get rid of shared modes to force software mirroring.
outputs_[1] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[1])
.SetNativeMode(big_mode_.Clone())
.SetCurrentMode(big_mode_.Clone())
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetIsAspectPerservingScaling(true)
.Build();
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
UpdateOutputs(2, true);
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
configurator_.display_state());
EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
// Setting MULTIPLE_DISPLAY_STATE_DUAL_MIRROR should try to reconfigure.
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
// Set back to software mirror mode.
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
configurator_.display_state());
EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
// Disconnect the second output.
observer_.Reset();
UpdateOutputs(1, true);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
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,
config_waiter_.on_configuration_callback());
EXPECT_EQ(kNoDelay, config_waiter_.Wait());
EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
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();
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
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();
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
// Get rid of shared modes to force software mirroring.
outputs_[1] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[1])
.SetNativeMode(big_mode_.Clone())
.SetCurrentMode(big_mode_.Clone())
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetIsAspectPerservingScaling(true)
.Build();
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
observer_.Reset();
UpdateOutputs(2, true);
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_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,
config_waiter_.on_configuration_callback());
EXPECT_EQ(kNoDelay, config_waiter_.Wait());
EXPECT_EQ(CALLBACK_SUCCESS, config_waiter_.callback_result());
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
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();
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(
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(),
nullptr),
log_->GetActionsAndClear());
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_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();
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(
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(),
nullptr),
log_->GetActionsAndClear());
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED,
configurator_.display_state());
EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
}
TEST_F(DisplayConfiguratorTest, SuspendAndResume) {
InitWithSingleOutput();
// Set the initial power state to on.
config_waiter_.Reset();
configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
DisplayConfigurator::kSetDisplayPowerNoFlags,
config_waiter_.on_configuration_callback());
// 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.
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
// Now turn the display off before suspending and check that the
// configurator turns it back on and syncs with the server.
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
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(kNoActions, 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());
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
UpdateOutputs(2, true);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
// 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(kNoActions, log_->GetActionsAndClear());
// If a display is disconnected while suspended, the configurator should
// 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,
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, Headless) {
UpdateOutputs(0, false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
Init(false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
configurator_.ForceInitialConfigure();
EXPECT_EQ(JoinActions(kInit, nullptr), log_->GetActionsAndClear());
// Not much should happen when the display power state is changed while
// no displays are connected.
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());
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(kNoActions, log_->GetActionsAndClear());
// Connect an external display and check that it's configured correctly.
outputs_[0] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.SetNativeMode(big_mode_.Clone())
.SetCurrentMode(big_mode_.Clone())
.AddMode(small_mode_.Clone())
.SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
.SetIsAspectPerservingScaling(true)
.Build();
UpdateOutputs(1, true);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], &big_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
UpdateOutputs(0, true);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, StartWithTwoOutputs) {
UpdateOutputs(2, false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
Init(false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
configurator_.ForceInitialConfigure();
EXPECT_EQ(
JoinActions(
kInit,
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, InvalidMultipleDisplayStates) {
UpdateOutputs(0, false);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
Init(false);
configurator_.ForceInitialConfigure();
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS);
EXPECT_EQ(1, observer_.num_changes());
EXPECT_EQ(0, observer_.num_failures());
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE);
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
EXPECT_EQ(1, observer_.num_changes());
EXPECT_EQ(3, observer_.num_failures());
UpdateOutputs(1, true);
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS);
EXPECT_EQ(0, observer_.num_changes());
EXPECT_EQ(1, observer_.num_failures());
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE);
EXPECT_EQ(1, observer_.num_changes());
EXPECT_EQ(1, observer_.num_failures());
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
EXPECT_EQ(1, observer_.num_changes());
EXPECT_EQ(3, observer_.num_failures());
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
UpdateOutputs(2, true);
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_HEADLESS);
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_SINGLE);
EXPECT_EQ(0, observer_.num_changes());
EXPECT_EQ(2, observer_.num_failures());
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
EXPECT_EQ(2, observer_.num_changes());
EXPECT_EQ(2, observer_.num_failures());
}
TEST_F(DisplayConfiguratorTest, GetMultipleDisplayStateForMirroredDisplays) {
UpdateOutputs(2, false);
Init(false);
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
configurator_.ForceInitialConfigure();
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR, configurator_.display_state());
}
TEST_F(DisplayConfiguratorTest, UpdateCachedOutputsEvenAfterFailure) {
InitWithSingleOutput();
const DisplayConfigurator::DisplayStateList& cached =
configurator_.cached_displays();
ASSERT_EQ(static_cast<size_t>(1), cached.size());
EXPECT_EQ(outputs_[0]->current_mode(), cached[0]->current_mode());
// After connecting a second output, check that it shows up in
// |cached_displays_| even if an invalid state is requested.
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
UpdateOutputs(2, true);
ASSERT_EQ(static_cast<size_t>(2), cached.size());
EXPECT_EQ(outputs_[0]->current_mode(), cached[0]->current_mode());
EXPECT_EQ(outputs_[1]->current_mode(), cached[1]->current_mode());
}
TEST_F(DisplayConfiguratorTest, ContentProtection) {
Init(false);
configurator_.ForceInitialConfigure();
EXPECT_NE(kNoActions, log_->GetActionsAndClear());
uint64_t id = configurator_.RegisterContentProtectionClient();
EXPECT_NE(0u, id);
// One output.
UpdateOutputs(1, true);
EXPECT_NE(kNoActions, log_->GetActionsAndClear());
configurator_.QueryContentProtectionStatus(
id, outputs_[0]->display_id(),
base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(1, query_content_protection_call_count_);
EXPECT_TRUE(query_content_protection_response_success_);
EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_INTERNAL),
query_content_protection_response_link_mask_);
EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
query_content_protection_response_protection_mask_);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
// Two outputs.
UpdateOutputs(2, true);
EXPECT_NE(kNoActions, log_->GetActionsAndClear());
configurator_.QueryContentProtectionStatus(
id, outputs_[1]->display_id(),
base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(2, query_content_protection_call_count_);
EXPECT_TRUE(query_content_protection_response_success_);
EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
query_content_protection_response_link_mask_);
EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_NONE),
query_content_protection_response_protection_mask_);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
configurator_.SetContentProtection(
id, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(1, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED),
log_->GetActionsAndClear());
// Enable protection.
native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
configurator_.QueryContentProtectionStatus(
id, outputs_[1]->display_id(),
base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(3, query_content_protection_call_count_);
EXPECT_TRUE(query_content_protection_response_success_);
EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
query_content_protection_response_link_mask_);
EXPECT_EQ(static_cast<uint32_t>(CONTENT_PROTECTION_METHOD_HDCP),
query_content_protection_response_protection_mask_);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
// Protections should be disabled after unregister.
configurator_.UnregisterContentProtectionClient(id);
EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_UNDESIRED),
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.
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
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.
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());
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
UpdateOutputs(2, false);
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
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();
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClients) {
uint64_t client1 = configurator_.RegisterContentProtectionClient();
uint64_t client2 = configurator_.RegisterContentProtectionClient();
EXPECT_NE(client1, client2);
Init(false);
configurator_.ForceInitialConfigure();
UpdateOutputs(2, true);
EXPECT_NE(kNoActions, log_->GetActionsAndClear());
// Clients never know state enableness for methods that they didn't request.
configurator_.SetContentProtection(
client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(1, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED).c_str(),
log_->GetActionsAndClear());
native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
configurator_.QueryContentProtectionStatus(
client1, outputs_[1]->display_id(),
base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(1, query_content_protection_call_count_);
EXPECT_TRUE(query_content_protection_response_success_);
EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
query_content_protection_response_link_mask_);
EXPECT_EQ(CONTENT_PROTECTION_METHOD_HDCP,
query_content_protection_response_protection_mask_);
configurator_.QueryContentProtectionStatus(
client2, outputs_[1]->display_id(),
base::Bind(&DisplayConfiguratorTest::QueryContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(2, query_content_protection_call_count_);
EXPECT_TRUE(query_content_protection_response_success_);
EXPECT_EQ(static_cast<uint32_t>(DISPLAY_CONNECTION_TYPE_HDMI),
query_content_protection_response_link_mask_);
EXPECT_EQ(CONTENT_PROTECTION_METHOD_NONE,
query_content_protection_response_protection_mask_);
// Protections will be disabled only if no more clients request them.
configurator_.SetContentProtection(
client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_NONE,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(2, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
configurator_.SetContentProtection(
client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_NONE,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(3, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_UNDESIRED).c_str(),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, ContentProtectionTwoClientsEnable) {
uint64_t client1 = configurator_.RegisterContentProtectionClient();
uint64_t client2 = configurator_.RegisterContentProtectionClient();
EXPECT_NE(client1, client2);
Init(false);
configurator_.ForceInitialConfigure();
UpdateOutputs(2, true);
log_->GetActionsAndClear();
// Only enable once if HDCP is enabling.
configurator_.SetContentProtection(
client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(1, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
native_display_delegate_->set_hdcp_state(HDCP_STATE_DESIRED);
configurator_.SetContentProtection(
client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(2, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
EXPECT_EQ(GetSetHDCPStateAction(*outputs_[1], HDCP_STATE_DESIRED).c_str(),
log_->GetActionsAndClear());
native_display_delegate_->set_hdcp_state(HDCP_STATE_ENABLED);
// Don't enable again if HDCP is already active.
configurator_.SetContentProtection(
client1, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(3, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
configurator_.SetContentProtection(
client2, outputs_[1]->display_id(), CONTENT_PROTECTION_METHOD_HDCP,
base::Bind(&DisplayConfiguratorTest::SetContentProtectionCallback,
base::Unretained(this)));
EXPECT_EQ(4, set_content_protection_call_count_);
EXPECT_TRUE(set_content_protection_status_);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, HandleConfigureCrtcFailure) {
InitWithSingleOutput();
std::vector<std::unique_ptr<const DisplayMode>> modes;
// The first mode is the mode we are requesting DisplayConfigurator to choose.
// The test will be setup so that this mode will fail and it will have to
// choose the next best option.
modes.push_back(MakeDisplayMode(2560, 1600, false, 60.0));
modes.push_back(MakeDisplayMode(1024, 768, false, 60.0));
modes.push_back(MakeDisplayMode(1280, 720, false, 60.0));
modes.push_back(MakeDisplayMode(1920, 1080, false, 60.0));
modes.push_back(MakeDisplayMode(1920, 1080, false, 40.0));
outputs_[0] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.SetNativeMode(modes[0]->Clone())
.SetCurrentMode(modes[0]->Clone())
.AddMode(modes[1]->Clone())
.AddMode(modes[2]->Clone())
.AddMode(modes[3]->Clone())
.AddMode(modes[4]->Clone())
.SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
.SetIsAspectPerservingScaling(true)
.Build();
// First test simply fails in MULTIPLE_DISPLAY_STATE_SINGLE mode. This is
// probably unrealistic but we want to make sure any assumptions don't creep
// in.
native_display_delegate_->set_max_configurable_pixels(
modes[2]->size().GetArea());
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
UpdateOutputs(1, true);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], modes[0].get(), gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[0], modes[3].get(), gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[0], modes[2].get(), gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
outputs_[1] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[1])
.SetNativeMode(modes[0]->Clone())
.SetCurrentMode(modes[0]->Clone())
.AddMode(modes[1]->Clone())
.AddMode(modes[2]->Clone())
.AddMode(modes[3]->Clone())
.AddMode(modes[4]->Clone())
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetIsAspectPerservingScaling(true)
.Build();
// This test should attempt to configure a mirror mode that will not succeed
// and should end up in extended mode.
native_display_delegate_->set_max_configurable_pixels(
modes[3]->size().GetArea());
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
UpdateOutputs(2, true);
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], modes[0].get(), gfx::Point(0, 0)).c_str(),
// Then attempt to configure crtc1 with the first mode.
GetCrtcAction(*outputs_[1], modes[0].get(), gfx::Point(0, 0)).c_str(),
// First mode tried is expected to fail and it will
// retry wil the 4th mode in the list.
GetCrtcAction(*outputs_[0], modes[3].get(), gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], modes[3].get(), gfx::Point(0, 0)).c_str(),
// Since it was requested to go into mirror mode
// and the configured modes were different, it
// should now try and setup a valid configurable
// extended mode.
GetCrtcAction(*outputs_[0], modes[0].get(), gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], modes[0].get(),
gfx::Point(0, modes[0]->size().height() +
DisplayConfigurator::kVerticalGap))
.c_str(),
GetCrtcAction(*outputs_[0], modes[3].get(), gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], modes[3].get(),
gfx::Point(0, modes[0]->size().height() +
DisplayConfigurator::kVerticalGap))
.c_str(),
nullptr),
log_->GetActionsAndClear());
}
// Tests that power state requests are saved after failed configuration attempts
// 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_MULTI_EXTENDED);
Init(false);
configurator_.ForceInitialConfigure();
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,
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,
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(
JoinActions(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
// Tests that the SetDisplayPowerState() task posted by HandleResume() doesn't
// use a stale state if a new state is requested before it runs:
// http://crosbug.com/p/32393
TEST_F(DisplayConfiguratorTest, DontRestoreStalePowerStateAfterResume) {
// Start out with two displays in mirrored mode.
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
Init(false);
configurator_.ForceInitialConfigure();
log_->GetActionsAndClear();
observer_.Reset();
// Turn off the internal display, simulating docked mode.
configurator_.SetDisplayPower(
chromeos::DISPLAY_POWER_INTERNAL_OFF_EXTERNAL_ON,
DisplayConfigurator::kSetDisplayPowerNoFlags,
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &big_mode_, gfx::Point(0, 0)).c_str(),
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.
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(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], nullptr, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
// Before the task runs, exit docked mode.
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
GetCrtcAction(*outputs_[1], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, ExternalControl) {
InitWithSingleOutput();
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_SINGLE);
// Set the initial power state and verify that it is restored when control is
// taken.
config_waiter_.Reset();
configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
DisplayConfigurator::kSetDisplayPowerNoFlags,
config_waiter_.on_configuration_callback());
configurator_.RelinquishControl(
base::BindOnce(&DisplayConfiguratorTest::OnDisplayControlUpdated,
base::Unretained(this)));
EXPECT_EQ(CALLBACK_SUCCESS, PopDisplayControlResult());
EXPECT_EQ(
JoinActions(
GetCrtcAction(*outputs_[0], nullptr, gfx::Point(0, 0)).c_str(),
kRelinquishDisplayControl, nullptr),
log_->GetActionsAndClear());
configurator_.TakeControl(
base::BindOnce(&DisplayConfiguratorTest::OnDisplayControlUpdated,
base::Unretained(this)));
EXPECT_EQ(CALLBACK_SUCCESS, PopDisplayControlResult());
EXPECT_EQ(
JoinActions(
kTakeDisplayControl,
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest,
SetDisplayPowerWhilePendingConfigurationTaskRunning) {
// Start out with two displays in extended mode.
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
Init(false);
configurator_.ForceInitialConfigure();
log_->GetActionsAndClear();
observer_.Reset();
native_display_delegate_->set_run_async(true);
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,
config_waiter_.on_configuration_callback());
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());
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
config_waiter_.Reset();
EXPECT_EQ(
base::TimeDelta::FromMilliseconds(DisplayConfigurator::kConfigureDelayMs),
config_waiter_.Wait());
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(2, observer_.num_changes());
EXPECT_EQ(0, observer_.num_failures());
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest,
SetDisplayPowerAfterFailedDisplayConfiguration) {
// Start out with two displays in extended mode.
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
Init(false);
configurator_.ForceInitialConfigure();
log_->GetActionsAndClear();
observer_.Reset();
// Fail display configuration.
native_display_delegate_->set_max_configurable_pixels(-1);
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());
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
// This configuration should trigger a display configuration since the
// previous configuration failed.
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(
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(),
GetCrtcAction(*outputs_[1], &small_mode_,
gfx::Point(0, small_mode_.size().height() +
DisplayConfigurator::kVerticalGap))
.c_str(),
nullptr),
log_->GetActionsAndClear());
// Allow configuration to succeed.
native_display_delegate_->set_max_configurable_pixels(0);
// Validate that a configuration event has the proper power state (displays
// should be on).
configurator_.OnConfigurationChanged();
EXPECT_TRUE(test_api_.TriggerConfigureTimeout());
EXPECT_EQ(1, observer_.num_changes());
EXPECT_EQ(2, observer_.num_failures());
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
}
TEST_F(DisplayConfiguratorTest, TestWithThreeDisplays) {
// Start out with two displays in extended mode.
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
Init(false);
configurator_.ForceInitialConfigure();
log_->GetActionsAndClear();
observer_.Reset();
UpdateOutputs(3, true);
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
EXPECT_EQ(
JoinActions(
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(),
GetCrtcAction(
*outputs_[2], &small_mode_,
gfx::Point(0, small_mode_.size().height() +
big_mode_.size().height() +
2 * DisplayConfigurator::kVerticalGap))
.c_str(),
nullptr),
log_->GetActionsAndClear());
// Verify that turning the power off works.
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(
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(),
nullptr),
log_->GetActionsAndClear());
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(
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(),
GetCrtcAction(
*outputs_[2], &small_mode_,
gfx::Point(0, small_mode_.size().height() +
big_mode_.size().height() +
2 * DisplayConfigurator::kVerticalGap))
.c_str(),
nullptr),
log_->GetActionsAndClear());
// Disconnect the third output.
observer_.Reset();
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
UpdateOutputs(2, true);
EXPECT_EQ(
JoinActions(
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(),
nullptr),
log_->GetActionsAndClear());
}
// Tests the suspend and resume behavior when in dual or multi display modes.
TEST_F(DisplayConfiguratorTest, SuspendResumeWithMultipleDisplays) {
InitWithSingleOutput();
// Set the initial power state and verify that it is restored on resume.
config_waiter_.Reset();
configurator_.SetDisplayPower(chromeos::DISPLAY_POWER_ALL_ON,
DisplayConfigurator::kSetDisplayPowerNoFlags,
config_waiter_.on_configuration_callback());
state_controller_.set_state(MULTIPLE_DISPLAY_STATE_MULTI_EXTENDED);
observer_.Reset();
UpdateOutputs(2, true);
EXPECT_EQ(MULTIPLE_DISPLAY_STATE_MULTI_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());
EXPECT_EQ(
JoinActions(
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(),
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_MULTI_EXTENDED,
configurator_.display_state());
EXPECT_EQ(
JoinActions(
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(),
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_MULTI_EXTENDED,
configurator_.display_state());
EXPECT_EQ(
JoinActions(
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(),
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_MULTI_EXTENDED,
configurator_.display_state());
EXPECT_EQ(chromeos::DISPLAY_POWER_ALL_OFF,
configurator_.current_power_state());
EXPECT_EQ(
JoinActions(
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(),
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(
GetCrtcAction(*outputs_[0], &small_mode_, gfx::Point(0, 0)).c_str(),
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());
}
class DisplayConfiguratorMultiMirroringTest : public DisplayConfiguratorTest {
public:
DisplayConfiguratorMultiMirroringTest() = default;
~DisplayConfiguratorMultiMirroringTest() override = default;
void SetUp() override {
configurator_.set_is_multi_mirroring_enabled_for_test(true);
DisplayConfiguratorTest::SetUp();
}
// Test that setting mirror mode with current outputs, all displays are set to
// expected mirror mode.
void TestHardwareMirrorModeExist(
std::unique_ptr<DisplayMode> expected_mirror_mode) {
UpdateOutputs(3, true);
log_->GetActionsAndClear();
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
EXPECT_EQ(
JoinActions(GetCrtcAction(*outputs_[0], expected_mirror_mode.get(),
gfx::Point(0, 0))
.c_str(),
GetCrtcAction(*outputs_[1], expected_mirror_mode.get(),
gfx::Point(0, 0))
.c_str(),
GetCrtcAction(*outputs_[2], expected_mirror_mode.get(),
gfx::Point(0, 0))
.c_str(),
nullptr),
log_->GetActionsAndClear());
EXPECT_FALSE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
}
// Test that setting mirror mode with current outputs, no matching mirror mode
// is found.
void TestHardwareMirrorModeNotExist() {
UpdateOutputs(3, true);
log_->GetActionsAndClear();
observer_.Reset();
configurator_.SetDisplayMode(MULTIPLE_DISPLAY_STATE_DUAL_MIRROR);
EXPECT_EQ(kNoActions, log_->GetActionsAndClear());
EXPECT_TRUE(mirroring_controller_.SoftwareMirroringEnabled());
EXPECT_EQ(1, observer_.num_changes());
}
private:
DISALLOW_COPY_AND_ASSIGN(DisplayConfiguratorMultiMirroringTest);
};
TEST_F(DisplayConfiguratorMultiMirroringTest,
FindMirrorModeWithInternalDisplay) {
// Initialize with one internal display and two external displays.
outputs_[0] = FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.SetType(DISPLAY_CONNECTION_TYPE_INTERNAL)
.SetNativeMode(MakeDisplayMode(1920, 1600, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1600, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1080, true, 60.0))
.AddMode(MakeDisplayMode(1440, 900, true, 60.0))
.Build();
outputs_[1] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[1])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, true, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, true, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1080, true, 60.0))
.AddMode(MakeDisplayMode(1680, 1050, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1440, 900, true, 60.0)) // same AR
.AddMode(MakeDisplayMode(500, 500, false, 60.0))
.Build();
outputs_[2] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[2])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1080, true, 60.0))
.AddMode(MakeDisplayMode(1680, 1050, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1440, 900, true, 60.0)) // same AR
.Build();
// Find an exactly matching mirror mode while preserving aspect.
TestHardwareMirrorModeExist(MakeDisplayMode(1440, 900, true, 60.0));
// Find an exactly matching mirror mode while not preserving aspect.
outputs_[2] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[2])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1080, true, 60.0))
.Build();
TestHardwareMirrorModeExist(MakeDisplayMode(1920, 1080, true, 60.0));
// Cannot find a matching mirror mode, so enable software mirroring.
outputs_[2] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[2])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(500, 500, true, 60.0))
.Build();
TestHardwareMirrorModeNotExist();
}
TEST_F(DisplayConfiguratorMultiMirroringTest,
FindMirrorModeWithoutInternalDisplay) {
// Initialize with 3 external displays.
outputs_[0] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[1])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, true, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, true, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1080, false, 60.0))
.AddMode(MakeDisplayMode(1680, 1050, true, 60.0)) // same AR
.Build();
outputs_[1] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[2])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1080, false, 60.0))
.AddMode(MakeDisplayMode(1680, 1050, true, 60.0)) // same AR
.Build();
outputs_[2] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[2])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1080, false, 60.0))
.AddMode(MakeDisplayMode(1680, 1050, true, 60.0)) // same AR
.Build();
// Find an exactly matching mirror mode while preserving aspect.
TestHardwareMirrorModeExist(MakeDisplayMode(1680, 1050, true, 60.0));
// Find an exactly matching mirror mode while not preserving aspect.
outputs_[2] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1600, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1600, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1080, false, 60.0))
.Build();
TestHardwareMirrorModeExist(MakeDisplayMode(1920, 1080, false, 60.0));
// Cannot find a matching mirror mode, so enable software mirroring.
outputs_[2] =
FakeDisplaySnapshot::Builder()
.SetId(kDisplayIds[0])
.SetType(DISPLAY_CONNECTION_TYPE_HDMI)
.SetNativeMode(MakeDisplayMode(1920, 1600, false, 60.0))
.AddMode(MakeDisplayMode(1920, 1600, false, 60.0)) // same AR
.AddMode(MakeDisplayMode(1920, 1200, false, 60.0))
.Build();
TestHardwareMirrorModeNotExist();
}
} // namespace test
} // namespace display