1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #undef LOG_TAG
18 #define LOG_TAG "LibSurfaceFlingerUnittests"
19
20 #include <scheduler/Fps.h>
21
22 #include "DisplayTransactionTestHelpers.h"
23 #include "FpsOps.h"
24
25 namespace android {
26 namespace {
27
28 class CreateDisplayTest : public DisplayTransactionTest {
29 public:
createDisplayWithRequestedRefreshRate(const std::string & name,VirtualDisplayId::BaseId baseId,float pacesetterDisplayRefreshRate,float requestedRefreshRate,float expectedAdjustedRefreshRate)30 void createDisplayWithRequestedRefreshRate(const std::string& name,
31 VirtualDisplayId::BaseId baseId,
32 float pacesetterDisplayRefreshRate,
33 float requestedRefreshRate,
34 float expectedAdjustedRefreshRate) {
35 // --------------------------------------------------------------------
36 // Call Expectations
37
38 // --------------------------------------------------------------------
39 // Invocation
40
41 sp<IBinder> displayToken = mFlinger.createVirtualDisplay(name, false, requestedRefreshRate);
42
43 // --------------------------------------------------------------------
44 // Postconditions
45
46 // The display should have been added to the current state
47 ASSERT_TRUE(hasCurrentDisplayState(displayToken));
48 const auto& display = getCurrentDisplayState(displayToken);
49 EXPECT_TRUE(display.isVirtual());
50 EXPECT_EQ(display.requestedRefreshRate, Fps::fromValue(requestedRefreshRate));
51 EXPECT_EQ(name.c_str(), display.displayName);
52
53 sp<DisplayDevice> device =
54 mFlinger.createVirtualDisplayDevice(displayToken, GpuVirtualDisplayId(baseId),
55 requestedRefreshRate);
56
57 EXPECT_TRUE(device->isVirtual());
58 device->adjustRefreshRate(Fps::fromValue(pacesetterDisplayRefreshRate));
59 // verifying desired value
60 EXPECT_EQ(device->getAdjustedRefreshRate(), Fps::fromValue(expectedAdjustedRefreshRate));
61 // verifying rounding up
62 if (requestedRefreshRate < pacesetterDisplayRefreshRate) {
63 EXPECT_GE(device->getAdjustedRefreshRate(), Fps::fromValue(requestedRefreshRate));
64 } else {
65 EXPECT_EQ(device->getAdjustedRefreshRate(),
66 Fps::fromValue(pacesetterDisplayRefreshRate));
67 }
68
69 // --------------------------------------------------------------------
70 // Cleanup conditions
71 }
72 };
73
TEST_F(CreateDisplayTest,createDisplaySetsCurrentStateForNonsecureDisplay)74 TEST_F(CreateDisplayTest, createDisplaySetsCurrentStateForNonsecureDisplay) {
75 static const std::string name("virtual.test");
76
77 // --------------------------------------------------------------------
78 // Call Expectations
79
80 // --------------------------------------------------------------------
81 // Invocation
82
83 sp<IBinder> displayToken = mFlinger.createVirtualDisplay(name, false);
84
85 // --------------------------------------------------------------------
86 // Postconditions
87
88 // The display should have been added to the current state
89 ASSERT_TRUE(hasCurrentDisplayState(displayToken));
90 const auto& display = getCurrentDisplayState(displayToken);
91 EXPECT_TRUE(display.isVirtual());
92 EXPECT_FALSE(display.isSecure);
93 EXPECT_EQ(name.c_str(), display.displayName);
94
95 // --------------------------------------------------------------------
96 // Cleanup conditions
97
98 // Creating the display commits a display transaction.
99 EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1);
100 }
101
TEST_F(CreateDisplayTest,createDisplaySetsCurrentStateForSecureDisplay)102 TEST_F(CreateDisplayTest, createDisplaySetsCurrentStateForSecureDisplay) {
103 static const std::string kDisplayName("virtual.test");
104
105 // --------------------------------------------------------------------
106 // Call Expectations
107
108 // --------------------------------------------------------------------
109 // Invocation
110 int64_t oldId = IPCThreadState::self()->clearCallingIdentity();
111 // Set the calling identity to graphics so captureDisplay with secure is allowed.
112 IPCThreadState::self()->restoreCallingIdentity(static_cast<int64_t>(AID_GRAPHICS) << 32 |
113 AID_GRAPHICS);
114 sp<IBinder> displayToken = mFlinger.createVirtualDisplay(kDisplayName, true);
115 IPCThreadState::self()->restoreCallingIdentity(oldId);
116
117 // --------------------------------------------------------------------
118 // Postconditions
119
120 // The display should have been added to the current state
121 ASSERT_TRUE(hasCurrentDisplayState(displayToken));
122 const auto& display = getCurrentDisplayState(displayToken);
123 EXPECT_TRUE(display.isVirtual());
124 EXPECT_TRUE(display.isSecure);
125 EXPECT_EQ(kDisplayName.c_str(), display.displayName);
126
127 // --------------------------------------------------------------------
128 // Cleanup conditions
129
130 // Creating the display commits a display transaction.
131 EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1);
132 }
133
TEST_F(CreateDisplayTest,createDisplaySetsCurrentStateForUniqueId)134 TEST_F(CreateDisplayTest, createDisplaySetsCurrentStateForUniqueId) {
135 static const std::string kDisplayName("virtual.test");
136 static const std::string kUniqueId = "virtual:package:id";
137
138 // --------------------------------------------------------------------
139 // Call Expectations
140
141 // --------------------------------------------------------------------
142 // Invocation
143
144 sp<IBinder> displayToken =
145 mFlinger.createVirtualDisplay(kDisplayName, false,
146 gui::ISurfaceComposer::OptimizationPolicy::
147 optimizeForPower,
148 kUniqueId);
149
150 // --------------------------------------------------------------------
151 // Postconditions
152
153 // The display should have been added to the current state
154 ASSERT_TRUE(hasCurrentDisplayState(displayToken));
155 const auto& display = getCurrentDisplayState(displayToken);
156 EXPECT_TRUE(display.isVirtual());
157 EXPECT_FALSE(display.isSecure);
158 EXPECT_EQ(display.uniqueId, "virtual:package:id");
159 EXPECT_EQ(kDisplayName.c_str(), display.displayName);
160
161 // --------------------------------------------------------------------
162 // Cleanup conditions
163
164 // Creating the display commits a display transaction.
165 EXPECT_CALL(*mFlinger.scheduler(), scheduleFrame(_)).Times(1);
166 }
167
168 // Requesting 0 tells SF not to do anything, i.e., default to refresh as physical displays
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRate0)169 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRate0) {
170 static const std::string kDisplayName("virtual.test");
171 constexpr uint64_t kDisplayId = 123ull;
172 constexpr float kPacesetterDisplayRefreshRate = 60.f;
173 constexpr float kRequestedRefreshRate = 0.f;
174 constexpr float kExpectedAdjustedRefreshRate = 0.f;
175 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
176 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
177 }
178
179 // Requesting negative refresh rate, will be ignored, same as requesting 0
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRateNegative)180 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRateNegative) {
181 static const std::string kDisplayName("virtual.test");
182 constexpr uint64_t kDisplayId = 123ull;
183 constexpr float kPacesetterDisplayRefreshRate = 60.f;
184 constexpr float kRequestedRefreshRate = -60.f;
185 constexpr float kExpectedAdjustedRefreshRate = 0.f;
186 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
187 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
188 }
189
190 // Requesting a higher refresh rate than the pacesetter
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRateHigh)191 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRateHigh) {
192 static const std::string kDisplayName("virtual.test");
193 constexpr uint64_t kDisplayId = 123ull;
194 constexpr float kPacesetterDisplayRefreshRate = 60.f;
195 constexpr float kRequestedRefreshRate = 90.f;
196 constexpr float kExpectedAdjustedRefreshRate = 60.f;
197 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
198 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
199 }
200
201 // Requesting the same refresh rate as the pacesetter
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRateSame)202 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRateSame) {
203 static const std::string kDisplayName("virtual.test");
204 constexpr uint64_t kDisplayId = 123ull;
205 constexpr float kPacesetterDisplayRefreshRate = 60.f;
206 constexpr float kRequestedRefreshRate = 60.f;
207 constexpr float kExpectedAdjustedRefreshRate = 60.f;
208 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
209 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
210 }
211
212 // Requesting a divisor (30) of the pacesetter (60) should be honored
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRateDivisor)213 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRateDivisor) {
214 static const std::string kDisplayName("virtual.test");
215 constexpr uint64_t kDisplayId = 123ull;
216 constexpr float kPacesetterDisplayRefreshRate = 60.f;
217 constexpr float kRequestedRefreshRate = 30.f;
218 constexpr float kExpectedAdjustedRefreshRate = 30.f;
219 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
220 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
221 }
222
223 // Requesting a non divisor (45) of the pacesetter (120) should round up to a divisor (60)
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRateNoneDivisor)224 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRateNoneDivisor) {
225 static const std::string kDisplayName("virtual.test");
226 constexpr uint64_t kDisplayId = 123ull;
227 constexpr float kPacesetterDisplayRefreshRate = 120.f;
228 constexpr float kRequestedRefreshRate = 45.f;
229 constexpr float kExpectedAdjustedRefreshRate = 60.f;
230 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
231 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
232 }
233
234 // Requesting a non divisor (75) of the pacesetter (120) should round up to pacesetter (120)
TEST_F(CreateDisplayTest,createDisplayWithRequestedRefreshRateNoneDivisorMax)235 TEST_F(CreateDisplayTest, createDisplayWithRequestedRefreshRateNoneDivisorMax) {
236 static const std::string kDisplayName("virtual.test");
237 constexpr uint64_t kDisplayId = 123ull;
238 constexpr float kPacesetterDisplayRefreshRate = 120.f;
239 constexpr float kRequestedRefreshRate = 75.f;
240 constexpr float kExpectedAdjustedRefreshRate = 120.f;
241 createDisplayWithRequestedRefreshRate(kDisplayName, kDisplayId, kPacesetterDisplayRefreshRate,
242 kRequestedRefreshRate, kExpectedAdjustedRefreshRate);
243 }
244
245 } // namespace
246 } // namespace android
247