lineage-rockchip/android_external_drm_hwcomposer
1
0
Fork 0
Code Activity Actions

drm_hwcomposer: Remove hwc2_display_t

Browse source 
Add DisplayHandle which is a typedef for int64_t. Use this type instead
of the HWC2 hwc2_display_t type.

Additionally, rename variable names to prefer `display_handle` over
`display_id`, since "DisplayId" is overloaded and carries a different
meaning in the Android framework.

Change-Id: I2a8ecce3b2c19fcd5e945d6c645f83d6a7d27a42
This commit is contained in:
Drew Davenport 2025-05-21 09:57:13 -06:00
parent 3b548894ac
commit ca711e95bf
15 changed files with 249 additions and 222 deletions
Download patch file Download diff file Expand all files Collapse all files

6
stats/CompositionStats.cpp
View file

@ -32,9 +32,9 @@ CompositionStats operator-(const CompositionStats& a,
void CompositionStatsTracker::ReportStats(const Callback& callback) {
auto new_stats = provider_->PullCompositionStats();
for (auto& [display_id, cumulative_stats] : new_stats) {
auto delta = cumulative_stats - previous_stats_[display_id];
callback(display_id, cumulative_stats, delta);
for (auto& [display_handle, cumulative_stats] : new_stats) {
auto delta = cumulative_stats - previous_stats_[display_handle];
callback(display_handle, cumulative_stats, delta);
}
previous_stats_ = new_stats;
}

2
stats/CompositionStats.h
View file

@ -54,7 +54,7 @@ class CompositionStatsProvider {
class CompositionStatsTracker {
public:
// Arguments are the display ID, the cumulative stats, and the stats delta.
using Callback = std::function<void(int64_t display_id,
using Callback = std::function<void(int64_t display_handle,
const CompositionStats& cumulative,
const CompositionStats& delta)>;
explicit CompositionStatsTracker(CompositionStatsProvider* provider)

75
stats/CompositionStatsTest.cpp
View file

@ -106,10 +106,10 @@ class CompositionStatsTrackerTest : public ::testing::Test {
// Initial call to ReportStats reports the same stats for cumulative and delta.
TEST_F(CompositionStatsTrackerTest, ReportStatsInitialCall) {
const int64_t display_id = 1;
const int64_t display_handle = 1;
CompositionStats current_stats = CreateStats(100);
std::map<int64_t, CompositionStats> provider_result = {
{display_id, current_stats}};
{display_handle, current_stats}};
StrictMock<MockStatsCallback> mock_callback;
@ -118,16 +118,17 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsInitialCall) {
// Expect that delta is same as cumulative.
EXPECT_CALL(mock_callback,
Invoke(Eq(display_id), Eq(current_stats), Eq(current_stats)));
Invoke(Eq(display_handle), Eq(current_stats), Eq(current_stats)));
tracker_->ReportStats(mock_callback.AsStdFunction());
}
// Subsequent calls to ReportStats with no change in cumulative stats.
TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallNoChange) {
const int64_t display_id = 1;
const int64_t display_handle = 1;
CompositionStats stats = CreateStats(100);
std::map<int64_t, CompositionStats> provider_result = {{display_id, stats}};
std::map<int64_t, CompositionStats> provider_result = {
{display_handle, stats}};
CompositionStats zero_delta = {};
// Same provider result for both calls.
@ -137,21 +138,24 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallNoChange) {
StrictMock<MockStatsCallback> mock_callback;
// Initial call.
EXPECT_CALL(mock_callback, Invoke(Eq(display_id), Eq(stats), Eq(stats)));
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle), Eq(stats), Eq(stats)));
tracker_->ReportStats(mock_callback.AsStdFunction());
// Second call. Delta should be zero.
EXPECT_CALL(mock_callback, Invoke(Eq(display_id), Eq(stats), Eq(zero_delta)));
EXPECT_CALL(mock_callback,
Invoke(Eq(display_handle), Eq(stats), Eq(zero_delta)));
tracker_->ReportStats(mock_callback.AsStdFunction());
}
// Test that the delta is reported as expected.
TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallWithChange) {
const int64_t display_id = 1;
const int64_t display_handle = 1;
CompositionStats stats1 = CreateStats(100);
CompositionStats stats2 = CreateStats(150);
std::map<int64_t, CompositionStats> provider_result1 = {{display_id, stats1}};
std::map<int64_t, CompositionStats> provider_result2 = {{display_id, stats2}};
std::map<int64_t, CompositionStats> provider_result1 = {
{display_handle, stats1}};
std::map<int64_t, CompositionStats> provider_result2 = {
{display_handle, stats2}};
CompositionStats expected_delta = stats2 - stats1;
StrictMock<MockStatsCallback> mock_callback;
@ -159,30 +163,31 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsSubsequentCallWithChange) {
// First call with the initial stats.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result1));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id), Eq(stats1), Eq(stats1)));
EXPECT_CALL(mock_callback,
Invoke(Eq(display_handle), Eq(stats1), Eq(stats1)));
tracker_->ReportStats(mock_callback.AsStdFunction());
// Second call with updated stats and non-trivial delta.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result2));
EXPECT_CALL(mock_callback,
Invoke(Eq(display_id), Eq(stats2), Eq(expected_delta)));
Invoke(Eq(display_handle), Eq(stats2), Eq(expected_delta)));
tracker_->ReportStats(mock_callback.AsStdFunction());
}
// Test that stats for multiple displays are reported correctly.
TEST_F(CompositionStatsTrackerTest, ReportStatsMultipleDisplays) {
const int64_t display_id1 = 10;
const int64_t display_id2 = 20;
const int64_t display_handle1 = 10;
const int64_t display_handle2 = 20;
CompositionStats display1_stats1 = CreateStats(100);
CompositionStats display2_stats1 = CreateStats(200);
CompositionStats display1_stats2 = CreateStats(110);
CompositionStats display2_stats2 = CreateStats(250);
std::map<int64_t, CompositionStats> provider_result1 =
{{display_id1, display1_stats1}, {display_id2, display2_stats1}};
{{display_handle1, display1_stats1}, {display_handle2, display2_stats1}};
std::map<int64_t, CompositionStats> provider_result2 =
{{display_id1, display1_stats2}, {display_id2, display2_stats2}};
{{display_handle1, display1_stats2}, {display_handle2, display2_stats2}};
CompositionStats display1_expected_delta1 = display1_stats1;
CompositionStats display1_expected_delta2 = display1_stats2 - display1_stats1;
@ -194,18 +199,18 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsMultipleDisplays) {
// Initial call. Ordering between displays doesn't matter.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result1));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats1),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats1),
Eq(display1_expected_delta1)));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats1),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats1),
Eq(display2_expected_delta1)));
tracker_->ReportStats(mock_callback.AsStdFunction());
// Updated call. Ordering between displays doesn't matter.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result2));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats2),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats2),
Eq(display1_expected_delta2)));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats2),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats2),
Eq(display2_expected_delta2)));
tracker_->ReportStats(mock_callback.AsStdFunction());
}
@ -223,16 +228,16 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsEmptyResult) {
// Display added in between calls to ReportStats.
TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayAdded) {
const int64_t display_id1 = 10;
const int64_t display_id2 = 20;
const int64_t display_handle1 = 10;
const int64_t display_handle2 = 20;
const CompositionStats display1_stats1 = CreateStats(100);
const CompositionStats display1_stats2 = CreateStats(110);
const CompositionStats display2_stats = CreateStats(50);
std::map<int64_t, CompositionStats> provider_result1 = {
{display_id1, display1_stats1}};
{display_handle1, display1_stats1}};
std::map<int64_t, CompositionStats> provider_result2 =
{{display_id1, display1_stats2}, {display_id2, display2_stats}};
{{display_handle1, display1_stats2}, {display_handle2, display2_stats}};
const CompositionStats display1_expected_delta1 = display1_stats1;
const CompositionStats display1_expected_delta2 = display1_stats2 -
@ -244,32 +249,32 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayAdded) {
// First call only contains display 1.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result1));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats1),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats1),
Eq(display1_expected_delta1)));
tracker_->ReportStats(mock_callback.AsStdFunction());
// Second call has both displays.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result2));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats2),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats2),
Eq(display1_expected_delta2)));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats),
Eq(display2_expected_delta)));
tracker_->ReportStats(mock_callback.AsStdFunction());
}
// Display removed in between calls to ReportStats.
TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayRemoved) {
const int64_t display_id1 = 10;
const int64_t display_id2 = 20;
const int64_t display_handle1 = 10;
const int64_t display_handle2 = 20;
const CompositionStats display1_stats1 = CreateStats(100);
const CompositionStats display2_stats = CreateStats(200);
const CompositionStats display1_stats2 = CreateStats(110);
std::map<int64_t, CompositionStats> provider_result1 =
{{display_id1, display1_stats1}, {display_id2, display2_stats}};
{{display_handle1, display1_stats1}, {display_handle2, display2_stats}};
std::map<int64_t, CompositionStats> provider_result2 = {
{display_id1, display1_stats2}};
{display_handle1, display1_stats2}};
const CompositionStats display1_expected_delta1 = display1_stats1;
const CompositionStats display2_expected_delta = display2_stats;
@ -281,17 +286,17 @@ TEST_F(CompositionStatsTrackerTest, ReportStatsDisplayRemoved) {
// Initial call has both displays.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result1));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats1),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats1),
Eq(display1_expected_delta1)));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id2), Eq(display2_stats),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle2), Eq(display2_stats),
Eq(display2_expected_delta)));
tracker_->ReportStats(mock_callback.AsStdFunction());
// Second call has only display 1. StrictMock will fail if Invoke is called
// for display_id2.
// for display_handle2.
EXPECT_CALL(*mock_provider_, PullCompositionStats())
.WillOnce(Return(provider_result2));
EXPECT_CALL(mock_callback, Invoke(Eq(display_id1), Eq(display1_stats2),
EXPECT_CALL(mock_callback, Invoke(Eq(display_handle1), Eq(display1_stats2),
Eq(display1_expected_delta2)));
tracker_->ReportStats(mock_callback.AsStdFunction());
}