blob: deaea87ff0edbd22682910fed906471c9530a932 [file] [log] [blame]
Lloyd Pique32cbe282018-10-19 13:09:22 -07001/*
2 * Copyright 2019 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
Lloyd Pique17ca7422019-11-14 14:24:10 -080017#include <android-base/stringprintf.h>
Lloyd Pique9755fb72019-03-26 14:44:40 -070018#include <compositionengine/LayerFECompositionState.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070019#include <compositionengine/impl/Output.h>
Lloyd Pique66d68602019-02-13 14:23:31 -080020#include <compositionengine/impl/OutputCompositionState.h>
Lloyd Pique56eba802019-08-28 15:45:25 -070021#include <compositionengine/impl/OutputLayerCompositionState.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070022#include <compositionengine/mock/CompositionEngine.h>
Lloyd Pique3d0c02e2018-10-19 18:38:12 -070023#include <compositionengine/mock/DisplayColorProfile.h>
Lloyd Piquecc01a452018-12-04 17:24:00 -080024#include <compositionengine/mock/LayerFE.h>
25#include <compositionengine/mock/OutputLayer.h>
Lloyd Pique31cb2942018-10-19 17:23:03 -070026#include <compositionengine/mock/RenderSurface.h>
Sally Qi59a9f502021-10-12 18:53:23 +000027#include <ftl/future.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070028#include <gtest/gtest.h>
Vishnu Nairdbbe3852022-01-12 20:22:11 -080029#include <renderengine/ExternalTexture.h>
30#include <renderengine/impl/ExternalTexture.h>
Vishnu Naira3140382022-02-24 14:07:11 -080031#include <renderengine/mock/FakeExternalTexture.h>
Lloyd Pique56eba802019-08-28 15:45:25 -070032#include <renderengine/mock/RenderEngine.h>
Lloyd Pique32cbe282018-10-19 13:09:22 -070033#include <ui/Rect.h>
34#include <ui/Region.h>
35
Alec Mouria90a5702021-04-16 16:36:21 +000036#include <cmath>
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -040037#include <cstdint>
Alec Mouria90a5702021-04-16 16:36:21 +000038
Lloyd Pique17ca7422019-11-14 14:24:10 -080039#include "CallOrderStateMachineHelper.h"
Lloyd Pique07178e32019-11-19 19:15:26 -080040#include "MockHWC2.h"
Lloyd Pique32cbe282018-10-19 13:09:22 -070041#include "RegionMatcher.h"
Sally Qi4cabdd02021-08-05 16:45:57 -070042#include "TestUtils.h"
Lloyd Pique32cbe282018-10-19 13:09:22 -070043
44namespace android::compositionengine {
45namespace {
46
Lloyd Pique56eba802019-08-28 15:45:25 -070047using testing::_;
Lloyd Pique03561a62019-11-19 18:34:52 -080048using testing::ByMove;
Lloyd Piquea4863342019-12-04 18:45:02 -080049using testing::ByRef;
Lloyd Pique17ca7422019-11-14 14:24:10 -080050using testing::DoAll;
Vishnu Nair9b079a22020-01-21 14:36:08 -080051using testing::ElementsAre;
Lloyd Pique6818fa52019-12-03 12:32:13 -080052using testing::ElementsAreArray;
Lloyd Pique07178e32019-11-19 19:15:26 -080053using testing::Eq;
Lloyd Piquefaa3f192019-11-14 14:05:09 -080054using testing::InSequence;
Lloyd Pique6818fa52019-12-03 12:32:13 -080055using testing::Invoke;
56using testing::IsEmpty;
Lloyd Pique17ca7422019-11-14 14:24:10 -080057using testing::Mock;
Vishnu Nair9b079a22020-01-21 14:36:08 -080058using testing::Pointee;
Lloyd Pique07178e32019-11-19 19:15:26 -080059using testing::Property;
Lloyd Piquefaa3f192019-11-14 14:05:09 -080060using testing::Ref;
Lloyd Pique31cb2942018-10-19 17:23:03 -070061using testing::Return;
Lloyd Pique32cbe282018-10-19 13:09:22 -070062using testing::ReturnRef;
Lloyd Pique17ca7422019-11-14 14:24:10 -080063using testing::SetArgPointee;
Lloyd Pique32cbe282018-10-19 13:09:22 -070064using testing::StrictMock;
65
Lloyd Pique56eba802019-08-28 15:45:25 -070066constexpr auto TR_IDENT = 0u;
67constexpr auto TR_ROT_90 = HAL_TRANSFORM_ROT_90;
Vishnu Nair9b079a22020-01-21 14:36:08 -080068constexpr auto MAX_CLIENT_COMPOSITION_CACHE_SIZE = 3;
Lloyd Pique56eba802019-08-28 15:45:25 -070069
Lloyd Pique3eb1b212019-03-07 21:15:40 -080070const mat4 kIdentity;
Lloyd Pique0a456232020-01-16 17:51:13 -080071const mat4 kNonIdentityHalf = mat4() * 0.5f;
72const mat4 kNonIdentityQuarter = mat4() * 0.25f;
Lloyd Pique3eb1b212019-03-07 21:15:40 -080073
Lloyd Pique17ca7422019-11-14 14:24:10 -080074constexpr OutputColorSetting kVendorSpecifiedOutputColorSetting =
75 static_cast<OutputColorSetting>(0x100);
76
Vishnu Nair9cf89262022-02-26 09:17:49 -080077using CompositionStrategyPredictionState = android::compositionengine::impl::
78 OutputCompositionState::CompositionStrategyPredictionState;
79
Lloyd Piquefaa3f192019-11-14 14:05:09 -080080struct OutputPartialMockBase : public impl::Output {
81 // compositionengine::Output overrides
82 const OutputCompositionState& getState() const override { return mState; }
83 OutputCompositionState& editState() override { return mState; }
84
85 // Use mocks for all the remaining virtual functions
86 // not implemented by the base implementation class.
87 MOCK_CONST_METHOD0(getOutputLayerCount, size_t());
88 MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex, compositionengine::OutputLayer*(size_t));
Lloyd Piquede196652020-01-22 17:29:58 -080089 MOCK_METHOD2(ensureOutputLayer,
90 compositionengine::OutputLayer*(std::optional<size_t>, const sp<LayerFE>&));
Lloyd Piquefaa3f192019-11-14 14:05:09 -080091 MOCK_METHOD0(finalizePendingOutputLayers, void());
92 MOCK_METHOD0(clearOutputLayers, void());
93 MOCK_CONST_METHOD1(dumpState, void(std::string&));
94 MOCK_CONST_METHOD0(getCompositionEngine, const CompositionEngine&());
Lloyd Piquede196652020-01-22 17:29:58 -080095 MOCK_METHOD1(injectOutputLayerForTest, compositionengine::OutputLayer*(const sp<LayerFE>&));
Lloyd Piquefaa3f192019-11-14 14:05:09 -080096 MOCK_METHOD1(injectOutputLayerForTest, void(std::unique_ptr<OutputLayer>));
97
98 impl::OutputCompositionState mState;
99};
100
Lloyd Piquede196652020-01-22 17:29:58 -0800101struct InjectedLayer {
102 InjectedLayer() {
103 EXPECT_CALL(*outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE.get()));
104 EXPECT_CALL(*outputLayer, getState()).WillRepeatedly(ReturnRef(outputLayerState));
105 EXPECT_CALL(*outputLayer, editState()).WillRepeatedly(ReturnRef(outputLayerState));
106
107 EXPECT_CALL(*layerFE, getCompositionState()).WillRepeatedly(Return(&layerFEState));
Dan Stoza269dc4d2021-01-15 15:07:43 -0800108 EXPECT_CALL(*layerFE, getSequence()).WillRepeatedly(Return(0));
109 EXPECT_CALL(*layerFE, getDebugName()).WillRepeatedly(Return("InjectedLayer"));
Lloyd Piquede196652020-01-22 17:29:58 -0800110 }
111
112 mock::OutputLayer* outputLayer = {new StrictMock<mock::OutputLayer>};
Ady Abrahame0eafa82022-02-02 19:30:47 -0800113 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Piquede196652020-01-22 17:29:58 -0800114 LayerFECompositionState layerFEState;
115 impl::OutputLayerCompositionState outputLayerState;
116};
117
118struct NonInjectedLayer {
119 NonInjectedLayer() {
120 EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE.get()));
121 EXPECT_CALL(outputLayer, getState()).WillRepeatedly(ReturnRef(outputLayerState));
122 EXPECT_CALL(outputLayer, editState()).WillRepeatedly(ReturnRef(outputLayerState));
123
124 EXPECT_CALL(*layerFE, getCompositionState()).WillRepeatedly(Return(&layerFEState));
Dan Stoza269dc4d2021-01-15 15:07:43 -0800125 EXPECT_CALL(*layerFE, getSequence()).WillRepeatedly(Return(0));
126 EXPECT_CALL(*layerFE, getDebugName()).WillRepeatedly(Return("NonInjectedLayer"));
Lloyd Piquede196652020-01-22 17:29:58 -0800127 }
128
129 mock::OutputLayer outputLayer;
Ady Abrahame0eafa82022-02-02 19:30:47 -0800130 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Piquede196652020-01-22 17:29:58 -0800131 LayerFECompositionState layerFEState;
132 impl::OutputLayerCompositionState outputLayerState;
133};
134
Lloyd Pique66d68602019-02-13 14:23:31 -0800135struct OutputTest : public testing::Test {
Lloyd Pique01c77c12019-04-17 12:48:32 -0700136 class Output : public impl::Output {
137 public:
138 using impl::Output::injectOutputLayerForTest;
139 virtual void injectOutputLayerForTest(std::unique_ptr<compositionengine::OutputLayer>) = 0;
140 };
141
142 static std::shared_ptr<Output> createOutput(
143 const compositionengine::CompositionEngine& compositionEngine) {
144 return impl::createOutputTemplated<Output>(compositionEngine);
145 }
146
Lloyd Pique31cb2942018-10-19 17:23:03 -0700147 OutputTest() {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700148 mOutput->setDisplayColorProfileForTest(
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700149 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700150 mOutput->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
Lloyd Piqueef958122019-02-05 18:00:12 -0800151
Angel Aguayob084e0c2021-08-04 23:27:28 +0000152 mOutput->editState().displaySpace.setBounds(
153 ui::Size(kDefaultDisplaySize.getWidth(), kDefaultDisplaySize.getHeight()));
Alec Mouridf6201b2021-06-01 16:20:42 -0700154 EXPECT_CALL(mCompositionEngine, getRenderEngine()).WillRepeatedly(ReturnRef(mRenderEngine));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700155 }
Lloyd Pique32cbe282018-10-19 13:09:22 -0700156
Lloyd Piquede196652020-01-22 17:29:58 -0800157 void injectOutputLayer(InjectedLayer& layer) {
158 mOutput->injectOutputLayerForTest(std::unique_ptr<OutputLayer>(layer.outputLayer));
159 }
160
161 void injectNullOutputLayer() {
162 mOutput->injectOutputLayerForTest(std::unique_ptr<OutputLayer>(nullptr));
163 }
164
Lloyd Piqueef958122019-02-05 18:00:12 -0800165 static const Rect kDefaultDisplaySize;
166
Lloyd Pique32cbe282018-10-19 13:09:22 -0700167 StrictMock<mock::CompositionEngine> mCompositionEngine;
Alec Mouridf6201b2021-06-01 16:20:42 -0700168 StrictMock<renderengine::mock::RenderEngine> mRenderEngine;
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700169 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
Lloyd Pique31cb2942018-10-19 17:23:03 -0700170 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Pique01c77c12019-04-17 12:48:32 -0700171 std::shared_ptr<Output> mOutput = createOutput(mCompositionEngine);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700172};
173
Lloyd Piqueef958122019-02-05 18:00:12 -0800174const Rect OutputTest::kDefaultDisplaySize{100, 200};
175
Lloyd Pique17ca7422019-11-14 14:24:10 -0800176using ColorProfile = compositionengine::Output::ColorProfile;
177
178void dumpColorProfile(ColorProfile profile, std::string& result, const char* name) {
179 android::base::StringAppendF(&result, "%s (%s[%d] %s[%d] %s[%d] %s[%d]) ", name,
180 toString(profile.mode).c_str(), profile.mode,
181 toString(profile.dataspace).c_str(), profile.dataspace,
182 toString(profile.renderIntent).c_str(), profile.renderIntent,
183 toString(profile.colorSpaceAgnosticDataspace).c_str(),
184 profile.colorSpaceAgnosticDataspace);
185}
186
187// Checks for a ColorProfile match
188MATCHER_P(ColorProfileEq, expected, "") {
189 std::string buf;
190 buf.append("ColorProfiles are not equal\n");
191 dumpColorProfile(expected, buf, "expected value");
192 dumpColorProfile(arg, buf, "actual value");
193 *result_listener << buf;
194
195 return (expected.mode == arg.mode) && (expected.dataspace == arg.dataspace) &&
196 (expected.renderIntent == arg.renderIntent) &&
197 (expected.colorSpaceAgnosticDataspace == arg.colorSpaceAgnosticDataspace);
198}
199
Lloyd Pique66d68602019-02-13 14:23:31 -0800200/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700201 * Basic construction
202 */
203
Lloyd Pique31cb2942018-10-19 17:23:03 -0700204TEST_F(OutputTest, canInstantiateOutput) {
205 // The validation check checks each required component.
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700206 EXPECT_CALL(*mDisplayColorProfile, isValid()).WillOnce(Return(true));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700207 EXPECT_CALL(*mRenderSurface, isValid()).WillOnce(Return(true));
208
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700209 EXPECT_TRUE(mOutput->isValid());
Lloyd Pique31cb2942018-10-19 17:23:03 -0700210
211 // If we take away the required components, it is no longer valid.
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700212 mOutput->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>());
Lloyd Pique31cb2942018-10-19 17:23:03 -0700213
Lloyd Pique3d0c02e2018-10-19 18:38:12 -0700214 EXPECT_CALL(*mDisplayColorProfile, isValid()).WillOnce(Return(true));
215
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700216 EXPECT_FALSE(mOutput->isValid());
Lloyd Pique31cb2942018-10-19 17:23:03 -0700217}
Lloyd Pique32cbe282018-10-19 13:09:22 -0700218
Lloyd Pique66d68602019-02-13 14:23:31 -0800219/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700220 * Output::setCompositionEnabled()
221 */
222
223TEST_F(OutputTest, setCompositionEnabledDoesNothingIfAlreadyEnabled) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700224 mOutput->editState().isEnabled = true;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700225
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700226 mOutput->setCompositionEnabled(true);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700227
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700228 EXPECT_TRUE(mOutput->getState().isEnabled);
229 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700230}
231
232TEST_F(OutputTest, setCompositionEnabledSetsEnabledAndDirtiesEntireOutput) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700233 mOutput->editState().isEnabled = false;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700234
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700235 mOutput->setCompositionEnabled(true);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700236
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700237 EXPECT_TRUE(mOutput->getState().isEnabled);
238 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700239}
240
241TEST_F(OutputTest, setCompositionEnabledSetsDisabledAndDirtiesEntireOutput) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700242 mOutput->editState().isEnabled = true;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700243
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700244 mOutput->setCompositionEnabled(false);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700245
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700246 EXPECT_FALSE(mOutput->getState().isEnabled);
247 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700248}
249
Lloyd Pique66d68602019-02-13 14:23:31 -0800250/*
Alec Mouridda07d92022-04-25 22:39:25 +0000251 * Output::setTreat170mAsSrgb()
252 */
253
254TEST_F(OutputTest, setTreat170mAsSrgb) {
255 EXPECT_FALSE(mOutput->getState().treat170mAsSrgb);
256
257 mOutput->setTreat170mAsSrgb(true);
258 EXPECT_TRUE(mOutput->getState().treat170mAsSrgb);
259
260 mOutput->setTreat170mAsSrgb(false);
261 EXPECT_FALSE(mOutput->getState().treat170mAsSrgb);
262}
263
264/*
Alec Mouri023c1882021-05-08 16:36:33 -0700265 * Output::setLayerCachingEnabled()
266 */
267
268TEST_F(OutputTest, setLayerCachingEnabled_enablesCaching) {
269 const auto kSize = ui::Size(1, 1);
270 EXPECT_CALL(*mRenderSurface, getSize()).WillRepeatedly(ReturnRef(kSize));
271 mOutput->setLayerCachingEnabled(false);
272 mOutput->setLayerCachingEnabled(true);
273
274 EXPECT_TRUE(mOutput->plannerEnabled());
275}
276
277TEST_F(OutputTest, setLayerCachingEnabled_disablesCaching) {
278 const auto kSize = ui::Size(1, 1);
279 EXPECT_CALL(*mRenderSurface, getSize()).WillRepeatedly(ReturnRef(kSize));
280 mOutput->setLayerCachingEnabled(true);
281 mOutput->setLayerCachingEnabled(false);
282
283 EXPECT_FALSE(mOutput->plannerEnabled());
284}
285
Alec Mouric773472b2021-05-19 14:29:05 -0700286TEST_F(OutputTest, setLayerCachingEnabled_disablesCachingAndResetsOverrideInfo) {
287 renderengine::mock::RenderEngine renderEngine;
288 const auto kSize = ui::Size(1, 1);
289 EXPECT_CALL(*mRenderSurface, getSize()).WillRepeatedly(ReturnRef(kSize));
290 mOutput->setLayerCachingEnabled(true);
291
292 // Inject some layers
293 InjectedLayer layer;
294 layer.outputLayerState.overrideInfo.buffer = std::make_shared<
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800295 renderengine::impl::
296 ExternalTexture>(new GraphicBuffer(), renderEngine,
297 renderengine::impl::ExternalTexture::Usage::READABLE |
298 renderengine::impl::ExternalTexture::Usage::WRITEABLE);
Alec Mouric773472b2021-05-19 14:29:05 -0700299 injectOutputLayer(layer);
300 // inject a null layer to check for null exceptions
301 injectNullOutputLayer();
302
303 EXPECT_NE(nullptr, layer.outputLayerState.overrideInfo.buffer);
304 mOutput->setLayerCachingEnabled(false);
305 EXPECT_EQ(nullptr, layer.outputLayerState.overrideInfo.buffer);
306}
307
Alec Mouri023c1882021-05-08 16:36:33 -0700308/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700309 * Output::setProjection()
310 */
311
Marin Shalamanov209ae612020-10-01 00:17:39 +0200312TEST_F(OutputTest, setProjectionWorks) {
313 const Rect displayRect{0, 0, 1000, 2000};
Angel Aguayob084e0c2021-08-04 23:27:28 +0000314 mOutput->editState().displaySpace.setBounds(
315 ui::Size(displayRect.getWidth(), displayRect.getHeight()));
316 mOutput->editState().framebufferSpace.setBounds(
317 ui::Size(displayRect.getWidth(), displayRect.getHeight()));
Marin Shalamanov209ae612020-10-01 00:17:39 +0200318
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200319 const ui::Rotation orientation = ui::ROTATION_90;
Marin Shalamanov209ae612020-10-01 00:17:39 +0200320 const Rect frame{50, 60, 100, 100};
321 const Rect viewport{10, 20, 30, 40};
Lloyd Pique32cbe282018-10-19 13:09:22 -0700322
Marin Shalamanov68933fb2020-09-10 17:58:12 +0200323 mOutput->setProjection(orientation, viewport, frame);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700324
Angel Aguayob084e0c2021-08-04 23:27:28 +0000325 EXPECT_EQ(orientation, mOutput->getState().displaySpace.getOrientation());
326 EXPECT_EQ(frame, mOutput->getState().orientedDisplaySpace.getContent());
327 EXPECT_EQ(viewport, mOutput->getState().layerStackSpace.getContent());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200328
329 const auto state = mOutput->getState();
Angel Aguayob084e0c2021-08-04 23:27:28 +0000330 EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.getOrientation());
331 EXPECT_EQ(viewport, state.layerStackSpace.getContent());
332 EXPECT_EQ(Rect(0, 0, 20, 20), state.layerStackSpace.getBoundsAsRect());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200333
Angel Aguayob084e0c2021-08-04 23:27:28 +0000334 EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.getOrientation());
335 EXPECT_EQ(frame, state.orientedDisplaySpace.getContent());
336 EXPECT_EQ(Rect(0, 0, 2000, 1000), state.orientedDisplaySpace.getBoundsAsRect());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200337
Angel Aguayob084e0c2021-08-04 23:27:28 +0000338 EXPECT_EQ(displayRect, state.displaySpace.getBoundsAsRect());
339 EXPECT_EQ(Rect(900, 50, 940, 100), state.displaySpace.getContent());
340 EXPECT_EQ(orientation, state.displaySpace.getOrientation());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200341
Angel Aguayob084e0c2021-08-04 23:27:28 +0000342 EXPECT_EQ(displayRect, state.framebufferSpace.getBoundsAsRect());
343 EXPECT_EQ(Rect(900, 50, 940, 100), state.framebufferSpace.getContent());
344 EXPECT_EQ(orientation, state.framebufferSpace.getOrientation());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200345
Angel Aguayob084e0c2021-08-04 23:27:28 +0000346 EXPECT_EQ(state.displaySpace.getContent(),
347 state.transform.transform(state.layerStackSpace.getContent()));
Garfield Tan54edd912020-10-21 16:31:41 -0700348
349 EXPECT_EQ(ui::Transform::ROT_90, mOutput->getTransformHint());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200350}
351
352TEST_F(OutputTest, setProjectionWithSmallFramebufferWorks) {
353 const Rect displayRect{0, 0, 1000, 2000};
354 const Rect framebufferRect{0, 0, 500, 1000};
Angel Aguayob084e0c2021-08-04 23:27:28 +0000355 mOutput->editState().displaySpace.setBounds(
356 ui::Size(displayRect.getWidth(), displayRect.getHeight()));
357 mOutput->editState().framebufferSpace.setBounds(
358 ui::Size(framebufferRect.getWidth(), framebufferRect.getHeight()));
Marin Shalamanov209ae612020-10-01 00:17:39 +0200359
360 const ui::Rotation orientation = ui::ROTATION_90;
361 const Rect frame{50, 60, 100, 100};
362 const Rect viewport{10, 20, 30, 40};
363
364 mOutput->setProjection(orientation, viewport, frame);
365
Angel Aguayob084e0c2021-08-04 23:27:28 +0000366 EXPECT_EQ(orientation, mOutput->getState().displaySpace.getOrientation());
367 EXPECT_EQ(frame, mOutput->getState().orientedDisplaySpace.getContent());
368 EXPECT_EQ(viewport, mOutput->getState().layerStackSpace.getContent());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200369
370 const auto state = mOutput->getState();
Angel Aguayob084e0c2021-08-04 23:27:28 +0000371 EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.getOrientation());
372 EXPECT_EQ(viewport, state.layerStackSpace.getContent());
373 EXPECT_EQ(Rect(0, 0, 20, 20), state.layerStackSpace.getBoundsAsRect());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200374
Angel Aguayob084e0c2021-08-04 23:27:28 +0000375 EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.getOrientation());
376 EXPECT_EQ(frame, state.orientedDisplaySpace.getContent());
377 EXPECT_EQ(Rect(0, 0, 2000, 1000), state.orientedDisplaySpace.getBoundsAsRect());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200378
Angel Aguayob084e0c2021-08-04 23:27:28 +0000379 EXPECT_EQ(displayRect, state.displaySpace.getBoundsAsRect());
380 EXPECT_EQ(Rect(900, 50, 940, 100), state.displaySpace.getContent());
381 EXPECT_EQ(orientation, state.displaySpace.getOrientation());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200382
Angel Aguayob084e0c2021-08-04 23:27:28 +0000383 EXPECT_EQ(framebufferRect, state.framebufferSpace.getBoundsAsRect());
384 EXPECT_EQ(Rect(450, 25, 470, 50), state.framebufferSpace.getContent());
385 EXPECT_EQ(orientation, state.framebufferSpace.getOrientation());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200386
Angel Aguayob084e0c2021-08-04 23:27:28 +0000387 EXPECT_EQ(state.displaySpace.getContent(),
388 state.transform.transform(state.layerStackSpace.getContent()));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700389}
390
Lloyd Pique66d68602019-02-13 14:23:31 -0800391/*
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200392 * Output::setDisplaySize()
Lloyd Pique32cbe282018-10-19 13:09:22 -0700393 */
394
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200395TEST_F(OutputTest, setDisplaySpaceSizeUpdatesOutputStateAndDirtiesEntireOutput) {
Angel Aguayob084e0c2021-08-04 23:27:28 +0000396 mOutput->editState().layerStackSpace.setContent(Rect(0, 0, 2000, 1000));
397 mOutput->editState().layerStackSpace.setBounds(ui::Size(2000, 1000));
398 mOutput->editState().orientedDisplaySpace.setContent(Rect(0, 0, 1800, 900));
399 mOutput->editState().orientedDisplaySpace.setBounds(ui::Size(2000, 1000));
400 mOutput->editState().framebufferSpace.setContent(Rect(0, 0, 900, 1800));
401 mOutput->editState().framebufferSpace.setBounds(ui::Size(1000, 2000));
402 mOutput->editState().framebufferSpace.setOrientation(ui::ROTATION_90);
403 mOutput->editState().displaySpace.setContent(Rect(0, 0, 900, 1800));
404 mOutput->editState().displaySpace.setBounds(ui::Size(1000, 2000));
405 mOutput->editState().displaySpace.setOrientation(ui::ROTATION_90);
Lloyd Pique31cb2942018-10-19 17:23:03 -0700406
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200407 const ui::Size newDisplaySize{500, 1000};
Lloyd Pique31cb2942018-10-19 17:23:03 -0700408
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200409 EXPECT_CALL(*mRenderSurface, setDisplaySize(newDisplaySize)).Times(1);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700410
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200411 mOutput->setDisplaySize(newDisplaySize);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700412
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200413 const auto state = mOutput->getState();
414
415 const Rect displayRect(newDisplaySize);
Angel Aguayob084e0c2021-08-04 23:27:28 +0000416 EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.getOrientation());
417 EXPECT_EQ(Rect(0, 0, 2000, 1000), state.layerStackSpace.getContent());
418 EXPECT_EQ(Rect(0, 0, 2000, 1000), state.layerStackSpace.getBoundsAsRect());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200419
Angel Aguayob084e0c2021-08-04 23:27:28 +0000420 EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.getOrientation());
421 EXPECT_EQ(Rect(0, 0, 1000, 500), state.orientedDisplaySpace.getBoundsAsRect());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200422
Angel Aguayob084e0c2021-08-04 23:27:28 +0000423 EXPECT_EQ(displayRect, state.displaySpace.getBoundsAsRect());
424 EXPECT_EQ(ui::ROTATION_90, state.displaySpace.getOrientation());
Marin Shalamanov209ae612020-10-01 00:17:39 +0200425
Angel Aguayob084e0c2021-08-04 23:27:28 +0000426 EXPECT_EQ(displayRect, state.framebufferSpace.getBoundsAsRect());
427 EXPECT_EQ(ui::ROTATION_90, state.framebufferSpace.getOrientation());
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200428
Angel Aguayob084e0c2021-08-04 23:27:28 +0000429 EXPECT_EQ(state.displaySpace.getContent(),
430 state.transform.transform(state.layerStackSpace.getContent()));
Marin Shalamanovb15d2272020-09-17 21:41:52 +0200431
432 EXPECT_THAT(state.dirtyRegion, RegionEq(Region(displayRect)));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700433}
434
Lloyd Pique66d68602019-02-13 14:23:31 -0800435/*
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700436 * Output::setLayerFilter()
Lloyd Pique32cbe282018-10-19 13:09:22 -0700437 */
438
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700439TEST_F(OutputTest, setLayerFilterSetsFilterAndDirtiesEntireOutput) {
440 constexpr ui::LayerFilter kFilter{ui::LayerStack{123u}, true};
441 mOutput->setLayerFilter(kFilter);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700442
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700443 const auto& state = mOutput->getState();
444 EXPECT_EQ(kFilter.layerStack, state.layerFilter.layerStack);
445 EXPECT_TRUE(state.layerFilter.toInternalDisplay);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700446
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700447 EXPECT_THAT(state.dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700448}
449
Lloyd Pique66d68602019-02-13 14:23:31 -0800450/*
Lloyd Pique32cbe282018-10-19 13:09:22 -0700451 * Output::setColorTransform
452 */
453
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800454TEST_F(OutputTest, setColorTransformWithNoChangeFlaggedSkipsUpdates) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700455 mOutput->editState().colorTransformMatrix = kIdentity;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700456
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800457 // If no colorTransformMatrix is set the update should be skipped.
458 CompositionRefreshArgs refreshArgs;
459 refreshArgs.colorTransformMatrix = std::nullopt;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700460
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700461 mOutput->setColorTransform(refreshArgs);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700462
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800463 // The internal state should be unchanged
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700464 EXPECT_EQ(kIdentity, mOutput->getState().colorTransformMatrix);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800465
466 // No dirty region should be set
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700467 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800468}
Lloyd Piqueef958122019-02-05 18:00:12 -0800469
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800470TEST_F(OutputTest, setColorTransformWithNoActualChangeSkipsUpdates) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700471 mOutput->editState().colorTransformMatrix = kIdentity;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700472
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800473 // Attempting to set the same colorTransformMatrix that is already set should
474 // also skip the update.
475 CompositionRefreshArgs refreshArgs;
476 refreshArgs.colorTransformMatrix = kIdentity;
Lloyd Pique32cbe282018-10-19 13:09:22 -0700477
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700478 mOutput->setColorTransform(refreshArgs);
Lloyd Pique77f79a22019-04-29 15:55:40 -0700479
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800480 // The internal state should be unchanged
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700481 EXPECT_EQ(kIdentity, mOutput->getState().colorTransformMatrix);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800482
483 // No dirty region should be set
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700484 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800485}
486
487TEST_F(OutputTest, setColorTransformPerformsUpdateToIdentity) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700488 mOutput->editState().colorTransformMatrix = kNonIdentityHalf;
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800489
490 // Setting a different colorTransformMatrix should perform the update.
491 CompositionRefreshArgs refreshArgs;
492 refreshArgs.colorTransformMatrix = kIdentity;
493
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700494 mOutput->setColorTransform(refreshArgs);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800495
496 // The internal state should have been updated
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700497 EXPECT_EQ(kIdentity, mOutput->getState().colorTransformMatrix);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800498
499 // The dirtyRegion should be set to the full display size
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700500 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800501}
Lloyd Pique77f79a22019-04-29 15:55:40 -0700502
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800503TEST_F(OutputTest, setColorTransformPerformsUpdateForIdentityToHalf) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700504 mOutput->editState().colorTransformMatrix = kIdentity;
Lloyd Pique77f79a22019-04-29 15:55:40 -0700505
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800506 // Setting a different colorTransformMatrix should perform the update.
507 CompositionRefreshArgs refreshArgs;
508 refreshArgs.colorTransformMatrix = kNonIdentityHalf;
Lloyd Pique77f79a22019-04-29 15:55:40 -0700509
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700510 mOutput->setColorTransform(refreshArgs);
Lloyd Piqueef958122019-02-05 18:00:12 -0800511
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800512 // The internal state should have been updated
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700513 EXPECT_EQ(kNonIdentityHalf, mOutput->getState().colorTransformMatrix);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800514
515 // The dirtyRegion should be set to the full display size
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700516 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800517}
518
519TEST_F(OutputTest, setColorTransformPerformsUpdateForHalfToQuarter) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700520 mOutput->editState().colorTransformMatrix = kNonIdentityHalf;
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800521
522 // Setting a different colorTransformMatrix should perform the update.
523 CompositionRefreshArgs refreshArgs;
524 refreshArgs.colorTransformMatrix = kNonIdentityQuarter;
525
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700526 mOutput->setColorTransform(refreshArgs);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800527
528 // The internal state should have been updated
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700529 EXPECT_EQ(kNonIdentityQuarter, mOutput->getState().colorTransformMatrix);
Lloyd Pique3eb1b212019-03-07 21:15:40 -0800530
531 // The dirtyRegion should be set to the full display size
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700532 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700533}
534
Lloyd Pique66d68602019-02-13 14:23:31 -0800535/*
Lloyd Pique17ca7422019-11-14 14:24:10 -0800536 * Output::setColorProfile
Lloyd Pique32cbe282018-10-19 13:09:22 -0700537 */
538
Lloyd Pique17ca7422019-11-14 14:24:10 -0800539using OutputSetColorProfileTest = OutputTest;
540
541TEST_F(OutputSetColorProfileTest, setsStateAndDirtiesOutputIfChanged) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800542 using ColorProfile = Output::ColorProfile;
543
Lloyd Piquef5275482019-01-29 18:42:42 -0800544 EXPECT_CALL(*mDisplayColorProfile,
545 getTargetDataspace(ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
546 ui::Dataspace::UNKNOWN))
547 .WillOnce(Return(ui::Dataspace::UNKNOWN));
Lloyd Piqueef958122019-02-05 18:00:12 -0800548 EXPECT_CALL(*mRenderSurface, setBufferDataspace(ui::Dataspace::DISPLAY_P3)).Times(1);
Lloyd Pique31cb2942018-10-19 17:23:03 -0700549
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700550 mOutput->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
551 ui::RenderIntent::TONE_MAP_COLORIMETRIC,
552 ui::Dataspace::UNKNOWN});
Lloyd Pique32cbe282018-10-19 13:09:22 -0700553
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700554 EXPECT_EQ(ui::ColorMode::DISPLAY_P3, mOutput->getState().colorMode);
555 EXPECT_EQ(ui::Dataspace::DISPLAY_P3, mOutput->getState().dataspace);
556 EXPECT_EQ(ui::RenderIntent::TONE_MAP_COLORIMETRIC, mOutput->getState().renderIntent);
557 EXPECT_EQ(ui::Dataspace::UNKNOWN, mOutput->getState().targetDataspace);
Lloyd Piquef5275482019-01-29 18:42:42 -0800558
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700559 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region(kDefaultDisplaySize)));
Lloyd Piqueef958122019-02-05 18:00:12 -0800560}
561
Lloyd Pique17ca7422019-11-14 14:24:10 -0800562TEST_F(OutputSetColorProfileTest, doesNothingIfNoChange) {
Lloyd Pique6a3b4462019-03-07 20:58:12 -0800563 using ColorProfile = Output::ColorProfile;
564
Lloyd Piquef5275482019-01-29 18:42:42 -0800565 EXPECT_CALL(*mDisplayColorProfile,
566 getTargetDataspace(ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
567 ui::Dataspace::UNKNOWN))
568 .WillOnce(Return(ui::Dataspace::UNKNOWN));
569
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700570 mOutput->editState().colorMode = ui::ColorMode::DISPLAY_P3;
571 mOutput->editState().dataspace = ui::Dataspace::DISPLAY_P3;
572 mOutput->editState().renderIntent = ui::RenderIntent::TONE_MAP_COLORIMETRIC;
573 mOutput->editState().targetDataspace = ui::Dataspace::UNKNOWN;
Lloyd Piqueef958122019-02-05 18:00:12 -0800574
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700575 mOutput->setColorProfile(ColorProfile{ui::ColorMode::DISPLAY_P3, ui::Dataspace::DISPLAY_P3,
576 ui::RenderIntent::TONE_MAP_COLORIMETRIC,
577 ui::Dataspace::UNKNOWN});
Lloyd Piqueef958122019-02-05 18:00:12 -0800578
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700579 EXPECT_THAT(mOutput->getState().dirtyRegion, RegionEq(Region()));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700580}
581
Lloyd Pique66d68602019-02-13 14:23:31 -0800582/*
Lloyd Pique31cb2942018-10-19 17:23:03 -0700583 * Output::setRenderSurface()
584 */
585
586TEST_F(OutputTest, setRenderSurfaceResetsBounds) {
587 const ui::Size newDisplaySize{640, 480};
588
589 mock::RenderSurface* renderSurface = new StrictMock<mock::RenderSurface>();
590 EXPECT_CALL(*renderSurface, getSize()).WillOnce(ReturnRef(newDisplaySize));
591
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700592 mOutput->setRenderSurface(std::unique_ptr<RenderSurface>(renderSurface));
Lloyd Pique31cb2942018-10-19 17:23:03 -0700593
Angel Aguayob084e0c2021-08-04 23:27:28 +0000594 EXPECT_EQ(Rect(newDisplaySize), mOutput->getState().framebufferSpace.getBoundsAsRect());
Lloyd Pique31cb2942018-10-19 17:23:03 -0700595}
596
Alec Mouricdf16792021-12-10 13:16:06 -0800597/**
598 * Output::setDisplayBrightness()
599 */
600
601TEST_F(OutputTest, setNextBrightness) {
602 constexpr float kDisplayBrightness = 0.5f;
603 mOutput->setNextBrightness(kDisplayBrightness);
604 ASSERT_TRUE(mOutput->getState().displayBrightness.has_value());
605 EXPECT_EQ(kDisplayBrightness, mOutput->getState().displayBrightness);
606}
607
Lloyd Pique66d68602019-02-13 14:23:31 -0800608/*
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000609 * Output::getDirtyRegion()
Lloyd Pique32cbe282018-10-19 13:09:22 -0700610 */
611
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700612TEST_F(OutputTest, getDirtyRegion) {
Alec Mourie7d1d4a2019-02-05 01:13:46 +0000613 const Rect viewport{100, 200};
Angel Aguayob084e0c2021-08-04 23:27:28 +0000614 mOutput->editState().layerStackSpace.setContent(viewport);
Lloyd Piquea38ea7e2019-04-16 18:10:26 -0700615 mOutput->editState().dirtyRegion.set(50, 300);
Lloyd Pique32cbe282018-10-19 13:09:22 -0700616
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -0700617 // The dirty region should be clipped to the display bounds.
618 EXPECT_THAT(mOutput->getDirtyRegion(), RegionEq(Region(Rect(50, 200))));
Lloyd Pique32cbe282018-10-19 13:09:22 -0700619}
620
Lloyd Pique66d68602019-02-13 14:23:31 -0800621/*
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700622 * Output::includesLayer()
Lloyd Piqueef36b002019-01-23 17:52:04 -0800623 */
624
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700625TEST_F(OutputTest, layerFiltering) {
626 const ui::LayerStack layerStack1{123u};
627 const ui::LayerStack layerStack2{456u};
Lloyd Piqueef36b002019-01-23 17:52:04 -0800628
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700629 // If the output is associated to layerStack1 and to an internal display...
630 mOutput->setLayerFilter({layerStack1, true});
Lloyd Piqueef36b002019-01-23 17:52:04 -0800631
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700632 // It excludes layers with no layer stack, internal-only or not.
633 EXPECT_FALSE(mOutput->includesLayer({ui::INVALID_LAYER_STACK, false}));
634 EXPECT_FALSE(mOutput->includesLayer({ui::INVALID_LAYER_STACK, true}));
Lloyd Piquec6687342019-03-07 21:34:57 -0800635
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700636 // It includes layers on layerStack1, internal-only or not.
637 EXPECT_TRUE(mOutput->includesLayer({layerStack1, false}));
638 EXPECT_TRUE(mOutput->includesLayer({layerStack1, true}));
639 EXPECT_FALSE(mOutput->includesLayer({layerStack2, true}));
640 EXPECT_FALSE(mOutput->includesLayer({layerStack2, false}));
Lloyd Piqueef36b002019-01-23 17:52:04 -0800641
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700642 // If the output is associated to layerStack1 but not to an internal display...
643 mOutput->setLayerFilter({layerStack1, false});
Lloyd Piqueef36b002019-01-23 17:52:04 -0800644
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700645 // It includes layers on layerStack1, unless they are internal-only.
646 EXPECT_TRUE(mOutput->includesLayer({layerStack1, false}));
647 EXPECT_FALSE(mOutput->includesLayer({layerStack1, true}));
648 EXPECT_FALSE(mOutput->includesLayer({layerStack2, true}));
649 EXPECT_FALSE(mOutput->includesLayer({layerStack2, false}));
Lloyd Piqueef36b002019-01-23 17:52:04 -0800650}
651
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700652TEST_F(OutputTest, layerFilteringWithoutCompositionState) {
Lloyd Piquede196652020-01-22 17:29:58 -0800653 NonInjectedLayer layer;
654 sp<LayerFE> layerFE(layer.layerFE);
Lloyd Pique66c20c42019-03-07 21:44:02 -0800655
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700656 // Layers without composition state are excluded.
Lloyd Piquede196652020-01-22 17:29:58 -0800657 EXPECT_CALL(*layer.layerFE, getCompositionState).WillOnce(Return(nullptr));
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700658 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Piquede196652020-01-22 17:29:58 -0800659}
660
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700661TEST_F(OutputTest, layerFilteringWithCompositionState) {
Lloyd Piquede196652020-01-22 17:29:58 -0800662 NonInjectedLayer layer;
663 sp<LayerFE> layerFE(layer.layerFE);
Lloyd Pique66c20c42019-03-07 21:44:02 -0800664
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700665 const ui::LayerStack layerStack1{123u};
666 const ui::LayerStack layerStack2{456u};
Lloyd Pique66c20c42019-03-07 21:44:02 -0800667
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700668 // If the output is associated to layerStack1 and to an internal display...
669 mOutput->setLayerFilter({layerStack1, true});
Lloyd Pique66c20c42019-03-07 21:44:02 -0800670
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700671 // It excludes layers with no layer stack, internal-only or not.
672 layer.layerFEState.outputFilter = {ui::INVALID_LAYER_STACK, false};
673 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800674
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700675 layer.layerFEState.outputFilter = {ui::INVALID_LAYER_STACK, true};
676 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800677
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700678 // It includes layers on layerStack1, internal-only or not.
679 layer.layerFEState.outputFilter = {layerStack1, false};
680 EXPECT_TRUE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800681
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700682 layer.layerFEState.outputFilter = {layerStack1, true};
683 EXPECT_TRUE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800684
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700685 layer.layerFEState.outputFilter = {layerStack2, true};
686 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800687
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700688 layer.layerFEState.outputFilter = {layerStack2, false};
689 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800690
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700691 // If the output is associated to layerStack1 but not to an internal display...
692 mOutput->setLayerFilter({layerStack1, false});
Lloyd Pique66c20c42019-03-07 21:44:02 -0800693
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700694 // It includes layers on layerStack1, unless they are internal-only.
695 layer.layerFEState.outputFilter = {layerStack1, false};
696 EXPECT_TRUE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800697
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700698 layer.layerFEState.outputFilter = {layerStack1, true};
699 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800700
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700701 layer.layerFEState.outputFilter = {layerStack2, true};
702 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800703
Dominik Laskowski29fa1462021-04-27 15:51:50 -0700704 layer.layerFEState.outputFilter = {layerStack2, false};
705 EXPECT_FALSE(mOutput->includesLayer(layerFE));
Lloyd Pique66c20c42019-03-07 21:44:02 -0800706}
707
Lloyd Pique66d68602019-02-13 14:23:31 -0800708/*
Lloyd Piquecc01a452018-12-04 17:24:00 -0800709 * Output::getOutputLayerForLayer()
710 */
711
712TEST_F(OutputTest, getOutputLayerForLayerWorks) {
Lloyd Piquede196652020-01-22 17:29:58 -0800713 InjectedLayer layer1;
714 InjectedLayer layer2;
715 NonInjectedLayer layer3;
Lloyd Piquecc01a452018-12-04 17:24:00 -0800716
Lloyd Piquede196652020-01-22 17:29:58 -0800717 injectOutputLayer(layer1);
718 injectNullOutputLayer();
719 injectOutputLayer(layer2);
Lloyd Piquecc01a452018-12-04 17:24:00 -0800720
721 // If the input layer matches the first OutputLayer, it will be returned.
Lloyd Piquede196652020-01-22 17:29:58 -0800722 EXPECT_CALL(*layer1.outputLayer, getLayerFE()).WillOnce(ReturnRef(*layer1.layerFE.get()));
723 EXPECT_EQ(layer1.outputLayer, mOutput->getOutputLayerForLayer(layer1.layerFE));
Lloyd Piquecc01a452018-12-04 17:24:00 -0800724
725 // If the input layer matches the second OutputLayer, it will be returned.
Lloyd Piquede196652020-01-22 17:29:58 -0800726 EXPECT_CALL(*layer1.outputLayer, getLayerFE()).WillOnce(ReturnRef(*layer1.layerFE.get()));
727 EXPECT_CALL(*layer2.outputLayer, getLayerFE()).WillOnce(ReturnRef(*layer2.layerFE.get()));
728 EXPECT_EQ(layer2.outputLayer, mOutput->getOutputLayerForLayer(layer2.layerFE));
Lloyd Piquecc01a452018-12-04 17:24:00 -0800729
730 // If the input layer does not match an output layer, null will be returned.
Lloyd Piquede196652020-01-22 17:29:58 -0800731 EXPECT_CALL(*layer1.outputLayer, getLayerFE()).WillOnce(ReturnRef(*layer1.layerFE.get()));
732 EXPECT_CALL(*layer2.outputLayer, getLayerFE()).WillOnce(ReturnRef(*layer2.layerFE.get()));
733 EXPECT_EQ(nullptr, mOutput->getOutputLayerForLayer(layer3.layerFE));
Lloyd Piquecc01a452018-12-04 17:24:00 -0800734}
735
Lloyd Pique66d68602019-02-13 14:23:31 -0800736/*
Lloyd Piquec9e60032019-11-14 11:47:26 -0800737 * Output::setReleasedLayers()
738 */
739
740using OutputSetReleasedLayersTest = OutputTest;
741
742TEST_F(OutputSetReleasedLayersTest, setReleasedLayersTakesGivenLayers) {
Ady Abrahame0eafa82022-02-02 19:30:47 -0800743 sp<StrictMock<mock::LayerFE>> layer1FE = sp<StrictMock<mock::LayerFE>>::make();
744 sp<StrictMock<mock::LayerFE>> layer2FE = sp<StrictMock<mock::LayerFE>>::make();
745 sp<StrictMock<mock::LayerFE>> layer3FE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Piquec9e60032019-11-14 11:47:26 -0800746
747 Output::ReleasedLayers layers;
748 layers.push_back(layer1FE);
749 layers.push_back(layer2FE);
750 layers.push_back(layer3FE);
751
752 mOutput->setReleasedLayers(std::move(layers));
753
754 const auto& setLayers = mOutput->getReleasedLayersForTest();
755 ASSERT_EQ(3u, setLayers.size());
756 ASSERT_EQ(layer1FE.get(), setLayers[0].promote().get());
757 ASSERT_EQ(layer2FE.get(), setLayers[1].promote().get());
758 ASSERT_EQ(layer3FE.get(), setLayers[2].promote().get());
759}
760
761/*
Lloyd Piquec0ee6ba2019-11-14 12:55:53 -0800762 * Output::updateLayerStateFromFE()
763 */
764
Lloyd Piquede196652020-01-22 17:29:58 -0800765using OutputUpdateLayerStateFromFETest = OutputTest;
Lloyd Piquec0ee6ba2019-11-14 12:55:53 -0800766
767TEST_F(OutputUpdateLayerStateFromFETest, handlesNoOutputLayerCase) {
768 CompositionRefreshArgs refreshArgs;
769
770 mOutput->updateLayerStateFromFE(refreshArgs);
771}
772
Lloyd Piquede196652020-01-22 17:29:58 -0800773TEST_F(OutputUpdateLayerStateFromFETest, preparesContentStateForAllContainedLayers) {
774 InjectedLayer layer1;
775 InjectedLayer layer2;
776 InjectedLayer layer3;
Lloyd Piquec0ee6ba2019-11-14 12:55:53 -0800777
Lloyd Piquede196652020-01-22 17:29:58 -0800778 EXPECT_CALL(*layer1.layerFE.get(), prepareCompositionState(LayerFE::StateSubset::Content));
779 EXPECT_CALL(*layer2.layerFE.get(), prepareCompositionState(LayerFE::StateSubset::Content));
780 EXPECT_CALL(*layer3.layerFE.get(), prepareCompositionState(LayerFE::StateSubset::Content));
781
782 injectOutputLayer(layer1);
783 injectOutputLayer(layer2);
784 injectOutputLayer(layer3);
Lloyd Piquec0ee6ba2019-11-14 12:55:53 -0800785
786 CompositionRefreshArgs refreshArgs;
787 refreshArgs.updatingGeometryThisFrame = false;
788
789 mOutput->updateLayerStateFromFE(refreshArgs);
790}
791
Lloyd Piquede196652020-01-22 17:29:58 -0800792TEST_F(OutputUpdateLayerStateFromFETest, preparesGeometryAndContentStateForAllContainedLayers) {
793 InjectedLayer layer1;
794 InjectedLayer layer2;
795 InjectedLayer layer3;
Lloyd Piquec0ee6ba2019-11-14 12:55:53 -0800796
Lloyd Piquede196652020-01-22 17:29:58 -0800797 EXPECT_CALL(*layer1.layerFE, prepareCompositionState(LayerFE::StateSubset::GeometryAndContent));
798 EXPECT_CALL(*layer2.layerFE, prepareCompositionState(LayerFE::StateSubset::GeometryAndContent));
799 EXPECT_CALL(*layer3.layerFE, prepareCompositionState(LayerFE::StateSubset::GeometryAndContent));
800
801 injectOutputLayer(layer1);
802 injectOutputLayer(layer2);
803 injectOutputLayer(layer3);
Lloyd Piquec0ee6ba2019-11-14 12:55:53 -0800804
805 CompositionRefreshArgs refreshArgs;
806 refreshArgs.updatingGeometryThisFrame = true;
807
808 mOutput->updateLayerStateFromFE(refreshArgs);
809}
810
811/*
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800812 * Output::updateAndWriteCompositionState()
813 */
814
Lloyd Piquede196652020-01-22 17:29:58 -0800815using OutputUpdateAndWriteCompositionStateTest = OutputTest;
Lloyd Piqueef63b612019-11-14 13:19:56 -0800816
817TEST_F(OutputUpdateAndWriteCompositionStateTest, doesNothingIfLayers) {
818 mOutput->editState().isEnabled = true;
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800819
820 CompositionRefreshArgs args;
Dan Stoza269dc4d2021-01-15 15:07:43 -0800821 mOutput->updateCompositionState(args);
822 mOutput->planComposition();
823 mOutput->writeCompositionState(args);
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800824}
825
Lloyd Piqueef63b612019-11-14 13:19:56 -0800826TEST_F(OutputUpdateAndWriteCompositionStateTest, doesNothingIfOutputNotEnabled) {
Lloyd Piquede196652020-01-22 17:29:58 -0800827 InjectedLayer layer1;
828 InjectedLayer layer2;
829 InjectedLayer layer3;
830
Lloyd Piqueef63b612019-11-14 13:19:56 -0800831 mOutput->editState().isEnabled = false;
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800832
Lloyd Piquede196652020-01-22 17:29:58 -0800833 injectOutputLayer(layer1);
834 injectOutputLayer(layer2);
835 injectOutputLayer(layer3);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800836
837 CompositionRefreshArgs args;
Dan Stoza269dc4d2021-01-15 15:07:43 -0800838 mOutput->updateCompositionState(args);
839 mOutput->planComposition();
840 mOutput->writeCompositionState(args);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800841}
842
843TEST_F(OutputUpdateAndWriteCompositionStateTest, updatesLayerContentForAllLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800844 InjectedLayer layer1;
845 InjectedLayer layer2;
846 InjectedLayer layer3;
Lloyd Piqueef63b612019-11-14 13:19:56 -0800847
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400848 uint32_t z = 0;
Snild Dolkow9e217d62020-04-22 15:53:42 +0200849 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));
Dan Stoza6166c312021-01-15 16:34:05 -0800850 EXPECT_CALL(*layer1.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400851 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
852 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +0200853 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));
Dan Stoza6166c312021-01-15 16:34:05 -0800854 EXPECT_CALL(*layer2.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400855 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
856 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +0200857 EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_180));
Dan Stoza6166c312021-01-15 16:34:05 -0800858 EXPECT_CALL(*layer3.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400859 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
860 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lloyd Piquede196652020-01-22 17:29:58 -0800861
862 injectOutputLayer(layer1);
863 injectOutputLayer(layer2);
864 injectOutputLayer(layer3);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800865
866 mOutput->editState().isEnabled = true;
867
868 CompositionRefreshArgs args;
869 args.updatingGeometryThisFrame = false;
870 args.devOptForceClientComposition = false;
Snild Dolkow9e217d62020-04-22 15:53:42 +0200871 args.internalDisplayRotationFlags = ui::Transform::ROT_180;
Dan Stoza269dc4d2021-01-15 15:07:43 -0800872 mOutput->updateCompositionState(args);
873 mOutput->planComposition();
874 mOutput->writeCompositionState(args);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800875}
876
877TEST_F(OutputUpdateAndWriteCompositionStateTest, updatesLayerGeometryAndContentForAllLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800878 InjectedLayer layer1;
879 InjectedLayer layer2;
880 InjectedLayer layer3;
Lloyd Piqueef63b612019-11-14 13:19:56 -0800881
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400882 uint32_t z = 0;
Snild Dolkow9e217d62020-04-22 15:53:42 +0200883 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -0800884 EXPECT_CALL(*layer1.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400885 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,
886 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +0200887 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -0800888 EXPECT_CALL(*layer2.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400889 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,
890 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +0200891 EXPECT_CALL(*layer3.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -0800892 EXPECT_CALL(*layer3.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400893 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,
894 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lloyd Piquede196652020-01-22 17:29:58 -0800895
896 injectOutputLayer(layer1);
897 injectOutputLayer(layer2);
898 injectOutputLayer(layer3);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800899
900 mOutput->editState().isEnabled = true;
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800901
902 CompositionRefreshArgs args;
903 args.updatingGeometryThisFrame = true;
Lloyd Piqueef63b612019-11-14 13:19:56 -0800904 args.devOptForceClientComposition = false;
Dan Stoza269dc4d2021-01-15 15:07:43 -0800905 mOutput->updateCompositionState(args);
906 mOutput->planComposition();
907 mOutput->writeCompositionState(args);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800908}
909
910TEST_F(OutputUpdateAndWriteCompositionStateTest, forcesClientCompositionForAllLayers) {
Lloyd Piquede196652020-01-22 17:29:58 -0800911 InjectedLayer layer1;
912 InjectedLayer layer2;
913 InjectedLayer layer3;
Lloyd Piqueef63b612019-11-14 13:19:56 -0800914
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -0400915 uint32_t z = 0;
Snild Dolkow9e217d62020-04-22 15:53:42 +0200916 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -0800917 EXPECT_CALL(*layer1.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400918 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
919 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +0200920 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -0800921 EXPECT_CALL(*layer2.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400922 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
923 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +0200924 EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -0800925 EXPECT_CALL(*layer3.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -0400926 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
927 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lloyd Piquede196652020-01-22 17:29:58 -0800928
929 injectOutputLayer(layer1);
930 injectOutputLayer(layer2);
931 injectOutputLayer(layer3);
Lloyd Piqueef63b612019-11-14 13:19:56 -0800932
933 mOutput->editState().isEnabled = true;
934
935 CompositionRefreshArgs args;
936 args.updatingGeometryThisFrame = false;
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800937 args.devOptForceClientComposition = true;
Dan Stoza269dc4d2021-01-15 15:07:43 -0800938 mOutput->updateCompositionState(args);
939 mOutput->planComposition();
940 mOutput->writeCompositionState(args);
Alec Mourif9a2a2c2019-11-12 12:46:02 -0800941}
942
Leon Scroggins III2e74a4c2021-04-09 13:41:14 -0400943TEST_F(OutputUpdateAndWriteCompositionStateTest, peekThroughLayerChangesOrder) {
944 renderengine::mock::RenderEngine renderEngine;
945 InjectedLayer layer0;
946 InjectedLayer layer1;
947 InjectedLayer layer2;
948 InjectedLayer layer3;
949
950 InSequence seq;
951 EXPECT_CALL(*layer0.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
952 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
953 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
954 EXPECT_CALL(*layer3.outputLayer, updateCompositionState(true, false, ui::Transform::ROT_0));
955
956 uint32_t z = 0;
957 EXPECT_CALL(*layer0.outputLayer,
958 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,
959 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
960
961 // After calling planComposition (which clears overrideInfo), this test sets
962 // layer3 to be the peekThroughLayer for layer1 and layer2. As a result, it
963 // comes first, setting isPeekingThrough to true and zIsOverridden to true
964 // for it and the following layers.
965 EXPECT_CALL(*layer3.outputLayer,
966 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,
967 /*zIsOverridden*/ true, /*isPeekingThrough*/
968 true));
969 EXPECT_CALL(*layer1.outputLayer,
970 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ false, z++,
971 /*zIsOverridden*/ true, /*isPeekingThrough*/ false));
972 EXPECT_CALL(*layer2.outputLayer,
973 writeStateToHWC(/*includeGeometry*/ true, /*skipLayer*/ true, z++,
974 /*zIsOverridden*/ true, /*isPeekingThrough*/ false));
975
976 injectOutputLayer(layer0);
977 injectOutputLayer(layer1);
978 injectOutputLayer(layer2);
979 injectOutputLayer(layer3);
980
981 mOutput->editState().isEnabled = true;
982
983 CompositionRefreshArgs args;
984 args.updatingGeometryThisFrame = true;
985 args.devOptForceClientComposition = false;
986 mOutput->updateCompositionState(args);
987 mOutput->planComposition();
988
989 std::shared_ptr<renderengine::ExternalTexture> buffer = std::make_shared<
Vishnu Nairdbbe3852022-01-12 20:22:11 -0800990 renderengine::impl::
991 ExternalTexture>(new GraphicBuffer(), renderEngine,
992 renderengine::impl::ExternalTexture::Usage::READABLE |
993 renderengine::impl::ExternalTexture::Usage::WRITEABLE);
Leon Scroggins III2e74a4c2021-04-09 13:41:14 -0400994 layer1.outputLayerState.overrideInfo.buffer = buffer;
995 layer2.outputLayerState.overrideInfo.buffer = buffer;
996 layer1.outputLayerState.overrideInfo.peekThroughLayer = layer3.outputLayer;
997 layer2.outputLayerState.overrideInfo.peekThroughLayer = layer3.outputLayer;
998
999 mOutput->writeCompositionState(args);
1000}
1001
Alec Mourif9a2a2c2019-11-12 12:46:02 -08001002/*
Lloyd Pique66d68602019-02-13 14:23:31 -08001003 * Output::prepareFrame()
1004 */
1005
1006struct OutputPrepareFrameTest : public testing::Test {
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001007 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08001008 // Sets up the helper functions called by the function under test to use
1009 // mock implementations.
Vishnu Naira3140382022-02-24 14:07:11 -08001010 MOCK_METHOD1(chooseCompositionStrategy,
1011 bool(std::optional<android::HWComposer::DeviceRequestedChanges>*));
1012 MOCK_METHOD0(resetCompositionStrategy, void());
Lloyd Pique66d68602019-02-13 14:23:31 -08001013 };
1014
1015 OutputPrepareFrameTest() {
1016 mOutput.setDisplayColorProfileForTest(
1017 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
1018 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
1019 }
1020
1021 StrictMock<mock::CompositionEngine> mCompositionEngine;
1022 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
1023 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001024 StrictMock<OutputPartialMock> mOutput;
Lloyd Pique66d68602019-02-13 14:23:31 -08001025};
1026
1027TEST_F(OutputPrepareFrameTest, takesEarlyOutIfNotEnabled) {
1028 mOutput.editState().isEnabled = false;
1029
1030 mOutput.prepareFrame();
1031}
1032
1033TEST_F(OutputPrepareFrameTest, delegatesToChooseCompositionStrategyAndRenderSurface) {
1034 mOutput.editState().isEnabled = true;
1035 mOutput.editState().usesClientComposition = false;
1036 mOutput.editState().usesDeviceComposition = true;
1037
Vishnu Naira3140382022-02-24 14:07:11 -08001038 EXPECT_CALL(mOutput, chooseCompositionStrategy(_)).WillRepeatedly(Return(true));
1039 EXPECT_CALL(mOutput, resetCompositionStrategy()).Times(1);
Alec Mouri023c1882021-05-08 16:36:33 -07001040 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
Lloyd Pique66d68602019-02-13 14:23:31 -08001041 EXPECT_CALL(*mRenderSurface, prepareFrame(false, true));
1042
1043 mOutput.prepareFrame();
Vishnu Nair9cf89262022-02-26 09:17:49 -08001044 EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::DISABLED);
Lloyd Pique66d68602019-02-13 14:23:31 -08001045}
1046
1047// Note: Use OutputTest and not OutputPrepareFrameTest, so the real
1048// base chooseCompositionStrategy() is invoked.
1049TEST_F(OutputTest, prepareFrameSetsClientCompositionOnlyByDefault) {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001050 mOutput->editState().isEnabled = true;
1051 mOutput->editState().usesClientComposition = false;
1052 mOutput->editState().usesDeviceComposition = true;
Lloyd Pique66d68602019-02-13 14:23:31 -08001053
1054 EXPECT_CALL(*mRenderSurface, prepareFrame(true, false));
1055
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001056 mOutput->prepareFrame();
Lloyd Pique66d68602019-02-13 14:23:31 -08001057
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07001058 EXPECT_TRUE(mOutput->getState().usesClientComposition);
1059 EXPECT_FALSE(mOutput->getState().usesDeviceComposition);
Vishnu Nair9cf89262022-02-26 09:17:49 -08001060 EXPECT_EQ(mOutput->getState().strategyPrediction, CompositionStrategyPredictionState::DISABLED);
Lloyd Pique66d68602019-02-13 14:23:31 -08001061}
1062
Vishnu Naira3140382022-02-24 14:07:11 -08001063struct OutputPrepareFrameAsyncTest : public testing::Test {
1064 struct OutputPartialMock : public OutputPartialMockBase {
1065 // Sets up the helper functions called by the function under test to use
1066 // mock implementations.
1067 MOCK_METHOD1(chooseCompositionStrategy,
1068 bool(std::optional<android::HWComposer::DeviceRequestedChanges>*));
1069 MOCK_METHOD0(updateProtectedContentState, void());
1070 MOCK_METHOD2(dequeueRenderBuffer,
1071 bool(base::unique_fd*, std::shared_ptr<renderengine::ExternalTexture>*));
1072 MOCK_METHOD1(
1073 chooseCompositionStrategyAsync,
1074 std::future<bool>(std::optional<android::HWComposer::DeviceRequestedChanges>*));
1075 MOCK_METHOD4(composeSurfaces,
1076 std::optional<base::unique_fd>(
1077 const Region&, const compositionengine::CompositionRefreshArgs&,
1078 std::shared_ptr<renderengine::ExternalTexture>, base::unique_fd&));
1079 MOCK_METHOD0(resetCompositionStrategy, void());
1080 };
1081
1082 OutputPrepareFrameAsyncTest() {
1083 mOutput.setDisplayColorProfileForTest(
1084 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
1085 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
1086 }
1087
1088 StrictMock<mock::CompositionEngine> mCompositionEngine;
1089 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
1090 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
1091 StrictMock<OutputPartialMock> mOutput;
1092 CompositionRefreshArgs mRefreshArgs;
1093};
1094
1095TEST_F(OutputPrepareFrameAsyncTest, delegatesToChooseCompositionStrategyAndRenderSurface) {
1096 mOutput.editState().isEnabled = true;
1097 mOutput.editState().usesClientComposition = false;
1098 mOutput.editState().usesDeviceComposition = true;
1099 mOutput.editState().previousDeviceRequestedChanges =
1100 std::make_optional<android::HWComposer::DeviceRequestedChanges>({});
1101 std::promise<bool> p;
1102 p.set_value(true);
1103
1104 EXPECT_CALL(mOutput, resetCompositionStrategy()).Times(1);
1105 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
1106 EXPECT_CALL(mOutput, updateProtectedContentState());
1107 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _)).WillOnce(Return(true));
1108 EXPECT_CALL(*mRenderSurface, prepareFrame(false, true)).Times(1);
1109 EXPECT_CALL(mOutput, chooseCompositionStrategyAsync(_))
1110 .WillOnce(DoAll(SetArgPointee<0>(mOutput.editState().previousDeviceRequestedChanges),
1111 Return(ByMove(p.get_future()))));
1112 EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));
1113
1114 impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);
Vishnu Nair9cf89262022-02-26 09:17:49 -08001115 EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::SUCCESS);
Vishnu Naira3140382022-02-24 14:07:11 -08001116 EXPECT_FALSE(result.bufferAvailable());
1117}
1118
1119TEST_F(OutputPrepareFrameAsyncTest, skipCompositionOnDequeueFailure) {
1120 mOutput.editState().isEnabled = true;
1121 mOutput.editState().usesClientComposition = false;
1122 mOutput.editState().usesDeviceComposition = true;
1123 mOutput.editState().previousDeviceRequestedChanges =
1124 std::make_optional<android::HWComposer::DeviceRequestedChanges>({});
1125 std::promise<bool> p;
1126 p.set_value(true);
1127
1128 EXPECT_CALL(mOutput, resetCompositionStrategy()).Times(2);
1129 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
1130 EXPECT_CALL(mOutput, updateProtectedContentState());
1131 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _)).WillOnce(Return(false));
1132 EXPECT_CALL(*mRenderSurface, prepareFrame(false, true)).Times(2);
1133 EXPECT_CALL(mOutput, chooseCompositionStrategyAsync(_))
1134 .WillOnce(DoAll(SetArgPointee<0>(mOutput.editState().previousDeviceRequestedChanges),
1135 Return(ByMove(p.get_future()))));
1136
1137 impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);
Vishnu Nair9cf89262022-02-26 09:17:49 -08001138 EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);
Vishnu Naira3140382022-02-24 14:07:11 -08001139 EXPECT_FALSE(result.bufferAvailable());
1140}
1141
1142// Tests that in the event of hwc error when choosing composition strategy, we would fall back
1143// client composition
1144TEST_F(OutputPrepareFrameAsyncTest, chooseCompositionStrategyFailureCallsPrepareFrame) {
1145 mOutput.editState().isEnabled = true;
1146 mOutput.editState().usesClientComposition = false;
1147 mOutput.editState().usesDeviceComposition = true;
1148 mOutput.editState().previousDeviceRequestedChanges =
1149 std::make_optional<android::HWComposer::DeviceRequestedChanges>({});
1150 std::promise<bool> p;
1151 p.set_value(false);
1152 std::shared_ptr<renderengine::ExternalTexture> tex =
1153 std::make_shared<renderengine::mock::FakeExternalTexture>(1, 1,
1154 HAL_PIXEL_FORMAT_RGBA_8888, 1,
1155 2);
1156 EXPECT_CALL(mOutput, resetCompositionStrategy()).Times(2);
1157 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
1158 EXPECT_CALL(mOutput, updateProtectedContentState());
1159 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _))
1160 .WillOnce(DoAll(SetArgPointee<1>(tex), Return(true)));
1161 EXPECT_CALL(*mRenderSurface, prepareFrame(false, true)).Times(2);
1162 EXPECT_CALL(mOutput, chooseCompositionStrategyAsync(_)).WillOnce([&] {
1163 return p.get_future();
1164 });
1165 EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));
1166
1167 impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);
Vishnu Nair9cf89262022-02-26 09:17:49 -08001168 EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);
Vishnu Naira3140382022-02-24 14:07:11 -08001169 EXPECT_TRUE(result.bufferAvailable());
1170}
1171
1172TEST_F(OutputPrepareFrameAsyncTest, predictionMiss) {
1173 mOutput.editState().isEnabled = true;
1174 mOutput.editState().usesClientComposition = false;
1175 mOutput.editState().usesDeviceComposition = true;
1176 mOutput.editState().previousDeviceRequestedChanges =
1177 std::make_optional<android::HWComposer::DeviceRequestedChanges>({});
1178 auto newDeviceRequestedChanges =
1179 std::make_optional<android::HWComposer::DeviceRequestedChanges>({});
1180 newDeviceRequestedChanges->displayRequests = static_cast<hal::DisplayRequest>(0);
1181 std::promise<bool> p;
1182 p.set_value(false);
1183 std::shared_ptr<renderengine::ExternalTexture> tex =
1184 std::make_shared<renderengine::mock::FakeExternalTexture>(1, 1,
1185 HAL_PIXEL_FORMAT_RGBA_8888, 1,
1186 2);
1187
1188 EXPECT_CALL(mOutput, resetCompositionStrategy()).Times(2);
1189 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
1190 EXPECT_CALL(mOutput, updateProtectedContentState());
1191 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _))
1192 .WillOnce(DoAll(SetArgPointee<1>(tex), Return(true)));
1193 EXPECT_CALL(*mRenderSurface, prepareFrame(false, true)).Times(2);
1194 EXPECT_CALL(mOutput, chooseCompositionStrategyAsync(_)).WillOnce([&] {
1195 return p.get_future();
1196 });
1197 EXPECT_CALL(mOutput, composeSurfaces(_, Ref(mRefreshArgs), _, _));
1198
1199 impl::GpuCompositionResult result = mOutput.prepareFrameAsync(mRefreshArgs);
Vishnu Nair9cf89262022-02-26 09:17:49 -08001200 EXPECT_EQ(mOutput.getState().strategyPrediction, CompositionStrategyPredictionState::FAIL);
Vishnu Naira3140382022-02-24 14:07:11 -08001201 EXPECT_TRUE(result.bufferAvailable());
1202}
1203
Lloyd Pique56eba802019-08-28 15:45:25 -07001204/*
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001205 * Output::prepare()
1206 */
1207
1208struct OutputPrepareTest : public testing::Test {
1209 struct OutputPartialMock : public OutputPartialMockBase {
1210 // Sets up the helper functions called by the function under test to use
1211 // mock implementations.
1212 MOCK_METHOD2(rebuildLayerStacks,
1213 void(const compositionengine::CompositionRefreshArgs&,
1214 compositionengine::LayerFESet&));
1215 };
1216
1217 StrictMock<OutputPartialMock> mOutput;
1218 CompositionRefreshArgs mRefreshArgs;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001219 LayerFESet mGeomSnapshots;
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001220};
1221
1222TEST_F(OutputPrepareTest, justInvokesRebuildLayerStacks) {
1223 InSequence seq;
1224 EXPECT_CALL(mOutput, rebuildLayerStacks(Ref(mRefreshArgs), Ref(mGeomSnapshots)));
1225
1226 mOutput.prepare(mRefreshArgs, mGeomSnapshots);
1227}
1228
1229/*
1230 * Output::rebuildLayerStacks()
1231 */
1232
1233struct OutputRebuildLayerStacksTest : public testing::Test {
1234 struct OutputPartialMock : public OutputPartialMockBase {
1235 // Sets up the helper functions called by the function under test to use
1236 // mock implementations.
1237 MOCK_METHOD2(collectVisibleLayers,
1238 void(const compositionengine::CompositionRefreshArgs&,
1239 compositionengine::Output::CoverageState&));
1240 };
1241
1242 OutputRebuildLayerStacksTest() {
1243 mOutput.mState.isEnabled = true;
1244 mOutput.mState.transform = kIdentityTransform;
Angel Aguayob084e0c2021-08-04 23:27:28 +00001245 mOutput.mState.displaySpace.setBounds(
1246 ui::Size(kOutputBounds.getWidth(), kOutputBounds.getHeight()));
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001247
1248 mRefreshArgs.updatingOutputGeometryThisFrame = true;
1249
1250 mCoverageAboveCoveredLayersToSet = Region(Rect(0, 0, 10, 10));
1251
1252 EXPECT_CALL(mOutput, collectVisibleLayers(Ref(mRefreshArgs), _))
1253 .WillRepeatedly(Invoke(this, &OutputRebuildLayerStacksTest::setTestCoverageValues));
1254 }
1255
1256 void setTestCoverageValues(const CompositionRefreshArgs&,
1257 compositionengine::Output::CoverageState& state) {
1258 state.aboveCoveredLayers = mCoverageAboveCoveredLayersToSet;
1259 state.aboveOpaqueLayers = mCoverageAboveOpaqueLayersToSet;
1260 state.dirtyRegion = mCoverageDirtyRegionToSet;
1261 }
1262
1263 static const ui::Transform kIdentityTransform;
1264 static const ui::Transform kRotate90Transform;
1265 static const Rect kOutputBounds;
1266
1267 StrictMock<OutputPartialMock> mOutput;
1268 CompositionRefreshArgs mRefreshArgs;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001269 LayerFESet mGeomSnapshots;
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001270 Region mCoverageAboveCoveredLayersToSet;
1271 Region mCoverageAboveOpaqueLayersToSet;
1272 Region mCoverageDirtyRegionToSet;
1273};
1274
1275const ui::Transform OutputRebuildLayerStacksTest::kIdentityTransform{TR_IDENT, 1920, 1080};
1276const ui::Transform OutputRebuildLayerStacksTest::kRotate90Transform{TR_ROT_90, 1920, 1080};
1277const Rect OutputRebuildLayerStacksTest::kOutputBounds{0, 0, 1920, 1080};
1278
1279TEST_F(OutputRebuildLayerStacksTest, doesNothingIfNotEnabled) {
1280 mOutput.mState.isEnabled = false;
1281
1282 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1283}
1284
1285TEST_F(OutputRebuildLayerStacksTest, doesNothingIfNotUpdatingGeometryThisFrame) {
1286 mRefreshArgs.updatingOutputGeometryThisFrame = false;
1287
1288 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1289}
1290
1291TEST_F(OutputRebuildLayerStacksTest, computesUndefinedRegionWithNoRotationAndFullCoverage) {
1292 mOutput.mState.transform = kIdentityTransform;
1293
1294 mCoverageAboveOpaqueLayersToSet = Region(Rect(0, 0, 1920, 1080));
1295
1296 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1297
1298 EXPECT_THAT(mOutput.mState.undefinedRegion, RegionEq(Region(Rect(0, 0, 0, 0))));
1299}
1300
1301TEST_F(OutputRebuildLayerStacksTest, computesUndefinedRegionWithNoRotationAndPartialCoverage) {
1302 mOutput.mState.transform = kIdentityTransform;
1303
1304 mCoverageAboveOpaqueLayersToSet = Region(Rect(0, 0, 960, 1080));
1305
1306 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1307
1308 EXPECT_THAT(mOutput.mState.undefinedRegion, RegionEq(Region(Rect(960, 0, 1920, 1080))));
1309}
1310
1311TEST_F(OutputRebuildLayerStacksTest, computesUndefinedRegionWith90RotationAndFullCoverage) {
1312 mOutput.mState.transform = kRotate90Transform;
1313
1314 mCoverageAboveOpaqueLayersToSet = Region(Rect(0, 0, 1080, 1920));
1315
1316 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1317
1318 EXPECT_THAT(mOutput.mState.undefinedRegion, RegionEq(Region(Rect(0, 0, 0, 0))));
1319}
1320
1321TEST_F(OutputRebuildLayerStacksTest, computesUndefinedRegionWith90RotationAndPartialCoverage) {
1322 mOutput.mState.transform = kRotate90Transform;
1323
1324 mCoverageAboveOpaqueLayersToSet = Region(Rect(0, 0, 1080, 960));
1325
1326 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1327
1328 EXPECT_THAT(mOutput.mState.undefinedRegion, RegionEq(Region(Rect(0, 0, 960, 1080))));
1329}
1330
1331TEST_F(OutputRebuildLayerStacksTest, addsToDirtyRegionWithNoRotation) {
1332 mOutput.mState.transform = kIdentityTransform;
1333 mOutput.mState.dirtyRegion = Region(Rect(960, 0, 1920, 1080));
1334
1335 mCoverageDirtyRegionToSet = Region(Rect(0, 0, 960, 1080));
1336
1337 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1338
1339 EXPECT_THAT(mOutput.mState.dirtyRegion, RegionEq(Region(Rect(0, 0, 1920, 1080))));
1340}
1341
1342TEST_F(OutputRebuildLayerStacksTest, addsToDirtyRegionWith90Rotation) {
1343 mOutput.mState.transform = kRotate90Transform;
1344 mOutput.mState.dirtyRegion = Region(Rect(0, 960, 1080, 1920));
1345
1346 mCoverageDirtyRegionToSet = Region(Rect(0, 0, 1080, 960));
1347
1348 mOutput.rebuildLayerStacks(mRefreshArgs, mGeomSnapshots);
1349
1350 EXPECT_THAT(mOutput.mState.dirtyRegion, RegionEq(Region(Rect(0, 0, 1080, 1920))));
1351}
1352
1353/*
1354 * Output::collectVisibleLayers()
1355 */
1356
Lloyd Pique1ef93222019-11-21 16:41:53 -08001357struct OutputCollectVisibleLayersTest : public testing::Test {
1358 struct OutputPartialMock : public OutputPartialMockBase {
1359 // Sets up the helper functions called by the function under test to use
1360 // mock implementations.
1361 MOCK_METHOD2(ensureOutputLayerIfVisible,
Lloyd Piquede196652020-01-22 17:29:58 -08001362 void(sp<compositionengine::LayerFE>&,
Lloyd Pique1ef93222019-11-21 16:41:53 -08001363 compositionengine::Output::CoverageState&));
1364 MOCK_METHOD1(setReleasedLayers, void(const compositionengine::CompositionRefreshArgs&));
1365 MOCK_METHOD0(finalizePendingOutputLayers, void());
1366 };
1367
1368 struct Layer {
1369 Layer() {
1370 EXPECT_CALL(outputLayer, getState()).WillRepeatedly(ReturnRef(outputLayerState));
1371 EXPECT_CALL(outputLayer, editState()).WillRepeatedly(ReturnRef(outputLayerState));
1372 }
1373
1374 StrictMock<mock::OutputLayer> outputLayer;
Lloyd Pique1ef93222019-11-21 16:41:53 -08001375 impl::OutputLayerCompositionState outputLayerState;
Ady Abrahame0eafa82022-02-02 19:30:47 -08001376 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Pique1ef93222019-11-21 16:41:53 -08001377 };
1378
1379 OutputCollectVisibleLayersTest() {
Lloyd Pique0a456232020-01-16 17:51:13 -08001380 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(3u));
Lloyd Pique1ef93222019-11-21 16:41:53 -08001381 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0))
1382 .WillRepeatedly(Return(&mLayer1.outputLayer));
1383 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1))
1384 .WillRepeatedly(Return(&mLayer2.outputLayer));
1385 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(2))
1386 .WillRepeatedly(Return(&mLayer3.outputLayer));
1387
Lloyd Piquede196652020-01-22 17:29:58 -08001388 mRefreshArgs.layers.push_back(mLayer1.layerFE);
1389 mRefreshArgs.layers.push_back(mLayer2.layerFE);
1390 mRefreshArgs.layers.push_back(mLayer3.layerFE);
Lloyd Pique1ef93222019-11-21 16:41:53 -08001391 }
1392
1393 StrictMock<OutputPartialMock> mOutput;
1394 CompositionRefreshArgs mRefreshArgs;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001395 LayerFESet mGeomSnapshots;
1396 Output::CoverageState mCoverageState{mGeomSnapshots};
Lloyd Pique1ef93222019-11-21 16:41:53 -08001397 Layer mLayer1;
1398 Layer mLayer2;
1399 Layer mLayer3;
1400};
1401
1402TEST_F(OutputCollectVisibleLayersTest, doesMinimalWorkIfNoLayers) {
1403 mRefreshArgs.layers.clear();
Lloyd Pique0a456232020-01-16 17:51:13 -08001404 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
Lloyd Pique1ef93222019-11-21 16:41:53 -08001405
1406 EXPECT_CALL(mOutput, setReleasedLayers(Ref(mRefreshArgs)));
1407 EXPECT_CALL(mOutput, finalizePendingOutputLayers());
1408
1409 mOutput.collectVisibleLayers(mRefreshArgs, mCoverageState);
1410}
1411
1412TEST_F(OutputCollectVisibleLayersTest, processesCandidateLayersReversedAndSetsOutputLayerZ) {
1413 // Enforce a call order sequence for this test.
1414 InSequence seq;
1415
1416 // Layer coverage is evaluated from front to back!
Lloyd Piquede196652020-01-22 17:29:58 -08001417 EXPECT_CALL(mOutput, ensureOutputLayerIfVisible(Eq(mLayer3.layerFE), Ref(mCoverageState)));
1418 EXPECT_CALL(mOutput, ensureOutputLayerIfVisible(Eq(mLayer2.layerFE), Ref(mCoverageState)));
1419 EXPECT_CALL(mOutput, ensureOutputLayerIfVisible(Eq(mLayer1.layerFE), Ref(mCoverageState)));
Lloyd Pique1ef93222019-11-21 16:41:53 -08001420
1421 EXPECT_CALL(mOutput, setReleasedLayers(Ref(mRefreshArgs)));
1422 EXPECT_CALL(mOutput, finalizePendingOutputLayers());
1423
1424 mOutput.collectVisibleLayers(mRefreshArgs, mCoverageState);
Lloyd Pique1ef93222019-11-21 16:41:53 -08001425}
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001426
1427/*
1428 * Output::ensureOutputLayerIfVisible()
1429 */
1430
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001431struct OutputEnsureOutputLayerIfVisibleTest : public testing::Test {
1432 struct OutputPartialMock : public OutputPartialMockBase {
1433 // Sets up the helper functions called by the function under test to use
1434 // mock implementations.
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001435 MOCK_METHOD(bool, includesLayer, (const sp<compositionengine::LayerFE>&),
1436 (const, override));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001437 MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex, OutputLayer*(size_t));
Lloyd Piquede196652020-01-22 17:29:58 -08001438 MOCK_METHOD2(ensureOutputLayer,
1439 compositionengine::OutputLayer*(std::optional<size_t>, const sp<LayerFE>&));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001440 };
1441
1442 OutputEnsureOutputLayerIfVisibleTest() {
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001443 EXPECT_CALL(mOutput, includesLayer(sp<LayerFE>(mLayer.layerFE)))
Lloyd Piquede196652020-01-22 17:29:58 -08001444 .WillRepeatedly(Return(true));
Lloyd Pique0a456232020-01-16 17:51:13 -08001445 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(1u));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001446 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
Lloyd Piquede196652020-01-22 17:29:58 -08001447 .WillRepeatedly(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001448
Angel Aguayob084e0c2021-08-04 23:27:28 +00001449 mOutput.mState.displaySpace.setBounds(ui::Size(200, 300));
1450 mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 200, 300));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001451 mOutput.mState.transform = ui::Transform(TR_IDENT, 200, 300);
1452
Lloyd Piquede196652020-01-22 17:29:58 -08001453 mLayer.layerFEState.isVisible = true;
1454 mLayer.layerFEState.isOpaque = true;
1455 mLayer.layerFEState.contentDirty = true;
1456 mLayer.layerFEState.geomLayerBounds = FloatRect{0, 0, 100, 200};
1457 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Leon Scroggins III9a0afda2022-01-11 16:53:09 -05001458 mLayer.layerFEState.transparentRegionHint = kTransparentRegionHint;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001459
Lloyd Piquede196652020-01-22 17:29:58 -08001460 mLayer.outputLayerState.visibleRegion = Region(Rect(0, 0, 50, 200));
1461 mLayer.outputLayerState.coveredRegion = Region(Rect(50, 0, 100, 200));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001462
Lloyd Piquede196652020-01-22 17:29:58 -08001463 mGeomSnapshots.insert(mLayer.layerFE);
1464 }
1465
1466 void ensureOutputLayerIfVisible() {
1467 sp<LayerFE> layerFE(mLayer.layerFE);
1468 mOutput.ensureOutputLayerIfVisible(layerFE, mCoverageState);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001469 }
1470
1471 static const Region kEmptyRegion;
1472 static const Region kFullBoundsNoRotation;
1473 static const Region kRightHalfBoundsNoRotation;
1474 static const Region kLowerHalfBoundsNoRotation;
1475 static const Region kFullBounds90Rotation;
Leon Scroggins III9a0afda2022-01-11 16:53:09 -05001476 static const Region kTransparentRegionHint;
Leon Scroggins III81aff792022-03-21 13:51:34 -04001477 static const Region kTransparentRegionHintTwo;
1478 static const Region kTransparentRegionHintTwo90Rotation;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001479
1480 StrictMock<OutputPartialMock> mOutput;
1481 LayerFESet mGeomSnapshots;
1482 Output::CoverageState mCoverageState{mGeomSnapshots};
1483
Lloyd Piquede196652020-01-22 17:29:58 -08001484 NonInjectedLayer mLayer;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001485};
1486
1487const Region OutputEnsureOutputLayerIfVisibleTest::kEmptyRegion = Region(Rect(0, 0, 0, 0));
1488const Region OutputEnsureOutputLayerIfVisibleTest::kFullBoundsNoRotation =
1489 Region(Rect(0, 0, 100, 200));
1490const Region OutputEnsureOutputLayerIfVisibleTest::kRightHalfBoundsNoRotation =
1491 Region(Rect(0, 100, 100, 200));
1492const Region OutputEnsureOutputLayerIfVisibleTest::kLowerHalfBoundsNoRotation =
1493 Region(Rect(50, 0, 100, 200));
1494const Region OutputEnsureOutputLayerIfVisibleTest::kFullBounds90Rotation =
1495 Region(Rect(0, 0, 200, 100));
Leon Scroggins III9a0afda2022-01-11 16:53:09 -05001496const Region OutputEnsureOutputLayerIfVisibleTest::kTransparentRegionHint =
Leon Scroggins III81aff792022-03-21 13:51:34 -04001497 Region(Rect(0, 0, 100, 100));
1498const Region OutputEnsureOutputLayerIfVisibleTest::kTransparentRegionHintTwo =
Leon Scroggins III7f7ad2c2022-03-17 17:06:20 -04001499 Region(Rect(25, 20, 50, 75));
Leon Scroggins III81aff792022-03-21 13:51:34 -04001500const Region OutputEnsureOutputLayerIfVisibleTest::kTransparentRegionHintTwo90Rotation =
Leon Scroggins III7f7ad2c2022-03-17 17:06:20 -04001501 Region(Rect(125, 25, 180, 50));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001502
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001503TEST_F(OutputEnsureOutputLayerIfVisibleTest, performsGeomLatchBeforeCheckingIfLayerIncluded) {
1504 EXPECT_CALL(mOutput, includesLayer(sp<LayerFE>(mLayer.layerFE))).WillOnce(Return(false));
Lloyd Piquede196652020-01-22 17:29:58 -08001505 EXPECT_CALL(*mLayer.layerFE,
1506 prepareCompositionState(compositionengine::LayerFE::StateSubset::BasicGeometry));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001507
1508 mGeomSnapshots.clear();
1509
Lloyd Piquede196652020-01-22 17:29:58 -08001510 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001511}
1512
1513TEST_F(OutputEnsureOutputLayerIfVisibleTest,
Dominik Laskowski29fa1462021-04-27 15:51:50 -07001514 skipsLatchIfAlreadyLatchedBeforeCheckingIfLayerIncluded) {
1515 EXPECT_CALL(mOutput, includesLayer(sp<LayerFE>(mLayer.layerFE))).WillOnce(Return(false));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001516
Lloyd Piquede196652020-01-22 17:29:58 -08001517 ensureOutputLayerIfVisible();
1518}
1519
1520TEST_F(OutputEnsureOutputLayerIfVisibleTest, takesEarlyOutIfLayerHasNoCompositionState) {
1521 EXPECT_CALL(*mLayer.layerFE, getCompositionState()).WillOnce(Return(nullptr));
1522
1523 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001524}
1525
1526TEST_F(OutputEnsureOutputLayerIfVisibleTest, takesEarlyOutIfLayerNotVisible) {
Lloyd Piquede196652020-01-22 17:29:58 -08001527 mLayer.layerFEState.isVisible = false;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001528
Lloyd Piquede196652020-01-22 17:29:58 -08001529 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001530}
1531
1532TEST_F(OutputEnsureOutputLayerIfVisibleTest, takesEarlyOutIfLayerHasEmptyVisibleRegion) {
Lloyd Piquede196652020-01-22 17:29:58 -08001533 mLayer.layerFEState.geomLayerBounds = FloatRect{0, 0, 0, 0};
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001534
Lloyd Piquede196652020-01-22 17:29:58 -08001535 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001536}
1537
Marin Shalamanove67fcd02020-07-01 13:25:38 +00001538TEST_F(OutputEnsureOutputLayerIfVisibleTest, takesNotSoEarlyOutifDrawRegionEmpty) {
Angel Aguayob084e0c2021-08-04 23:27:28 +00001539 mOutput.mState.displaySpace.setBounds(ui::Size(0, 0));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001540
Lloyd Piquede196652020-01-22 17:29:58 -08001541 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001542}
1543
1544TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1545 handlesCreatingOutputLayerForOpaqueDirtyNotRotatedLayer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001546 mLayer.layerFEState.isOpaque = true;
1547 mLayer.layerFEState.contentDirty = true;
1548 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001549
1550 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
Lloyd Piquede196652020-01-22 17:29:58 -08001551 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1552 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001553
Lloyd Piquede196652020-01-22 17:29:58 -08001554 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001555
1556 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1557 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1558 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1559
Lloyd Piquede196652020-01-22 17:29:58 -08001560 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1561 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1562 RegionEq(kFullBoundsNoRotation));
1563 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1564 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001565}
1566
1567TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1568 handlesUpdatingOutputLayerForOpaqueDirtyNotRotatedLayer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001569 mLayer.layerFEState.isOpaque = true;
1570 mLayer.layerFEState.contentDirty = true;
1571 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001572
Lloyd Piquede196652020-01-22 17:29:58 -08001573 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1574 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001575
Lloyd Piquede196652020-01-22 17:29:58 -08001576 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001577
1578 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1579 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1580 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1581
Lloyd Piquede196652020-01-22 17:29:58 -08001582 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1583 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1584 RegionEq(kFullBoundsNoRotation));
1585 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1586 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001587}
1588
1589TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1590 handlesCreatingOutputLayerForTransparentDirtyNotRotatedLayer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001591 mLayer.layerFEState.isOpaque = false;
1592 mLayer.layerFEState.contentDirty = true;
1593 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001594
1595 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
Lloyd Piquede196652020-01-22 17:29:58 -08001596 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1597 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001598
Lloyd Piquede196652020-01-22 17:29:58 -08001599 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001600
1601 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1602 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1603 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kEmptyRegion));
1604
Lloyd Piquede196652020-01-22 17:29:58 -08001605 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1606 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001607 RegionEq(kRightHalfBoundsNoRotation));
Lloyd Piquede196652020-01-22 17:29:58 -08001608 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1609 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001610}
1611
1612TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1613 handlesUpdatingOutputLayerForTransparentDirtyNotRotatedLayer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001614 mLayer.layerFEState.isOpaque = false;
1615 mLayer.layerFEState.contentDirty = true;
1616 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001617
Lloyd Piquede196652020-01-22 17:29:58 -08001618 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1619 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001620
Lloyd Piquede196652020-01-22 17:29:58 -08001621 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001622
1623 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1624 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1625 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kEmptyRegion));
1626
Lloyd Piquede196652020-01-22 17:29:58 -08001627 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1628 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001629 RegionEq(kRightHalfBoundsNoRotation));
Lloyd Piquede196652020-01-22 17:29:58 -08001630 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1631 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001632}
1633
1634TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1635 handlesCreatingOutputLayerForOpaqueNonDirtyNotRotatedLayer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001636 mLayer.layerFEState.isOpaque = true;
1637 mLayer.layerFEState.contentDirty = false;
1638 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001639
1640 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
Lloyd Piquede196652020-01-22 17:29:58 -08001641 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1642 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001643
Lloyd Piquede196652020-01-22 17:29:58 -08001644 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001645
1646 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1647 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1648 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1649
Lloyd Piquede196652020-01-22 17:29:58 -08001650 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1651 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1652 RegionEq(kFullBoundsNoRotation));
1653 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1654 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001655}
1656
1657TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1658 handlesUpdatingOutputLayerForOpaqueNonDirtyNotRotatedLayer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001659 mLayer.layerFEState.isOpaque = true;
1660 mLayer.layerFEState.contentDirty = false;
1661 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001662
Lloyd Piquede196652020-01-22 17:29:58 -08001663 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1664 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001665
Lloyd Piquede196652020-01-22 17:29:58 -08001666 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001667
1668 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kLowerHalfBoundsNoRotation));
1669 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1670 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1671
Lloyd Piquede196652020-01-22 17:29:58 -08001672 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1673 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1674 RegionEq(kFullBoundsNoRotation));
1675 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1676 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001677}
1678
1679TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1680 handlesCreatingOutputLayerForOpaqueDirtyRotated90Layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001681 mLayer.layerFEState.isOpaque = true;
1682 mLayer.layerFEState.contentDirty = true;
1683 mLayer.layerFEState.geomLayerBounds = FloatRect{0, 0, 200, 100};
1684 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_ROT_90, 100, 200);
1685 mLayer.outputLayerState.visibleRegion = Region(Rect(0, 0, 100, 100));
1686 mLayer.outputLayerState.coveredRegion = Region(Rect(100, 0, 200, 100));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001687
1688 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
Lloyd Piquede196652020-01-22 17:29:58 -08001689 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1690 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001691
Lloyd Piquede196652020-01-22 17:29:58 -08001692 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001693
1694 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1695 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1696 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1697
Lloyd Piquede196652020-01-22 17:29:58 -08001698 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1699 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1700 RegionEq(kFullBoundsNoRotation));
1701 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1702 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001703}
1704
1705TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1706 handlesUpdatingOutputLayerForOpaqueDirtyRotated90Layer) {
Lloyd Piquede196652020-01-22 17:29:58 -08001707 mLayer.layerFEState.isOpaque = true;
1708 mLayer.layerFEState.contentDirty = true;
1709 mLayer.layerFEState.geomLayerBounds = FloatRect{0, 0, 200, 100};
1710 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_ROT_90, 100, 200);
1711 mLayer.outputLayerState.visibleRegion = Region(Rect(0, 0, 100, 100));
1712 mLayer.outputLayerState.coveredRegion = Region(Rect(100, 0, 200, 100));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001713
Lloyd Piquede196652020-01-22 17:29:58 -08001714 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1715 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001716
Lloyd Piquede196652020-01-22 17:29:58 -08001717 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001718
1719 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1720 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1721 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1722
Lloyd Piquede196652020-01-22 17:29:58 -08001723 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1724 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1725 RegionEq(kFullBoundsNoRotation));
1726 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1727 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBoundsNoRotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001728}
1729
1730TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1731 handlesCreatingOutputLayerForOpaqueDirtyNotRotatedLayerRotatedOutput) {
Lloyd Piquede196652020-01-22 17:29:58 -08001732 mLayer.layerFEState.isOpaque = true;
1733 mLayer.layerFEState.contentDirty = true;
1734 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001735
Angel Aguayob084e0c2021-08-04 23:27:28 +00001736 mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 300, 200));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001737 mOutput.mState.transform = ui::Transform(TR_ROT_90, 200, 300);
1738
1739 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
Lloyd Piquede196652020-01-22 17:29:58 -08001740 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1741 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001742
Lloyd Piquede196652020-01-22 17:29:58 -08001743 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001744
1745 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1746 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1747 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1748
Lloyd Piquede196652020-01-22 17:29:58 -08001749 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1750 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1751 RegionEq(kFullBoundsNoRotation));
1752 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1753 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBounds90Rotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001754}
1755
1756TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1757 handlesUpdatingOutputLayerForOpaqueDirtyNotRotatedLayerRotatedOutput) {
Lloyd Piquede196652020-01-22 17:29:58 -08001758 mLayer.layerFEState.isOpaque = true;
1759 mLayer.layerFEState.contentDirty = true;
1760 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001761
Angel Aguayob084e0c2021-08-04 23:27:28 +00001762 mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 300, 200));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001763 mOutput.mState.transform = ui::Transform(TR_ROT_90, 200, 300);
1764
Lloyd Piquede196652020-01-22 17:29:58 -08001765 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1766 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001767
Lloyd Piquede196652020-01-22 17:29:58 -08001768 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001769
1770 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kFullBoundsNoRotation));
1771 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kFullBoundsNoRotation));
1772 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kFullBoundsNoRotation));
1773
Lloyd Piquede196652020-01-22 17:29:58 -08001774 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kFullBoundsNoRotation));
1775 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
1776 RegionEq(kFullBoundsNoRotation));
1777 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1778 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kFullBounds90Rotation));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001779}
1780
1781TEST_F(OutputEnsureOutputLayerIfVisibleTest,
1782 handlesCreatingOutputLayerForOpaqueDirtyArbitraryTransformLayer) {
1783 ui::Transform arbitraryTransform;
1784 arbitraryTransform.set(1, 1, -1, 1);
1785 arbitraryTransform.set(0, 100);
1786
Lloyd Piquede196652020-01-22 17:29:58 -08001787 mLayer.layerFEState.isOpaque = true;
1788 mLayer.layerFEState.contentDirty = true;
1789 mLayer.layerFEState.geomLayerBounds = FloatRect{0, 0, 100, 200};
1790 mLayer.layerFEState.geomLayerTransform = arbitraryTransform;
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001791
1792 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
Lloyd Piquede196652020-01-22 17:29:58 -08001793 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1794 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001795
Lloyd Piquede196652020-01-22 17:29:58 -08001796 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001797
1798 const Region kRegion = Region(Rect(0, 0, 300, 300));
1799 const Region kRegionClipped = Region(Rect(0, 0, 200, 300));
1800
1801 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kRegion));
1802 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kRegion));
1803 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kEmptyRegion));
1804
Lloyd Piquede196652020-01-22 17:29:58 -08001805 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kRegion));
1806 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion, RegionEq(kRegion));
1807 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kEmptyRegion));
1808 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion, RegionEq(kRegionClipped));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001809}
1810
1811TEST_F(OutputEnsureOutputLayerIfVisibleTest, coverageAccumulatesTest) {
Lloyd Piquede196652020-01-22 17:29:58 -08001812 mLayer.layerFEState.isOpaque = false;
1813 mLayer.layerFEState.contentDirty = true;
1814 mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001815
1816 mCoverageState.dirtyRegion = Region(Rect(0, 0, 500, 500));
1817 mCoverageState.aboveCoveredLayers = Region(Rect(50, 0, 150, 200));
1818 mCoverageState.aboveOpaqueLayers = Region(Rect(50, 0, 150, 200));
1819
Lloyd Piquede196652020-01-22 17:29:58 -08001820 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1821 .WillOnce(Return(&mLayer.outputLayer));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001822
Lloyd Piquede196652020-01-22 17:29:58 -08001823 ensureOutputLayerIfVisible();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001824
1825 const Region kExpectedDirtyRegion = Region(Rect(0, 0, 500, 500));
1826 const Region kExpectedAboveCoveredRegion = Region(Rect(0, 0, 150, 200));
1827 const Region kExpectedAboveOpaqueRegion = Region(Rect(50, 0, 150, 200));
1828 const Region kExpectedLayerVisibleRegion = Region(Rect(0, 0, 50, 200));
1829 const Region kExpectedLayerCoveredRegion = Region(Rect(50, 0, 100, 200));
1830 const Region kExpectedLayerVisibleNonTransparentRegion = Region(Rect(0, 100, 50, 200));
1831
1832 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kExpectedDirtyRegion));
1833 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kExpectedAboveCoveredRegion));
1834 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kExpectedAboveOpaqueRegion));
1835
Lloyd Piquede196652020-01-22 17:29:58 -08001836 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kExpectedLayerVisibleRegion));
1837 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001838 RegionEq(kExpectedLayerVisibleNonTransparentRegion));
Lloyd Piquede196652020-01-22 17:29:58 -08001839 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kExpectedLayerCoveredRegion));
1840 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion,
1841 RegionEq(kExpectedLayerVisibleRegion));
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08001842}
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001843
Vishnu Naira483b4a2019-12-12 15:07:52 -08001844TEST_F(OutputEnsureOutputLayerIfVisibleTest, coverageAccumulatesWithShadowsTest) {
1845 ui::Transform translate;
1846 translate.set(50, 50);
Lloyd Piquede196652020-01-22 17:29:58 -08001847 mLayer.layerFEState.geomLayerTransform = translate;
1848 mLayer.layerFEState.shadowRadius = 10.0f;
Vishnu Naira483b4a2019-12-12 15:07:52 -08001849
1850 mCoverageState.dirtyRegion = Region(Rect(0, 0, 500, 500));
1851 // half of the layer including the casting shadow is covered and opaque
1852 mCoverageState.aboveCoveredLayers = Region(Rect(40, 40, 100, 260));
1853 mCoverageState.aboveOpaqueLayers = Region(Rect(40, 40, 100, 260));
1854
Lloyd Piquede196652020-01-22 17:29:58 -08001855 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1856 .WillOnce(Return(&mLayer.outputLayer));
Vishnu Naira483b4a2019-12-12 15:07:52 -08001857
Lloyd Piquede196652020-01-22 17:29:58 -08001858 ensureOutputLayerIfVisible();
Vishnu Naira483b4a2019-12-12 15:07:52 -08001859
1860 const Region kExpectedDirtyRegion = Region(Rect(0, 0, 500, 500));
1861 const Region kExpectedAboveCoveredRegion = Region(Rect(40, 40, 160, 260));
1862 // add starting opaque region to the opaque half of the casting layer bounds
1863 const Region kExpectedAboveOpaqueRegion =
1864 Region(Rect(40, 40, 100, 260)).orSelf(Rect(100, 50, 150, 250));
1865 const Region kExpectedLayerVisibleRegion = Region(Rect(100, 40, 160, 260));
1866 const Region kExpectedoutputSpaceLayerVisibleRegion = Region(Rect(100, 50, 150, 250));
1867 const Region kExpectedLayerCoveredRegion = Region(Rect(40, 40, 100, 260));
1868 const Region kExpectedLayerVisibleNonTransparentRegion = Region(Rect(100, 40, 160, 260));
1869 const Region kExpectedLayerShadowRegion =
1870 Region(Rect(40, 40, 160, 260)).subtractSelf(Rect(50, 50, 150, 250));
1871
1872 EXPECT_THAT(mCoverageState.dirtyRegion, RegionEq(kExpectedDirtyRegion));
1873 EXPECT_THAT(mCoverageState.aboveCoveredLayers, RegionEq(kExpectedAboveCoveredRegion));
1874 EXPECT_THAT(mCoverageState.aboveOpaqueLayers, RegionEq(kExpectedAboveOpaqueRegion));
1875
Lloyd Piquede196652020-01-22 17:29:58 -08001876 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kExpectedLayerVisibleRegion));
1877 EXPECT_THAT(mLayer.outputLayerState.visibleNonTransparentRegion,
Vishnu Naira483b4a2019-12-12 15:07:52 -08001878 RegionEq(kExpectedLayerVisibleNonTransparentRegion));
Lloyd Piquede196652020-01-22 17:29:58 -08001879 EXPECT_THAT(mLayer.outputLayerState.coveredRegion, RegionEq(kExpectedLayerCoveredRegion));
1880 EXPECT_THAT(mLayer.outputLayerState.outputSpaceVisibleRegion,
Vishnu Naira483b4a2019-12-12 15:07:52 -08001881 RegionEq(kExpectedoutputSpaceLayerVisibleRegion));
Lloyd Piquede196652020-01-22 17:29:58 -08001882 EXPECT_THAT(mLayer.outputLayerState.shadowRegion, RegionEq(kExpectedLayerShadowRegion));
Vishnu Naira483b4a2019-12-12 15:07:52 -08001883 EXPECT_FALSE(kExpectedLayerVisibleRegion.subtract(kExpectedLayerShadowRegion).isEmpty());
1884}
1885
1886TEST_F(OutputEnsureOutputLayerIfVisibleTest, shadowRegionOnlyTest) {
1887 ui::Transform translate;
1888 translate.set(50, 50);
Lloyd Piquede196652020-01-22 17:29:58 -08001889 mLayer.layerFEState.geomLayerTransform = translate;
1890 mLayer.layerFEState.shadowRadius = 10.0f;
Vishnu Naira483b4a2019-12-12 15:07:52 -08001891
1892 mCoverageState.dirtyRegion = Region(Rect(0, 0, 500, 500));
1893 // Casting layer is covered by an opaque region leaving only part of its shadow to be drawn
1894 mCoverageState.aboveCoveredLayers = Region(Rect(40, 40, 150, 260));
1895 mCoverageState.aboveOpaqueLayers = Region(Rect(40, 40, 150, 260));
1896
Lloyd Piquede196652020-01-22 17:29:58 -08001897 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
1898 .WillOnce(Return(&mLayer.outputLayer));
Vishnu Naira483b4a2019-12-12 15:07:52 -08001899
Lloyd Piquede196652020-01-22 17:29:58 -08001900 ensureOutputLayerIfVisible();
Vishnu Naira483b4a2019-12-12 15:07:52 -08001901
1902 const Region kExpectedLayerVisibleRegion = Region(Rect(150, 40, 160, 260));
1903 const Region kExpectedLayerShadowRegion =
1904 Region(Rect(40, 40, 160, 260)).subtractSelf(Rect(50, 50, 150, 250));
1905
Lloyd Piquede196652020-01-22 17:29:58 -08001906 EXPECT_THAT(mLayer.outputLayerState.visibleRegion, RegionEq(kExpectedLayerVisibleRegion));
1907 EXPECT_THAT(mLayer.outputLayerState.shadowRegion, RegionEq(kExpectedLayerShadowRegion));
Vishnu Naira483b4a2019-12-12 15:07:52 -08001908 EXPECT_TRUE(kExpectedLayerVisibleRegion.subtract(kExpectedLayerShadowRegion).isEmpty());
1909}
1910
Marin Shalamanove67fcd02020-07-01 13:25:38 +00001911TEST_F(OutputEnsureOutputLayerIfVisibleTest, takesNotSoEarlyOutifLayerWithShadowIsCovered) {
Vishnu Naira483b4a2019-12-12 15:07:52 -08001912 ui::Transform translate;
1913 translate.set(50, 50);
Lloyd Piquede196652020-01-22 17:29:58 -08001914 mLayer.layerFEState.geomLayerTransform = translate;
1915 mLayer.layerFEState.shadowRadius = 10.0f;
Vishnu Naira483b4a2019-12-12 15:07:52 -08001916
1917 mCoverageState.dirtyRegion = Region(Rect(0, 0, 500, 500));
1918 // Casting layer and its shadows are covered by an opaque region
1919 mCoverageState.aboveCoveredLayers = Region(Rect(40, 40, 160, 260));
1920 mCoverageState.aboveOpaqueLayers = Region(Rect(40, 40, 160, 260));
1921
Lloyd Piquede196652020-01-22 17:29:58 -08001922 ensureOutputLayerIfVisible();
Vishnu Naira483b4a2019-12-12 15:07:52 -08001923}
1924
Leon Scroggins III9a0afda2022-01-11 16:53:09 -05001925TEST_F(OutputEnsureOutputLayerIfVisibleTest, displayDecorSetsBlockingFromTransparentRegion) {
1926 mLayer.layerFEState.isOpaque = false;
1927 mLayer.layerFEState.contentDirty = true;
1928 mLayer.layerFEState.compositionType =
1929 aidl::android::hardware::graphics::composer3::Composition::DISPLAY_DECORATION;
1930
1931 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
1932 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1933 .WillOnce(Return(&mLayer.outputLayer));
1934 ensureOutputLayerIfVisible();
1935
1936 EXPECT_THAT(mLayer.outputLayerState.outputSpaceBlockingRegionHint,
1937 RegionEq(kTransparentRegionHint));
1938}
1939
1940TEST_F(OutputEnsureOutputLayerIfVisibleTest, normalLayersDoNotSetBlockingRegion) {
1941 mLayer.layerFEState.isOpaque = false;
1942 mLayer.layerFEState.contentDirty = true;
1943
1944 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
1945 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1946 .WillOnce(Return(&mLayer.outputLayer));
1947 ensureOutputLayerIfVisible();
1948
1949 EXPECT_THAT(mLayer.outputLayerState.outputSpaceBlockingRegionHint, RegionEq(Region()));
1950}
1951
Leon Scroggins III7f7ad2c2022-03-17 17:06:20 -04001952TEST_F(OutputEnsureOutputLayerIfVisibleTest, blockingRegionIsInOutputSpace) {
1953 mLayer.layerFEState.isOpaque = false;
1954 mLayer.layerFEState.contentDirty = true;
1955 mLayer.layerFEState.compositionType =
1956 aidl::android::hardware::graphics::composer3::Composition::DISPLAY_DECORATION;
Leon Scroggins III81aff792022-03-21 13:51:34 -04001957 mLayer.layerFEState.transparentRegionHint = kTransparentRegionHintTwo;
Leon Scroggins III7f7ad2c2022-03-17 17:06:20 -04001958
1959 mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 300, 200));
1960 mOutput.mState.transform = ui::Transform(TR_ROT_90, 200, 300);
1961
1962 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
1963 EXPECT_CALL(mOutput, ensureOutputLayer(Eq(std::nullopt), Eq(mLayer.layerFE)))
1964 .WillOnce(Return(&mLayer.outputLayer));
1965 ensureOutputLayerIfVisible();
1966
1967 EXPECT_THAT(mLayer.outputLayerState.outputSpaceBlockingRegionHint,
Leon Scroggins III81aff792022-03-21 13:51:34 -04001968 RegionEq(kTransparentRegionHintTwo90Rotation));
Leon Scroggins III7f7ad2c2022-03-17 17:06:20 -04001969}
1970
Lloyd Piqueb62cebc2019-11-20 18:31:52 -08001971/*
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001972 * Output::present()
1973 */
1974
1975struct OutputPresentTest : public testing::Test {
1976 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08001977 // Sets up the helper functions called by the function under test to use
1978 // mock implementations.
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001979 MOCK_METHOD1(updateColorProfile, void(const compositionengine::CompositionRefreshArgs&));
Dan Stoza269dc4d2021-01-15 15:07:43 -08001980 MOCK_METHOD1(updateCompositionState,
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001981 void(const compositionengine::CompositionRefreshArgs&));
Dan Stoza269dc4d2021-01-15 15:07:43 -08001982 MOCK_METHOD0(planComposition, void());
1983 MOCK_METHOD1(writeCompositionState, void(const compositionengine::CompositionRefreshArgs&));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001984 MOCK_METHOD1(setColorTransform, void(const compositionengine::CompositionRefreshArgs&));
1985 MOCK_METHOD0(beginFrame, void());
1986 MOCK_METHOD0(prepareFrame, void());
Vishnu Naira3140382022-02-24 14:07:11 -08001987 MOCK_METHOD1(prepareFrameAsync, GpuCompositionResult(const CompositionRefreshArgs&));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001988 MOCK_METHOD1(devOptRepaintFlash, void(const compositionengine::CompositionRefreshArgs&));
Vishnu Naira3140382022-02-24 14:07:11 -08001989 MOCK_METHOD2(finishFrame,
1990 void(const compositionengine::CompositionRefreshArgs&,
1991 GpuCompositionResult&&));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001992 MOCK_METHOD0(postFramebuffer, void());
Alec Mouriaa831582021-06-07 16:23:01 -07001993 MOCK_METHOD1(renderCachedSets, void(const compositionengine::CompositionRefreshArgs&));
Vishnu Naira3140382022-02-24 14:07:11 -08001994 MOCK_METHOD1(canPredictCompositionStrategy, bool(const CompositionRefreshArgs&));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08001995 };
1996
1997 StrictMock<OutputPartialMock> mOutput;
1998};
1999
2000TEST_F(OutputPresentTest, justInvokesChildFunctionsInSequence) {
2001 CompositionRefreshArgs args;
2002
2003 InSequence seq;
2004 EXPECT_CALL(mOutput, updateColorProfile(Ref(args)));
Dan Stoza269dc4d2021-01-15 15:07:43 -08002005 EXPECT_CALL(mOutput, updateCompositionState(Ref(args)));
2006 EXPECT_CALL(mOutput, planComposition());
2007 EXPECT_CALL(mOutput, writeCompositionState(Ref(args)));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08002008 EXPECT_CALL(mOutput, setColorTransform(Ref(args)));
2009 EXPECT_CALL(mOutput, beginFrame());
Vishnu Naira3140382022-02-24 14:07:11 -08002010 EXPECT_CALL(mOutput, canPredictCompositionStrategy(Ref(args))).WillOnce(Return(false));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08002011 EXPECT_CALL(mOutput, prepareFrame());
2012 EXPECT_CALL(mOutput, devOptRepaintFlash(Ref(args)));
Vishnu Naira3140382022-02-24 14:07:11 -08002013 EXPECT_CALL(mOutput, finishFrame(Ref(args), _));
2014 EXPECT_CALL(mOutput, postFramebuffer());
2015 EXPECT_CALL(mOutput, renderCachedSets(Ref(args)));
2016
2017 mOutput.present(args);
2018}
2019
2020TEST_F(OutputPresentTest, predictingCompositionStrategyInvokesPrepareFrameAsync) {
2021 CompositionRefreshArgs args;
2022
2023 InSequence seq;
2024 EXPECT_CALL(mOutput, updateColorProfile(Ref(args)));
2025 EXPECT_CALL(mOutput, updateCompositionState(Ref(args)));
2026 EXPECT_CALL(mOutput, planComposition());
2027 EXPECT_CALL(mOutput, writeCompositionState(Ref(args)));
2028 EXPECT_CALL(mOutput, setColorTransform(Ref(args)));
2029 EXPECT_CALL(mOutput, beginFrame());
2030 EXPECT_CALL(mOutput, canPredictCompositionStrategy(Ref(args))).WillOnce(Return(true));
2031 EXPECT_CALL(mOutput, prepareFrameAsync(Ref(args)));
2032 EXPECT_CALL(mOutput, devOptRepaintFlash(Ref(args)));
2033 EXPECT_CALL(mOutput, finishFrame(Ref(args), _));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08002034 EXPECT_CALL(mOutput, postFramebuffer());
Alec Mouriaa831582021-06-07 16:23:01 -07002035 EXPECT_CALL(mOutput, renderCachedSets(Ref(args)));
Lloyd Piquefaa3f192019-11-14 14:05:09 -08002036
2037 mOutput.present(args);
2038}
2039
2040/*
2041 * Output::updateColorProfile()
2042 */
2043
Lloyd Pique17ca7422019-11-14 14:24:10 -08002044struct OutputUpdateColorProfileTest : public testing::Test {
2045 using TestType = OutputUpdateColorProfileTest;
2046
2047 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08002048 // Sets up the helper functions called by the function under test to use
2049 // mock implementations.
Lloyd Pique17ca7422019-11-14 14:24:10 -08002050 MOCK_METHOD1(setColorProfile, void(const ColorProfile&));
2051 };
2052
2053 struct Layer {
2054 Layer() {
Ady Abrahameca9d752021-03-03 12:20:00 -08002055 EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));
2056 EXPECT_CALL(*mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002057 }
2058
2059 StrictMock<mock::OutputLayer> mOutputLayer;
Ady Abrahameca9d752021-03-03 12:20:00 -08002060 sp<StrictMock<mock::LayerFE>> mLayerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Pique17ca7422019-11-14 14:24:10 -08002061 LayerFECompositionState mLayerFEState;
2062 };
2063
2064 OutputUpdateColorProfileTest() {
2065 mOutput.setDisplayColorProfileForTest(
2066 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
2067 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
2068
2069 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0))
2070 .WillRepeatedly(Return(&mLayer1.mOutputLayer));
2071 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1))
2072 .WillRepeatedly(Return(&mLayer2.mOutputLayer));
2073 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(2))
2074 .WillRepeatedly(Return(&mLayer3.mOutputLayer));
2075 }
2076
2077 struct ExecuteState : public CallOrderStateMachineHelper<TestType, ExecuteState> {
2078 void execute() { getInstance()->mOutput.updateColorProfile(getInstance()->mRefreshArgs); }
2079 };
2080
2081 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
2082 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
2083 StrictMock<OutputPartialMock> mOutput;
2084
2085 Layer mLayer1;
2086 Layer mLayer2;
2087 Layer mLayer3;
2088
2089 CompositionRefreshArgs mRefreshArgs;
2090};
2091
2092// TODO(b/144522012): Refactor Output::updateColorProfile and the related code
2093// to make it easier to write unit tests.
2094
2095TEST_F(OutputUpdateColorProfileTest, setsAColorProfileWhenUnmanaged) {
2096 // When the outputColorSetting is set to kUnmanaged, the implementation sets
2097 // a simple default color profile without looking at anything else.
2098
Lloyd Pique0a456232020-01-16 17:51:13 -08002099 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(3u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002100 EXPECT_CALL(mOutput,
2101 setColorProfile(ColorProfileEq(
2102 ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
2103 ui::RenderIntent::COLORIMETRIC, ui::Dataspace::UNKNOWN})));
2104
2105 mRefreshArgs.outputColorSetting = OutputColorSetting::kUnmanaged;
2106 mRefreshArgs.colorSpaceAgnosticDataspace = ui::Dataspace::UNKNOWN;
2107
2108 mOutput.updateColorProfile(mRefreshArgs);
2109}
2110
2111struct OutputUpdateColorProfileTest_GetBestColorModeResultBecomesSetProfile
2112 : public OutputUpdateColorProfileTest {
2113 OutputUpdateColorProfileTest_GetBestColorModeResultBecomesSetProfile() {
Lloyd Pique0a456232020-01-16 17:51:13 -08002114 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002115 mRefreshArgs.outputColorSetting = OutputColorSetting::kEnhanced;
2116 mRefreshArgs.colorSpaceAgnosticDataspace = ui::Dataspace::UNKNOWN;
2117 }
2118
2119 struct ExpectBestColorModeCallResultUsedToSetColorProfileState
2120 : public CallOrderStateMachineHelper<
2121 TestType, ExpectBestColorModeCallResultUsedToSetColorProfileState> {
2122 [[nodiscard]] auto expectBestColorModeCallResultUsedToSetColorProfile(
2123 ui::ColorMode colorMode, ui::Dataspace dataspace, ui::RenderIntent renderIntent) {
2124 EXPECT_CALL(*getInstance()->mDisplayColorProfile,
2125 getBestColorMode(ui::Dataspace::V0_SRGB, ui::RenderIntent::ENHANCE, _, _,
2126 _))
2127 .WillOnce(DoAll(SetArgPointee<2>(dataspace), SetArgPointee<3>(colorMode),
2128 SetArgPointee<4>(renderIntent)));
2129 EXPECT_CALL(getInstance()->mOutput,
2130 setColorProfile(
2131 ColorProfileEq(ColorProfile{colorMode, dataspace, renderIntent,
2132 ui::Dataspace::UNKNOWN})));
2133 return nextState<ExecuteState>();
2134 }
2135 };
2136
2137 // Call this member function to start using the mini-DSL defined above.
2138 [[nodiscard]] auto verify() {
2139 return ExpectBestColorModeCallResultUsedToSetColorProfileState::make(this);
2140 }
2141};
2142
2143TEST_F(OutputUpdateColorProfileTest_GetBestColorModeResultBecomesSetProfile,
2144 Native_Unknown_Colorimetric_Set) {
2145 verify().expectBestColorModeCallResultUsedToSetColorProfile(ui::ColorMode::NATIVE,
2146 ui::Dataspace::UNKNOWN,
2147 ui::RenderIntent::COLORIMETRIC)
2148 .execute();
2149}
2150
2151TEST_F(OutputUpdateColorProfileTest_GetBestColorModeResultBecomesSetProfile,
2152 DisplayP3_DisplayP3_Enhance_Set) {
2153 verify().expectBestColorModeCallResultUsedToSetColorProfile(ui::ColorMode::DISPLAY_P3,
2154 ui::Dataspace::DISPLAY_P3,
2155 ui::RenderIntent::ENHANCE)
2156 .execute();
2157}
2158
2159struct OutputUpdateColorProfileTest_ColorSpaceAgnosticeDataspaceAffectsSetColorProfile
2160 : public OutputUpdateColorProfileTest {
2161 OutputUpdateColorProfileTest_ColorSpaceAgnosticeDataspaceAffectsSetColorProfile() {
Lloyd Pique0a456232020-01-16 17:51:13 -08002162 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(0u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002163 EXPECT_CALL(*mDisplayColorProfile,
2164 getBestColorMode(ui::Dataspace::V0_SRGB, ui::RenderIntent::ENHANCE, _, _, _))
2165 .WillRepeatedly(DoAll(SetArgPointee<2>(ui::Dataspace::UNKNOWN),
2166 SetArgPointee<3>(ui::ColorMode::NATIVE),
2167 SetArgPointee<4>(ui::RenderIntent::COLORIMETRIC)));
2168 mRefreshArgs.outputColorSetting = OutputColorSetting::kEnhanced;
2169 }
2170
2171 struct IfColorSpaceAgnosticDataspaceSetToState
2172 : public CallOrderStateMachineHelper<TestType, IfColorSpaceAgnosticDataspaceSetToState> {
2173 [[nodiscard]] auto ifColorSpaceAgnosticDataspaceSetTo(ui::Dataspace dataspace) {
2174 getInstance()->mRefreshArgs.colorSpaceAgnosticDataspace = dataspace;
2175 return nextState<ThenExpectSetColorProfileCallUsesColorSpaceAgnosticDataspaceState>();
2176 }
2177 };
2178
2179 struct ThenExpectSetColorProfileCallUsesColorSpaceAgnosticDataspaceState
2180 : public CallOrderStateMachineHelper<
2181 TestType, ThenExpectSetColorProfileCallUsesColorSpaceAgnosticDataspaceState> {
2182 [[nodiscard]] auto thenExpectSetColorProfileCallUsesColorSpaceAgnosticDataspace(
2183 ui::Dataspace dataspace) {
2184 EXPECT_CALL(getInstance()->mOutput,
2185 setColorProfile(ColorProfileEq(
2186 ColorProfile{ui::ColorMode::NATIVE, ui::Dataspace::UNKNOWN,
2187 ui::RenderIntent::COLORIMETRIC, dataspace})));
2188 return nextState<ExecuteState>();
2189 }
2190 };
2191
2192 // Call this member function to start using the mini-DSL defined above.
2193 [[nodiscard]] auto verify() { return IfColorSpaceAgnosticDataspaceSetToState::make(this); }
2194};
2195
2196TEST_F(OutputUpdateColorProfileTest_ColorSpaceAgnosticeDataspaceAffectsSetColorProfile, DisplayP3) {
2197 verify().ifColorSpaceAgnosticDataspaceSetTo(ui::Dataspace::DISPLAY_P3)
2198 .thenExpectSetColorProfileCallUsesColorSpaceAgnosticDataspace(ui::Dataspace::DISPLAY_P3)
2199 .execute();
2200}
2201
2202TEST_F(OutputUpdateColorProfileTest_ColorSpaceAgnosticeDataspaceAffectsSetColorProfile, V0_SRGB) {
2203 verify().ifColorSpaceAgnosticDataspaceSetTo(ui::Dataspace::V0_SRGB)
2204 .thenExpectSetColorProfileCallUsesColorSpaceAgnosticDataspace(ui::Dataspace::V0_SRGB)
2205 .execute();
2206}
2207
2208struct OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference
2209 : public OutputUpdateColorProfileTest {
2210 // Internally the implementation looks through the dataspaces of all the
2211 // visible layers. The topmost one that also has an actual dataspace
2212 // preference set is used to drive subsequent choices.
2213
2214 OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference() {
2215 mRefreshArgs.outputColorSetting = OutputColorSetting::kEnhanced;
2216 mRefreshArgs.colorSpaceAgnosticDataspace = ui::Dataspace::UNKNOWN;
2217
Lloyd Pique0a456232020-01-16 17:51:13 -08002218 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(3u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002219 EXPECT_CALL(mOutput, setColorProfile(_)).WillRepeatedly(Return());
2220 }
2221
2222 struct IfTopLayerDataspaceState
2223 : public CallOrderStateMachineHelper<TestType, IfTopLayerDataspaceState> {
2224 [[nodiscard]] auto ifTopLayerIs(ui::Dataspace dataspace) {
2225 getInstance()->mLayer3.mLayerFEState.dataspace = dataspace;
2226 return nextState<AndIfMiddleLayerDataspaceState>();
2227 }
2228 [[nodiscard]] auto ifTopLayerHasNoPreference() {
2229 return ifTopLayerIs(ui::Dataspace::UNKNOWN);
2230 }
2231 };
2232
2233 struct AndIfMiddleLayerDataspaceState
2234 : public CallOrderStateMachineHelper<TestType, AndIfMiddleLayerDataspaceState> {
2235 [[nodiscard]] auto andIfMiddleLayerIs(ui::Dataspace dataspace) {
2236 getInstance()->mLayer2.mLayerFEState.dataspace = dataspace;
2237 return nextState<AndIfBottomLayerDataspaceState>();
2238 }
2239 [[nodiscard]] auto andIfMiddleLayerHasNoPreference() {
2240 return andIfMiddleLayerIs(ui::Dataspace::UNKNOWN);
2241 }
2242 };
2243
2244 struct AndIfBottomLayerDataspaceState
2245 : public CallOrderStateMachineHelper<TestType, AndIfBottomLayerDataspaceState> {
2246 [[nodiscard]] auto andIfBottomLayerIs(ui::Dataspace dataspace) {
2247 getInstance()->mLayer1.mLayerFEState.dataspace = dataspace;
2248 return nextState<ThenExpectBestColorModeCallUsesState>();
2249 }
2250 [[nodiscard]] auto andIfBottomLayerHasNoPreference() {
2251 return andIfBottomLayerIs(ui::Dataspace::UNKNOWN);
2252 }
2253 };
2254
2255 struct ThenExpectBestColorModeCallUsesState
2256 : public CallOrderStateMachineHelper<TestType, ThenExpectBestColorModeCallUsesState> {
2257 [[nodiscard]] auto thenExpectBestColorModeCallUses(ui::Dataspace dataspace) {
2258 EXPECT_CALL(*getInstance()->mDisplayColorProfile,
2259 getBestColorMode(dataspace, _, _, _, _));
2260 return nextState<ExecuteState>();
2261 }
2262 };
2263
2264 // Call this member function to start using the mini-DSL defined above.
2265 [[nodiscard]] auto verify() { return IfTopLayerDataspaceState::make(this); }
2266};
2267
2268TEST_F(OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference,
2269 noStrongLayerPrefenceUses_V0_SRGB) {
2270 // If none of the layers indicate a preference, then V0_SRGB is the
2271 // preferred choice (subject to additional checks).
2272 verify().ifTopLayerHasNoPreference()
2273 .andIfMiddleLayerHasNoPreference()
2274 .andIfBottomLayerHasNoPreference()
2275 .thenExpectBestColorModeCallUses(ui::Dataspace::V0_SRGB)
2276 .execute();
2277}
2278
2279TEST_F(OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference,
2280 ifTopmostUses_DisplayP3_Then_DisplayP3_Chosen) {
2281 // If only the topmost layer has a preference, then that is what is chosen.
2282 verify().ifTopLayerIs(ui::Dataspace::DISPLAY_P3)
2283 .andIfMiddleLayerHasNoPreference()
2284 .andIfBottomLayerHasNoPreference()
2285 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_P3)
2286 .execute();
2287}
2288
2289TEST_F(OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference,
2290 ifMiddleUses_DisplayP3_Then_DisplayP3_Chosen) {
2291 // If only the middle layer has a preference, that that is what is chosen.
2292 verify().ifTopLayerHasNoPreference()
2293 .andIfMiddleLayerIs(ui::Dataspace::DISPLAY_P3)
2294 .andIfBottomLayerHasNoPreference()
2295 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_P3)
2296 .execute();
2297}
2298
2299TEST_F(OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference,
2300 ifBottomUses_DisplayP3_Then_DisplayP3_Chosen) {
2301 // If only the middle layer has a preference, that that is what is chosen.
2302 verify().ifTopLayerHasNoPreference()
2303 .andIfMiddleLayerHasNoPreference()
2304 .andIfBottomLayerIs(ui::Dataspace::DISPLAY_P3)
2305 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_P3)
2306 .execute();
2307}
2308
2309TEST_F(OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference,
2310 ifTopUses_DisplayBT2020_AndBottomUses_DisplayP3_Then_DisplayBT2020_Chosen) {
2311 // If multiple layers have a preference, the topmost value is what is used.
2312 verify().ifTopLayerIs(ui::Dataspace::DISPLAY_BT2020)
2313 .andIfMiddleLayerHasNoPreference()
2314 .andIfBottomLayerIs(ui::Dataspace::DISPLAY_P3)
2315 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_BT2020)
2316 .execute();
2317}
2318
2319TEST_F(OutputUpdateColorProfileTest_TopmostLayerPreferenceSetsOutputPreference,
2320 ifTopUses_DisplayP3_AndBottomUses_V0_SRGB_Then_DisplayP3_Chosen) {
2321 // If multiple layers have a preference, the topmost value is what is used.
2322 verify().ifTopLayerIs(ui::Dataspace::DISPLAY_P3)
2323 .andIfMiddleLayerHasNoPreference()
2324 .andIfBottomLayerIs(ui::Dataspace::DISPLAY_BT2020)
2325 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_P3)
2326 .execute();
2327}
2328
2329struct OutputUpdateColorProfileTest_ForceOutputColorOverrides
2330 : public OutputUpdateColorProfileTest {
2331 // If CompositionRefreshArgs::forceOutputColorMode is set to some specific
2332 // values, it overrides the layer dataspace choice.
2333
2334 OutputUpdateColorProfileTest_ForceOutputColorOverrides() {
2335 mRefreshArgs.outputColorSetting = OutputColorSetting::kEnhanced;
2336 mRefreshArgs.colorSpaceAgnosticDataspace = ui::Dataspace::UNKNOWN;
2337
2338 mLayer1.mLayerFEState.dataspace = ui::Dataspace::DISPLAY_BT2020;
2339
Lloyd Pique0a456232020-01-16 17:51:13 -08002340 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(1u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002341 EXPECT_CALL(mOutput, setColorProfile(_)).WillRepeatedly(Return());
2342 }
2343
2344 struct IfForceOutputColorModeState
2345 : public CallOrderStateMachineHelper<TestType, IfForceOutputColorModeState> {
2346 [[nodiscard]] auto ifForceOutputColorMode(ui::ColorMode colorMode) {
2347 getInstance()->mRefreshArgs.forceOutputColorMode = colorMode;
2348 return nextState<ThenExpectBestColorModeCallUsesState>();
2349 }
2350 [[nodiscard]] auto ifNoOverride() { return ifForceOutputColorMode(ui::ColorMode::NATIVE); }
2351 };
2352
2353 struct ThenExpectBestColorModeCallUsesState
2354 : public CallOrderStateMachineHelper<TestType, ThenExpectBestColorModeCallUsesState> {
2355 [[nodiscard]] auto thenExpectBestColorModeCallUses(ui::Dataspace dataspace) {
2356 EXPECT_CALL(*getInstance()->mDisplayColorProfile,
2357 getBestColorMode(dataspace, _, _, _, _));
2358 return nextState<ExecuteState>();
2359 }
2360 };
2361
2362 // Call this member function to start using the mini-DSL defined above.
2363 [[nodiscard]] auto verify() { return IfForceOutputColorModeState::make(this); }
2364};
2365
2366TEST_F(OutputUpdateColorProfileTest_ForceOutputColorOverrides, NoOverride_DoesNotOverride) {
2367 // By default the layer state is used to set the preferred dataspace
2368 verify().ifNoOverride()
2369 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_BT2020)
2370 .execute();
2371}
2372
2373TEST_F(OutputUpdateColorProfileTest_ForceOutputColorOverrides, SRGB_Override_USES_V0_SRGB) {
2374 // Setting ui::ColorMode::SRGB overrides it with ui::Dataspace::V0_SRGB
2375 verify().ifForceOutputColorMode(ui::ColorMode::SRGB)
2376 .thenExpectBestColorModeCallUses(ui::Dataspace::V0_SRGB)
2377 .execute();
2378}
2379
2380TEST_F(OutputUpdateColorProfileTest_ForceOutputColorOverrides, DisplayP3_Override_Uses_DisplayP3) {
2381 // Setting ui::ColorMode::DISPLAY_P3 overrides it with ui::Dataspace::DISPLAY_P3
2382 verify().ifForceOutputColorMode(ui::ColorMode::DISPLAY_P3)
2383 .thenExpectBestColorModeCallUses(ui::Dataspace::DISPLAY_P3)
2384 .execute();
2385}
2386
2387// HDR output requires all layers to be compatible with the chosen HDR
2388// dataspace, along with there being proper support.
2389struct OutputUpdateColorProfileTest_Hdr : public OutputUpdateColorProfileTest {
2390 OutputUpdateColorProfileTest_Hdr() {
2391 mRefreshArgs.outputColorSetting = OutputColorSetting::kEnhanced;
2392 mRefreshArgs.colorSpaceAgnosticDataspace = ui::Dataspace::UNKNOWN;
Lloyd Pique0a456232020-01-16 17:51:13 -08002393 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(2u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002394 EXPECT_CALL(mOutput, setColorProfile(_)).WillRepeatedly(Return());
2395 }
2396
2397 static constexpr ui::Dataspace kNonHdrDataspace = ui::Dataspace::DISPLAY_P3;
2398 static constexpr ui::Dataspace BT2020_PQ = ui::Dataspace::BT2020_PQ;
2399 static constexpr ui::Dataspace BT2020_HLG = ui::Dataspace::BT2020_HLG;
2400 static constexpr ui::Dataspace DISPLAY_P3 = ui::Dataspace::DISPLAY_P3;
2401
2402 struct IfTopLayerDataspaceState
2403 : public CallOrderStateMachineHelper<TestType, IfTopLayerDataspaceState> {
2404 [[nodiscard]] auto ifTopLayerIs(ui::Dataspace dataspace) {
2405 getInstance()->mLayer2.mLayerFEState.dataspace = dataspace;
2406 return nextState<AndTopLayerCompositionTypeState>();
2407 }
2408 [[nodiscard]] auto ifTopLayerIsNotHdr() { return ifTopLayerIs(kNonHdrDataspace); }
2409 };
2410
2411 struct AndTopLayerCompositionTypeState
2412 : public CallOrderStateMachineHelper<TestType, AndTopLayerCompositionTypeState> {
2413 [[nodiscard]] auto andTopLayerIsREComposed(bool renderEngineComposed) {
2414 getInstance()->mLayer2.mLayerFEState.forceClientComposition = renderEngineComposed;
2415 return nextState<AndIfBottomLayerDataspaceState>();
2416 }
2417 };
2418
2419 struct AndIfBottomLayerDataspaceState
2420 : public CallOrderStateMachineHelper<TestType, AndIfBottomLayerDataspaceState> {
2421 [[nodiscard]] auto andIfBottomLayerIs(ui::Dataspace dataspace) {
2422 getInstance()->mLayer1.mLayerFEState.dataspace = dataspace;
2423 return nextState<AndBottomLayerCompositionTypeState>();
2424 }
2425 [[nodiscard]] auto andIfBottomLayerIsNotHdr() {
2426 return andIfBottomLayerIs(kNonHdrDataspace);
2427 }
2428 };
2429
2430 struct AndBottomLayerCompositionTypeState
2431 : public CallOrderStateMachineHelper<TestType, AndBottomLayerCompositionTypeState> {
2432 [[nodiscard]] auto andBottomLayerIsREComposed(bool renderEngineComposed) {
2433 getInstance()->mLayer1.mLayerFEState.forceClientComposition = renderEngineComposed;
2434 return nextState<AndIfHasLegacySupportState>();
2435 }
2436 };
2437
2438 struct AndIfHasLegacySupportState
2439 : public CallOrderStateMachineHelper<TestType, AndIfHasLegacySupportState> {
2440 [[nodiscard]] auto andIfLegacySupportFor(ui::Dataspace dataspace, bool legacySupport) {
2441 EXPECT_CALL(*getInstance()->mDisplayColorProfile, hasLegacyHdrSupport(dataspace))
2442 .WillOnce(Return(legacySupport));
2443 return nextState<ThenExpectBestColorModeCallUsesState>();
2444 }
2445 };
2446
2447 struct ThenExpectBestColorModeCallUsesState
2448 : public CallOrderStateMachineHelper<TestType, ThenExpectBestColorModeCallUsesState> {
2449 [[nodiscard]] auto thenExpectBestColorModeCallUses(ui::Dataspace dataspace) {
2450 EXPECT_CALL(*getInstance()->mDisplayColorProfile,
2451 getBestColorMode(dataspace, _, _, _, _));
2452 return nextState<ExecuteState>();
2453 }
2454 };
2455
2456 // Call this member function to start using the mini-DSL defined above.
2457 [[nodiscard]] auto verify() { return IfTopLayerDataspaceState::make(this); }
2458};
2459
2460TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_PQ_HW_Uses_PQ) {
2461 // If all layers use BT2020_PQ, and there are no other special conditions,
2462 // BT2020_PQ is used.
2463 verify().ifTopLayerIs(BT2020_PQ)
2464 .andTopLayerIsREComposed(false)
2465 .andIfBottomLayerIs(BT2020_PQ)
2466 .andBottomLayerIsREComposed(false)
2467 .andIfLegacySupportFor(BT2020_PQ, false)
2468 .thenExpectBestColorModeCallUses(BT2020_PQ)
2469 .execute();
2470}
2471
2472TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_PQ_HW_IfPQHasLegacySupport_Uses_DisplayP3) {
2473 // BT2020_PQ is not used if there is only legacy support for it.
2474 verify().ifTopLayerIs(BT2020_PQ)
2475 .andTopLayerIsREComposed(false)
2476 .andIfBottomLayerIs(BT2020_PQ)
2477 .andBottomLayerIsREComposed(false)
2478 .andIfLegacySupportFor(BT2020_PQ, true)
2479 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2480 .execute();
2481}
2482
2483TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_PQ_RE_Uses_PQ) {
2484 // BT2020_PQ is still used if the bottom layer is RenderEngine composed.
2485 verify().ifTopLayerIs(BT2020_PQ)
2486 .andTopLayerIsREComposed(false)
2487 .andIfBottomLayerIs(BT2020_PQ)
2488 .andBottomLayerIsREComposed(true)
2489 .andIfLegacySupportFor(BT2020_PQ, false)
2490 .thenExpectBestColorModeCallUses(BT2020_PQ)
2491 .execute();
2492}
2493
2494TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_RE_On_PQ_HW_Uses_DisplayP3) {
2495 // BT2020_PQ is not used if the top layer is RenderEngine composed.
2496 verify().ifTopLayerIs(BT2020_PQ)
2497 .andTopLayerIsREComposed(true)
2498 .andIfBottomLayerIs(BT2020_PQ)
2499 .andBottomLayerIsREComposed(false)
2500 .andIfLegacySupportFor(BT2020_PQ, false)
2501 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2502 .execute();
2503}
2504
2505TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_HLG_HW_Uses_PQ) {
2506 // If there is mixed HLG/PQ use, and the topmost layer is PQ, then PQ is used if there
2507 // are no other special conditions.
2508 verify().ifTopLayerIs(BT2020_PQ)
2509 .andTopLayerIsREComposed(false)
2510 .andIfBottomLayerIs(BT2020_HLG)
2511 .andBottomLayerIsREComposed(false)
2512 .andIfLegacySupportFor(BT2020_PQ, false)
2513 .thenExpectBestColorModeCallUses(BT2020_PQ)
2514 .execute();
2515}
2516
2517TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_HLG_HW_IfPQHasLegacySupport_Uses_DisplayP3) {
2518 // BT2020_PQ is not used if there is only legacy support for it.
2519 verify().ifTopLayerIs(BT2020_PQ)
2520 .andTopLayerIsREComposed(false)
2521 .andIfBottomLayerIs(BT2020_HLG)
2522 .andBottomLayerIsREComposed(false)
2523 .andIfLegacySupportFor(BT2020_PQ, true)
2524 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2525 .execute();
2526}
2527
2528TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_HLG_RE_Uses_PQ) {
2529 // BT2020_PQ is used if the bottom HLG layer is RenderEngine composed.
2530 verify().ifTopLayerIs(BT2020_PQ)
2531 .andTopLayerIsREComposed(false)
2532 .andIfBottomLayerIs(BT2020_HLG)
2533 .andBottomLayerIsREComposed(true)
2534 .andIfLegacySupportFor(BT2020_PQ, false)
2535 .thenExpectBestColorModeCallUses(BT2020_PQ)
2536 .execute();
2537}
2538
2539TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_RE_On_HLG_HW_Uses_DisplayP3) {
2540 // BT2020_PQ is not used if the top PQ layer is RenderEngine composed.
2541 verify().ifTopLayerIs(BT2020_PQ)
2542 .andTopLayerIsREComposed(true)
2543 .andIfBottomLayerIs(BT2020_HLG)
2544 .andBottomLayerIsREComposed(false)
2545 .andIfLegacySupportFor(BT2020_PQ, false)
2546 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2547 .execute();
2548}
2549
2550TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_PQ_HW_Uses_PQ) {
2551 // If there is mixed HLG/PQ use, and the topmost layer is HLG, then PQ is
2552 // used if there are no other special conditions.
2553 verify().ifTopLayerIs(BT2020_HLG)
2554 .andTopLayerIsREComposed(false)
2555 .andIfBottomLayerIs(BT2020_PQ)
2556 .andBottomLayerIsREComposed(false)
2557 .andIfLegacySupportFor(BT2020_PQ, false)
2558 .thenExpectBestColorModeCallUses(BT2020_PQ)
2559 .execute();
2560}
2561
2562TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_PQ_HW_IfPQHasLegacySupport_Uses_DisplayP3) {
2563 // BT2020_PQ is not used if there is only legacy support for it.
2564 verify().ifTopLayerIs(BT2020_HLG)
2565 .andTopLayerIsREComposed(false)
2566 .andIfBottomLayerIs(BT2020_PQ)
2567 .andBottomLayerIsREComposed(false)
2568 .andIfLegacySupportFor(BT2020_PQ, true)
2569 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2570 .execute();
2571}
2572
2573TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_PQ_RE_Uses_DisplayP3) {
2574 // BT2020_PQ is not used if the bottom PQ layer is RenderEngine composed.
2575 verify().ifTopLayerIs(BT2020_HLG)
2576 .andTopLayerIsREComposed(false)
2577 .andIfBottomLayerIs(BT2020_PQ)
2578 .andBottomLayerIsREComposed(true)
2579 .andIfLegacySupportFor(BT2020_PQ, false)
2580 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2581 .execute();
2582}
2583
2584TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_RE_On_PQ_HW_Uses_PQ) {
2585 // BT2020_PQ is still used if the top HLG layer is RenderEngine composed.
2586 verify().ifTopLayerIs(BT2020_HLG)
2587 .andTopLayerIsREComposed(true)
2588 .andIfBottomLayerIs(BT2020_PQ)
2589 .andBottomLayerIsREComposed(false)
2590 .andIfLegacySupportFor(BT2020_PQ, false)
2591 .thenExpectBestColorModeCallUses(BT2020_PQ)
2592 .execute();
2593}
2594
2595TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_HLG_HW_Uses_HLG) {
2596 // If all layers use HLG then HLG is used if there are no other special
2597 // conditions.
2598 verify().ifTopLayerIs(BT2020_HLG)
2599 .andTopLayerIsREComposed(false)
2600 .andIfBottomLayerIs(BT2020_HLG)
2601 .andBottomLayerIsREComposed(false)
2602 .andIfLegacySupportFor(BT2020_HLG, false)
2603 .thenExpectBestColorModeCallUses(BT2020_HLG)
2604 .execute();
2605}
2606
2607TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_HLG_HW_IfPQHasLegacySupport_Uses_DisplayP3) {
2608 // BT2020_HLG is not used if there is legacy support for it.
2609 verify().ifTopLayerIs(BT2020_HLG)
2610 .andTopLayerIsREComposed(false)
2611 .andIfBottomLayerIs(BT2020_HLG)
2612 .andBottomLayerIsREComposed(false)
2613 .andIfLegacySupportFor(BT2020_HLG, true)
2614 .thenExpectBestColorModeCallUses(DISPLAY_P3)
2615 .execute();
2616}
2617
2618TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_HLG_RE_Uses_HLG) {
2619 // BT2020_HLG is used even if the bottom layer is client composed.
2620 verify().ifTopLayerIs(BT2020_HLG)
2621 .andTopLayerIsREComposed(false)
2622 .andIfBottomLayerIs(BT2020_HLG)
2623 .andBottomLayerIsREComposed(true)
2624 .andIfLegacySupportFor(BT2020_HLG, false)
2625 .thenExpectBestColorModeCallUses(BT2020_HLG)
2626 .execute();
2627}
2628
2629TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_RE_On_HLG_HW_Uses_HLG) {
2630 // BT2020_HLG is used even if the top layer is client composed.
2631 verify().ifTopLayerIs(BT2020_HLG)
2632 .andTopLayerIsREComposed(true)
2633 .andIfBottomLayerIs(BT2020_HLG)
2634 .andBottomLayerIsREComposed(false)
2635 .andIfLegacySupportFor(BT2020_HLG, false)
2636 .thenExpectBestColorModeCallUses(BT2020_HLG)
2637 .execute();
2638}
2639
2640TEST_F(OutputUpdateColorProfileTest_Hdr, PQ_HW_On_NonHdr_HW_Uses_PQ) {
2641 // Even if there are non-HDR layers present, BT2020_PQ can still be used.
2642 verify().ifTopLayerIs(BT2020_PQ)
2643 .andTopLayerIsREComposed(false)
2644 .andIfBottomLayerIsNotHdr()
2645 .andBottomLayerIsREComposed(false)
2646 .andIfLegacySupportFor(BT2020_PQ, false)
2647 .thenExpectBestColorModeCallUses(BT2020_PQ)
2648 .execute();
2649}
2650
2651TEST_F(OutputUpdateColorProfileTest_Hdr, HLG_HW_On_NonHdr_RE_Uses_HLG) {
2652 // If all layers use HLG then HLG is used if there are no other special
2653 // conditions.
2654 verify().ifTopLayerIs(BT2020_HLG)
2655 .andTopLayerIsREComposed(false)
2656 .andIfBottomLayerIsNotHdr()
2657 .andBottomLayerIsREComposed(true)
2658 .andIfLegacySupportFor(BT2020_HLG, false)
2659 .thenExpectBestColorModeCallUses(BT2020_HLG)
2660 .execute();
2661}
2662
2663struct OutputUpdateColorProfile_AffectsChosenRenderIntentTest
2664 : public OutputUpdateColorProfileTest {
2665 // The various values for CompositionRefreshArgs::outputColorSetting affect
2666 // the chosen renderIntent, along with whether the preferred dataspace is an
2667 // HDR dataspace or not.
2668
2669 OutputUpdateColorProfile_AffectsChosenRenderIntentTest() {
2670 mRefreshArgs.outputColorSetting = OutputColorSetting::kEnhanced;
2671 mRefreshArgs.colorSpaceAgnosticDataspace = ui::Dataspace::UNKNOWN;
2672 mLayer1.mLayerFEState.dataspace = ui::Dataspace::BT2020_PQ;
Lloyd Pique0a456232020-01-16 17:51:13 -08002673 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(1u));
Lloyd Pique17ca7422019-11-14 14:24:10 -08002674 EXPECT_CALL(mOutput, setColorProfile(_)).WillRepeatedly(Return());
2675 EXPECT_CALL(*mDisplayColorProfile, hasLegacyHdrSupport(ui::Dataspace::BT2020_PQ))
2676 .WillRepeatedly(Return(false));
2677 }
2678
2679 // The tests here involve enough state and GMock setup that using a mini-DSL
2680 // makes the tests much more readable, and allows the test to focus more on
2681 // the intent than on some of the details.
2682
2683 static constexpr ui::Dataspace kNonHdrDataspace = ui::Dataspace::DISPLAY_P3;
2684 static constexpr ui::Dataspace kHdrDataspace = ui::Dataspace::BT2020_PQ;
2685
2686 struct IfDataspaceChosenState
2687 : public CallOrderStateMachineHelper<TestType, IfDataspaceChosenState> {
2688 [[nodiscard]] auto ifDataspaceChosenIs(ui::Dataspace dataspace) {
2689 getInstance()->mLayer1.mLayerFEState.dataspace = dataspace;
2690 return nextState<AndOutputColorSettingState>();
2691 }
2692 [[nodiscard]] auto ifDataspaceChosenIsNonHdr() {
2693 return ifDataspaceChosenIs(kNonHdrDataspace);
2694 }
2695 [[nodiscard]] auto ifDataspaceChosenIsHdr() { return ifDataspaceChosenIs(kHdrDataspace); }
2696 };
2697
2698 struct AndOutputColorSettingState
2699 : public CallOrderStateMachineHelper<TestType, AndOutputColorSettingState> {
2700 [[nodiscard]] auto andOutputColorSettingIs(OutputColorSetting setting) {
2701 getInstance()->mRefreshArgs.outputColorSetting = setting;
2702 return nextState<ThenExpectBestColorModeCallUsesState>();
2703 }
2704 };
2705
2706 struct ThenExpectBestColorModeCallUsesState
2707 : public CallOrderStateMachineHelper<TestType, ThenExpectBestColorModeCallUsesState> {
2708 [[nodiscard]] auto thenExpectBestColorModeCallUses(ui::RenderIntent intent) {
2709 EXPECT_CALL(*getInstance()->mDisplayColorProfile,
2710 getBestColorMode(getInstance()->mLayer1.mLayerFEState.dataspace, intent, _,
2711 _, _));
2712 return nextState<ExecuteState>();
2713 }
2714 };
2715
2716 // Tests call one of these two helper member functions to start using the
2717 // mini-DSL defined above.
2718 [[nodiscard]] auto verify() { return IfDataspaceChosenState::make(this); }
2719};
2720
2721TEST_F(OutputUpdateColorProfile_AffectsChosenRenderIntentTest,
2722 Managed_NonHdr_Prefers_Colorimetric) {
2723 verify().ifDataspaceChosenIsNonHdr()
2724 .andOutputColorSettingIs(OutputColorSetting::kManaged)
2725 .thenExpectBestColorModeCallUses(ui::RenderIntent::COLORIMETRIC)
2726 .execute();
2727}
2728
2729TEST_F(OutputUpdateColorProfile_AffectsChosenRenderIntentTest,
2730 Managed_Hdr_Prefers_ToneMapColorimetric) {
2731 verify().ifDataspaceChosenIsHdr()
2732 .andOutputColorSettingIs(OutputColorSetting::kManaged)
2733 .thenExpectBestColorModeCallUses(ui::RenderIntent::TONE_MAP_COLORIMETRIC)
2734 .execute();
2735}
2736
2737TEST_F(OutputUpdateColorProfile_AffectsChosenRenderIntentTest, Enhanced_NonHdr_Prefers_Enhance) {
2738 verify().ifDataspaceChosenIsNonHdr()
2739 .andOutputColorSettingIs(OutputColorSetting::kEnhanced)
2740 .thenExpectBestColorModeCallUses(ui::RenderIntent::ENHANCE)
2741 .execute();
2742}
2743
2744TEST_F(OutputUpdateColorProfile_AffectsChosenRenderIntentTest,
2745 Enhanced_Hdr_Prefers_ToneMapEnhance) {
2746 verify().ifDataspaceChosenIsHdr()
2747 .andOutputColorSettingIs(OutputColorSetting::kEnhanced)
2748 .thenExpectBestColorModeCallUses(ui::RenderIntent::TONE_MAP_ENHANCE)
2749 .execute();
2750}
2751
2752TEST_F(OutputUpdateColorProfile_AffectsChosenRenderIntentTest, Vendor_NonHdr_Prefers_Vendor) {
2753 verify().ifDataspaceChosenIsNonHdr()
2754 .andOutputColorSettingIs(kVendorSpecifiedOutputColorSetting)
2755 .thenExpectBestColorModeCallUses(
2756 static_cast<ui::RenderIntent>(kVendorSpecifiedOutputColorSetting))
2757 .execute();
2758}
2759
2760TEST_F(OutputUpdateColorProfile_AffectsChosenRenderIntentTest, Vendor_Hdr_Prefers_Vendor) {
2761 verify().ifDataspaceChosenIsHdr()
2762 .andOutputColorSettingIs(kVendorSpecifiedOutputColorSetting)
2763 .thenExpectBestColorModeCallUses(
2764 static_cast<ui::RenderIntent>(kVendorSpecifiedOutputColorSetting))
2765 .execute();
2766}
Lloyd Piquefaa3f192019-11-14 14:05:09 -08002767
2768/*
2769 * Output::beginFrame()
2770 */
2771
Lloyd Piquee5965952019-11-18 16:16:32 -08002772struct OutputBeginFrameTest : public ::testing::Test {
2773 using TestType = OutputBeginFrameTest;
2774
2775 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08002776 // Sets up the helper functions called by the function under test to use
2777 // mock implementations.
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002778 MOCK_METHOD(Region, getDirtyRegion, (), (const));
Lloyd Piquee5965952019-11-18 16:16:32 -08002779 };
2780
2781 OutputBeginFrameTest() {
2782 mOutput.setDisplayColorProfileForTest(
2783 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
2784 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
2785 }
2786
2787 struct IfGetDirtyRegionExpectationState
2788 : public CallOrderStateMachineHelper<TestType, IfGetDirtyRegionExpectationState> {
2789 [[nodiscard]] auto ifGetDirtyRegionReturns(Region dirtyRegion) {
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002790 EXPECT_CALL(getInstance()->mOutput, getDirtyRegion()).WillOnce(Return(dirtyRegion));
Lloyd Piquee5965952019-11-18 16:16:32 -08002791 return nextState<AndIfGetOutputLayerCountExpectationState>();
2792 }
2793 };
2794
2795 struct AndIfGetOutputLayerCountExpectationState
2796 : public CallOrderStateMachineHelper<TestType, AndIfGetOutputLayerCountExpectationState> {
2797 [[nodiscard]] auto andIfGetOutputLayerCountReturns(size_t layerCount) {
2798 EXPECT_CALL(getInstance()->mOutput, getOutputLayerCount()).WillOnce(Return(layerCount));
2799 return nextState<AndIfLastCompositionHadVisibleLayersState>();
2800 }
2801 };
2802
2803 struct AndIfLastCompositionHadVisibleLayersState
2804 : public CallOrderStateMachineHelper<TestType,
2805 AndIfLastCompositionHadVisibleLayersState> {
2806 [[nodiscard]] auto andIfLastCompositionHadVisibleLayersIs(bool hadOutputLayers) {
2807 getInstance()->mOutput.mState.lastCompositionHadVisibleLayers = hadOutputLayers;
2808 return nextState<ThenExpectRenderSurfaceBeginFrameCallState>();
2809 }
2810 };
2811
2812 struct ThenExpectRenderSurfaceBeginFrameCallState
2813 : public CallOrderStateMachineHelper<TestType,
2814 ThenExpectRenderSurfaceBeginFrameCallState> {
2815 [[nodiscard]] auto thenExpectRenderSurfaceBeginFrameCall(bool mustRecompose) {
2816 EXPECT_CALL(*getInstance()->mRenderSurface, beginFrame(mustRecompose));
2817 return nextState<ExecuteState>();
2818 }
2819 };
2820
2821 struct ExecuteState : public CallOrderStateMachineHelper<TestType, ExecuteState> {
2822 [[nodiscard]] auto execute() {
2823 getInstance()->mOutput.beginFrame();
2824 return nextState<CheckPostconditionHadVisibleLayersState>();
2825 }
2826 };
2827
2828 struct CheckPostconditionHadVisibleLayersState
2829 : public CallOrderStateMachineHelper<TestType, CheckPostconditionHadVisibleLayersState> {
2830 void checkPostconditionHadVisibleLayers(bool expected) {
2831 EXPECT_EQ(expected, getInstance()->mOutput.mState.lastCompositionHadVisibleLayers);
2832 }
2833 };
2834
2835 // Tests call one of these two helper member functions to start using the
2836 // mini-DSL defined above.
2837 [[nodiscard]] auto verify() { return IfGetDirtyRegionExpectationState::make(this); }
2838
2839 static const Region kEmptyRegion;
2840 static const Region kNotEmptyRegion;
2841
2842 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
2843 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
2844 StrictMock<OutputPartialMock> mOutput;
2845};
2846
2847const Region OutputBeginFrameTest::kEmptyRegion{Rect{0, 0, 0, 0}};
2848const Region OutputBeginFrameTest::kNotEmptyRegion{Rect{0, 0, 1, 1}};
2849
2850TEST_F(OutputBeginFrameTest, hasDirtyHasLayersHadLayersLastFrame) {
2851 verify().ifGetDirtyRegionReturns(kNotEmptyRegion)
2852 .andIfGetOutputLayerCountReturns(1u)
2853 .andIfLastCompositionHadVisibleLayersIs(true)
2854 .thenExpectRenderSurfaceBeginFrameCall(true)
2855 .execute()
2856 .checkPostconditionHadVisibleLayers(true);
2857}
2858
2859TEST_F(OutputBeginFrameTest, hasDirtyNotHasLayersHadLayersLastFrame) {
2860 verify().ifGetDirtyRegionReturns(kNotEmptyRegion)
2861 .andIfGetOutputLayerCountReturns(0u)
2862 .andIfLastCompositionHadVisibleLayersIs(true)
2863 .thenExpectRenderSurfaceBeginFrameCall(true)
2864 .execute()
2865 .checkPostconditionHadVisibleLayers(false);
2866}
2867
2868TEST_F(OutputBeginFrameTest, hasDirtyHasLayersNotHadLayersLastFrame) {
2869 verify().ifGetDirtyRegionReturns(kNotEmptyRegion)
2870 .andIfGetOutputLayerCountReturns(1u)
2871 .andIfLastCompositionHadVisibleLayersIs(false)
2872 .thenExpectRenderSurfaceBeginFrameCall(true)
2873 .execute()
2874 .checkPostconditionHadVisibleLayers(true);
2875}
2876
2877TEST_F(OutputBeginFrameTest, hasDirtyNotHasLayersNotHadLayersLastFrame) {
2878 verify().ifGetDirtyRegionReturns(kNotEmptyRegion)
2879 .andIfGetOutputLayerCountReturns(0u)
2880 .andIfLastCompositionHadVisibleLayersIs(false)
2881 .thenExpectRenderSurfaceBeginFrameCall(false)
2882 .execute()
2883 .checkPostconditionHadVisibleLayers(false);
2884}
2885
2886TEST_F(OutputBeginFrameTest, notHasDirtyHasLayersHadLayersLastFrame) {
2887 verify().ifGetDirtyRegionReturns(kEmptyRegion)
2888 .andIfGetOutputLayerCountReturns(1u)
2889 .andIfLastCompositionHadVisibleLayersIs(true)
2890 .thenExpectRenderSurfaceBeginFrameCall(false)
2891 .execute()
2892 .checkPostconditionHadVisibleLayers(true);
2893}
2894
2895TEST_F(OutputBeginFrameTest, notHasDirtyNotHasLayersHadLayersLastFrame) {
2896 verify().ifGetDirtyRegionReturns(kEmptyRegion)
2897 .andIfGetOutputLayerCountReturns(0u)
2898 .andIfLastCompositionHadVisibleLayersIs(true)
2899 .thenExpectRenderSurfaceBeginFrameCall(false)
2900 .execute()
2901 .checkPostconditionHadVisibleLayers(true);
2902}
2903
2904TEST_F(OutputBeginFrameTest, notHasDirtyHasLayersNotHadLayersLastFrame) {
2905 verify().ifGetDirtyRegionReturns(kEmptyRegion)
2906 .andIfGetOutputLayerCountReturns(1u)
2907 .andIfLastCompositionHadVisibleLayersIs(false)
2908 .thenExpectRenderSurfaceBeginFrameCall(false)
2909 .execute()
2910 .checkPostconditionHadVisibleLayers(false);
2911}
2912
2913TEST_F(OutputBeginFrameTest, notHasDirtyNotHasLayersNotHadLayersLastFrame) {
2914 verify().ifGetDirtyRegionReturns(kEmptyRegion)
2915 .andIfGetOutputLayerCountReturns(0u)
2916 .andIfLastCompositionHadVisibleLayersIs(false)
2917 .thenExpectRenderSurfaceBeginFrameCall(false)
2918 .execute()
2919 .checkPostconditionHadVisibleLayers(false);
2920}
2921
Lloyd Piquefaa3f192019-11-14 14:05:09 -08002922/*
2923 * Output::devOptRepaintFlash()
2924 */
2925
Lloyd Piquedb462d82019-11-19 17:58:46 -08002926struct OutputDevOptRepaintFlashTest : public testing::Test {
2927 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08002928 // Sets up the helper functions called by the function under test to use
2929 // mock implementations.
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002930 MOCK_METHOD(Region, getDirtyRegion, (), (const));
Vishnu Naira3140382022-02-24 14:07:11 -08002931 MOCK_METHOD4(composeSurfaces,
Lucas Dupin2dd6f392020-02-18 17:43:36 -08002932 std::optional<base::unique_fd>(
Vishnu Naira3140382022-02-24 14:07:11 -08002933 const Region&, const compositionengine::CompositionRefreshArgs&,
2934 std::shared_ptr<renderengine::ExternalTexture>, base::unique_fd&));
Lloyd Piquedb462d82019-11-19 17:58:46 -08002935 MOCK_METHOD0(postFramebuffer, void());
2936 MOCK_METHOD0(prepareFrame, void());
Vishnu Naira3140382022-02-24 14:07:11 -08002937 MOCK_METHOD0(updateProtectedContentState, void());
2938 MOCK_METHOD2(dequeueRenderBuffer,
2939 bool(base::unique_fd*, std::shared_ptr<renderengine::ExternalTexture>*));
Lloyd Piquedb462d82019-11-19 17:58:46 -08002940 };
2941
2942 OutputDevOptRepaintFlashTest() {
2943 mOutput.setDisplayColorProfileForTest(
2944 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
2945 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
2946 }
2947
2948 static const Region kEmptyRegion;
2949 static const Region kNotEmptyRegion;
2950
2951 StrictMock<OutputPartialMock> mOutput;
2952 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
2953 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
2954 CompositionRefreshArgs mRefreshArgs;
2955};
2956
2957const Region OutputDevOptRepaintFlashTest::kEmptyRegion{Rect{0, 0, 0, 0}};
2958const Region OutputDevOptRepaintFlashTest::kNotEmptyRegion{Rect{0, 0, 1, 1}};
2959
2960TEST_F(OutputDevOptRepaintFlashTest, doesNothingIfFlashDelayNotSet) {
2961 mRefreshArgs.devOptFlashDirtyRegionsDelay = {};
Lloyd Piquedb462d82019-11-19 17:58:46 -08002962 mOutput.mState.isEnabled = true;
2963
2964 mOutput.devOptRepaintFlash(mRefreshArgs);
2965}
2966
2967TEST_F(OutputDevOptRepaintFlashTest, postsAndPreparesANewFrameIfNotEnabled) {
2968 mRefreshArgs.devOptFlashDirtyRegionsDelay = std::chrono::microseconds(1);
Lloyd Piquedb462d82019-11-19 17:58:46 -08002969 mOutput.mState.isEnabled = false;
2970
2971 InSequence seq;
2972 EXPECT_CALL(mOutput, postFramebuffer());
2973 EXPECT_CALL(mOutput, prepareFrame());
2974
2975 mOutput.devOptRepaintFlash(mRefreshArgs);
2976}
2977
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002978TEST_F(OutputDevOptRepaintFlashTest, postsAndPreparesANewFrameIfEnabled) {
Lloyd Piquedb462d82019-11-19 17:58:46 -08002979 mRefreshArgs.devOptFlashDirtyRegionsDelay = std::chrono::microseconds(1);
Lloyd Piquedb462d82019-11-19 17:58:46 -08002980 mOutput.mState.isEnabled = true;
2981
2982 InSequence seq;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002983 EXPECT_CALL(mOutput, getDirtyRegion()).WillOnce(Return(kEmptyRegion));
Lloyd Piquedb462d82019-11-19 17:58:46 -08002984 EXPECT_CALL(mOutput, postFramebuffer());
2985 EXPECT_CALL(mOutput, prepareFrame());
2986
2987 mOutput.devOptRepaintFlash(mRefreshArgs);
2988}
2989
2990TEST_F(OutputDevOptRepaintFlashTest, alsoComposesSurfacesAndQueuesABufferIfDirty) {
2991 mRefreshArgs.devOptFlashDirtyRegionsDelay = std::chrono::microseconds(1);
Lloyd Piquedb462d82019-11-19 17:58:46 -08002992 mOutput.mState.isEnabled = true;
2993
2994 InSequence seq;
Dominik Laskowski8da6b0e2021-05-12 15:34:13 -07002995 EXPECT_CALL(mOutput, getDirtyRegion()).WillOnce(Return(kNotEmptyRegion));
Vishnu Naira3140382022-02-24 14:07:11 -08002996 EXPECT_CALL(mOutput, updateProtectedContentState());
2997 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _));
2998 EXPECT_CALL(mOutput, composeSurfaces(RegionEq(kNotEmptyRegion), Ref(mRefreshArgs), _, _));
Lloyd Piquedb462d82019-11-19 17:58:46 -08002999 EXPECT_CALL(*mRenderSurface, queueBuffer(_));
3000 EXPECT_CALL(mOutput, postFramebuffer());
3001 EXPECT_CALL(mOutput, prepareFrame());
3002
3003 mOutput.devOptRepaintFlash(mRefreshArgs);
3004}
3005
Lloyd Piquefaa3f192019-11-14 14:05:09 -08003006/*
3007 * Output::finishFrame()
3008 */
3009
Lloyd Pique03561a62019-11-19 18:34:52 -08003010struct OutputFinishFrameTest : public testing::Test {
3011 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08003012 // Sets up the helper functions called by the function under test to use
3013 // mock implementations.
Vishnu Naira3140382022-02-24 14:07:11 -08003014 MOCK_METHOD4(composeSurfaces,
Lucas Dupin2dd6f392020-02-18 17:43:36 -08003015 std::optional<base::unique_fd>(
Vishnu Naira3140382022-02-24 14:07:11 -08003016 const Region&, const compositionengine::CompositionRefreshArgs&,
3017 std::shared_ptr<renderengine::ExternalTexture>, base::unique_fd&));
Lloyd Pique03561a62019-11-19 18:34:52 -08003018 MOCK_METHOD0(postFramebuffer, void());
Vishnu Naira3140382022-02-24 14:07:11 -08003019 MOCK_METHOD0(updateProtectedContentState, void());
3020 MOCK_METHOD2(dequeueRenderBuffer,
3021 bool(base::unique_fd*, std::shared_ptr<renderengine::ExternalTexture>*));
Lloyd Pique03561a62019-11-19 18:34:52 -08003022 };
3023
3024 OutputFinishFrameTest() {
3025 mOutput.setDisplayColorProfileForTest(
3026 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
3027 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
3028 }
3029
3030 StrictMock<OutputPartialMock> mOutput;
3031 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
3032 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
3033 CompositionRefreshArgs mRefreshArgs;
3034};
3035
3036TEST_F(OutputFinishFrameTest, ifNotEnabledDoesNothing) {
3037 mOutput.mState.isEnabled = false;
3038
Vishnu Naira3140382022-02-24 14:07:11 -08003039 impl::GpuCompositionResult result;
3040 mOutput.finishFrame(mRefreshArgs, std::move(result));
Lloyd Pique03561a62019-11-19 18:34:52 -08003041}
3042
3043TEST_F(OutputFinishFrameTest, takesEarlyOutifComposeSurfacesReturnsNoFence) {
3044 mOutput.mState.isEnabled = true;
Vishnu Naira3140382022-02-24 14:07:11 -08003045 EXPECT_CALL(mOutput, updateProtectedContentState());
3046 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _)).WillOnce(Return(true));
3047 EXPECT_CALL(mOutput, composeSurfaces(RegionEq(Region::INVALID_REGION), _, _, _));
Lloyd Pique03561a62019-11-19 18:34:52 -08003048
Vishnu Naira3140382022-02-24 14:07:11 -08003049 impl::GpuCompositionResult result;
3050 mOutput.finishFrame(mRefreshArgs, std::move(result));
Lloyd Pique03561a62019-11-19 18:34:52 -08003051}
3052
3053TEST_F(OutputFinishFrameTest, queuesBufferIfComposeSurfacesReturnsAFence) {
3054 mOutput.mState.isEnabled = true;
3055
3056 InSequence seq;
Vishnu Naira3140382022-02-24 14:07:11 -08003057 EXPECT_CALL(mOutput, updateProtectedContentState());
3058 EXPECT_CALL(mOutput, dequeueRenderBuffer(_, _)).WillOnce(Return(true));
3059 EXPECT_CALL(mOutput, composeSurfaces(RegionEq(Region::INVALID_REGION), _, _, _))
Lloyd Pique03561a62019-11-19 18:34:52 -08003060 .WillOnce(Return(ByMove(base::unique_fd())));
3061 EXPECT_CALL(*mRenderSurface, queueBuffer(_));
3062
Vishnu Naira3140382022-02-24 14:07:11 -08003063 impl::GpuCompositionResult result;
3064 mOutput.finishFrame(mRefreshArgs, std::move(result));
3065}
3066
3067TEST_F(OutputFinishFrameTest, predictionSucceeded) {
3068 mOutput.mState.isEnabled = true;
Vishnu Nair9cf89262022-02-26 09:17:49 -08003069 mOutput.mState.strategyPrediction = CompositionStrategyPredictionState::SUCCESS;
Vishnu Naira3140382022-02-24 14:07:11 -08003070 InSequence seq;
3071 EXPECT_CALL(*mRenderSurface, queueBuffer(_));
3072
3073 impl::GpuCompositionResult result;
Vishnu Naira3140382022-02-24 14:07:11 -08003074 mOutput.finishFrame(mRefreshArgs, std::move(result));
3075}
3076
3077TEST_F(OutputFinishFrameTest, predictionFailedAndBufferIsReused) {
3078 mOutput.mState.isEnabled = true;
Vishnu Nair9cf89262022-02-26 09:17:49 -08003079 mOutput.mState.strategyPrediction = CompositionStrategyPredictionState::FAIL;
Vishnu Naira3140382022-02-24 14:07:11 -08003080
3081 InSequence seq;
3082
3083 impl::GpuCompositionResult result;
Vishnu Naira3140382022-02-24 14:07:11 -08003084 result.buffer =
3085 std::make_shared<renderengine::mock::FakeExternalTexture>(1, 1,
3086 HAL_PIXEL_FORMAT_RGBA_8888, 1,
3087 2);
3088
3089 EXPECT_CALL(mOutput,
3090 composeSurfaces(RegionEq(Region::INVALID_REGION), _, result.buffer,
3091 Eq(ByRef(result.fence))))
3092 .WillOnce(Return(ByMove(base::unique_fd())));
3093 EXPECT_CALL(*mRenderSurface, queueBuffer(_));
3094 mOutput.finishFrame(mRefreshArgs, std::move(result));
Lloyd Pique03561a62019-11-19 18:34:52 -08003095}
Lloyd Piquefaa3f192019-11-14 14:05:09 -08003096
3097/*
3098 * Output::postFramebuffer()
3099 */
3100
Lloyd Pique07178e32019-11-19 19:15:26 -08003101struct OutputPostFramebufferTest : public testing::Test {
3102 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08003103 // Sets up the helper functions called by the function under test to use
3104 // mock implementations.
Lloyd Pique07178e32019-11-19 19:15:26 -08003105 MOCK_METHOD0(presentAndGetFrameFences, compositionengine::Output::FrameFences());
3106 };
3107
3108 struct Layer {
3109 Layer() {
Ady Abrahameca9d752021-03-03 12:20:00 -08003110 EXPECT_CALL(outputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*layerFE));
Lloyd Pique07178e32019-11-19 19:15:26 -08003111 EXPECT_CALL(outputLayer, getHwcLayer()).WillRepeatedly(Return(&hwc2Layer));
3112 }
3113
3114 StrictMock<mock::OutputLayer> outputLayer;
Ady Abrahameca9d752021-03-03 12:20:00 -08003115 sp<StrictMock<mock::LayerFE>> layerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Pique07178e32019-11-19 19:15:26 -08003116 StrictMock<HWC2::mock::Layer> hwc2Layer;
3117 };
3118
3119 OutputPostFramebufferTest() {
3120 mOutput.setDisplayColorProfileForTest(
3121 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
3122 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
3123
3124 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(3u));
3125 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
3126 .WillRepeatedly(Return(&mLayer1.outputLayer));
3127 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1u))
3128 .WillRepeatedly(Return(&mLayer2.outputLayer));
3129 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(2u))
3130 .WillRepeatedly(Return(&mLayer3.outputLayer));
3131 }
3132
3133 StrictMock<OutputPartialMock> mOutput;
3134 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
3135 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
3136
3137 Layer mLayer1;
3138 Layer mLayer2;
3139 Layer mLayer3;
3140};
3141
3142TEST_F(OutputPostFramebufferTest, ifNotEnabledDoesNothing) {
3143 mOutput.mState.isEnabled = false;
3144
3145 mOutput.postFramebuffer();
3146}
3147
3148TEST_F(OutputPostFramebufferTest, ifEnabledMustFlipThenPresentThenSendPresentCompleted) {
3149 mOutput.mState.isEnabled = true;
3150
3151 compositionengine::Output::FrameFences frameFences;
3152
3153 // This should happen even if there are no output layers.
3154 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
3155
3156 // For this test in particular we want to make sure the call expectations
3157 // setup below are satisfied in the specific order.
3158 InSequence seq;
3159
3160 EXPECT_CALL(*mRenderSurface, flip());
3161 EXPECT_CALL(mOutput, presentAndGetFrameFences()).WillOnce(Return(frameFences));
3162 EXPECT_CALL(*mRenderSurface, onPresentDisplayCompleted());
3163
3164 mOutput.postFramebuffer();
3165}
3166
3167TEST_F(OutputPostFramebufferTest, releaseFencesAreSentToLayerFE) {
3168 // Simulate getting release fences from each layer, and ensure they are passed to the
3169 // front-end layer interface for each layer correctly.
3170
3171 mOutput.mState.isEnabled = true;
3172
3173 // Create three unique fence instances
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003174 sp<Fence> layer1Fence = sp<Fence>::make();
3175 sp<Fence> layer2Fence = sp<Fence>::make();
3176 sp<Fence> layer3Fence = sp<Fence>::make();
Lloyd Pique07178e32019-11-19 19:15:26 -08003177
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08003178 Output::FrameFences frameFences;
Lloyd Pique07178e32019-11-19 19:15:26 -08003179 frameFences.layerFences.emplace(&mLayer1.hwc2Layer, layer1Fence);
3180 frameFences.layerFences.emplace(&mLayer2.hwc2Layer, layer2Fence);
3181 frameFences.layerFences.emplace(&mLayer3.hwc2Layer, layer3Fence);
3182
3183 EXPECT_CALL(*mRenderSurface, flip());
3184 EXPECT_CALL(mOutput, presentAndGetFrameFences()).WillOnce(Return(frameFences));
3185 EXPECT_CALL(*mRenderSurface, onPresentDisplayCompleted());
3186
3187 // Compare the pointers values of each fence to make sure the correct ones
3188 // are passed. This happens to work with the current implementation, but
3189 // would not survive certain calls like Fence::merge() which would return a
3190 // new instance.
Sally Qi59a9f502021-10-12 18:53:23 +00003191 EXPECT_CALL(*mLayer1.layerFE, onLayerDisplayed(_))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07003192 .WillOnce([&layer1Fence](ftl::SharedFuture<FenceResult> futureFenceResult) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003193 EXPECT_EQ(FenceResult(layer1Fence), futureFenceResult.get());
Sally Qi59a9f502021-10-12 18:53:23 +00003194 });
3195 EXPECT_CALL(*mLayer2.layerFE, onLayerDisplayed(_))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07003196 .WillOnce([&layer2Fence](ftl::SharedFuture<FenceResult> futureFenceResult) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003197 EXPECT_EQ(FenceResult(layer2Fence), futureFenceResult.get());
Sally Qi59a9f502021-10-12 18:53:23 +00003198 });
3199 EXPECT_CALL(*mLayer3.layerFE, onLayerDisplayed(_))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07003200 .WillOnce([&layer3Fence](ftl::SharedFuture<FenceResult> futureFenceResult) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003201 EXPECT_EQ(FenceResult(layer3Fence), futureFenceResult.get());
Sally Qi59a9f502021-10-12 18:53:23 +00003202 });
Lloyd Pique07178e32019-11-19 19:15:26 -08003203
3204 mOutput.postFramebuffer();
3205}
3206
3207TEST_F(OutputPostFramebufferTest, releaseFencesIncludeClientTargetAcquireFence) {
3208 mOutput.mState.isEnabled = true;
3209 mOutput.mState.usesClientComposition = true;
3210
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08003211 Output::FrameFences frameFences;
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003212 frameFences.clientTargetAcquireFence = sp<Fence>::make();
3213 frameFences.layerFences.emplace(&mLayer1.hwc2Layer, sp<Fence>::make());
3214 frameFences.layerFences.emplace(&mLayer2.hwc2Layer, sp<Fence>::make());
3215 frameFences.layerFences.emplace(&mLayer3.hwc2Layer, sp<Fence>::make());
Lloyd Pique07178e32019-11-19 19:15:26 -08003216
3217 EXPECT_CALL(*mRenderSurface, flip());
3218 EXPECT_CALL(mOutput, presentAndGetFrameFences()).WillOnce(Return(frameFences));
3219 EXPECT_CALL(*mRenderSurface, onPresentDisplayCompleted());
3220
3221 // Fence::merge is called, and since none of the fences are actually valid,
3222 // Fence::NO_FENCE is returned and passed to each onLayerDisplayed() call.
3223 // This is the best we can do without creating a real kernel fence object.
Sally Qi59a9f502021-10-12 18:53:23 +00003224 EXPECT_CALL(*mLayer1.layerFE, onLayerDisplayed).WillOnce(Return());
3225 EXPECT_CALL(*mLayer2.layerFE, onLayerDisplayed).WillOnce(Return());
3226 EXPECT_CALL(*mLayer3.layerFE, onLayerDisplayed).WillOnce(Return());
Lloyd Pique07178e32019-11-19 19:15:26 -08003227
3228 mOutput.postFramebuffer();
3229}
3230
3231TEST_F(OutputPostFramebufferTest, releasedLayersSentPresentFence) {
3232 mOutput.mState.isEnabled = true;
3233 mOutput.mState.usesClientComposition = true;
3234
3235 // This should happen even if there are no (current) output layers.
3236 EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
3237
3238 // Load up the released layers with some mock instances
Ady Abrahame0eafa82022-02-02 19:30:47 -08003239 sp<StrictMock<mock::LayerFE>> releasedLayer1 = sp<StrictMock<mock::LayerFE>>::make();
3240 sp<StrictMock<mock::LayerFE>> releasedLayer2 = sp<StrictMock<mock::LayerFE>>::make();
3241 sp<StrictMock<mock::LayerFE>> releasedLayer3 = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Pique07178e32019-11-19 19:15:26 -08003242 Output::ReleasedLayers layers;
3243 layers.push_back(releasedLayer1);
3244 layers.push_back(releasedLayer2);
3245 layers.push_back(releasedLayer3);
3246 mOutput.setReleasedLayers(std::move(layers));
3247
3248 // Set up a fake present fence
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003249 sp<Fence> presentFence = sp<Fence>::make();
Lloyd Piquefe0ee9e2019-11-22 16:30:30 -08003250 Output::FrameFences frameFences;
Lloyd Pique07178e32019-11-19 19:15:26 -08003251 frameFences.presentFence = presentFence;
3252
3253 EXPECT_CALL(*mRenderSurface, flip());
3254 EXPECT_CALL(mOutput, presentAndGetFrameFences()).WillOnce(Return(frameFences));
3255 EXPECT_CALL(*mRenderSurface, onPresentDisplayCompleted());
3256
3257 // Each released layer should be given the presentFence.
Sally Qi59a9f502021-10-12 18:53:23 +00003258 EXPECT_CALL(*releasedLayer1, onLayerDisplayed(_))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07003259 .WillOnce([&presentFence](ftl::SharedFuture<FenceResult> futureFenceResult) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003260 EXPECT_EQ(FenceResult(presentFence), futureFenceResult.get());
Sally Qi59a9f502021-10-12 18:53:23 +00003261 });
3262 EXPECT_CALL(*releasedLayer2, onLayerDisplayed(_))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07003263 .WillOnce([&presentFence](ftl::SharedFuture<FenceResult> futureFenceResult) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003264 EXPECT_EQ(FenceResult(presentFence), futureFenceResult.get());
Sally Qi59a9f502021-10-12 18:53:23 +00003265 });
3266 EXPECT_CALL(*releasedLayer3, onLayerDisplayed(_))
Dominik Laskowskib17c6212022-05-09 09:36:19 -07003267 .WillOnce([&presentFence](ftl::SharedFuture<FenceResult> futureFenceResult) {
Dominik Laskowskibb448ce2022-05-07 15:52:55 -07003268 EXPECT_EQ(FenceResult(presentFence), futureFenceResult.get());
Sally Qi59a9f502021-10-12 18:53:23 +00003269 });
Lloyd Pique07178e32019-11-19 19:15:26 -08003270
3271 mOutput.postFramebuffer();
3272
3273 // After the call the list of released layers should have been cleared.
3274 EXPECT_TRUE(mOutput.getReleasedLayersForTest().empty());
3275}
Lloyd Piquefaa3f192019-11-14 14:05:09 -08003276
3277/*
Lloyd Pique56eba802019-08-28 15:45:25 -07003278 * Output::composeSurfaces()
3279 */
3280
3281struct OutputComposeSurfacesTest : public testing::Test {
Lloyd Pique6818fa52019-12-03 12:32:13 -08003282 using TestType = OutputComposeSurfacesTest;
Lloyd Pique56eba802019-08-28 15:45:25 -07003283
Lloyd Piquefaa3f192019-11-14 14:05:09 -08003284 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Pique739afaf2019-11-21 16:40:05 -08003285 // Sets up the helper functions called by the function under test to use
3286 // mock implementations.
Lloyd Pique56eba802019-08-28 15:45:25 -07003287 MOCK_CONST_METHOD0(getSkipColorTransform, bool());
Robert Carrccab4242021-09-28 16:53:03 -07003288 MOCK_METHOD3(generateClientCompositionRequests,
3289 std::vector<LayerFE::LayerSettings>(bool, ui::Dataspace, std::vector<LayerFE*>&));
Lloyd Pique56eba802019-08-28 15:45:25 -07003290 MOCK_METHOD2(appendRegionFlashRequests,
Vishnu Nair9b079a22020-01-21 14:36:08 -08003291 void(const Region&, std::vector<LayerFE::LayerSettings>&));
Lloyd Pique56eba802019-08-28 15:45:25 -07003292 MOCK_METHOD1(setExpensiveRenderingExpected, void(bool));
3293 };
3294
3295 OutputComposeSurfacesTest() {
3296 mOutput.setDisplayColorProfileForTest(
3297 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
3298 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
Vishnu Nair9b079a22020-01-21 14:36:08 -08003299 mOutput.cacheClientCompositionRequests(MAX_CLIENT_COMPOSITION_CACHE_SIZE);
Lloyd Pique56eba802019-08-28 15:45:25 -07003300
Angel Aguayob084e0c2021-08-04 23:27:28 +00003301 mOutput.mState.orientedDisplaySpace.setContent(kDefaultOutputFrame);
3302 mOutput.mState.layerStackSpace.setContent(kDefaultOutputViewport);
3303 mOutput.mState.framebufferSpace.setContent(kDefaultOutputDestinationClip);
3304 mOutput.mState.displaySpace.setContent(kDefaultOutputDestinationClip);
3305 mOutput.mState.displaySpace.setOrientation(kDefaultOutputOrientation);
Marin Shalamanovb15d2272020-09-17 21:41:52 +02003306 mOutput.mState.transform = ui::Transform{kDefaultOutputOrientationFlags};
Lloyd Pique6818fa52019-12-03 12:32:13 -08003307 mOutput.mState.dataspace = kDefaultOutputDataspace;
3308 mOutput.mState.colorTransformMatrix = kDefaultColorTransformMat;
3309 mOutput.mState.isSecure = false;
3310 mOutput.mState.needsFiltering = false;
3311 mOutput.mState.usesClientComposition = true;
3312 mOutput.mState.usesDeviceComposition = false;
Vishnu Nair9b079a22020-01-21 14:36:08 -08003313 mOutput.mState.reusedClientComposition = false;
Lloyd Piquee9eff972020-05-05 12:36:44 -07003314 mOutput.mState.flipClientTarget = false;
Alec Mourif8d093d2022-02-10 15:16:59 -08003315 mOutput.mState.clientTargetBrightness = kClientTargetBrightness;
Lloyd Pique56eba802019-08-28 15:45:25 -07003316
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07003317 EXPECT_CALL(mOutput, getCompositionEngine()).WillRepeatedly(ReturnRef(mCompositionEngine));
Lloyd Pique56eba802019-08-28 15:45:25 -07003318 EXPECT_CALL(mCompositionEngine, getRenderEngine()).WillRepeatedly(ReturnRef(mRenderEngine));
Alec Mourie4034bb2019-11-19 12:45:54 -08003319 EXPECT_CALL(mCompositionEngine, getTimeStats())
3320 .WillRepeatedly(ReturnRef(*mTimeStats.get()));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003321 EXPECT_CALL(*mDisplayColorProfile, getHdrCapabilities())
3322 .WillRepeatedly(ReturnRef(kHdrCapabilities));
Lloyd Pique56eba802019-08-28 15:45:25 -07003323 }
3324
Lloyd Pique6818fa52019-12-03 12:32:13 -08003325 struct ExecuteState : public CallOrderStateMachineHelper<TestType, ExecuteState> {
3326 auto execute() {
Vishnu Naira3140382022-02-24 14:07:11 -08003327 base::unique_fd fence;
3328 std::shared_ptr<renderengine::ExternalTexture> externalTexture;
3329 const bool success =
3330 getInstance()->mOutput.dequeueRenderBuffer(&fence, &externalTexture);
3331 if (success) {
3332 getInstance()->mReadyFence =
3333 getInstance()->mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs,
3334 externalTexture, fence);
3335 }
Lloyd Pique6818fa52019-12-03 12:32:13 -08003336 return nextState<FenceCheckState>();
3337 }
3338 };
3339
3340 struct FenceCheckState : public CallOrderStateMachineHelper<TestType, FenceCheckState> {
3341 void expectNoFenceWasReturned() { EXPECT_FALSE(getInstance()->mReadyFence); }
3342
3343 void expectAFenceWasReturned() { EXPECT_TRUE(getInstance()->mReadyFence); }
3344 };
3345
3346 // Call this member function to start using the mini-DSL defined above.
3347 [[nodiscard]] auto verify() { return ExecuteState::make(this); }
3348
Marin Shalamanov68933fb2020-09-10 17:58:12 +02003349 static constexpr ui::Rotation kDefaultOutputOrientation = ui::ROTATION_0;
3350 static constexpr uint32_t kDefaultOutputOrientationFlags =
3351 ui::Transform::toRotationFlags(kDefaultOutputOrientation);
Lloyd Pique6818fa52019-12-03 12:32:13 -08003352 static constexpr ui::Dataspace kDefaultOutputDataspace = ui::Dataspace::UNKNOWN;
3353 static constexpr ui::Dataspace kExpensiveOutputDataspace = ui::Dataspace::DISPLAY_P3;
3354 static constexpr float kDefaultMaxLuminance = 0.9f;
3355 static constexpr float kDefaultAvgLuminance = 0.7f;
3356 static constexpr float kDefaultMinLuminance = 0.1f;
Alec Mourib21d94e2022-01-13 17:44:10 -08003357 static constexpr float kUnknownLuminance = -1.f;
Alec Mourif8d093d2022-02-10 15:16:59 -08003358 static constexpr float kDisplayLuminance = 400.f;
Alec Mouricdf6cbc2021-11-01 17:21:15 -07003359 static constexpr float kClientTargetLuminanceNits = 200.f;
Alec Mourif8d093d2022-02-10 15:16:59 -08003360 static constexpr float kClientTargetBrightness = 0.5f;
Lloyd Pique6818fa52019-12-03 12:32:13 -08003361
3362 static const Rect kDefaultOutputFrame;
3363 static const Rect kDefaultOutputViewport;
Lloyd Piquee8fe4742020-01-21 15:26:18 -08003364 static const Rect kDefaultOutputDestinationClip;
Lloyd Pique6818fa52019-12-03 12:32:13 -08003365 static const mat4 kDefaultColorTransformMat;
3366
3367 static const Region kDebugRegion;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08003368 static const compositionengine::CompositionRefreshArgs kDefaultRefreshArgs;
Lloyd Pique6818fa52019-12-03 12:32:13 -08003369 static const HdrCapabilities kHdrCapabilities;
3370
Lloyd Pique56eba802019-08-28 15:45:25 -07003371 StrictMock<mock::CompositionEngine> mCompositionEngine;
3372 StrictMock<renderengine::mock::RenderEngine> mRenderEngine;
Alec Mourie4034bb2019-11-19 12:45:54 -08003373 // TODO: make this is a proper mock.
3374 std::shared_ptr<TimeStats> mTimeStats = std::make_shared<android::impl::TimeStats>();
Lloyd Pique56eba802019-08-28 15:45:25 -07003375 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
3376 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07003377 StrictMock<OutputPartialMock> mOutput;
Alec Mouria90a5702021-04-16 16:36:21 +00003378 std::shared_ptr<renderengine::ExternalTexture> mOutputBuffer = std::make_shared<
Vishnu Nairdbbe3852022-01-12 20:22:11 -08003379 renderengine::impl::
3380 ExternalTexture>(new GraphicBuffer(), mRenderEngine,
3381 renderengine::impl::ExternalTexture::Usage::READABLE |
3382 renderengine::impl::ExternalTexture::Usage::WRITEABLE);
Lloyd Pique6818fa52019-12-03 12:32:13 -08003383
3384 std::optional<base::unique_fd> mReadyFence;
Lloyd Pique56eba802019-08-28 15:45:25 -07003385};
3386
3387const Rect OutputComposeSurfacesTest::kDefaultOutputFrame{1001, 1002, 1003, 1004};
3388const Rect OutputComposeSurfacesTest::kDefaultOutputViewport{1005, 1006, 1007, 1008};
Lloyd Piquee8fe4742020-01-21 15:26:18 -08003389const Rect OutputComposeSurfacesTest::kDefaultOutputDestinationClip{1013, 1014, 1015, 1016};
Lloyd Pique0a456232020-01-16 17:51:13 -08003390const mat4 OutputComposeSurfacesTest::kDefaultColorTransformMat{mat4() * 0.5f};
Lucas Dupin2dd6f392020-02-18 17:43:36 -08003391const compositionengine::CompositionRefreshArgs OutputComposeSurfacesTest::kDefaultRefreshArgs;
Lloyd Pique6818fa52019-12-03 12:32:13 -08003392const Region OutputComposeSurfacesTest::kDebugRegion{Rect{100, 101, 102, 103}};
Alec Mourib21d94e2022-01-13 17:44:10 -08003393
Lloyd Pique6818fa52019-12-03 12:32:13 -08003394const HdrCapabilities OutputComposeSurfacesTest::
3395 kHdrCapabilities{{},
3396 OutputComposeSurfacesTest::kDefaultMaxLuminance,
3397 OutputComposeSurfacesTest::kDefaultAvgLuminance,
3398 OutputComposeSurfacesTest::kDefaultMinLuminance};
Lloyd Pique56eba802019-08-28 15:45:25 -07003399
Lloyd Piquea76ce462020-01-14 13:06:37 -08003400TEST_F(OutputComposeSurfacesTest, doesNothingButSignalNoExpensiveRenderingIfNoClientComposition) {
Lloyd Pique6818fa52019-12-03 12:32:13 -08003401 mOutput.mState.usesClientComposition = false;
Lloyd Pique56eba802019-08-28 15:45:25 -07003402
Lloyd Piquee9eff972020-05-05 12:36:44 -07003403 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003404 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Lloyd Piquee9eff972020-05-05 12:36:44 -07003405
Lloyd Piquea76ce462020-01-14 13:06:37 -08003406 EXPECT_CALL(mOutput, setExpensiveRenderingExpected(false));
3407
Lloyd Pique6818fa52019-12-03 12:32:13 -08003408 verify().execute().expectAFenceWasReturned();
Lloyd Pique56eba802019-08-28 15:45:25 -07003409}
3410
Lloyd Piquee9eff972020-05-05 12:36:44 -07003411TEST_F(OutputComposeSurfacesTest,
3412 dequeuesABufferIfNoClientCompositionButFlipClientTargetRequested) {
3413 mOutput.mState.usesClientComposition = false;
3414 mOutput.mState.flipClientTarget = true;
3415
Lloyd Pique6818fa52019-12-03 12:32:13 -08003416 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003417 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Lloyd Piquee9eff972020-05-05 12:36:44 -07003418
3419 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillOnce(Return(mOutputBuffer));
3420 EXPECT_CALL(mOutput, setExpensiveRenderingExpected(false));
3421
3422 verify().execute().expectAFenceWasReturned();
3423}
3424
3425TEST_F(OutputComposeSurfacesTest, doesMinimalWorkIfDequeueBufferFailsForClientComposition) {
3426 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003427 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Lloyd Piquee9eff972020-05-05 12:36:44 -07003428
3429 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillOnce(Return(nullptr));
3430
3431 verify().execute().expectNoFenceWasReturned();
3432}
3433
3434TEST_F(OutputComposeSurfacesTest,
3435 doesMinimalWorkIfDequeueBufferFailsForNoClientCompositionButFlipClientTargetRequested) {
3436 mOutput.mState.usesClientComposition = false;
3437 mOutput.mState.flipClientTarget = true;
3438
3439 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003440 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Lloyd Pique56eba802019-08-28 15:45:25 -07003441
Lloyd Pique6818fa52019-12-03 12:32:13 -08003442 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillOnce(Return(nullptr));
Lloyd Pique56eba802019-08-28 15:45:25 -07003443
Lloyd Pique6818fa52019-12-03 12:32:13 -08003444 verify().execute().expectNoFenceWasReturned();
3445}
Lloyd Pique56eba802019-08-28 15:45:25 -07003446
Lloyd Pique6818fa52019-12-03 12:32:13 -08003447TEST_F(OutputComposeSurfacesTest, handlesZeroCompositionRequests) {
3448 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3449 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3450 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003451 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003452 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003453 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{}));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003454 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3455 .WillRepeatedly(Return());
Lloyd Pique56eba802019-08-28 15:45:25 -07003456
Lloyd Pique6818fa52019-12-03 12:32:13 -08003457 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi4cabdd02021-08-05 16:45:57 -07003458 EXPECT_CALL(mRenderEngine, drawLayers(_, IsEmpty(), _, false, _))
3459 .WillRepeatedly([&](const renderengine::DisplaySettings&,
Sally Qi59a9f502021-10-12 18:53:23 +00003460 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -07003461 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +00003462 base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -07003463 -> std::future<renderengine::RenderEngineResult> {
3464 return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
3465 });
Lloyd Pique6818fa52019-12-03 12:32:13 -08003466 verify().execute().expectAFenceWasReturned();
3467}
Lloyd Pique56eba802019-08-28 15:45:25 -07003468
Lloyd Pique6818fa52019-12-03 12:32:13 -08003469TEST_F(OutputComposeSurfacesTest, buildsAndRendersRequestList) {
Vishnu Nair9b079a22020-01-21 14:36:08 -08003470 LayerFE::LayerSettings r1;
3471 LayerFE::LayerSettings r2;
Lloyd Pique6818fa52019-12-03 12:32:13 -08003472
3473 r1.geometry.boundaries = FloatRect{1, 2, 3, 4};
3474 r2.geometry.boundaries = FloatRect{5, 6, 7, 8};
3475
3476 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3477 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3478 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003479 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003480 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003481 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{r1}));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003482 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3483 .WillRepeatedly(
3484 Invoke([&](const Region&,
Vishnu Nair9b079a22020-01-21 14:36:08 -08003485 std::vector<LayerFE::LayerSettings>& clientCompositionLayers) {
Lloyd Pique6818fa52019-12-03 12:32:13 -08003486 clientCompositionLayers.emplace_back(r2);
3487 }));
3488
3489 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi59a9f502021-10-12 18:53:23 +00003490 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r2), _, false, _))
Sally Qi4cabdd02021-08-05 16:45:57 -07003491 .WillRepeatedly([&](const renderengine::DisplaySettings&,
Sally Qi59a9f502021-10-12 18:53:23 +00003492 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -07003493 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +00003494 base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -07003495 -> std::future<renderengine::RenderEngineResult> {
3496 return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
3497 });
Alec Mouri1684c702021-02-04 12:27:26 -08003498
3499 verify().execute().expectAFenceWasReturned();
3500}
3501
3502TEST_F(OutputComposeSurfacesTest,
3503 buildsAndRendersRequestListAndCachesFramebufferForInternalLayers) {
3504 LayerFE::LayerSettings r1;
3505 LayerFE::LayerSettings r2;
3506
3507 r1.geometry.boundaries = FloatRect{1, 2, 3, 4};
3508 r2.geometry.boundaries = FloatRect{5, 6, 7, 8};
Dominik Laskowski29fa1462021-04-27 15:51:50 -07003509 mOutput.setLayerFilter({ui::LayerStack{1234u}, true});
Alec Mouri1684c702021-02-04 12:27:26 -08003510
3511 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3512 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3513 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
3514 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003515 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Alec Mouri1684c702021-02-04 12:27:26 -08003516 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{r1}));
3517 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3518 .WillRepeatedly(
3519 Invoke([&](const Region&,
3520 std::vector<LayerFE::LayerSettings>& clientCompositionLayers) {
3521 clientCompositionLayers.emplace_back(r2);
3522 }));
3523
3524 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi59a9f502021-10-12 18:53:23 +00003525 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r2), _, true, _))
Sally Qi4cabdd02021-08-05 16:45:57 -07003526 .WillRepeatedly([&](const renderengine::DisplaySettings&,
Sally Qi59a9f502021-10-12 18:53:23 +00003527 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -07003528 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +00003529 base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -07003530 -> std::future<renderengine::RenderEngineResult> {
3531 return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
3532 });
Lloyd Pique6818fa52019-12-03 12:32:13 -08003533
3534 verify().execute().expectAFenceWasReturned();
3535}
3536
Vishnu Nair9b079a22020-01-21 14:36:08 -08003537TEST_F(OutputComposeSurfacesTest, renderDuplicateClientCompositionRequestsWithoutCache) {
3538 mOutput.cacheClientCompositionRequests(0);
3539 LayerFE::LayerSettings r1;
3540 LayerFE::LayerSettings r2;
3541
3542 r1.geometry.boundaries = FloatRect{1, 2, 3, 4};
3543 r2.geometry.boundaries = FloatRect{5, 6, 7, 8};
3544
3545 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3546 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3547 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003548 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003549 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003550 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{r1, r2}));
3551 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3552 .WillRepeatedly(Return());
3553
3554 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi59a9f502021-10-12 18:53:23 +00003555 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r2), _, false, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003556 .Times(2)
Sally Qi4cabdd02021-08-05 16:45:57 -07003557 .WillOnce(Return(ByMove(
3558 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))))
3559 .WillOnce(Return(ByMove(
3560 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))));
Vishnu Nair9b079a22020-01-21 14:36:08 -08003561
3562 verify().execute().expectAFenceWasReturned();
3563 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3564
3565 verify().execute().expectAFenceWasReturned();
3566 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3567}
3568
3569TEST_F(OutputComposeSurfacesTest, skipDuplicateClientCompositionRequests) {
3570 mOutput.cacheClientCompositionRequests(3);
3571 LayerFE::LayerSettings r1;
3572 LayerFE::LayerSettings r2;
3573
3574 r1.geometry.boundaries = FloatRect{1, 2, 3, 4};
3575 r2.geometry.boundaries = FloatRect{5, 6, 7, 8};
3576
3577 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3578 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3579 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003580 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003581 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003582 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{r1, r2}));
3583 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3584 .WillRepeatedly(Return());
3585
3586 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi59a9f502021-10-12 18:53:23 +00003587 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r2), _, false, _))
Sally Qi4cabdd02021-08-05 16:45:57 -07003588 .WillOnce(Return(ByMove(
3589 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))));
Vishnu Nair9b079a22020-01-21 14:36:08 -08003590 EXPECT_CALL(mOutput, setExpensiveRenderingExpected(false));
3591
3592 verify().execute().expectAFenceWasReturned();
3593 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3594
3595 // We do not expect another call to draw layers.
3596 verify().execute().expectAFenceWasReturned();
3597 EXPECT_TRUE(mOutput.mState.reusedClientComposition);
3598}
3599
3600TEST_F(OutputComposeSurfacesTest, clientCompositionIfBufferChanges) {
3601 LayerFE::LayerSettings r1;
3602 LayerFE::LayerSettings r2;
3603
3604 r1.geometry.boundaries = FloatRect{1, 2, 3, 4};
3605 r2.geometry.boundaries = FloatRect{5, 6, 7, 8};
3606
3607 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3608 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3609 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003610 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003611 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003612 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{r1, r2}));
3613 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3614 .WillRepeatedly(Return());
3615
Alec Mouria90a5702021-04-16 16:36:21 +00003616 const auto otherOutputBuffer = std::make_shared<
Vishnu Nairdbbe3852022-01-12 20:22:11 -08003617 renderengine::impl::
3618 ExternalTexture>(new GraphicBuffer(), mRenderEngine,
3619 renderengine::impl::ExternalTexture::Usage::READABLE |
3620 renderengine::impl::ExternalTexture::Usage::WRITEABLE);
Vishnu Nair9b079a22020-01-21 14:36:08 -08003621 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_))
3622 .WillOnce(Return(mOutputBuffer))
3623 .WillOnce(Return(otherOutputBuffer));
Sally Qi59a9f502021-10-12 18:53:23 +00003624 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r2), _, false, _))
Sally Qi4cabdd02021-08-05 16:45:57 -07003625 .WillRepeatedly([&](const renderengine::DisplaySettings&,
Sally Qi59a9f502021-10-12 18:53:23 +00003626 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -07003627 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +00003628 base::unique_fd&&)
Sally Qi4cabdd02021-08-05 16:45:57 -07003629 -> std::future<renderengine::RenderEngineResult> {
3630 return futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()});
3631 });
Vishnu Nair9b079a22020-01-21 14:36:08 -08003632
3633 verify().execute().expectAFenceWasReturned();
3634 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3635
3636 verify().execute().expectAFenceWasReturned();
3637 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3638}
3639
3640TEST_F(OutputComposeSurfacesTest, clientCompositionIfRequestChanges) {
3641 LayerFE::LayerSettings r1;
3642 LayerFE::LayerSettings r2;
3643 LayerFE::LayerSettings r3;
3644
3645 r1.geometry.boundaries = FloatRect{1, 2, 3, 4};
3646 r2.geometry.boundaries = FloatRect{5, 6, 7, 8};
3647 r3.geometry.boundaries = FloatRect{5, 6, 7, 9};
3648
3649 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3650 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3651 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003652 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003653 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003654 .WillOnce(Return(std::vector<LayerFE::LayerSettings>{r1, r2}))
3655 .WillOnce(Return(std::vector<LayerFE::LayerSettings>{r1, r3}));
3656 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3657 .WillRepeatedly(Return());
3658
3659 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi59a9f502021-10-12 18:53:23 +00003660 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r2), _, false, _))
Sally Qi4cabdd02021-08-05 16:45:57 -07003661 .WillOnce(Return(ByMove(
3662 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))));
Sally Qi59a9f502021-10-12 18:53:23 +00003663 EXPECT_CALL(mRenderEngine, drawLayers(_, ElementsAre(r1, r3), _, false, _))
Sally Qi4cabdd02021-08-05 16:45:57 -07003664 .WillOnce(Return(ByMove(
3665 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))));
Vishnu Nair9b079a22020-01-21 14:36:08 -08003666
3667 verify().execute().expectAFenceWasReturned();
3668 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3669
3670 verify().execute().expectAFenceWasReturned();
3671 EXPECT_FALSE(mOutput.mState.reusedClientComposition);
3672}
3673
Lloyd Pique6818fa52019-12-03 12:32:13 -08003674struct OutputComposeSurfacesTest_UsesExpectedDisplaySettings : public OutputComposeSurfacesTest {
3675 OutputComposeSurfacesTest_UsesExpectedDisplaySettings() {
3676 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07003677 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Robert Carrccab4242021-09-28 16:53:03 -07003678 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003679 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{}));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003680 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3681 .WillRepeatedly(Return());
3682 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
3683 }
3684
3685 struct MixedCompositionState
3686 : public CallOrderStateMachineHelper<TestType, MixedCompositionState> {
3687 auto ifMixedCompositionIs(bool used) {
3688 getInstance()->mOutput.mState.usesDeviceComposition = used;
3689 return nextState<OutputUsesHdrState>();
3690 }
3691 };
3692
3693 struct OutputUsesHdrState : public CallOrderStateMachineHelper<TestType, OutputUsesHdrState> {
3694 auto andIfUsesHdr(bool used) {
3695 EXPECT_CALL(*getInstance()->mDisplayColorProfile, hasWideColorGamut())
3696 .WillOnce(Return(used));
Alec Mourib21d94e2022-01-13 17:44:10 -08003697 return nextState<OutputWithDisplayBrightnessNits>();
3698 }
3699 };
3700
3701 struct OutputWithDisplayBrightnessNits
3702 : public CallOrderStateMachineHelper<TestType, OutputWithDisplayBrightnessNits> {
3703 auto withDisplayBrightnessNits(float nits) {
3704 getInstance()->mOutput.mState.displayBrightnessNits = nits;
Alec Mouri85065692022-03-18 00:58:26 +00003705 return nextState<OutputWithDimmingStage>();
3706 }
3707 };
3708
3709 struct OutputWithDimmingStage
3710 : public CallOrderStateMachineHelper<TestType, OutputWithDimmingStage> {
3711 auto withDimmingStage(
3712 aidl::android::hardware::graphics::composer3::DimmingStage dimmingStage) {
3713 getInstance()->mOutput.mState.clientTargetDimmingStage = dimmingStage;
Alec Mourifcedb9c2022-04-11 20:02:17 +00003714 return nextState<OutputWithRenderIntent>();
3715 }
3716 };
3717
3718 struct OutputWithRenderIntent
3719 : public CallOrderStateMachineHelper<TestType, OutputWithRenderIntent> {
3720 auto withRenderIntent(
3721 aidl::android::hardware::graphics::composer3::RenderIntent renderIntent) {
3722 getInstance()->mOutput.mState.renderIntent =
3723 static_cast<ui::RenderIntent>(renderIntent);
Lloyd Pique6818fa52019-12-03 12:32:13 -08003724 return nextState<SkipColorTransformState>();
3725 }
3726 };
3727
3728 struct SkipColorTransformState
3729 : public CallOrderStateMachineHelper<TestType, SkipColorTransformState> {
3730 auto andIfSkipColorTransform(bool skip) {
3731 // May be called zero or one times.
3732 EXPECT_CALL(getInstance()->mOutput, getSkipColorTransform())
3733 .WillRepeatedly(Return(skip));
3734 return nextState<ExpectDisplaySettingsState>();
3735 }
3736 };
3737
3738 struct ExpectDisplaySettingsState
3739 : public CallOrderStateMachineHelper<TestType, ExpectDisplaySettingsState> {
3740 auto thenExpectDisplaySettingsUsed(renderengine::DisplaySettings settings) {
Sally Qi4cabdd02021-08-05 16:45:57 -07003741 EXPECT_CALL(getInstance()->mRenderEngine, drawLayers(settings, _, _, false, _))
3742 .WillOnce(Return(ByMove(futureOf<renderengine::RenderEngineResult>(
3743 {NO_ERROR, base::unique_fd()}))));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003744 return nextState<ExecuteState>();
3745 }
3746 };
3747
3748 // Call this member function to start using the mini-DSL defined above.
3749 [[nodiscard]] auto verify() { return MixedCompositionState::make(this); }
3750};
3751
3752TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, forHdrMixedComposition) {
3753 verify().ifMixedCompositionIs(true)
3754 .andIfUsesHdr(true)
Alec Mourib21d94e2022-01-13 17:44:10 -08003755 .withDisplayBrightnessNits(kUnknownLuminance)
Alec Mouri85065692022-03-18 00:58:26 +00003756 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
Alec Mourifcedb9c2022-04-11 20:02:17 +00003757 .withRenderIntent(
3758 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
Lloyd Pique6818fa52019-12-03 12:32:13 -08003759 .andIfSkipColorTransform(false)
Alec Mouri85065692022-03-18 00:58:26 +00003760 .thenExpectDisplaySettingsUsed(
3761 {.physicalDisplay = kDefaultOutputDestinationClip,
3762 .clip = kDefaultOutputViewport,
3763 .maxLuminance = kDefaultMaxLuminance,
3764 .currentLuminanceNits = kDefaultMaxLuminance,
3765 .outputDataspace = kDefaultOutputDataspace,
3766 .colorTransform = kDefaultColorTransformMat,
3767 .deviceHandlesColorTransform = true,
3768 .orientation = kDefaultOutputOrientationFlags,
3769 .targetLuminanceNits = kClientTargetLuminanceNits,
3770 .dimmingStage =
Alec Mourifcedb9c2022-04-11 20:02:17 +00003771 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3772 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3773 COLORIMETRIC})
Alec Mourib21d94e2022-01-13 17:44:10 -08003774 .execute()
3775 .expectAFenceWasReturned();
3776}
3777
3778TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings,
3779 forHdrMixedCompositionWithDisplayBrightness) {
3780 verify().ifMixedCompositionIs(true)
3781 .andIfUsesHdr(true)
3782 .withDisplayBrightnessNits(kDisplayLuminance)
Alec Mouri85065692022-03-18 00:58:26 +00003783 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
Alec Mourifcedb9c2022-04-11 20:02:17 +00003784 .withRenderIntent(
3785 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
Alec Mouri85065692022-03-18 00:58:26 +00003786 .andIfSkipColorTransform(false)
3787 .thenExpectDisplaySettingsUsed(
3788 {.physicalDisplay = kDefaultOutputDestinationClip,
3789 .clip = kDefaultOutputViewport,
3790 .maxLuminance = kDefaultMaxLuminance,
3791 .currentLuminanceNits = kDisplayLuminance,
3792 .outputDataspace = kDefaultOutputDataspace,
3793 .colorTransform = kDefaultColorTransformMat,
3794 .deviceHandlesColorTransform = true,
3795 .orientation = kDefaultOutputOrientationFlags,
3796 .targetLuminanceNits = kClientTargetLuminanceNits,
3797 .dimmingStage =
Alec Mourifcedb9c2022-04-11 20:02:17 +00003798 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3799 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3800 COLORIMETRIC})
Alec Mouri85065692022-03-18 00:58:26 +00003801 .execute()
3802 .expectAFenceWasReturned();
3803}
3804
3805TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings,
3806 forHdrMixedCompositionWithDimmingStage) {
3807 verify().ifMixedCompositionIs(true)
3808 .andIfUsesHdr(true)
3809 .withDisplayBrightnessNits(kUnknownLuminance)
3810 .withDimmingStage(
3811 aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF)
Alec Mourifcedb9c2022-04-11 20:02:17 +00003812 .withRenderIntent(
3813 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
Lloyd Pique6818fa52019-12-03 12:32:13 -08003814 .andIfSkipColorTransform(false)
Alec Mouri85065692022-03-18 00:58:26 +00003815 .thenExpectDisplaySettingsUsed(
3816 {.physicalDisplay = kDefaultOutputDestinationClip,
3817 .clip = kDefaultOutputViewport,
3818 .maxLuminance = kDefaultMaxLuminance,
3819 .currentLuminanceNits = kDefaultMaxLuminance,
3820 .outputDataspace = kDefaultOutputDataspace,
3821 .colorTransform = kDefaultColorTransformMat,
3822 .deviceHandlesColorTransform = true,
3823 .orientation = kDefaultOutputOrientationFlags,
3824 .targetLuminanceNits = kClientTargetLuminanceNits,
3825 .dimmingStage =
Alec Mourifcedb9c2022-04-11 20:02:17 +00003826 aidl::android::hardware::graphics::composer3::DimmingStage::GAMMA_OETF,
3827 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3828 COLORIMETRIC})
3829 .execute()
3830 .expectAFenceWasReturned();
3831}
3832
3833TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings,
3834 forHdrMixedCompositionWithRenderIntent) {
3835 verify().ifMixedCompositionIs(true)
3836 .andIfUsesHdr(true)
3837 .withDisplayBrightnessNits(kUnknownLuminance)
3838 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
3839 .withRenderIntent(aidl::android::hardware::graphics::composer3::RenderIntent::ENHANCE)
3840 .andIfSkipColorTransform(false)
3841 .thenExpectDisplaySettingsUsed(
3842 {.physicalDisplay = kDefaultOutputDestinationClip,
3843 .clip = kDefaultOutputViewport,
3844 .maxLuminance = kDefaultMaxLuminance,
3845 .currentLuminanceNits = kDefaultMaxLuminance,
3846 .outputDataspace = kDefaultOutputDataspace,
3847 .colorTransform = kDefaultColorTransformMat,
3848 .deviceHandlesColorTransform = true,
3849 .orientation = kDefaultOutputOrientationFlags,
3850 .targetLuminanceNits = kClientTargetLuminanceNits,
3851 .dimmingStage =
3852 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3853 .renderIntent =
3854 aidl::android::hardware::graphics::composer3::RenderIntent::ENHANCE})
3855 .execute()
3856 .expectAFenceWasReturned();
3857}
3858
3859TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, forNonHdrMixedComposition) {
3860 verify().ifMixedCompositionIs(true)
3861 .andIfUsesHdr(false)
3862 .withDisplayBrightnessNits(kUnknownLuminance)
3863 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
3864 .withRenderIntent(
3865 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
3866 .andIfSkipColorTransform(false)
3867 .thenExpectDisplaySettingsUsed(
3868 {.physicalDisplay = kDefaultOutputDestinationClip,
3869 .clip = kDefaultOutputViewport,
3870 .maxLuminance = kDefaultMaxLuminance,
3871 .currentLuminanceNits = kDefaultMaxLuminance,
3872 .outputDataspace = kDefaultOutputDataspace,
3873 .colorTransform = kDefaultColorTransformMat,
3874 .deviceHandlesColorTransform = true,
3875 .orientation = kDefaultOutputOrientationFlags,
3876 .targetLuminanceNits = kClientTargetLuminanceNits,
3877 .dimmingStage =
3878 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3879 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3880 COLORIMETRIC})
Lloyd Pique6818fa52019-12-03 12:32:13 -08003881 .execute()
3882 .expectAFenceWasReturned();
3883}
3884
3885TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, forHdrOnlyClientComposition) {
3886 verify().ifMixedCompositionIs(false)
3887 .andIfUsesHdr(true)
Alec Mourib21d94e2022-01-13 17:44:10 -08003888 .withDisplayBrightnessNits(kUnknownLuminance)
Alec Mouri85065692022-03-18 00:58:26 +00003889 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
Alec Mourifcedb9c2022-04-11 20:02:17 +00003890 .withRenderIntent(
3891 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
Lloyd Pique6818fa52019-12-03 12:32:13 -08003892 .andIfSkipColorTransform(false)
Alec Mouri85065692022-03-18 00:58:26 +00003893 .thenExpectDisplaySettingsUsed(
3894 {.physicalDisplay = kDefaultOutputDestinationClip,
3895 .clip = kDefaultOutputViewport,
3896 .maxLuminance = kDefaultMaxLuminance,
3897 .currentLuminanceNits = kDefaultMaxLuminance,
3898 .outputDataspace = kDefaultOutputDataspace,
3899 .colorTransform = kDefaultColorTransformMat,
3900 .deviceHandlesColorTransform = false,
3901 .orientation = kDefaultOutputOrientationFlags,
3902 .targetLuminanceNits = kClientTargetLuminanceNits,
3903 .dimmingStage =
Alec Mourifcedb9c2022-04-11 20:02:17 +00003904 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3905 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3906 COLORIMETRIC})
Lloyd Pique6818fa52019-12-03 12:32:13 -08003907 .execute()
3908 .expectAFenceWasReturned();
3909}
3910
3911TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings, forNonHdrOnlyClientComposition) {
3912 verify().ifMixedCompositionIs(false)
3913 .andIfUsesHdr(false)
Alec Mourib21d94e2022-01-13 17:44:10 -08003914 .withDisplayBrightnessNits(kUnknownLuminance)
Alec Mouri85065692022-03-18 00:58:26 +00003915 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
Alec Mourifcedb9c2022-04-11 20:02:17 +00003916 .withRenderIntent(
3917 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
Lloyd Pique6818fa52019-12-03 12:32:13 -08003918 .andIfSkipColorTransform(false)
Alec Mouri85065692022-03-18 00:58:26 +00003919 .thenExpectDisplaySettingsUsed(
3920 {.physicalDisplay = kDefaultOutputDestinationClip,
3921 .clip = kDefaultOutputViewport,
3922 .maxLuminance = kDefaultMaxLuminance,
3923 .currentLuminanceNits = kDefaultMaxLuminance,
3924 .outputDataspace = kDefaultOutputDataspace,
3925 .colorTransform = kDefaultColorTransformMat,
3926 .deviceHandlesColorTransform = false,
3927 .orientation = kDefaultOutputOrientationFlags,
3928 .targetLuminanceNits = kClientTargetLuminanceNits,
3929 .dimmingStage =
Alec Mourifcedb9c2022-04-11 20:02:17 +00003930 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3931 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3932 COLORIMETRIC})
Lloyd Pique6818fa52019-12-03 12:32:13 -08003933 .execute()
3934 .expectAFenceWasReturned();
3935}
3936
3937TEST_F(OutputComposeSurfacesTest_UsesExpectedDisplaySettings,
3938 usesExpectedDisplaySettingsForHdrOnlyClientCompositionWithSkipClientTransform) {
3939 verify().ifMixedCompositionIs(false)
3940 .andIfUsesHdr(true)
Alec Mourib21d94e2022-01-13 17:44:10 -08003941 .withDisplayBrightnessNits(kUnknownLuminance)
Alec Mouri85065692022-03-18 00:58:26 +00003942 .withDimmingStage(aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR)
Alec Mourifcedb9c2022-04-11 20:02:17 +00003943 .withRenderIntent(
3944 aidl::android::hardware::graphics::composer3::RenderIntent::COLORIMETRIC)
Lloyd Pique6818fa52019-12-03 12:32:13 -08003945 .andIfSkipColorTransform(true)
Alec Mouri85065692022-03-18 00:58:26 +00003946 .thenExpectDisplaySettingsUsed(
3947 {.physicalDisplay = kDefaultOutputDestinationClip,
3948 .clip = kDefaultOutputViewport,
3949 .maxLuminance = kDefaultMaxLuminance,
3950 .currentLuminanceNits = kDefaultMaxLuminance,
3951 .outputDataspace = kDefaultOutputDataspace,
3952 .colorTransform = kDefaultColorTransformMat,
3953 .deviceHandlesColorTransform = true,
3954 .orientation = kDefaultOutputOrientationFlags,
3955 .targetLuminanceNits = kClientTargetLuminanceNits,
3956 .dimmingStage =
Alec Mourifcedb9c2022-04-11 20:02:17 +00003957 aidl::android::hardware::graphics::composer3::DimmingStage::LINEAR,
3958 .renderIntent = aidl::android::hardware::graphics::composer3::RenderIntent::
3959 COLORIMETRIC})
Lloyd Pique6818fa52019-12-03 12:32:13 -08003960 .execute()
3961 .expectAFenceWasReturned();
3962}
3963
3964struct OutputComposeSurfacesTest_HandlesProtectedContent : public OutputComposeSurfacesTest {
3965 struct Layer {
3966 Layer() {
Ady Abrahameca9d752021-03-03 12:20:00 -08003967 EXPECT_CALL(*mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));
3968 EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003969 }
3970
3971 StrictMock<mock::OutputLayer> mOutputLayer;
Ady Abrahameca9d752021-03-03 12:20:00 -08003972 sp<StrictMock<mock::LayerFE>> mLayerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Pique6818fa52019-12-03 12:32:13 -08003973 LayerFECompositionState mLayerFEState;
3974 };
3975
3976 OutputComposeSurfacesTest_HandlesProtectedContent() {
3977 mLayer1.mLayerFEState.hasProtectedContent = false;
3978 mLayer2.mLayerFEState.hasProtectedContent = false;
3979
3980 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(2u));
3981 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
3982 .WillRepeatedly(Return(&mLayer1.mOutputLayer));
3983 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1u))
3984 .WillRepeatedly(Return(&mLayer2.mOutputLayer));
3985
3986 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
3987
3988 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
3989
Robert Carrccab4242021-09-28 16:53:03 -07003990 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, _, _))
Vishnu Nair9b079a22020-01-21 14:36:08 -08003991 .WillRepeatedly(Return(std::vector<LayerFE::LayerSettings>{}));
Lloyd Pique6818fa52019-12-03 12:32:13 -08003992 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
3993 .WillRepeatedly(Return());
3994 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi4cabdd02021-08-05 16:45:57 -07003995 EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, false, _))
3996 .WillRepeatedly(
3997 [&](const renderengine::DisplaySettings&,
Sally Qi59a9f502021-10-12 18:53:23 +00003998 const std::vector<renderengine::LayerSettings>&,
Sally Qi4cabdd02021-08-05 16:45:57 -07003999 const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
Sally Qi59a9f502021-10-12 18:53:23 +00004000 base::unique_fd&&) -> std::future<renderengine::RenderEngineResult> {
Sally Qi4cabdd02021-08-05 16:45:57 -07004001 return futureOf<renderengine::RenderEngineResult>(
4002 {NO_ERROR, base::unique_fd()});
4003 });
Lloyd Pique6818fa52019-12-03 12:32:13 -08004004 }
4005
4006 Layer mLayer1;
4007 Layer mLayer2;
4008};
4009
4010TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifDisplayIsNotSecure) {
4011 mOutput.mState.isSecure = false;
4012 mLayer2.mLayerFEState.hasProtectedContent = true;
4013 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
Peiyong Lin09f910f2020-09-25 10:54:13 -07004014 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(true));
Derek Sollenberger1ec2fb52021-06-16 15:11:27 -04004015 EXPECT_CALL(mRenderEngine, useProtectedContext(false));
Lloyd Pique6818fa52019-12-03 12:32:13 -08004016
Vishnu Naira3140382022-02-24 14:07:11 -08004017 base::unique_fd fd;
4018 std::shared_ptr<renderengine::ExternalTexture> tex;
4019 mOutput.updateProtectedContentState();
4020 mOutput.dequeueRenderBuffer(&fd, &tex);
4021 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004022}
4023
4024TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifRenderEngineDoesNotSupportIt) {
4025 mOutput.mState.isSecure = true;
4026 mLayer2.mLayerFEState.hasProtectedContent = true;
4027 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
4028
Vishnu Naira3140382022-02-24 14:07:11 -08004029 base::unique_fd fd;
4030 std::shared_ptr<renderengine::ExternalTexture> tex;
4031 mOutput.updateProtectedContentState();
4032 mOutput.dequeueRenderBuffer(&fd, &tex);
4033 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004034}
4035
4036TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifNoProtectedContentLayers) {
4037 mOutput.mState.isSecure = true;
4038 mLayer2.mLayerFEState.hasProtectedContent = false;
4039 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
4040 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(true)).WillOnce(Return(false));
4041 EXPECT_CALL(*mRenderSurface, isProtected).WillOnce(Return(true));
4042 EXPECT_CALL(mRenderEngine, useProtectedContext(false));
4043 EXPECT_CALL(*mRenderSurface, setProtected(false));
4044
Vishnu Naira3140382022-02-24 14:07:11 -08004045 base::unique_fd fd;
4046 std::shared_ptr<renderengine::ExternalTexture> tex;
4047 mOutput.updateProtectedContentState();
4048 mOutput.dequeueRenderBuffer(&fd, &tex);
4049 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004050}
4051
4052TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifNotEnabled) {
4053 mOutput.mState.isSecure = true;
4054 mLayer2.mLayerFEState.hasProtectedContent = true;
4055 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
4056
4057 // For this test, we also check the call order of key functions.
4058 InSequence seq;
4059
4060 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(false));
4061 EXPECT_CALL(mRenderEngine, useProtectedContext(true));
4062 EXPECT_CALL(*mRenderSurface, isProtected).WillOnce(Return(false));
4063 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(true));
4064 EXPECT_CALL(*mRenderSurface, setProtected(true));
4065 // Must happen after setting the protected content state.
4066 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
Sally Qi4cabdd02021-08-05 16:45:57 -07004067 EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, false, _))
4068 .WillOnce(Return(ByMove(
4069 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))));
Lloyd Pique6818fa52019-12-03 12:32:13 -08004070
Vishnu Naira3140382022-02-24 14:07:11 -08004071 base::unique_fd fd;
4072 std::shared_ptr<renderengine::ExternalTexture> tex;
4073 mOutput.updateProtectedContentState();
4074 mOutput.dequeueRenderBuffer(&fd, &tex);
4075 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004076}
4077
4078TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifAlreadyEnabledEverywhere) {
4079 mOutput.mState.isSecure = true;
4080 mLayer2.mLayerFEState.hasProtectedContent = true;
4081 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
4082 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(true));
4083 EXPECT_CALL(*mRenderSurface, isProtected).WillOnce(Return(true));
4084
Vishnu Naira3140382022-02-24 14:07:11 -08004085 base::unique_fd fd;
4086 std::shared_ptr<renderengine::ExternalTexture> tex;
4087 mOutput.updateProtectedContentState();
4088 mOutput.dequeueRenderBuffer(&fd, &tex);
4089 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004090}
4091
4092TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifFailsToEnableInRenderEngine) {
4093 mOutput.mState.isSecure = true;
4094 mLayer2.mLayerFEState.hasProtectedContent = true;
4095 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
4096 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(false)).WillOnce(Return(false));
4097 EXPECT_CALL(*mRenderSurface, isProtected).WillOnce(Return(false));
4098 EXPECT_CALL(mRenderEngine, useProtectedContext(true));
4099
Vishnu Naira3140382022-02-24 14:07:11 -08004100 base::unique_fd fd;
4101 std::shared_ptr<renderengine::ExternalTexture> tex;
4102 mOutput.updateProtectedContentState();
4103 mOutput.dequeueRenderBuffer(&fd, &tex);
4104 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004105}
4106
4107TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifAlreadyEnabledInRenderEngine) {
4108 mOutput.mState.isSecure = true;
4109 mLayer2.mLayerFEState.hasProtectedContent = true;
4110 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
4111 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(true)).WillOnce(Return(true));
4112 EXPECT_CALL(*mRenderSurface, isProtected).WillOnce(Return(false));
4113 EXPECT_CALL(*mRenderSurface, setProtected(true));
4114
Vishnu Naira3140382022-02-24 14:07:11 -08004115 base::unique_fd fd;
4116 std::shared_ptr<renderengine::ExternalTexture> tex;
4117 mOutput.updateProtectedContentState();
4118 mOutput.dequeueRenderBuffer(&fd, &tex);
4119 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004120}
4121
4122TEST_F(OutputComposeSurfacesTest_HandlesProtectedContent, ifAlreadyEnabledInRenderSurface) {
4123 mOutput.mState.isSecure = true;
4124 mLayer2.mLayerFEState.hasProtectedContent = true;
4125 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(true));
4126 EXPECT_CALL(mRenderEngine, isProtected).WillOnce(Return(false));
4127 EXPECT_CALL(*mRenderSurface, isProtected).WillOnce(Return(true));
4128 EXPECT_CALL(mRenderEngine, useProtectedContext(true));
4129
Vishnu Naira3140382022-02-24 14:07:11 -08004130 base::unique_fd fd;
4131 std::shared_ptr<renderengine::ExternalTexture> tex;
4132 mOutput.updateProtectedContentState();
4133 mOutput.dequeueRenderBuffer(&fd, &tex);
4134 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lloyd Pique6818fa52019-12-03 12:32:13 -08004135}
4136
4137struct OutputComposeSurfacesTest_SetsExpensiveRendering : public OutputComposeSurfacesTest {
4138 OutputComposeSurfacesTest_SetsExpensiveRendering() {
4139 EXPECT_CALL(mOutput, getSkipColorTransform()).WillRepeatedly(Return(false));
4140 EXPECT_CALL(*mDisplayColorProfile, hasWideColorGamut()).WillRepeatedly(Return(true));
4141 EXPECT_CALL(mRenderEngine, supportsProtectedContent()).WillRepeatedly(Return(false));
Peiyong Lin09f910f2020-09-25 10:54:13 -07004142 EXPECT_CALL(mRenderEngine, isProtected()).WillRepeatedly(Return(false));
Lloyd Pique6818fa52019-12-03 12:32:13 -08004143 EXPECT_CALL(mOutput, appendRegionFlashRequests(RegionEq(kDebugRegion), _))
4144 .WillRepeatedly(Return());
4145 EXPECT_CALL(*mRenderSurface, dequeueBuffer(_)).WillRepeatedly(Return(mOutputBuffer));
4146 }
4147};
4148
4149TEST_F(OutputComposeSurfacesTest_SetsExpensiveRendering, IfExepensiveOutputDataspaceIsUsed) {
4150 mOutput.mState.dataspace = kExpensiveOutputDataspace;
4151
Leon Scroggins III7bdcceb2022-03-09 16:53:52 -05004152 LayerFE::LayerSettings layerSettings;
Robert Carrccab4242021-09-28 16:53:03 -07004153 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kExpensiveOutputDataspace, _))
Leon Scroggins III7bdcceb2022-03-09 16:53:52 -05004154 .WillOnce(Return(std::vector<LayerFE::LayerSettings>{layerSettings}));
Lloyd Pique6818fa52019-12-03 12:32:13 -08004155
4156 // For this test, we also check the call order of key functions.
4157 InSequence seq;
4158
4159 EXPECT_CALL(mOutput, setExpensiveRenderingExpected(true));
Sally Qi4cabdd02021-08-05 16:45:57 -07004160 EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, false, _))
4161 .WillOnce(Return(ByMove(
4162 futureOf<renderengine::RenderEngineResult>({NO_ERROR, base::unique_fd()}))));
Lloyd Pique6818fa52019-12-03 12:32:13 -08004163
Vishnu Naira3140382022-02-24 14:07:11 -08004164 base::unique_fd fd;
4165 std::shared_ptr<renderengine::ExternalTexture> tex;
4166 mOutput.updateProtectedContentState();
4167 mOutput.dequeueRenderBuffer(&fd, &tex);
4168 mOutput.composeSurfaces(kDebugRegion, kDefaultRefreshArgs, tex, fd);
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004169}
4170
4171struct OutputComposeSurfacesTest_SetsExpensiveRendering_ForBlur
4172 : public OutputComposeSurfacesTest_SetsExpensiveRendering {
4173 OutputComposeSurfacesTest_SetsExpensiveRendering_ForBlur() {
4174 mLayer.layerFEState.backgroundBlurRadius = 10;
Lucas Dupin084a6d42021-08-26 22:10:29 +00004175 mLayer.layerFEState.isOpaque = false;
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004176 mOutput.editState().isEnabled = true;
4177
Snild Dolkow9e217d62020-04-22 15:53:42 +02004178 EXPECT_CALL(mLayer.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004179 EXPECT_CALL(mLayer.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004180 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, 0,
4181 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Robert Carrccab4242021-09-28 16:53:03 -07004182 EXPECT_CALL(mOutput, generateClientCompositionRequests(_, kDefaultOutputDataspace, _))
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004183 .WillOnce(Return(std::vector<LayerFE::LayerSettings>{}));
Sally Qi4cabdd02021-08-05 16:45:57 -07004184 EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, false, _))
4185 .WillOnce(Return(ByMove(futureOf<renderengine::RenderEngineResult>(
4186 {NO_ERROR, base::unique_fd()}))));
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004187 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(1u));
4188 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
4189 .WillRepeatedly(Return(&mLayer.outputLayer));
4190 }
4191
4192 NonInjectedLayer mLayer;
4193 compositionengine::CompositionRefreshArgs mRefreshArgs;
4194};
4195
4196TEST_F(OutputComposeSurfacesTest_SetsExpensiveRendering_ForBlur, IfBlursAreExpensive) {
4197 mRefreshArgs.blursAreExpensive = true;
Dan Stoza269dc4d2021-01-15 15:07:43 -08004198 mOutput.updateCompositionState(mRefreshArgs);
4199 mOutput.planComposition();
4200 mOutput.writeCompositionState(mRefreshArgs);
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004201
4202 EXPECT_CALL(mOutput, setExpensiveRenderingExpected(true));
Vishnu Naira3140382022-02-24 14:07:11 -08004203
4204 base::unique_fd fd;
4205 std::shared_ptr<renderengine::ExternalTexture> tex;
4206 mOutput.updateProtectedContentState();
4207 mOutput.dequeueRenderBuffer(&fd, &tex);
4208 mOutput.composeSurfaces(kDebugRegion, mRefreshArgs, tex, fd);
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004209}
4210
4211TEST_F(OutputComposeSurfacesTest_SetsExpensiveRendering_ForBlur, IfBlursAreNotExpensive) {
4212 mRefreshArgs.blursAreExpensive = false;
Dan Stoza269dc4d2021-01-15 15:07:43 -08004213 mOutput.updateCompositionState(mRefreshArgs);
4214 mOutput.planComposition();
4215 mOutput.writeCompositionState(mRefreshArgs);
Lucas Dupin2dd6f392020-02-18 17:43:36 -08004216
4217 EXPECT_CALL(mOutput, setExpensiveRenderingExpected(true)).Times(0);
Vishnu Naira3140382022-02-24 14:07:11 -08004218
4219 base::unique_fd fd;
4220 std::shared_ptr<renderengine::ExternalTexture> tex;
4221 mOutput.updateProtectedContentState();
4222 mOutput.dequeueRenderBuffer(&fd, &tex);
4223 mOutput.composeSurfaces(kDebugRegion, mRefreshArgs, tex, fd);
Lloyd Pique56eba802019-08-28 15:45:25 -07004224}
4225
4226/*
4227 * Output::generateClientCompositionRequests()
4228 */
4229
4230struct GenerateClientCompositionRequestsTest : public testing::Test {
Lloyd Piquefaa3f192019-11-14 14:05:09 -08004231 struct OutputPartialMock : public OutputPartialMockBase {
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07004232 // compositionengine::Output overrides
Robert Carrccab4242021-09-28 16:53:03 -07004233 std::vector<LayerFE::LayerSettings> generateClientCompositionRequestsHelper(
4234 bool supportsProtectedContent, ui::Dataspace dataspace) {
4235 std::vector<LayerFE*> ignore;
Lloyd Pique56eba802019-08-28 15:45:25 -07004236 return impl::Output::generateClientCompositionRequests(supportsProtectedContent,
Robert Carrccab4242021-09-28 16:53:03 -07004237 dataspace, ignore);
Lloyd Pique56eba802019-08-28 15:45:25 -07004238 }
4239 };
4240
Lloyd Piquea4863342019-12-04 18:45:02 -08004241 struct Layer {
4242 Layer() {
4243 EXPECT_CALL(mOutputLayer, getState()).WillRepeatedly(ReturnRef(mOutputLayerState));
4244 EXPECT_CALL(mOutputLayer, editState()).WillRepeatedly(ReturnRef(mOutputLayerState));
Ady Abrahameca9d752021-03-03 12:20:00 -08004245 EXPECT_CALL(mOutputLayer, getLayerFE()).WillRepeatedly(ReturnRef(*mLayerFE));
4246 EXPECT_CALL(*mLayerFE, getCompositionState()).WillRepeatedly(Return(&mLayerFEState));
Lloyd Piquea4863342019-12-04 18:45:02 -08004247 }
4248
4249 StrictMock<mock::OutputLayer> mOutputLayer;
Ady Abrahameca9d752021-03-03 12:20:00 -08004250 sp<StrictMock<mock::LayerFE>> mLayerFE = sp<StrictMock<mock::LayerFE>>::make();
Lloyd Piquea4863342019-12-04 18:45:02 -08004251 LayerFECompositionState mLayerFEState;
4252 impl::OutputLayerCompositionState mOutputLayerState;
Vishnu Nair9b079a22020-01-21 14:36:08 -08004253 LayerFE::LayerSettings mLayerSettings;
Lloyd Piquea4863342019-12-04 18:45:02 -08004254 };
4255
Lloyd Pique56eba802019-08-28 15:45:25 -07004256 GenerateClientCompositionRequestsTest() {
Lloyd Piquea4863342019-12-04 18:45:02 -08004257 mOutput.mState.needsFiltering = false;
4258
Lloyd Pique56eba802019-08-28 15:45:25 -07004259 mOutput.setDisplayColorProfileForTest(
4260 std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
4261 mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
4262 }
4263
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004264 static constexpr float kLayerWhitePointNits = 200.f;
4265
Lloyd Pique56eba802019-08-28 15:45:25 -07004266 mock::DisplayColorProfile* mDisplayColorProfile = new StrictMock<mock::DisplayColorProfile>();
4267 mock::RenderSurface* mRenderSurface = new StrictMock<mock::RenderSurface>();
Lloyd Piquea38ea7e2019-04-16 18:10:26 -07004268 StrictMock<OutputPartialMock> mOutput;
Lloyd Pique56eba802019-08-28 15:45:25 -07004269};
4270
Lloyd Piquea4863342019-12-04 18:45:02 -08004271struct GenerateClientCompositionRequestsTest_ThreeLayers
4272 : public GenerateClientCompositionRequestsTest {
4273 GenerateClientCompositionRequestsTest_ThreeLayers() {
Angel Aguayob084e0c2021-08-04 23:27:28 +00004274 mOutput.mState.orientedDisplaySpace.setContent(kDisplayFrame);
4275 mOutput.mState.layerStackSpace.setContent(kDisplayViewport);
4276 mOutput.mState.displaySpace.setContent(kDisplayDestinationClip);
Marin Shalamanov68933fb2020-09-10 17:58:12 +02004277 mOutput.mState.transform =
4278 ui::Transform{ui::Transform::toRotationFlags(kDisplayOrientation)};
Angel Aguayob084e0c2021-08-04 23:27:28 +00004279 mOutput.mState.displaySpace.setOrientation(kDisplayOrientation);
Lloyd Piquea4863342019-12-04 18:45:02 -08004280 mOutput.mState.needsFiltering = false;
4281 mOutput.mState.isSecure = false;
Lloyd Pique56eba802019-08-28 15:45:25 -07004282
Lloyd Piquea4863342019-12-04 18:45:02 -08004283 for (size_t i = 0; i < mLayers.size(); i++) {
4284 mLayers[i].mOutputLayerState.clearClientTarget = false;
4285 mLayers[i].mOutputLayerState.visibleRegion = Region(kDisplayFrame);
4286 mLayers[i].mLayerFEState.isOpaque = true;
Vishnu Nair9b079a22020-01-21 14:36:08 -08004287 mLayers[i].mLayerSettings.geometry.boundaries =
Lloyd Piquea4863342019-12-04 18:45:02 -08004288 FloatRect{static_cast<float>(i + 1), 0.f, 0.f, 0.f};
Vishnu Nair9b079a22020-01-21 14:36:08 -08004289 mLayers[i].mLayerSettings.source.solidColor = {1.0f, 1.0f, 1.0f};
4290 mLayers[i].mLayerSettings.alpha = 1.0f;
4291 mLayers[i].mLayerSettings.disableBlending = false;
Lloyd Pique56eba802019-08-28 15:45:25 -07004292
Lloyd Piquea4863342019-12-04 18:45:02 -08004293 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(i))
4294 .WillRepeatedly(Return(&mLayers[i].mOutputLayer));
4295 EXPECT_CALL(mLayers[i].mOutputLayer, requiresClientComposition())
4296 .WillRepeatedly(Return(true));
4297 EXPECT_CALL(mLayers[i].mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
4298 }
Lloyd Pique56eba802019-08-28 15:45:25 -07004299
Lloyd Piquea4863342019-12-04 18:45:02 -08004300 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(mLayers.size()));
4301 }
Lloyd Pique56eba802019-08-28 15:45:25 -07004302
Marin Shalamanov68933fb2020-09-10 17:58:12 +02004303 static constexpr ui::Rotation kDisplayOrientation = ui::ROTATION_0;
Lloyd Piquea4863342019-12-04 18:45:02 -08004304 static constexpr ui::Dataspace kDisplayDataspace = ui::Dataspace::UNKNOWN;
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004305 static constexpr float kLayerWhitePointNits = 200.f;
Lloyd Pique56eba802019-08-28 15:45:25 -07004306
Lloyd Piquea4863342019-12-04 18:45:02 -08004307 static const Rect kDisplayFrame;
4308 static const Rect kDisplayViewport;
Lloyd Piquee8fe4742020-01-21 15:26:18 -08004309 static const Rect kDisplayDestinationClip;
Lloyd Pique56eba802019-08-28 15:45:25 -07004310
Lloyd Piquea4863342019-12-04 18:45:02 -08004311 std::array<Layer, 3> mLayers;
4312};
Lloyd Pique56eba802019-08-28 15:45:25 -07004313
Lloyd Piquea4863342019-12-04 18:45:02 -08004314const Rect GenerateClientCompositionRequestsTest_ThreeLayers::kDisplayFrame(0, 0, 100, 200);
4315const Rect GenerateClientCompositionRequestsTest_ThreeLayers::kDisplayViewport(0, 0, 101, 201);
Lloyd Piquee8fe4742020-01-21 15:26:18 -08004316const Rect GenerateClientCompositionRequestsTest_ThreeLayers::kDisplayDestinationClip(0, 0, 103,
4317 203);
Lloyd Pique56eba802019-08-28 15:45:25 -07004318
Lloyd Piquea4863342019-12-04 18:45:02 -08004319TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, handlesNoClientCompostionLayers) {
4320 EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4321 EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4322 EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
Lloyd Pique56eba802019-08-28 15:45:25 -07004323
Robert Carrccab4242021-09-28 16:53:03 -07004324 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004325 kDisplayDataspace);
Lloyd Pique56eba802019-08-28 15:45:25 -07004326 EXPECT_EQ(0u, requests.size());
4327}
4328
Lloyd Piquea4863342019-12-04 18:45:02 -08004329TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, requiresVisibleRegionAfterViewportClip) {
4330 mLayers[0].mOutputLayerState.visibleRegion = Region(Rect(10, 10, 10, 10));
4331 mLayers[1].mOutputLayerState.visibleRegion = Region(Rect(4000, 0, 4010, 10));
4332 mLayers[2].mOutputLayerState.visibleRegion = Region(Rect(-10, -10, 0, 0));
4333
Robert Carrccab4242021-09-28 16:53:03 -07004334 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004335 kDisplayDataspace);
Lloyd Piquea4863342019-12-04 18:45:02 -08004336 EXPECT_EQ(0u, requests.size());
Lloyd Piquea4863342019-12-04 18:45:02 -08004337}
4338
4339TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, gathersClientCompositionRequests) {
Vishnu Nair9b079a22020-01-21 14:36:08 -08004340 LayerFE::LayerSettings mShadowSettings;
4341 mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
Lloyd Piquea4863342019-12-04 18:45:02 -08004342
Ady Abrahameca9d752021-03-03 12:20:00 -08004343 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004344 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004345 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004346 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings})));
Ady Abrahameca9d752021-03-03 12:20:00 -08004347 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004348 .WillOnce(Return(std::vector<LayerFE::LayerSettings>(
4349 {mShadowSettings, mLayers[2].mLayerSettings})));
Lloyd Piquea4863342019-12-04 18:45:02 -08004350
Robert Carrccab4242021-09-28 16:53:03 -07004351 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004352 kDisplayDataspace);
Lloyd Piquea4863342019-12-04 18:45:02 -08004353 ASSERT_EQ(3u, requests.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08004354 EXPECT_EQ(mLayers[1].mLayerSettings, requests[0]);
4355 EXPECT_EQ(mShadowSettings, requests[1]);
4356 EXPECT_EQ(mLayers[2].mLayerSettings, requests[2]);
Lloyd Piquea4863342019-12-04 18:45:02 -08004357
Lloyd Piquea4863342019-12-04 18:45:02 -08004358 // Check that a timestamp was set for the layers that generated requests
4359 EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp);
4360 EXPECT_TRUE(0 != mLayers[1].mOutputLayerState.clientCompositionTimestamp);
4361 EXPECT_TRUE(0 != mLayers[2].mOutputLayerState.clientCompositionTimestamp);
4362}
4363
Alec Mourif54453c2021-05-13 16:28:28 -07004364MATCHER_P(ClientCompositionTargetSettingsBlurSettingsEq, expectedBlurSetting, "") {
4365 *result_listener << "ClientCompositionTargetSettings' BlurSettings aren't equal \n";
4366 *result_listener << "expected " << expectedBlurSetting << "\n";
4367 *result_listener << "actual " << arg.blurSetting << "\n";
4368
4369 return expectedBlurSetting == arg.blurSetting;
4370}
4371
4372TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, overridesBlur) {
4373 LayerFE::LayerSettings mShadowSettings;
4374 mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
4375
4376 mLayers[2].mOutputLayerState.overrideInfo.disableBackgroundBlur = true;
4377
4378 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(_))
4379 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
4380 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(_))
4381 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[1].mLayerSettings})));
4382 EXPECT_CALL(*mLayers[2].mLayerFE,
4383 prepareClientCompositionList(ClientCompositionTargetSettingsBlurSettingsEq(
4384 LayerFE::ClientCompositionTargetSettings::BlurSetting::BlurRegionsOnly)))
4385 .WillOnce(Return(std::vector<LayerFE::LayerSettings>(
4386 {mShadowSettings, mLayers[2].mLayerSettings})));
4387
Robert Carrccab4242021-09-28 16:53:03 -07004388 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004389 kDisplayDataspace);
Alec Mourif54453c2021-05-13 16:28:28 -07004390 ASSERT_EQ(3u, requests.size());
4391 EXPECT_EQ(mLayers[1].mLayerSettings, requests[0]);
4392 EXPECT_EQ(mShadowSettings, requests[1]);
4393 EXPECT_EQ(mLayers[2].mLayerSettings, requests[2]);
4394
Alec Mourif54453c2021-05-13 16:28:28 -07004395 // Check that a timestamp was set for the layers that generated requests
4396 EXPECT_TRUE(0 == mLayers[0].mOutputLayerState.clientCompositionTimestamp);
4397 EXPECT_TRUE(0 != mLayers[1].mOutputLayerState.clientCompositionTimestamp);
4398 EXPECT_TRUE(0 != mLayers[2].mOutputLayerState.clientCompositionTimestamp);
4399}
4400
Lloyd Piquea4863342019-12-04 18:45:02 -08004401TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4402 onlyClientComposesClientComposedLayersIfNoClearingNeeded) {
4403 EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4404 EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4405 EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(true));
4406
4407 mLayers[0].mOutputLayerState.clearClientTarget = false;
4408 mLayers[1].mOutputLayerState.clearClientTarget = false;
4409 mLayers[2].mOutputLayerState.clearClientTarget = false;
4410
4411 mLayers[0].mLayerFEState.isOpaque = true;
4412 mLayers[1].mLayerFEState.isOpaque = true;
4413 mLayers[2].mLayerFEState.isOpaque = true;
4414
Ady Abrahameca9d752021-03-03 12:20:00 -08004415 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004416 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));
Lloyd Piquea4863342019-12-04 18:45:02 -08004417
Robert Carrccab4242021-09-28 16:53:03 -07004418 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004419 kDisplayDataspace);
Lloyd Piquea4863342019-12-04 18:45:02 -08004420 ASSERT_EQ(1u, requests.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08004421 EXPECT_EQ(mLayers[2].mLayerSettings, requests[0]);
Lloyd Piquea4863342019-12-04 18:45:02 -08004422}
4423
4424TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4425 onlyClientComposesClientComposedLayersIfOthersAreNotOpaque) {
4426 EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4427 EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4428 EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(true));
4429
4430 mLayers[0].mOutputLayerState.clearClientTarget = true;
4431 mLayers[1].mOutputLayerState.clearClientTarget = true;
4432 mLayers[2].mOutputLayerState.clearClientTarget = true;
4433
4434 mLayers[0].mLayerFEState.isOpaque = false;
4435 mLayers[1].mLayerFEState.isOpaque = false;
4436 mLayers[2].mLayerFEState.isOpaque = false;
4437
Ady Abrahameca9d752021-03-03 12:20:00 -08004438 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(_))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004439 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));
Lloyd Piquea4863342019-12-04 18:45:02 -08004440
Robert Carrccab4242021-09-28 16:53:03 -07004441 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004442 kDisplayDataspace);
Lloyd Piquea4863342019-12-04 18:45:02 -08004443 ASSERT_EQ(1u, requests.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08004444 EXPECT_EQ(mLayers[2].mLayerSettings, requests[0]);
Lloyd Piquea4863342019-12-04 18:45:02 -08004445}
4446
4447TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers, clearsHWCLayersIfOpaqueAndNotFirst) {
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004448 // If client composition is performed with some layers set to use device
4449 // composition, device layers after the first layer (device or client) will
4450 // clear the frame buffer if they are opaque and if that layer has a flag
4451 // set to do so. The first layer is skipped as the frame buffer is already
4452 // expected to be clear.
4453
Lloyd Piquea4863342019-12-04 18:45:02 -08004454 EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4455 EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4456 EXPECT_CALL(mLayers[2].mOutputLayer, requiresClientComposition()).WillOnce(Return(true));
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004457
Lloyd Piquea4863342019-12-04 18:45:02 -08004458 mLayers[0].mOutputLayerState.clearClientTarget = true;
4459 mLayers[1].mOutputLayerState.clearClientTarget = true;
4460 mLayers[2].mOutputLayerState.clearClientTarget = true;
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004461
Lloyd Piquea4863342019-12-04 18:45:02 -08004462 mLayers[0].mLayerFEState.isOpaque = true;
4463 mLayers[1].mLayerFEState.isOpaque = true;
4464 mLayers[2].mLayerFEState.isOpaque = true;
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004465
4466 compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
4467 Region(kDisplayFrame),
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004468 false, /* needs filtering */
4469 false, /* secure */
4470 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004471 kDisplayViewport,
4472 kDisplayDataspace,
4473 false /* realContentIsVisible */,
4474 true /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004475 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004476 kLayerWhitePointNits,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004477 };
4478 compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
4479 Region(kDisplayFrame),
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004480 false, /* needs filtering */
4481 false, /* secure */
4482 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004483 kDisplayViewport,
4484 kDisplayDataspace,
4485 true /* realContentIsVisible */,
4486 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004487 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004488 kLayerWhitePointNits,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004489 };
4490
4491 LayerFE::LayerSettings mBlackoutSettings = mLayers[1].mLayerSettings;
4492 mBlackoutSettings.source.buffer.buffer = nullptr;
4493 mBlackoutSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
4494 mBlackoutSettings.alpha = 0.f;
4495 mBlackoutSettings.disableBlending = true;
4496
Ady Abrahameca9d752021-03-03 12:20:00 -08004497 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004498 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mBlackoutSettings})));
Ady Abrahameca9d752021-03-03 12:20:00 -08004499 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004500 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mLayers[2].mLayerSettings})));
4501
Robert Carrccab4242021-09-28 16:53:03 -07004502 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004503 kDisplayDataspace);
Lloyd Piquea4863342019-12-04 18:45:02 -08004504 ASSERT_EQ(2u, requests.size());
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004505
Lloyd Piquea4863342019-12-04 18:45:02 -08004506 // The second layer is expected to be rendered as alpha=0 black with no blending
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004507 EXPECT_EQ(mBlackoutSettings, requests[0]);
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004508
Vishnu Nair9b079a22020-01-21 14:36:08 -08004509 EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]);
Lloyd Piquea4863342019-12-04 18:45:02 -08004510}
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004511
Lloyd Piquea4863342019-12-04 18:45:02 -08004512TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4513 clippedVisibleRegionUsedToGenerateRequest) {
4514 mLayers[0].mOutputLayerState.visibleRegion = Region(Rect(10, 10, 20, 20));
4515 mLayers[1].mOutputLayerState.visibleRegion = Region(Rect(-10, -10, 30, 30));
4516 mLayers[2].mOutputLayerState.visibleRegion = Region(Rect(-10, 0, 40, 4000));
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004517
Lloyd Piquea4863342019-12-04 18:45:02 -08004518 compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
4519 Region(Rect(10, 10, 20, 20)),
Lloyd Piquea4863342019-12-04 18:45:02 -08004520 false, /* needs filtering */
4521 false, /* secure */
4522 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004523 kDisplayViewport,
4524 kDisplayDataspace,
4525 true /* realContentIsVisible */,
4526 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004527 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004528 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004529 };
4530 compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
4531 Region(Rect(0, 0, 30, 30)),
Lloyd Piquea4863342019-12-04 18:45:02 -08004532 false, /* needs filtering */
4533 false, /* secure */
4534 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004535 kDisplayViewport,
4536 kDisplayDataspace,
4537 true /* realContentIsVisible */,
4538 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004539 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004540 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004541 };
4542 compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
4543 Region(Rect(0, 0, 40, 201)),
Lloyd Piquea4863342019-12-04 18:45:02 -08004544 false, /* needs filtering */
4545 false, /* secure */
4546 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004547 kDisplayViewport,
4548 kDisplayDataspace,
4549 true /* realContentIsVisible */,
4550 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004551 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004552 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004553 };
4554
Ady Abrahameca9d752021-03-03 12:20:00 -08004555 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004556 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004557 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004558 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004559 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004560 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Lloyd Piquea4863342019-12-04 18:45:02 -08004561
4562 static_cast<void>(
Robert Carrccab4242021-09-28 16:53:03 -07004563 mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004564 kDisplayDataspace));
Lloyd Piquea4863342019-12-04 18:45:02 -08004565}
4566
4567TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4568 perLayerNeedsFilteringUsedToGenerateRequests) {
4569 mOutput.mState.needsFiltering = false;
4570 EXPECT_CALL(mLayers[0].mOutputLayer, needsFiltering()).WillRepeatedly(Return(true));
4571
Lloyd Piquea4863342019-12-04 18:45:02 -08004572 compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
4573 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004574 true, /* needs filtering */
4575 false, /* secure */
4576 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004577 kDisplayViewport,
4578 kDisplayDataspace,
4579 true /* realContentIsVisible */,
4580 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004581 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004582 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004583 };
4584 compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
4585 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004586 false, /* needs filtering */
4587 false, /* secure */
4588 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004589 kDisplayViewport,
4590 kDisplayDataspace,
4591 true /* realContentIsVisible */,
4592 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004593 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004594 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004595 };
4596 compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
4597 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004598 false, /* needs filtering */
4599 false, /* secure */
4600 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004601 kDisplayViewport,
4602 kDisplayDataspace,
4603 true /* realContentIsVisible */,
4604 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004605 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004606 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004607 };
4608
Ady Abrahameca9d752021-03-03 12:20:00 -08004609 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004610 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004611 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004612 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004613 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004614 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Lloyd Piquea4863342019-12-04 18:45:02 -08004615
4616 static_cast<void>(
Robert Carrccab4242021-09-28 16:53:03 -07004617 mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
4618 kDisplayDataspace));
Lloyd Piquea4863342019-12-04 18:45:02 -08004619}
4620
4621TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4622 wholeOutputNeedsFilteringUsedToGenerateRequests) {
4623 mOutput.mState.needsFiltering = true;
4624 EXPECT_CALL(mLayers[0].mOutputLayer, needsFiltering()).WillRepeatedly(Return(true));
4625
Lloyd Piquea4863342019-12-04 18:45:02 -08004626 compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
4627 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004628 true, /* needs filtering */
4629 false, /* secure */
4630 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004631 kDisplayViewport,
4632 kDisplayDataspace,
4633 true /* realContentIsVisible */,
4634 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004635 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004636 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004637 };
4638 compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
4639 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004640 true, /* needs filtering */
4641 false, /* secure */
4642 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004643 kDisplayViewport,
4644 kDisplayDataspace,
4645 true /* realContentIsVisible */,
4646 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004647 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004648 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004649 };
4650 compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
4651 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004652 true, /* needs filtering */
4653 false, /* secure */
4654 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004655 kDisplayViewport,
4656 kDisplayDataspace,
4657 true /* realContentIsVisible */,
4658 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004659 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004660 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004661 };
4662
Ady Abrahameca9d752021-03-03 12:20:00 -08004663 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004664 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004665 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004666 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004667 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004668 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Lloyd Piquea4863342019-12-04 18:45:02 -08004669
4670 static_cast<void>(
Robert Carrccab4242021-09-28 16:53:03 -07004671 mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
4672 kDisplayDataspace));
Lloyd Piquea4863342019-12-04 18:45:02 -08004673}
4674
4675TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4676 wholeOutputSecurityUsedToGenerateRequests) {
4677 mOutput.mState.isSecure = true;
4678
Lloyd Piquea4863342019-12-04 18:45:02 -08004679 compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
4680 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004681 false, /* needs filtering */
4682 true, /* secure */
4683 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004684 kDisplayViewport,
4685 kDisplayDataspace,
4686 true /* realContentIsVisible */,
4687 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004688 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004689 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004690 };
4691 compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
4692 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004693 false, /* needs filtering */
4694 true, /* secure */
4695 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004696 kDisplayViewport,
4697 kDisplayDataspace,
4698 true /* realContentIsVisible */,
4699 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004700 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004701 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004702 };
4703 compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
4704 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004705 false, /* needs filtering */
4706 true, /* secure */
4707 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004708 kDisplayViewport,
4709 kDisplayDataspace,
4710 true /* realContentIsVisible */,
4711 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004712 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004713 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004714 };
4715
Ady Abrahameca9d752021-03-03 12:20:00 -08004716 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004717 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004718 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004719 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004720 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004721 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Lloyd Piquea4863342019-12-04 18:45:02 -08004722
4723 static_cast<void>(
Robert Carrccab4242021-09-28 16:53:03 -07004724 mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
4725 kDisplayDataspace));
Lloyd Piquea4863342019-12-04 18:45:02 -08004726}
4727
4728TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4729 protectedContentSupportUsedToGenerateRequests) {
Lloyd Piquea4863342019-12-04 18:45:02 -08004730 compositionengine::LayerFE::ClientCompositionTargetSettings layer0TargetSettings{
4731 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004732 false, /* needs filtering */
4733 false, /* secure */
4734 true, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004735 kDisplayViewport,
4736 kDisplayDataspace,
4737 true /* realContentIsVisible */,
4738 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004739 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004740 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004741 };
4742 compositionengine::LayerFE::ClientCompositionTargetSettings layer1TargetSettings{
4743 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004744 false, /* needs filtering */
4745 false, /* secure */
4746 true, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004747 kDisplayViewport,
4748 kDisplayDataspace,
4749 true /* realContentIsVisible */,
4750 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004751 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004752 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004753 };
4754 compositionengine::LayerFE::ClientCompositionTargetSettings layer2TargetSettings{
4755 Region(kDisplayFrame),
Lloyd Piquea4863342019-12-04 18:45:02 -08004756 false, /* needs filtering */
4757 false, /* secure */
4758 true, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004759 kDisplayViewport,
4760 kDisplayDataspace,
4761 true /* realContentIsVisible */,
4762 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004763 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004764 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004765 };
4766
Ady Abrahameca9d752021-03-03 12:20:00 -08004767 EXPECT_CALL(*mLayers[0].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer0TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004768 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004769 EXPECT_CALL(*mLayers[1].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer1TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004770 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Ady Abrahameca9d752021-03-03 12:20:00 -08004771 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2TargetSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004772 .WillOnce(Return(std::vector<LayerFE::LayerSettings>()));
Lloyd Piquea4863342019-12-04 18:45:02 -08004773
Robert Carrccab4242021-09-28 16:53:03 -07004774 static_cast<void>(mOutput.generateClientCompositionRequestsHelper(true /* supportsProtectedContent */,
Lloyd Piquea4863342019-12-04 18:45:02 -08004775 kDisplayDataspace));
4776}
4777
Lucas Dupin084a6d42021-08-26 22:10:29 +00004778TEST_F(OutputUpdateAndWriteCompositionStateTest, noBackgroundBlurWhenOpaque) {
4779 InjectedLayer layer1;
4780 InjectedLayer layer2;
4781
4782 uint32_t z = 0;
4783 // Layer requesting blur, or below, should request client composition, unless opaque.
4784 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));
4785 EXPECT_CALL(*layer1.outputLayer,
4786 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4787 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
4788 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));
4789 EXPECT_CALL(*layer2.outputLayer,
4790 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4791 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
4792
4793 layer2.layerFEState.backgroundBlurRadius = 10;
4794 layer2.layerFEState.isOpaque = true;
4795
4796 injectOutputLayer(layer1);
4797 injectOutputLayer(layer2);
4798
4799 mOutput->editState().isEnabled = true;
4800
4801 CompositionRefreshArgs args;
4802 args.updatingGeometryThisFrame = false;
4803 args.devOptForceClientComposition = false;
4804 mOutput->updateCompositionState(args);
4805 mOutput->planComposition();
4806 mOutput->writeCompositionState(args);
4807}
4808
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004809TEST_F(OutputUpdateAndWriteCompositionStateTest, handlesBackgroundBlurRequests) {
Lloyd Piquede196652020-01-22 17:29:58 -08004810 InjectedLayer layer1;
4811 InjectedLayer layer2;
4812 InjectedLayer layer3;
4813
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -04004814 uint32_t z = 0;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004815 // Layer requesting blur, or below, should request client composition.
Snild Dolkow9e217d62020-04-22 15:53:42 +02004816 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004817 EXPECT_CALL(*layer1.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004818 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4819 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +02004820 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004821 EXPECT_CALL(*layer2.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004822 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4823 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Snild Dolkow9e217d62020-04-22 15:53:42 +02004824 EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004825 EXPECT_CALL(*layer3.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004826 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4827 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004828
Lloyd Piquede196652020-01-22 17:29:58 -08004829 layer2.layerFEState.backgroundBlurRadius = 10;
Lucas Dupin084a6d42021-08-26 22:10:29 +00004830 layer2.layerFEState.isOpaque = false;
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004831
Lloyd Piquede196652020-01-22 17:29:58 -08004832 injectOutputLayer(layer1);
4833 injectOutputLayer(layer2);
4834 injectOutputLayer(layer3);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004835
4836 mOutput->editState().isEnabled = true;
4837
4838 CompositionRefreshArgs args;
4839 args.updatingGeometryThisFrame = false;
4840 args.devOptForceClientComposition = false;
Dan Stoza269dc4d2021-01-15 15:07:43 -08004841 mOutput->updateCompositionState(args);
4842 mOutput->planComposition();
4843 mOutput->writeCompositionState(args);
Lucas Dupin19c8f0e2019-11-25 17:55:44 -08004844}
4845
Lucas Dupinc3800b82020-10-02 16:24:48 -07004846TEST_F(OutputUpdateAndWriteCompositionStateTest, handlesBlurRegionRequests) {
4847 InjectedLayer layer1;
4848 InjectedLayer layer2;
4849 InjectedLayer layer3;
4850
Leon Scroggins IIIe2ee0402021-04-02 16:59:37 -04004851 uint32_t z = 0;
Lucas Dupinc3800b82020-10-02 16:24:48 -07004852 // Layer requesting blur, or below, should request client composition.
4853 EXPECT_CALL(*layer1.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004854 EXPECT_CALL(*layer1.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004855 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4856 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lucas Dupinc3800b82020-10-02 16:24:48 -07004857 EXPECT_CALL(*layer2.outputLayer, updateCompositionState(false, true, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004858 EXPECT_CALL(*layer2.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004859 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4860 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lucas Dupinc3800b82020-10-02 16:24:48 -07004861 EXPECT_CALL(*layer3.outputLayer, updateCompositionState(false, false, ui::Transform::ROT_0));
Dan Stoza6166c312021-01-15 16:34:05 -08004862 EXPECT_CALL(*layer3.outputLayer,
Leon Scroggins III9aa25c22021-04-15 15:30:19 -04004863 writeStateToHWC(/*includeGeometry*/ false, /*skipLayer*/ false, z++,
4864 /*zIsOverridden*/ false, /*isPeekingThrough*/ false));
Lucas Dupinc3800b82020-10-02 16:24:48 -07004865
4866 BlurRegion region;
4867 layer2.layerFEState.blurRegions.push_back(region);
Lucas Dupin084a6d42021-08-26 22:10:29 +00004868 layer2.layerFEState.isOpaque = false;
Lucas Dupinc3800b82020-10-02 16:24:48 -07004869
4870 injectOutputLayer(layer1);
4871 injectOutputLayer(layer2);
4872 injectOutputLayer(layer3);
4873
4874 mOutput->editState().isEnabled = true;
4875
4876 CompositionRefreshArgs args;
4877 args.updatingGeometryThisFrame = false;
4878 args.devOptForceClientComposition = false;
Dan Stoza269dc4d2021-01-15 15:07:43 -08004879 mOutput->updateCompositionState(args);
4880 mOutput->planComposition();
4881 mOutput->writeCompositionState(args);
Lucas Dupinc3800b82020-10-02 16:24:48 -07004882}
4883
Lloyd Piquea4863342019-12-04 18:45:02 -08004884TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenRequests) {
4885 // In split-screen landscape mode, the screen is rotated 90 degrees, with
4886 // one layer on the left covering the left side of the output, and one layer
4887 // on the right covering that side of the output.
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004888
4889 const Rect kPortraitFrame(0, 0, 1000, 2000);
4890 const Rect kPortraitViewport(0, 0, 2000, 1000);
Lloyd Piquee8fe4742020-01-21 15:26:18 -08004891 const Rect kPortraitDestinationClip(0, 0, 1000, 2000);
Marin Shalamanov68933fb2020-09-10 17:58:12 +02004892 const ui::Rotation kPortraitOrientation = ui::ROTATION_90;
Lloyd Piquea4863342019-12-04 18:45:02 -08004893 constexpr ui::Dataspace kOutputDataspace = ui::Dataspace::DISPLAY_P3;
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004894
Angel Aguayob084e0c2021-08-04 23:27:28 +00004895 mOutput.mState.orientedDisplaySpace.setContent(kPortraitFrame);
4896 mOutput.mState.layerStackSpace.setContent(kPortraitViewport);
4897 mOutput.mState.displaySpace.setContent(kPortraitDestinationClip);
Marin Shalamanov68933fb2020-09-10 17:58:12 +02004898 mOutput.mState.transform = ui::Transform{ui::Transform::toRotationFlags(kPortraitOrientation)};
Angel Aguayob084e0c2021-08-04 23:27:28 +00004899 mOutput.mState.displaySpace.setOrientation(kPortraitOrientation);
Lloyd Piquea4863342019-12-04 18:45:02 -08004900 mOutput.mState.needsFiltering = false;
4901 mOutput.mState.isSecure = true;
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004902
Lloyd Piquea4863342019-12-04 18:45:02 -08004903 Layer leftLayer;
4904 Layer rightLayer;
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004905
Lloyd Piquea4863342019-12-04 18:45:02 -08004906 leftLayer.mOutputLayerState.clearClientTarget = false;
4907 leftLayer.mOutputLayerState.visibleRegion = Region(Rect(0, 0, 1000, 1000));
4908 leftLayer.mLayerFEState.isOpaque = true;
Vishnu Nair9b079a22020-01-21 14:36:08 -08004909 leftLayer.mLayerSettings.source.solidColor = {1.f, 0.f, 0.f};
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004910
Lloyd Piquea4863342019-12-04 18:45:02 -08004911 rightLayer.mOutputLayerState.clearClientTarget = false;
4912 rightLayer.mOutputLayerState.visibleRegion = Region(Rect(1000, 0, 2000, 1000));
4913 rightLayer.mLayerFEState.isOpaque = true;
Vishnu Nair9b079a22020-01-21 14:36:08 -08004914 rightLayer.mLayerSettings.source.solidColor = {0.f, 1.f, 0.f};
Lloyd Piquea4863342019-12-04 18:45:02 -08004915
4916 EXPECT_CALL(mOutput, getOutputLayerCount()).WillRepeatedly(Return(2u));
4917 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
4918 .WillRepeatedly(Return(&leftLayer.mOutputLayer));
4919 EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(1u))
4920 .WillRepeatedly(Return(&rightLayer.mOutputLayer));
4921
Lloyd Piquea4863342019-12-04 18:45:02 -08004922 compositionengine::LayerFE::ClientCompositionTargetSettings leftLayerSettings{
4923 Region(Rect(0, 0, 1000, 1000)),
Lloyd Piquea4863342019-12-04 18:45:02 -08004924 false, /* needs filtering */
4925 true, /* secure */
4926 true, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004927 kPortraitViewport,
4928 kOutputDataspace,
4929 true /* realContentIsVisible */,
4930 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004931 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004932 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004933 };
4934
4935 EXPECT_CALL(leftLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
4936 EXPECT_CALL(leftLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
Ady Abrahameca9d752021-03-03 12:20:00 -08004937 EXPECT_CALL(*leftLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(leftLayerSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004938 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({leftLayer.mLayerSettings})));
Lloyd Piquea4863342019-12-04 18:45:02 -08004939
4940 compositionengine::LayerFE::ClientCompositionTargetSettings rightLayerSettings{
4941 Region(Rect(1000, 0, 2000, 1000)),
Lloyd Piquea4863342019-12-04 18:45:02 -08004942 false, /* needs filtering */
4943 true, /* secure */
4944 true, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004945 kPortraitViewport,
4946 kOutputDataspace,
4947 true /* realContentIsVisible */,
4948 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004949 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004950 kLayerWhitePointNits,
Lloyd Piquea4863342019-12-04 18:45:02 -08004951 };
4952
4953 EXPECT_CALL(rightLayer.mOutputLayer, requiresClientComposition()).WillRepeatedly(Return(true));
4954 EXPECT_CALL(rightLayer.mOutputLayer, needsFiltering()).WillRepeatedly(Return(false));
Ady Abrahameca9d752021-03-03 12:20:00 -08004955 EXPECT_CALL(*rightLayer.mLayerFE, prepareClientCompositionList(Eq(ByRef(rightLayerSettings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004956 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({rightLayer.mLayerSettings})));
Lloyd Piquea4863342019-12-04 18:45:02 -08004957
4958 constexpr bool supportsProtectedContent = true;
Sally Qidf3da512021-07-08 17:27:02 +00004959 auto requests =
Robert Carrccab4242021-09-28 16:53:03 -07004960 mOutput.generateClientCompositionRequestsHelper(supportsProtectedContent, kOutputDataspace);
Lloyd Piquea4863342019-12-04 18:45:02 -08004961 ASSERT_EQ(2u, requests.size());
Vishnu Nair9b079a22020-01-21 14:36:08 -08004962 EXPECT_EQ(leftLayer.mLayerSettings, requests[0]);
4963 EXPECT_EQ(rightLayer.mLayerSettings, requests[1]);
Lloyd Piquec2d54d42019-08-28 18:04:21 -07004964}
4965
Vishnu Naira483b4a2019-12-12 15:07:52 -08004966TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
4967 shadowRegionOnlyVisibleSkipsContentComposition) {
4968 const Rect kContentWithShadow(40, 40, 70, 90);
4969 const Rect kContent(50, 50, 60, 80);
4970 const Region kShadowRegion = Region(kContentWithShadow).subtract(kContent);
4971 const Region kPartialShadowRegion = Region(kContentWithShadow).subtract(Rect(40, 40, 60, 80));
4972
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004973 compositionengine::LayerFE::ClientCompositionTargetSettings layer2Settings{
4974 Region(Rect(60, 40, 70, 80)).merge(Rect(40, 80, 70, 90)), /* visible region */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004975 false, /* needs filtering */
4976 false, /* secure */
4977 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004978 kDisplayViewport,
4979 kDisplayDataspace,
4980 false /* realContentIsVisible */,
4981 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07004982 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07004983 kLayerWhitePointNits,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004984 };
4985
Vishnu Nair9b079a22020-01-21 14:36:08 -08004986 LayerFE::LayerSettings mShadowSettings;
4987 mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
Vishnu Naira483b4a2019-12-12 15:07:52 -08004988
4989 mLayers[2].mOutputLayerState.visibleRegion = kPartialShadowRegion;
4990 mLayers[2].mOutputLayerState.shadowRegion = kShadowRegion;
4991
4992 EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
4993 EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
Ady Abrahameca9d752021-03-03 12:20:00 -08004994 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08004995 .WillOnce(Return(std::vector<LayerFE::LayerSettings>({mShadowSettings})));
Vishnu Naira483b4a2019-12-12 15:07:52 -08004996
Robert Carrccab4242021-09-28 16:53:03 -07004997 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00004998 kDisplayDataspace);
Vishnu Naira483b4a2019-12-12 15:07:52 -08004999 ASSERT_EQ(1u, requests.size());
5000
Vishnu Nair9b079a22020-01-21 14:36:08 -08005001 EXPECT_EQ(mShadowSettings, requests[0]);
Vishnu Naira483b4a2019-12-12 15:07:52 -08005002}
5003
5004TEST_F(GenerateClientCompositionRequestsTest_ThreeLayers,
5005 shadowRegionWithContentVisibleRequestsContentAndShadowComposition) {
5006 const Rect kContentWithShadow(40, 40, 70, 90);
5007 const Rect kContent(50, 50, 60, 80);
5008 const Region kShadowRegion = Region(kContentWithShadow).subtract(kContent);
5009 const Region kPartialContentWithPartialShadowRegion =
5010 Region(kContentWithShadow).subtract(Rect(40, 40, 50, 80));
5011
Vishnu Nair9b079a22020-01-21 14:36:08 -08005012 LayerFE::LayerSettings mShadowSettings;
5013 mShadowSettings.source.solidColor = {0.1f, 0.1f, 0.1f};
Vishnu Naira483b4a2019-12-12 15:07:52 -08005014
5015 mLayers[2].mOutputLayerState.visibleRegion = kPartialContentWithPartialShadowRegion;
5016 mLayers[2].mOutputLayerState.shadowRegion = kShadowRegion;
5017
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005018 compositionengine::LayerFE::ClientCompositionTargetSettings layer2Settings{
5019 Region(Rect(50, 40, 70, 80)).merge(Rect(40, 80, 70, 90)), /* visible region */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005020 false, /* needs filtering */
5021 false, /* secure */
5022 false, /* supports protected content */
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005023 kDisplayViewport,
5024 kDisplayDataspace,
5025 true /* realContentIsVisible */,
5026 false /* clearContent */,
Alec Mourif54453c2021-05-13 16:28:28 -07005027 compositionengine::LayerFE::ClientCompositionTargetSettings::BlurSetting::Enabled,
Alec Mouricdf6cbc2021-11-01 17:21:15 -07005028 kLayerWhitePointNits,
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005029 };
5030
Vishnu Naira483b4a2019-12-12 15:07:52 -08005031 EXPECT_CALL(mLayers[0].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
5032 EXPECT_CALL(mLayers[1].mOutputLayer, requiresClientComposition()).WillOnce(Return(false));
Ady Abrahameca9d752021-03-03 12:20:00 -08005033 EXPECT_CALL(*mLayers[2].mLayerFE, prepareClientCompositionList(Eq(ByRef(layer2Settings))))
Vishnu Nairb87d94f2020-02-13 09:17:36 -08005034 .WillOnce(Return(std::vector<LayerFE::LayerSettings>(
5035 {mShadowSettings, mLayers[2].mLayerSettings})));
Vishnu Naira483b4a2019-12-12 15:07:52 -08005036
Robert Carrccab4242021-09-28 16:53:03 -07005037 auto requests = mOutput.generateClientCompositionRequestsHelper(false /* supportsProtectedContent */,
Sally Qidf3da512021-07-08 17:27:02 +00005038 kDisplayDataspace);
Vishnu Naira483b4a2019-12-12 15:07:52 -08005039 ASSERT_EQ(2u, requests.size());
5040
Vishnu Nair9b079a22020-01-21 14:36:08 -08005041 EXPECT_EQ(mShadowSettings, requests[0]);
5042 EXPECT_EQ(mLayers[2].mLayerSettings, requests[1]);
Vishnu Naira483b4a2019-12-12 15:07:52 -08005043}
5044
Lloyd Pique32cbe282018-10-19 13:09:22 -07005045} // namespace
5046} // namespace android::compositionengine