1 /*
2  * Copyright (C) 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 
17 // TODO(b/129481165): remove the #pragma below and fix conversion issues
18 #pragma clang diagnostic push
19 #pragma clang diagnostic ignored "-Wconversion"
20 
21 #include <gui/BufferItemConsumer.h>
22 #include <ui/Transform.h>
23 #include <thread>
24 #include "TransactionTestHarnesses.h"
25 namespace android {
26 
27 using android::hardware::graphics::common::V1_1::BufferUsage;
28 
29 ::testing::Environment* const binderEnv =
30         ::testing::AddGlobalTestEnvironment(new BinderEnvironment());
31 
32 class LayerRenderTypeTransactionTest : public LayerTransactionTest,
33                                        public ::testing::WithParamInterface<RenderPath> {
34 public:
LayerRenderTypeTransactionTest()35     LayerRenderTypeTransactionTest() : mHarness(LayerRenderPathTestHarness(this, GetParam())) {}
36 
getScreenCapture()37     std::unique_ptr<ScreenCapture> getScreenCapture() { return mHarness.getScreenCapture(); }
38     void setRelativeZBasicHelper(uint32_t layerType);
39     void setRelativeZGroupHelper(uint32_t layerType);
40     void setAlphaBasicHelper(uint32_t layerType);
41     void setBackgroundColorHelper(uint32_t layerType, bool priorColor, bool bufferFill, float alpha,
42                                   Color finalColor);
43 
44 protected:
45     LayerRenderPathTestHarness mHarness;
46 
47     static constexpr int64_t kUsageFlags = BufferUsage::CPU_READ_OFTEN |
48             BufferUsage::CPU_WRITE_OFTEN | BufferUsage::COMPOSER_OVERLAY | BufferUsage::GPU_TEXTURE;
49 };
50 
51 INSTANTIATE_TEST_CASE_P(LayerRenderTypeTransactionTests, LayerRenderTypeTransactionTest,
52                         ::testing::Values(RenderPath::VIRTUAL_DISPLAY, RenderPath::SCREENSHOT));
53 
TEST_P(LayerRenderTypeTransactionTest,SetPositionBasic_BufferQueue)54 TEST_P(LayerRenderTypeTransactionTest, SetPositionBasic_BufferQueue) {
55     sp<SurfaceControl> layer;
56     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
57     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
58 
59     {
60         SCOPED_TRACE("default position");
61         const Rect rect(0, 0, 32, 32);
62         auto shot = getScreenCapture();
63         shot->expectColor(rect, Color::RED);
64         shot->expectBorder(rect, Color::BLACK);
65     }
66 
67     Transaction().setPosition(layer, 5, 10).apply();
68     {
69         SCOPED_TRACE("new position");
70         const Rect rect(5, 10, 37, 42);
71         auto shot = getScreenCapture();
72         shot->expectColor(rect, Color::RED);
73         shot->expectBorder(rect, Color::BLACK);
74     }
75 }
76 
TEST_P(LayerRenderTypeTransactionTest,SetPositionRounding_BufferQueue)77 TEST_P(LayerRenderTypeTransactionTest, SetPositionRounding_BufferQueue) {
78     sp<SurfaceControl> layer;
79     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
80     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
81 
82     // GPU composition requires only 4 bits of subpixel precision during rasterization
83     // XXX GPU composition does not match HWC composition due to precision
84     // loss (b/69315223)
85     const float epsilon = 1.0f / 16.0f;
86     Transaction().setPosition(layer, 0.5f - epsilon, 0.5f - epsilon).apply();
87     {
88         SCOPED_TRACE("rounding down");
89         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
90     }
91 
92     Transaction().setPosition(layer, 0.5f + epsilon, 0.5f + epsilon).apply();
93     {
94         SCOPED_TRACE("rounding up");
95         getScreenCapture()->expectColor(Rect(1, 1, 33, 33), Color::RED);
96     }
97 }
98 
TEST_P(LayerRenderTypeTransactionTest,SetPositionOutOfBounds_BufferQueue)99 TEST_P(LayerRenderTypeTransactionTest, SetPositionOutOfBounds_BufferQueue) {
100     sp<SurfaceControl> layer;
101     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
102     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
103 
104     Transaction().setPosition(layer, -32, -32).apply();
105     {
106         SCOPED_TRACE("negative coordinates");
107         getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
108     }
109 
110     Transaction().setPosition(layer, mDisplayWidth, mDisplayHeight).apply();
111     {
112         SCOPED_TRACE("positive coordinates");
113         getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
114     }
115 }
116 
TEST_P(LayerRenderTypeTransactionTest,SetPositionPartiallyOutOfBounds_BufferQueue)117 TEST_P(LayerRenderTypeTransactionTest, SetPositionPartiallyOutOfBounds_BufferQueue) {
118     sp<SurfaceControl> layer;
119     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
120     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
121 
122     // partially out of bounds
123     Transaction().setPosition(layer, -30, -30).apply();
124     {
125         SCOPED_TRACE("negative coordinates");
126         getScreenCapture()->expectColor(Rect(0, 0, 2, 2), Color::RED);
127     }
128 
129     Transaction().setPosition(layer, mDisplayWidth - 2, mDisplayHeight - 2).apply();
130     {
131         SCOPED_TRACE("positive coordinates");
132         getScreenCapture()->expectColor(Rect(mDisplayWidth - 2, mDisplayHeight - 2, mDisplayWidth,
133                                              mDisplayHeight),
134                                         Color::RED);
135     }
136 }
137 
TEST_P(LayerRenderTypeTransactionTest,CreateLayer_BufferState)138 TEST_P(LayerRenderTypeTransactionTest, CreateLayer_BufferState) {
139     uint32_t transformHint = ui::Transform::ROT_INVALID;
140     sp<SurfaceControl> layer;
141     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32,
142                                                 ISurfaceComposerClient::eFXSurfaceBufferState,
143                                                 /*parent*/ nullptr, &transformHint));
144     ASSERT_NE(ui::Transform::ROT_INVALID, transformHint);
145 }
146 
setRelativeZBasicHelper(uint32_t layerType)147 void LayerRenderTypeTransactionTest::setRelativeZBasicHelper(uint32_t layerType) {
148     sp<SurfaceControl> layerR;
149     sp<SurfaceControl> layerG;
150     ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32, layerType));
151     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerR, Color::RED, 32, 32));
152     ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32, layerType));
153     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerG, Color::GREEN, 32, 32));
154 
155     switch (layerType) {
156         case ISurfaceComposerClient::eFXSurfaceBufferQueue:
157             Transaction().setPosition(layerG, 16, 16).setRelativeLayer(layerG, layerR, 1).apply();
158             break;
159         case ISurfaceComposerClient::eFXSurfaceBufferState:
160             Transaction().setPosition(layerG, 16, 16).setRelativeLayer(layerG, layerR, 1).apply();
161             break;
162         default:
163             ASSERT_FALSE(true) << "Unsupported layer type";
164     }
165     {
166         SCOPED_TRACE("layerG above");
167         auto shot = getScreenCapture();
168         shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
169         shot->expectColor(Rect(16, 16, 48, 48), Color::GREEN);
170     }
171 
172     Transaction().setRelativeLayer(layerG, layerR, -1).apply();
173     {
174         SCOPED_TRACE("layerG below");
175         auto shot = getScreenCapture();
176         shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
177         shot->expectColor(Rect(32, 32, 48, 48), Color::GREEN);
178     }
179 }
180 
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZBasic_BufferQueue)181 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZBasic_BufferQueue) {
182     ASSERT_NO_FATAL_FAILURE(setRelativeZBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
183 }
184 
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZBasic_BufferState)185 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZBasic_BufferState) {
186     ASSERT_NO_FATAL_FAILURE(setRelativeZBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
187 }
188 
setRelativeZGroupHelper(uint32_t layerType)189 void LayerRenderTypeTransactionTest::setRelativeZGroupHelper(uint32_t layerType) {
190     sp<SurfaceControl> layerR;
191     sp<SurfaceControl> layerG;
192     sp<SurfaceControl> layerB;
193     ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test", 32, 32, layerType));
194     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerR, Color::RED, 32, 32));
195     ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test", 32, 32, layerType));
196     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerG, Color::GREEN, 32, 32));
197     ASSERT_NO_FATAL_FAILURE(layerB = createLayer("test", 32, 32, layerType));
198     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerB, Color::BLUE, 32, 32));
199 
200     // layerR = 0, layerG = layerR + 3, layerB = 2
201     switch (layerType) {
202         case ISurfaceComposerClient::eFXSurfaceBufferQueue:
203             Transaction()
204                     .setPosition(layerG, 8, 8)
205                     .setRelativeLayer(layerG, layerR, 3)
206                     .setPosition(layerB, 16, 16)
207                     .setLayer(layerB, mLayerZBase + 2)
208                     .apply();
209             break;
210         case ISurfaceComposerClient::eFXSurfaceBufferState:
211             Transaction()
212                     .setPosition(layerG, 8, 8)
213                     .setRelativeLayer(layerG, layerR, 3)
214                     .setPosition(layerB, 16, 16)
215                     .setLayer(layerB, mLayerZBase + 2)
216                     .apply();
217             break;
218         default:
219             ASSERT_FALSE(true) << "Unsupported layer type";
220     }
221 
222     {
223         SCOPED_TRACE("(layerR < layerG) < layerB");
224         auto shot = getScreenCapture();
225         shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
226         shot->expectColor(Rect(8, 8, 16, 16), Color::GREEN);
227         shot->expectColor(Rect(16, 16, 48, 48), Color::BLUE);
228     }
229 
230     // layerR = 4, layerG = layerR + 3, layerB = 2
231     Transaction().setLayer(layerR, mLayerZBase + 4).apply();
232     {
233         SCOPED_TRACE("layerB < (layerR < layerG)");
234         auto shot = getScreenCapture();
235         shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
236         shot->expectColor(Rect(8, 8, 40, 40), Color::GREEN);
237         shot->expectColor(Rect(40, 40, 48, 48), Color::BLUE);
238     }
239 
240     // layerR = 4, layerG = layerR - 3, layerB = 2
241     Transaction().setRelativeLayer(layerG, layerR, -3).apply();
242     {
243         SCOPED_TRACE("layerB < (layerG < layerR)");
244         auto shot = getScreenCapture();
245         shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
246         shot->expectColor(Rect(32, 32, 40, 40), Color::GREEN);
247         shot->expectColor(Rect(40, 40, 48, 48), Color::BLUE);
248     }
249 
250     // restore to absolute z
251     // layerR = 4, layerG = 0, layerB = 2
252     Transaction().setLayer(layerG, mLayerZBase).apply();
253     {
254         SCOPED_TRACE("layerG < layerB < layerR");
255         auto shot = getScreenCapture();
256         shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
257         shot->expectColor(Rect(32, 32, 48, 48), Color::BLUE);
258     }
259 
260     // layerR should not affect layerG anymore
261     // layerR = 1, layerG = 0, layerB = 2
262     Transaction().setLayer(layerR, mLayerZBase + 1).apply();
263     {
264         SCOPED_TRACE("layerG < layerR < layerB");
265         auto shot = getScreenCapture();
266         shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
267         shot->expectColor(Rect(16, 16, 48, 48), Color::BLUE);
268     }
269 }
270 
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZGroup_BufferQueue)271 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZGroup_BufferQueue) {
272     ASSERT_NO_FATAL_FAILURE(setRelativeZGroupHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
273 }
274 
TEST_P(LayerRenderTypeTransactionTest,SetRelativeZGroup_BufferState)275 TEST_P(LayerRenderTypeTransactionTest, SetRelativeZGroup_BufferState) {
276     ASSERT_NO_FATAL_FAILURE(setRelativeZGroupHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
277 }
278 
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintBasic_BufferQueue)279 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintBasic_BufferQueue) {
280     const Rect top(0, 0, 32, 16);
281     const Rect bottom(0, 16, 32, 32);
282     sp<SurfaceControl> layer;
283     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
284 
285     ANativeWindow_Buffer buffer;
286     ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
287     ASSERT_NO_FATAL_FAILURE(
288             TransactionUtils::fillANativeWindowBufferColor(buffer, top, Color::TRANSPARENT));
289     ASSERT_NO_FATAL_FAILURE(
290             TransactionUtils::fillANativeWindowBufferColor(buffer, bottom, Color::RED));
291     // setTransparentRegionHint always applies to the following buffer
292     Transaction().setTransparentRegionHint(layer, Region(top)).apply();
293     ASSERT_NO_FATAL_FAILURE(postBufferQueueLayerBuffer(layer));
294     {
295         SCOPED_TRACE("top transparent");
296         auto shot = getScreenCapture();
297         shot->expectColor(top, Color::BLACK);
298         shot->expectColor(bottom, Color::RED);
299     }
300 
301     Transaction().setTransparentRegionHint(layer, Region(bottom)).apply();
302     {
303         SCOPED_TRACE("transparent region hint pending");
304         auto shot = getScreenCapture();
305         shot->expectColor(top, Color::BLACK);
306         shot->expectColor(bottom, Color::RED);
307     }
308 
309     ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
310     ASSERT_NO_FATAL_FAILURE(
311             TransactionUtils::fillANativeWindowBufferColor(buffer, top, Color::RED));
312     ASSERT_NO_FATAL_FAILURE(
313             TransactionUtils::fillANativeWindowBufferColor(buffer, bottom, Color::TRANSPARENT));
314     ASSERT_NO_FATAL_FAILURE(postBufferQueueLayerBuffer(layer));
315     {
316         SCOPED_TRACE("bottom transparent");
317         auto shot = getScreenCapture();
318         shot->expectColor(top, Color::RED);
319         shot->expectColor(bottom, Color::BLACK);
320     }
321 }
322 
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintBasic_BufferState)323 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintBasic_BufferState) {
324     const Rect top(0, 0, 32, 16);
325     const Rect bottom(0, 16, 32, 32);
326     sp<SurfaceControl> layer;
327     ASSERT_NO_FATAL_FAILURE(
328             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
329 
330     sp<GraphicBuffer> buffer =
331             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
332 
333     ASSERT_NO_FATAL_FAILURE(
334             TransactionUtils::fillGraphicBufferColor(buffer, top, Color::TRANSPARENT));
335     ASSERT_NO_FATAL_FAILURE(TransactionUtils::fillGraphicBufferColor(buffer, bottom, Color::RED));
336     Transaction()
337             .setTransparentRegionHint(layer, Region(top))
338             .setBuffer(layer, buffer)
339             .apply();
340     {
341         SCOPED_TRACE("top transparent");
342         auto shot = getScreenCapture();
343         shot->expectColor(top, Color::BLACK);
344         shot->expectColor(bottom, Color::RED);
345     }
346 
347     Transaction().setTransparentRegionHint(layer, Region(bottom)).apply();
348     {
349         SCOPED_TRACE("transparent region hint intermediate");
350         auto shot = getScreenCapture();
351         shot->expectColor(top, Color::BLACK);
352         shot->expectColor(bottom, Color::BLACK);
353     }
354 
355     buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
356 
357     ASSERT_NO_FATAL_FAILURE(TransactionUtils::fillGraphicBufferColor(buffer, top, Color::RED));
358     ASSERT_NO_FATAL_FAILURE(
359             TransactionUtils::fillGraphicBufferColor(buffer, bottom, Color::TRANSPARENT));
360     Transaction().setBuffer(layer, buffer).apply();
361     {
362         SCOPED_TRACE("bottom transparent");
363         auto shot = getScreenCapture();
364         shot->expectColor(top, Color::RED);
365         shot->expectColor(bottom, Color::BLACK);
366     }
367 }
368 
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintOutOfBounds_BufferQueue)369 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintOutOfBounds_BufferQueue) {
370     sp<SurfaceControl> layerTransparent;
371     sp<SurfaceControl> layerR;
372     ASSERT_NO_FATAL_FAILURE(layerTransparent = createLayer("test transparent", 32, 32));
373     ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
374 
375     // check that transparent region hint is bound by the layer size
376     Transaction()
377             .setTransparentRegionHint(layerTransparent, Region(mDisplayRect))
378             .setPosition(layerR, 16, 16)
379             .setLayer(layerR, mLayerZBase + 1)
380             .apply();
381     ASSERT_NO_FATAL_FAILURE(
382             fillBufferQueueLayerColor(layerTransparent, Color::TRANSPARENT, 32, 32));
383     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layerR, Color::RED, 32, 32));
384     getScreenCapture()->expectColor(Rect(16, 16, 48, 48), Color::RED);
385 }
386 
TEST_P(LayerRenderTypeTransactionTest,SetTransparentRegionHintOutOfBounds_BufferState)387 TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintOutOfBounds_BufferState) {
388     sp<SurfaceControl> layerTransparent;
389     sp<SurfaceControl> layerR;
390     ASSERT_NO_FATAL_FAILURE(layerTransparent = createLayer("test transparent", 32, 32));
391     ASSERT_NO_FATAL_FAILURE(
392             layerR = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
393 
394     // check that transparent region hint is bound by the layer size
395     Transaction()
396             .setTransparentRegionHint(layerTransparent, Region(mDisplayRect))
397             .setPosition(layerR, 16, 16)
398             .setLayer(layerR, mLayerZBase + 1)
399             .apply();
400     ASSERT_NO_FATAL_FAILURE(
401             fillBufferQueueLayerColor(layerTransparent, Color::TRANSPARENT, 32, 32));
402     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layerR, Color::RED, 32, 32));
403     getScreenCapture()->expectColor(Rect(16, 16, 48, 48), Color::RED);
404 }
405 
setAlphaBasicHelper(uint32_t layerType)406 void LayerRenderTypeTransactionTest::setAlphaBasicHelper(uint32_t layerType) {
407     sp<SurfaceControl> layer1;
408     sp<SurfaceControl> layer2;
409     ASSERT_NO_FATAL_FAILURE(layer1 = createLayer("test 1", 32, 32, layerType));
410     ASSERT_NO_FATAL_FAILURE(layer2 = createLayer("test 2", 32, 32, layerType));
411     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layer1, {64, 0, 0, 255}, 32, 32));
412     ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layer2, {0, 64, 0, 255}, 32, 32));
413 
414     switch (layerType) {
415         case ISurfaceComposerClient::eFXSurfaceBufferQueue:
416             Transaction()
417                     .setAlpha(layer1, 0.25f)
418                     .setAlpha(layer2, 0.75f)
419                     .setPosition(layer2, 16, 0)
420                     .setLayer(layer2, mLayerZBase + 1)
421                     .apply();
422             break;
423         case ISurfaceComposerClient::eFXSurfaceBufferState:
424             Transaction()
425                     .setAlpha(layer1, 0.25f)
426                     .setAlpha(layer2, 0.75f)
427                     .setPosition(layer2, 16, 0)
428                     .setLayer(layer2, mLayerZBase + 1)
429                     .apply();
430             break;
431         default:
432             ASSERT_FALSE(true) << "Unsupported layer type";
433     }
434     {
435         auto shot = getScreenCapture();
436         uint8_t r = 16; // 64 * 0.25f
437         uint8_t g = 48; // 64 * 0.75f
438         shot->expectColor(Rect(0, 0, 16, 32), {r, 0, 0, 255});
439         shot->expectColor(Rect(32, 0, 48, 32), {0, g, 0, 255});
440 
441         r /= 4; // r * (1.0f - 0.75f)
442         shot->expectColor(Rect(16, 0, 32, 32), {r, g, 0, 255});
443     }
444 }
445 
TEST_P(LayerRenderTypeTransactionTest,SetAlphaBasic_BufferQueue)446 TEST_P(LayerRenderTypeTransactionTest, SetAlphaBasic_BufferQueue) {
447     ASSERT_NO_FATAL_FAILURE(setAlphaBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
448 }
449 
TEST_P(LayerRenderTypeTransactionTest,SetAlphaBasic_BufferState)450 TEST_P(LayerRenderTypeTransactionTest, SetAlphaBasic_BufferState) {
451     ASSERT_NO_FATAL_FAILURE(setAlphaBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
452 }
453 
TEST_P(LayerRenderTypeTransactionTest,SetColorBasic)454 TEST_P(LayerRenderTypeTransactionTest, SetColorBasic) {
455     sp<SurfaceControl> bufferLayer;
456     sp<SurfaceControl> colorLayer;
457     ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
458     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
459     ASSERT_NO_FATAL_FAILURE(colorLayer =
460                                     createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
461                                                 ISurfaceComposerClient::eFXSurfaceEffect));
462 
463     Transaction()
464             .setCrop(colorLayer, Rect(0, 0, 32, 32))
465             .setLayer(colorLayer, mLayerZBase + 1)
466             .apply();
467 
468     {
469         SCOPED_TRACE("default color");
470         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
471     }
472 
473     const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
474     const Color expected = {15, 51, 85, 255};
475     // this is handwavy, but the precison loss scaled by 255 (8-bit per
476     // channel) should be less than one
477     const uint8_t tolerance = 1;
478     Transaction().setColor(colorLayer, color).apply();
479     {
480         SCOPED_TRACE("new color");
481         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expected, tolerance);
482     }
483 }
484 
485 // RED: Color layer base color and BufferQueueLayer/BufferStateLayer fill
486 // BLUE: prior background color
487 // GREEN: final background color
488 // BLACK: no color or fill
setBackgroundColorHelper(uint32_t layerType,bool priorColor,bool bufferFill,float alpha,Color finalColor)489 void LayerRenderTypeTransactionTest::setBackgroundColorHelper(uint32_t layerType, bool priorColor,
490                                                               bool bufferFill, float alpha,
491                                                               Color finalColor) {
492     sp<SurfaceControl> layer;
493     int32_t width = 500;
494     int32_t height = 500;
495 
496     Color fillColor = Color::RED;
497     Color priorBgColor = Color::BLUE;
498     Color expectedColor = Color::BLACK;
499     switch (layerType) {
500         case ISurfaceComposerClient::eFXSurfaceEffect:
501             ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 0, 0, layerType));
502             Transaction()
503                     .setCrop(layer, Rect(0, 0, width, height))
504                     .setColor(layer, half3(1.0f, 0, 0))
505                     .apply();
506             expectedColor = fillColor;
507             break;
508         case ISurfaceComposerClient::eFXSurfaceBufferQueue:
509             ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", width, height));
510             if (bufferFill) {
511                 ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, fillColor, width, height));
512                 expectedColor = fillColor;
513             }
514             Transaction().setCrop(layer, Rect(0, 0, width, height)).apply();
515             break;
516         case ISurfaceComposerClient::eFXSurfaceBufferState:
517             ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", width, height, layerType));
518             if (bufferFill) {
519                 ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, fillColor, width, height));
520                 expectedColor = fillColor;
521             }
522             Transaction().setCrop(layer, Rect(0, 0, width, height)).apply();
523             break;
524         default:
525             GTEST_FAIL() << "Unknown layer type in setBackgroundColorHelper";
526             return;
527     }
528 
529     if (priorColor && layerType != ISurfaceComposerClient::eFXSurfaceEffect) {
530         Transaction()
531                 .setBackgroundColor(layer, half3(0, 0, 1.0f), 1.0f, ui::Dataspace::UNKNOWN)
532                 .apply();
533         if (!bufferFill) {
534             expectedColor = priorBgColor;
535         }
536     }
537 
538     {
539         SCOPED_TRACE("default before setting background color layer");
540         screenshot()->expectColor(Rect(0, 0, width, height), expectedColor);
541     }
542     Transaction()
543             .setBackgroundColor(layer, half3(0, 1.0f, 0), alpha, ui::Dataspace::UNKNOWN)
544             .apply();
545 
546     {
547         auto shot = screenshot();
548         shot->expectColor(Rect(0, 0, width, height), finalColor);
549         shot->expectBorder(Rect(0, 0, width, height), Color::BLACK);
550     }
551 }
552 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_Color_NoEffect)553 TEST_P(LayerRenderTypeTransactionTest, SetBackgroundColor_Color_NoEffect) {
554     bool priorColor = false;
555     bool bufferFill = false;
556     float alpha = 1.0f;
557     Color finalColor = Color::RED;
558     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceEffect,
559                                                      priorColor, bufferFill, alpha, finalColor));
560 }
561 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferQueue_NoPriorColor_ZeroAlpha_NoEffect)562 TEST_P(LayerRenderTypeTransactionTest,
563        SetBackgroundColor_BufferQueue_NoPriorColor_ZeroAlpha_NoEffect) {
564     bool priorColor = false;
565     bool bufferFill = false;
566     float alpha = 0;
567     Color finalColor = Color::BLACK;
568     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
569                                                      priorColor, bufferFill, alpha, finalColor));
570 }
571 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferQueue_PriorColor_ZeroAlpha_DeleteBackground)572 TEST_P(LayerRenderTypeTransactionTest,
573        SetBackgroundColor_BufferQueue_PriorColor_ZeroAlpha_DeleteBackground) {
574     bool priorColor = true;
575     bool bufferFill = false;
576     float alpha = 0;
577     Color finalColor = Color::BLACK;
578     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
579                                                      priorColor, bufferFill, alpha, finalColor));
580 }
581 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_BufferFill_NoPriorColor_Basic)582 TEST_P(LayerRenderTypeTransactionTest,
583        SetBackgroundColor_BufferState_BufferFill_NoPriorColor_Basic) {
584     bool priorColor = false;
585     bool bufferFill = true;
586     float alpha = 1.0f;
587     Color finalColor = Color::RED;
588     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
589                                                      priorColor, bufferFill, alpha, finalColor));
590 }
591 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_NoBufferFill_NoPriorColor_Basic)592 TEST_P(LayerRenderTypeTransactionTest,
593        SetBackgroundColor_BufferState_NoBufferFill_NoPriorColor_Basic) {
594     bool priorColor = false;
595     bool bufferFill = false;
596     float alpha = 1.0f;
597     Color finalColor = Color::GREEN;
598     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
599                                                      priorColor, bufferFill, alpha, finalColor));
600 }
601 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_NoBufferFill_PriorColor_Basic)602 TEST_P(LayerRenderTypeTransactionTest,
603        SetBackgroundColor_BufferState_NoBufferFill_PriorColor_Basic) {
604     bool priorColor = true;
605     bool bufferFill = false;
606     float alpha = 1.0f;
607     Color finalColor = Color::GREEN;
608     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
609                                                      priorColor, bufferFill, alpha, finalColor));
610 }
611 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_NoPriorColor_ZeroAlpha_NoEffect)612 TEST_P(LayerRenderTypeTransactionTest,
613        SetBackgroundColor_BufferState_NoPriorColor_ZeroAlpha_NoEffect) {
614     bool priorColor = false;
615     bool bufferFill = false;
616     float alpha = 0;
617     Color finalColor = Color::BLACK;
618     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
619                                                      priorColor, bufferFill, alpha, finalColor));
620 }
621 
TEST_P(LayerRenderTypeTransactionTest,SetBackgroundColor_BufferState_PriorColor_ZeroAlpha_DeleteBackground)622 TEST_P(LayerRenderTypeTransactionTest,
623        SetBackgroundColor_BufferState_PriorColor_ZeroAlpha_DeleteBackground) {
624     bool priorColor = true;
625     bool bufferFill = false;
626     float alpha = 0;
627     Color finalColor = Color::BLACK;
628     ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
629                                                      priorColor, bufferFill, alpha, finalColor));
630 }
631 
TEST_P(LayerRenderTypeTransactionTest,SetColorClamped)632 TEST_P(LayerRenderTypeTransactionTest, SetColorClamped) {
633     sp<SurfaceControl> colorLayer;
634     ASSERT_NO_FATAL_FAILURE(colorLayer =
635                                     createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
636                                                 ISurfaceComposerClient::eFXSurfaceEffect));
637     Transaction()
638             .setCrop(colorLayer, Rect(0, 0, 32, 32))
639             .setColor(colorLayer, half3(2.0f, 0.0f, 0.0f))
640             .apply();
641 
642     getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
643 }
644 
645 // An invalid color will not render a color and the layer will not be visible.
TEST_P(LayerRenderTypeTransactionTest,SetInvalidColor)646 TEST_P(LayerRenderTypeTransactionTest, SetInvalidColor) {
647     sp<SurfaceControl> colorLayer;
648     ASSERT_NO_FATAL_FAILURE(colorLayer =
649                                     createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
650                                                 ISurfaceComposerClient::eFXSurfaceEffect));
651     Transaction()
652             .setCrop(colorLayer, Rect(0, 0, 32, 32))
653             .setColor(colorLayer, half3(1.0f, -1.0f, 0.5f))
654             .apply();
655 
656     getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
657 }
658 
TEST_P(LayerRenderTypeTransactionTest,SetColorWithAlpha)659 TEST_P(LayerRenderTypeTransactionTest, SetColorWithAlpha) {
660     sp<SurfaceControl> bufferLayer;
661     sp<SurfaceControl> colorLayer;
662     ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
663     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
664     ASSERT_NO_FATAL_FAILURE(colorLayer =
665                                     createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
666                                                 ISurfaceComposerClient::eFXSurfaceEffect));
667     Transaction().setCrop(colorLayer, Rect(0, 0, 32, 32)).apply();
668 
669     const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
670     const float alpha = 0.25f;
671     const ubyte3 expected((vec3(color) * alpha + vec3(1.0f, 0.0f, 0.0f) * (1.0f - alpha)) * 255.0f);
672     // this is handwavy, but the precison loss scaled by 255 (8-bit per
673     // channel) should be less than one
674     const uint8_t tolerance = 1;
675     Transaction()
676             .setColor(colorLayer, color)
677             .setAlpha(colorLayer, alpha)
678             .setLayer(colorLayer, mLayerZBase + 1)
679             .apply();
680     getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {expected.r, expected.g, expected.b, 255},
681                                     tolerance);
682 }
683 
TEST_P(LayerRenderTypeTransactionTest,SetColorWithParentAlpha_Bug74220420)684 TEST_P(LayerRenderTypeTransactionTest, SetColorWithParentAlpha_Bug74220420) {
685     sp<SurfaceControl> bufferLayer;
686     sp<SurfaceControl> parentLayer;
687     sp<SurfaceControl> colorLayer;
688     ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
689     ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parentWithAlpha", 32, 32));
690     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
691     ASSERT_NO_FATAL_FAILURE(colorLayer = createLayer("childWithColor", 0 /* buffer width */,
692                                                      0 /* buffer height */,
693                                                      ISurfaceComposerClient::eFXSurfaceEffect));
694     Transaction().setCrop(colorLayer, Rect(0, 0, 32, 32)).apply();
695     const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
696     const float alpha = 0.25f;
697     const ubyte3 expected((vec3(color) * alpha + vec3(1.0f, 0.0f, 0.0f) * (1.0f - alpha)) * 255.0f);
698     // this is handwavy, but the precision loss scaled by 255 (8-bit per
699     // channel) should be less than one
700     const uint8_t tolerance = 1;
701     Transaction()
702             .reparent(colorLayer, parentLayer)
703             .setColor(colorLayer, color)
704             .setAlpha(parentLayer, alpha)
705             .setLayer(parentLayer, mLayerZBase + 1)
706             .apply();
707     getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {expected.r, expected.g, expected.b, 255},
708                                     tolerance);
709 }
710 
TEST_P(LayerRenderTypeTransactionTest,SetMatrixBasic_BufferQueue)711 TEST_P(LayerRenderTypeTransactionTest, SetMatrixBasic_BufferQueue) {
712     sp<SurfaceControl> layer;
713     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
714     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
715                                                          Color::BLUE, Color::WHITE));
716 
717     Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, 1.0f).setPosition(layer, 0, 0).apply();
718     {
719         SCOPED_TRACE("IDENTITY");
720         getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
721                                            Color::BLUE, Color::WHITE);
722     }
723 
724     Transaction().setMatrix(layer, -1.0f, 0.0f, 0.0f, 1.0f).setPosition(layer, 32, 0).apply();
725     {
726         SCOPED_TRACE("FLIP_H");
727         getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::GREEN, Color::RED,
728                                            Color::WHITE, Color::BLUE);
729     }
730 
731     Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, -1.0f).setPosition(layer, 0, 32).apply();
732     {
733         SCOPED_TRACE("FLIP_V");
734         getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::WHITE,
735                                            Color::RED, Color::GREEN);
736     }
737 
738     Transaction().setMatrix(layer, 0.0f, 1.0f, -1.0f, 0.0f).setPosition(layer, 32, 0).apply();
739     {
740         SCOPED_TRACE("ROT_90");
741         getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::RED,
742                                            Color::WHITE, Color::GREEN);
743     }
744 
745     Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).setPosition(layer, 0, 0).apply();
746     {
747         SCOPED_TRACE("SCALE");
748         getScreenCapture()->expectQuadrant(Rect(0, 0, 64, 64), Color::RED, Color::GREEN,
749                                            Color::BLUE, Color::WHITE, true /* filtered */);
750     }
751 }
752 
TEST_P(LayerRenderTypeTransactionTest,SetMatrixBasic_BufferState)753 TEST_P(LayerRenderTypeTransactionTest, SetMatrixBasic_BufferState) {
754     sp<SurfaceControl> layer;
755     ASSERT_NO_FATAL_FAILURE(
756             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
757     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
758                                                          Color::BLUE, Color::WHITE));
759 
760     Transaction().setPosition(layer, 32, 32).setMatrix(layer, 1.0f, 0.0f, 0.0f, 1.0f).apply();
761     {
762         SCOPED_TRACE("IDENTITY");
763         getScreenCapture()->expectQuadrant(Rect(32, 32, 64, 64), Color::RED, Color::GREEN,
764                                            Color::BLUE, Color::WHITE);
765     }
766 
767     Transaction().setMatrix(layer, -1.0f, 0.0f, 0.0f, 1.0f).apply();
768     {
769         SCOPED_TRACE("FLIP_H");
770         getScreenCapture()->expectQuadrant(Rect(0, 32, 32, 64), Color::GREEN, Color::RED,
771                                            Color::WHITE, Color::BLUE);
772     }
773 
774     Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, -1.0f).apply();
775     {
776         SCOPED_TRACE("FLIP_V");
777         getScreenCapture()->expectQuadrant(Rect(32, 0, 64, 32), Color::BLUE, Color::WHITE,
778                                            Color::RED, Color::GREEN);
779     }
780 
781     Transaction().setMatrix(layer, 0.0f, 1.0f, -1.0f, 0.0f).apply();
782     {
783         SCOPED_TRACE("ROT_90");
784         getScreenCapture()->expectQuadrant(Rect(0, 32, 32, 64), Color::BLUE, Color::RED,
785                                            Color::WHITE, Color::GREEN);
786     }
787 
788     Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).apply();
789     {
790         SCOPED_TRACE("SCALE");
791         getScreenCapture()->expectQuadrant(Rect(32, 32, 96, 96), Color::RED, Color::GREEN,
792                                            Color::BLUE, Color::WHITE, 1 /* tolerance */);
793     }
794 }
795 
TEST_P(LayerRenderTypeTransactionTest,SetMatrixRot45_BufferQueue)796 TEST_P(LayerRenderTypeTransactionTest, SetMatrixRot45_BufferQueue) {
797     sp<SurfaceControl> layer;
798     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
799     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
800                                                          Color::BLUE, Color::WHITE));
801 
802     const float rot = M_SQRT1_2; // 45 degrees
803     const float trans = M_SQRT2 * 16.0f;
804     Transaction().setMatrix(layer, rot, rot, -rot, rot).setPosition(layer, trans, 0).apply();
805 
806     auto shot = getScreenCapture();
807     // check a 8x8 region inside each color
808     auto get8x8Rect = [](int32_t centerX, int32_t centerY) {
809         const int32_t halfL = 4;
810         return Rect(centerX - halfL, centerY - halfL, centerX + halfL, centerY + halfL);
811     };
812     const int32_t unit = int32_t(trans / 2);
813     shot->expectColor(get8x8Rect(2 * unit, 1 * unit), Color::RED);
814     shot->expectColor(get8x8Rect(3 * unit, 2 * unit), Color::GREEN);
815     shot->expectColor(get8x8Rect(1 * unit, 2 * unit), Color::BLUE);
816     shot->expectColor(get8x8Rect(2 * unit, 3 * unit), Color::WHITE);
817 }
818 
TEST_P(LayerRenderTypeTransactionTest,SetCropBasic_BufferQueue)819 TEST_P(LayerRenderTypeTransactionTest, SetCropBasic_BufferQueue) {
820     sp<SurfaceControl> layer;
821     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
822     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
823     const Rect crop(8, 8, 24, 24);
824 
825     Transaction().setCrop(layer, crop).apply();
826     auto shot = getScreenCapture();
827     shot->expectColor(crop, Color::RED);
828     shot->expectBorder(crop, Color::BLACK);
829 }
830 
TEST_P(LayerRenderTypeTransactionTest,SetCropBasic_BufferState)831 TEST_P(LayerRenderTypeTransactionTest, SetCropBasic_BufferState) {
832     sp<SurfaceControl> layer;
833     ASSERT_NO_FATAL_FAILURE(
834             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
835     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
836     const Rect crop(8, 8, 24, 24);
837 
838     Transaction().setCrop(layer, crop).apply();
839     auto shot = getScreenCapture();
840     shot->expectColor(crop, Color::RED);
841     shot->expectBorder(crop, Color::BLACK);
842 }
843 
TEST_P(LayerRenderTypeTransactionTest,SetCropEmpty_BufferQueue)844 TEST_P(LayerRenderTypeTransactionTest, SetCropEmpty_BufferQueue) {
845     sp<SurfaceControl> layer;
846     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
847     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
848 
849     {
850         SCOPED_TRACE("empty rect");
851         Transaction().setCrop(layer, Rect(8, 8, 8, 8)).apply();
852         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
853     }
854 
855     {
856         SCOPED_TRACE("negative rect");
857         Transaction().setCrop(layer, Rect(8, 8, 0, 0)).apply();
858         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
859     }
860 }
861 
TEST_P(LayerRenderTypeTransactionTest,SetCropEmpty_BufferState)862 TEST_P(LayerRenderTypeTransactionTest, SetCropEmpty_BufferState) {
863     sp<SurfaceControl> layer;
864     ASSERT_NO_FATAL_FAILURE(
865             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
866     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
867 
868     {
869         SCOPED_TRACE("empty rect");
870         Transaction().setCrop(layer, Rect(8, 8, 8, 8)).apply();
871         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
872     }
873 
874     {
875         SCOPED_TRACE("negative rect");
876         Transaction().setCrop(layer, Rect(8, 8, 0, 0)).apply();
877         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
878     }
879 }
880 
TEST_P(LayerRenderTypeTransactionTest,SetCropOutOfBounds_BufferQueue)881 TEST_P(LayerRenderTypeTransactionTest, SetCropOutOfBounds_BufferQueue) {
882     sp<SurfaceControl> layer;
883     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
884     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
885 
886     Transaction().setCrop(layer, Rect(-128, -64, 128, 64)).apply();
887     auto shot = getScreenCapture();
888     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
889     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
890 }
891 
TEST_P(LayerRenderTypeTransactionTest,SetCropOutOfBounds_BufferState)892 TEST_P(LayerRenderTypeTransactionTest, SetCropOutOfBounds_BufferState) {
893     sp<SurfaceControl> layer;
894     ASSERT_NO_FATAL_FAILURE(
895             layer = createLayer("test", 32, 64, ISurfaceComposerClient::eFXSurfaceBufferState));
896     sp<GraphicBuffer> buffer =
897             new GraphicBuffer(32, 64, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
898     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 16), Color::BLUE);
899     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 16, 32, 64), Color::RED);
900 
901     Transaction().setBuffer(layer, buffer).apply();
902 
903     // Partially out of bounds in the negative (upper left) direction
904     Transaction().setCrop(layer, Rect(-128, -128, 32, 16)).apply();
905     {
906         SCOPED_TRACE("out of bounds, negative (upper left) direction");
907         auto shot = getScreenCapture();
908         shot->expectColor(Rect(0, 0, 32, 16), Color::BLUE);
909         shot->expectBorder(Rect(0, 0, 32, 16), Color::BLACK);
910     }
911 
912     // Partially out of bounds in the positive (lower right) direction
913     Transaction().setCrop(layer, Rect(0, 16, 128, 128)).apply();
914     {
915         SCOPED_TRACE("out of bounds, positive (lower right) direction");
916         auto shot = getScreenCapture();
917         shot->expectColor(Rect(0, 16, 32, 64), Color::RED);
918         shot->expectBorder(Rect(0, 16, 32, 64), Color::BLACK);
919     }
920 
921     // Fully out of buffer space bounds
922     Transaction().setCrop(layer, Rect(-128, -128, -1, -1)).apply();
923     {
924         SCOPED_TRACE("Fully out of bounds");
925         auto shot = getScreenCapture();
926         shot->expectColor(Rect(0, 0, 64, 64), Color::BLACK);
927     }
928 }
929 
TEST_P(LayerRenderTypeTransactionTest,SetCropWithTranslation_BufferQueue)930 TEST_P(LayerRenderTypeTransactionTest, SetCropWithTranslation_BufferQueue) {
931     sp<SurfaceControl> layer;
932     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
933     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
934 
935     const Point position(32, 32);
936     const Rect crop(8, 8, 24, 24);
937     Transaction().setPosition(layer, position.x, position.y).setCrop(layer, crop).apply();
938     auto shot = getScreenCapture();
939     shot->expectColor(crop + position, Color::RED);
940     shot->expectBorder(crop + position, Color::BLACK);
941 }
942 
TEST_P(LayerRenderTypeTransactionTest,SetCropWithTranslation_BufferState)943 TEST_P(LayerRenderTypeTransactionTest, SetCropWithTranslation_BufferState) {
944     sp<SurfaceControl> layer;
945     ASSERT_NO_FATAL_FAILURE(
946             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
947     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
948 
949     const Rect crop(8, 8, 24, 24);
950     Transaction().setPosition(layer, 32, 32).setCrop(layer, crop).apply();
951     auto shot = getScreenCapture();
952     shot->expectColor(Rect(40, 40, 56, 56), Color::RED);
953     shot->expectBorder(Rect(40, 40, 56, 56), Color::BLACK);
954 }
955 
TEST_P(LayerRenderTypeTransactionTest,SetCropWithScale_BufferQueue)956 TEST_P(LayerRenderTypeTransactionTest, SetCropWithScale_BufferQueue) {
957     sp<SurfaceControl> layer;
958     ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
959     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
960 
961     // crop is affected by matrix
962     Transaction()
963             .setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f)
964             .setCrop(layer, Rect(8, 8, 24, 24))
965             .apply();
966     auto shot = getScreenCapture();
967     shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
968     shot->expectBorder(Rect(16, 16, 48, 48), Color::BLACK);
969 }
970 
TEST_P(LayerRenderTypeTransactionTest,SetFrameBasic_BufferState)971 TEST_P(LayerRenderTypeTransactionTest, SetFrameBasic_BufferState) {
972     sp<SurfaceControl> layer;
973     ASSERT_NO_FATAL_FAILURE(
974             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
975     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
976     const Rect frame(8, 8, 24, 24);
977 
978     Transaction t;
979     TransactionUtils::setFrame(t, layer, Rect(0, 0, 32, 32), frame);
980     t.apply();
981 
982     auto shot = getScreenCapture();
983     shot->expectColor(frame, Color::RED);
984     shot->expectBorder(frame, Color::BLACK);
985 }
986 
TEST_P(LayerRenderTypeTransactionTest,SetFrameEmpty_BufferState)987 TEST_P(LayerRenderTypeTransactionTest, SetFrameEmpty_BufferState) {
988     sp<SurfaceControl> layer;
989     ASSERT_NO_FATAL_FAILURE(
990             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
991     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
992 
993     Transaction t;
994     {
995         SCOPED_TRACE("empty rect");
996         TransactionUtils::setFrame(t, layer, Rect(0, 0, 32, 32), Rect(8, 8, 8, 8));
997         t.apply();
998 
999         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1000     }
1001 
1002     {
1003         SCOPED_TRACE("negative rect");
1004         TransactionUtils::setFrame(t, layer, Rect(0, 0, 32, 32), Rect(8, 8, 0, 0));
1005         t.apply();
1006 
1007         auto shot = getScreenCapture();
1008         shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
1009         shot->expectBorder(Rect(0, 0, 8, 8), Color::BLACK);
1010     }
1011 }
1012 
TEST_P(LayerRenderTypeTransactionTest,SetFrameDefaultParentless_BufferState)1013 TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultParentless_BufferState) {
1014     sp<SurfaceControl> layer;
1015     ASSERT_NO_FATAL_FAILURE(
1016             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1017     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 10, 10));
1018 
1019     // A layer with a buffer will have a computed size that matches the buffer size.
1020     auto shot = getScreenCapture();
1021     shot->expectColor(Rect(0, 0, 10, 10), Color::RED);
1022     shot->expectBorder(Rect(0, 0, 10, 10), Color::BLACK);
1023 }
1024 
TEST_P(LayerRenderTypeTransactionTest,SetFrameDefaultBSParent_BufferState)1025 TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultBSParent_BufferState) {
1026     sp<SurfaceControl> parent, child;
1027     ASSERT_NO_FATAL_FAILURE(
1028             parent = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1029     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(parent, Color::RED, 32, 32));
1030 
1031     ASSERT_NO_FATAL_FAILURE(
1032             child = createLayer("test", 10, 10, ISurfaceComposerClient::eFXSurfaceBufferState));
1033     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(child, Color::BLUE, 10, 10));
1034 
1035     Transaction().reparent(child, parent).apply();
1036 
1037     // A layer with a buffer will have a computed size that matches the buffer size.
1038     auto shot = getScreenCapture();
1039     shot->expectColor(Rect(0, 0, 10, 10), Color::BLUE);
1040     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1041 }
1042 
TEST_P(LayerRenderTypeTransactionTest,SetFrameDefaultBQParent_BufferState)1043 TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultBQParent_BufferState) {
1044     sp<SurfaceControl> parent, child;
1045     ASSERT_NO_FATAL_FAILURE(parent = createLayer("test", 32, 32));
1046     ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(parent, Color::RED, 32, 32));
1047 
1048     ASSERT_NO_FATAL_FAILURE(
1049             child = createLayer("test", 10, 10, ISurfaceComposerClient::eFXSurfaceBufferState));
1050     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(child, Color::BLUE, 10, 10));
1051 
1052     Transaction().reparent(child, parent).apply();
1053 
1054     // A layer with a buffer will have a computed size that matches the buffer size.
1055     auto shot = getScreenCapture();
1056     shot->expectColor(Rect(0, 0, 10, 10), Color::BLUE);
1057     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1058 }
1059 
TEST_P(LayerRenderTypeTransactionTest,SetFrameUpdate_BufferState)1060 TEST_P(LayerRenderTypeTransactionTest, SetFrameUpdate_BufferState) {
1061     sp<SurfaceControl> layer;
1062     ASSERT_NO_FATAL_FAILURE(
1063             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1064     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
1065 
1066     std::this_thread::sleep_for(500ms);
1067 
1068     Transaction().setPosition(layer, 16, 16).apply();
1069 
1070     auto shot = getScreenCapture();
1071     shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
1072     shot->expectBorder(Rect(16, 16, 48, 48), Color::BLACK);
1073 }
1074 
TEST_P(LayerRenderTypeTransactionTest,SetFrameOutsideBounds_BufferState)1075 TEST_P(LayerRenderTypeTransactionTest, SetFrameOutsideBounds_BufferState) {
1076     sp<SurfaceControl> parent, child;
1077     ASSERT_NO_FATAL_FAILURE(
1078             parent = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1079     ASSERT_NO_FATAL_FAILURE(
1080             child = createLayer("test", 10, 10, ISurfaceComposerClient::eFXSurfaceBufferState));
1081     Transaction().reparent(child, parent).apply();
1082 
1083     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(parent, Color::RED, 32, 32));
1084 
1085     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(child, Color::BLUE, 10, 10));
1086     Rect childDst(0, 16, 32, 32);
1087     Transaction t;
1088     TransactionUtils::setFrame(t, child, Rect(0, 0, 10, 10), childDst);
1089     t.apply();
1090 
1091     auto shot = getScreenCapture();
1092     shot->expectColor(Rect(0, 0, 32, 16), Color::RED);
1093     shot->expectColor(childDst, Color::BLUE);
1094     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1095 }
1096 
TEST_P(LayerRenderTypeTransactionTest,SetBufferBasic_BufferState)1097 TEST_P(LayerRenderTypeTransactionTest, SetBufferBasic_BufferState) {
1098     sp<SurfaceControl> layer;
1099     ASSERT_NO_FATAL_FAILURE(
1100             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1101 
1102     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
1103 
1104     auto shot = getScreenCapture();
1105     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1106     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1107 }
1108 
TEST_P(LayerRenderTypeTransactionTest,SetBufferMultipleBuffers_BufferState)1109 TEST_P(LayerRenderTypeTransactionTest, SetBufferMultipleBuffers_BufferState) {
1110     sp<SurfaceControl> layer;
1111     ASSERT_NO_FATAL_FAILURE(
1112             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1113 
1114     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
1115 
1116     {
1117         SCOPED_TRACE("set buffer 1");
1118         auto shot = getScreenCapture();
1119         shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1120         shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1121     }
1122 
1123     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::BLUE, 32, 32));
1124 
1125     {
1126         SCOPED_TRACE("set buffer 2");
1127         auto shot = getScreenCapture();
1128         shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
1129         shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1130     }
1131 
1132     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
1133 
1134     {
1135         SCOPED_TRACE("set buffer 3");
1136         auto shot = getScreenCapture();
1137         shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1138         shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1139     }
1140 }
1141 
TEST_P(LayerRenderTypeTransactionTest,SetBufferMultipleLayers_BufferState)1142 TEST_P(LayerRenderTypeTransactionTest, SetBufferMultipleLayers_BufferState) {
1143     sp<SurfaceControl> layer1;
1144     ASSERT_NO_FATAL_FAILURE(
1145             layer1 = createLayer("test", 64, 64, ISurfaceComposerClient::eFXSurfaceBufferState));
1146 
1147     sp<SurfaceControl> layer2;
1148     ASSERT_NO_FATAL_FAILURE(
1149             layer2 = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1150 
1151     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer1, Color::RED, 64, 64));
1152 
1153     {
1154         SCOPED_TRACE("set layer 1 buffer red");
1155         auto shot = getScreenCapture();
1156         shot->expectColor(Rect(0, 0, 64, 64), Color::RED);
1157     }
1158 
1159     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer2, Color::BLUE, 32, 32));
1160 
1161     {
1162         SCOPED_TRACE("set layer 2 buffer blue");
1163         auto shot = getScreenCapture();
1164         shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
1165         shot->expectColor(Rect(0, 32, 64, 64), Color::RED);
1166         shot->expectColor(Rect(0, 32, 32, 64), Color::RED);
1167     }
1168 
1169     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer1, Color::GREEN, 64, 64));
1170     {
1171         SCOPED_TRACE("set layer 1 buffer green");
1172         auto shot = getScreenCapture();
1173         shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
1174         shot->expectColor(Rect(0, 32, 64, 64), Color::GREEN);
1175         shot->expectColor(Rect(0, 32, 32, 64), Color::GREEN);
1176     }
1177 
1178     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer2, Color::WHITE, 32, 32));
1179 
1180     {
1181         SCOPED_TRACE("set layer 2 buffer white");
1182         auto shot = getScreenCapture();
1183         shot->expectColor(Rect(0, 0, 32, 32), Color::WHITE);
1184         shot->expectColor(Rect(0, 32, 64, 64), Color::GREEN);
1185         shot->expectColor(Rect(0, 32, 32, 64), Color::GREEN);
1186     }
1187 }
1188 
TEST_P(LayerRenderTypeTransactionTest,SetBufferCaching_BufferState)1189 TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_BufferState) {
1190     sp<SurfaceControl> layer;
1191     ASSERT_NO_FATAL_FAILURE(
1192             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1193 
1194     std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
1195 
1196     std::array<sp<GraphicBuffer>, 10> buffers;
1197 
1198     size_t idx = 0;
1199     for (auto& buffer : buffers) {
1200         buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1201         Color color = colors[idx % colors.size()];
1202         TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
1203         idx++;
1204     }
1205 
1206     // Set each buffer twice. The first time adds it to the cache, the second time tests that the
1207     // cache is working.
1208     idx = 0;
1209     for (auto& buffer : buffers) {
1210         for (int i = 0; i < 2; i++) {
1211             Transaction().setBuffer(layer, buffer).apply();
1212 
1213             Color color = colors[idx % colors.size()];
1214             auto shot = screenshot();
1215             shot->expectColor(Rect(0, 0, 32, 32), color);
1216             shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1217         }
1218         idx++;
1219     }
1220 }
1221 
TEST_P(LayerRenderTypeTransactionTest,SetBufferCaching_LeastRecentlyUsed_BufferState)1222 TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_LeastRecentlyUsed_BufferState) {
1223     sp<SurfaceControl> layer;
1224     ASSERT_NO_FATAL_FAILURE(
1225             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1226 
1227     std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
1228 
1229     std::array<sp<GraphicBuffer>, 70> buffers;
1230 
1231     size_t idx = 0;
1232     for (auto& buffer : buffers) {
1233         buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1234         Color color = colors[idx % colors.size()];
1235         TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
1236         idx++;
1237     }
1238 
1239     // Set each buffer twice. The first time adds it to the cache, the second time tests that the
1240     // cache is working.
1241     idx = 0;
1242     for (auto& buffer : buffers) {
1243         for (int i = 0; i < 2; i++) {
1244             Transaction().setBuffer(layer, buffer).apply();
1245 
1246             Color color = colors[idx % colors.size()];
1247             auto shot = screenshot();
1248             shot->expectColor(Rect(0, 0, 32, 32), color);
1249             shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1250         }
1251         idx++;
1252     }
1253 }
1254 
TEST_P(LayerRenderTypeTransactionTest,SetBufferCaching_DestroyedBuffer_BufferState)1255 TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_DestroyedBuffer_BufferState) {
1256     sp<SurfaceControl> layer;
1257     ASSERT_NO_FATAL_FAILURE(
1258             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1259 
1260     std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
1261 
1262     std::array<sp<GraphicBuffer>, 65> buffers;
1263 
1264     size_t idx = 0;
1265     for (auto& buffer : buffers) {
1266         buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1267         Color color = colors[idx % colors.size()];
1268         TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
1269         idx++;
1270     }
1271 
1272     // Set each buffer twice. The first time adds it to the cache, the second time tests that the
1273     // cache is working.
1274     idx = 0;
1275     for (auto& buffer : buffers) {
1276         for (int i = 0; i < 2; i++) {
1277             Transaction().setBuffer(layer, buffer).apply();
1278 
1279             Color color = colors[idx % colors.size()];
1280             auto shot = screenshot();
1281             shot->expectColor(Rect(0, 0, 32, 32), color);
1282             shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1283         }
1284         if (idx == 0) {
1285             buffers[0].clear();
1286         }
1287         idx++;
1288     }
1289 }
1290 
TEST_P(LayerRenderTypeTransactionTest,SetTransformRotate90_BufferState)1291 TEST_P(LayerRenderTypeTransactionTest, SetTransformRotate90_BufferState) {
1292     sp<SurfaceControl> layer;
1293     ASSERT_NO_FATAL_FAILURE(
1294             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1295 
1296     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
1297                                                          Color::BLUE, Color::WHITE));
1298 
1299     Transaction()
1300             .setTransform(layer, NATIVE_WINDOW_TRANSFORM_ROT_90)
1301             .apply();
1302 
1303     getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::RED, Color::WHITE,
1304                                        Color::GREEN, true /* filtered */);
1305 }
1306 
TEST_P(LayerRenderTypeTransactionTest,SetTransformFlipH_BufferState)1307 TEST_P(LayerRenderTypeTransactionTest, SetTransformFlipH_BufferState) {
1308     sp<SurfaceControl> layer;
1309     ASSERT_NO_FATAL_FAILURE(
1310             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1311 
1312     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
1313                                                          Color::BLUE, Color::WHITE));
1314 
1315     Transaction()
1316             .setTransform(layer, NATIVE_WINDOW_TRANSFORM_FLIP_H)
1317             .apply();
1318 
1319     getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::GREEN, Color::RED, Color::WHITE,
1320                                        Color::BLUE, true /* filtered */);
1321 }
1322 
TEST_P(LayerRenderTypeTransactionTest,SetTransformFlipV_BufferState)1323 TEST_P(LayerRenderTypeTransactionTest, SetTransformFlipV_BufferState) {
1324     sp<SurfaceControl> layer;
1325     ASSERT_NO_FATAL_FAILURE(
1326             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1327 
1328     ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
1329                                                          Color::BLUE, Color::WHITE));
1330 
1331     Transaction()
1332             .setTransform(layer, NATIVE_WINDOW_TRANSFORM_FLIP_V)
1333             .apply();
1334 
1335     getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::WHITE, Color::RED,
1336                                        Color::GREEN, true /* filtered */);
1337 }
1338 
1339 // TODO (b/186543004): Fix & re-enable
TEST_P(LayerRenderTypeTransactionTest,DISABLED_SetFenceBasic_BufferState)1340 TEST_P(LayerRenderTypeTransactionTest, DISABLED_SetFenceBasic_BufferState) {
1341     sp<SurfaceControl> layer;
1342     Transaction transaction;
1343     ASSERT_NO_FATAL_FAILURE(
1344             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1345 
1346     sp<GraphicBuffer> buffer =
1347             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1348     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1349 
1350     sp<Fence> fence;
1351     if (getBuffer(nullptr, &fence) != NO_ERROR) {
1352         GTEST_SUCCEED() << "test not supported";
1353         return;
1354     }
1355 
1356     Transaction().setBuffer(layer, buffer).setAcquireFence(layer, fence).apply();
1357 
1358     status_t status = fence->wait(1000);
1359     ASSERT_NE(static_cast<status_t>(Fence::Status::Unsignaled), status);
1360     std::this_thread::sleep_for(200ms);
1361 
1362     auto shot = getScreenCapture();
1363     shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
1364     shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
1365 }
1366 
TEST_P(LayerRenderTypeTransactionTest,SetFenceNull_BufferState)1367 TEST_P(LayerRenderTypeTransactionTest, SetFenceNull_BufferState) {
1368     sp<SurfaceControl> layer;
1369     ASSERT_NO_FATAL_FAILURE(
1370             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1371 
1372     sp<GraphicBuffer> buffer =
1373             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1374     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1375 
1376     sp<Fence> fence = Fence::NO_FENCE;
1377 
1378     Transaction().setBuffer(layer, buffer).setAcquireFence(layer, fence).apply();
1379 
1380     auto shot = getScreenCapture();
1381     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1382     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1383 }
1384 
TEST_P(LayerRenderTypeTransactionTest,SetDataspaceBasic_BufferState)1385 TEST_P(LayerRenderTypeTransactionTest, SetDataspaceBasic_BufferState) {
1386     sp<SurfaceControl> layer;
1387     ASSERT_NO_FATAL_FAILURE(
1388             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1389 
1390     sp<GraphicBuffer> buffer =
1391             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1392     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1393 
1394     Transaction().setBuffer(layer, buffer).setDataspace(layer, ui::Dataspace::UNKNOWN).apply();
1395 
1396     auto shot = getScreenCapture();
1397     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1398     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1399 }
1400 
TEST_P(LayerRenderTypeTransactionTest,SetHdrMetadataBasic_BufferState)1401 TEST_P(LayerRenderTypeTransactionTest, SetHdrMetadataBasic_BufferState) {
1402     sp<SurfaceControl> layer;
1403     ASSERT_NO_FATAL_FAILURE(
1404             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1405 
1406     sp<GraphicBuffer> buffer =
1407             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1408     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1409 
1410     HdrMetadata hdrMetadata;
1411     hdrMetadata.validTypes = 0;
1412     Transaction().setBuffer(layer, buffer).setHdrMetadata(layer, hdrMetadata).apply();
1413 
1414     auto shot = getScreenCapture();
1415     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1416     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1417 }
1418 
TEST_P(LayerRenderTypeTransactionTest,SetSurfaceDamageRegionBasic_BufferState)1419 TEST_P(LayerRenderTypeTransactionTest, SetSurfaceDamageRegionBasic_BufferState) {
1420     sp<SurfaceControl> layer;
1421     ASSERT_NO_FATAL_FAILURE(
1422             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1423 
1424     sp<GraphicBuffer> buffer =
1425             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1426     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1427 
1428     Region region;
1429     region.set(32, 32);
1430     Transaction().setBuffer(layer, buffer).setSurfaceDamageRegion(layer, region).apply();
1431 
1432     auto shot = getScreenCapture();
1433     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1434     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1435 }
1436 
TEST_P(LayerRenderTypeTransactionTest,SetApiBasic_BufferState)1437 TEST_P(LayerRenderTypeTransactionTest, SetApiBasic_BufferState) {
1438     sp<SurfaceControl> layer;
1439     ASSERT_NO_FATAL_FAILURE(
1440             layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
1441 
1442     sp<GraphicBuffer> buffer =
1443             new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1, kUsageFlags, "test");
1444     TransactionUtils::fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
1445 
1446     Transaction().setBuffer(layer, buffer).setApi(layer, NATIVE_WINDOW_API_CPU).apply();
1447 
1448     auto shot = getScreenCapture();
1449     shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
1450     shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
1451 }
1452 
TEST_P(LayerRenderTypeTransactionTest,SetColorTransformBasic)1453 TEST_P(LayerRenderTypeTransactionTest, SetColorTransformBasic) {
1454     sp<SurfaceControl> colorLayer;
1455     ASSERT_NO_FATAL_FAILURE(colorLayer =
1456                                     createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
1457                                                 ISurfaceComposerClient::eFXSurfaceEffect));
1458     Transaction()
1459             .setCrop(colorLayer, Rect(0, 0, 32, 32))
1460             .setLayer(colorLayer, mLayerZBase + 1)
1461             .apply();
1462     {
1463         SCOPED_TRACE("default color");
1464         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1465     }
1466 
1467     const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
1468     half3 expected = color;
1469     mat3 matrix;
1470     matrix[0][0] = 0.3;
1471     matrix[1][0] = 0.59;
1472     matrix[2][0] = 0.11;
1473     matrix[0][1] = 0.3;
1474     matrix[1][1] = 0.59;
1475     matrix[2][1] = 0.11;
1476     matrix[0][2] = 0.3;
1477     matrix[1][2] = 0.59;
1478     matrix[2][2] = 0.11;
1479 
1480     // degamma before applying the matrix
1481     if (mColorManagementUsed) {
1482         ColorTransformHelper::DegammaColor(expected);
1483     }
1484 
1485     ColorTransformHelper::applyMatrix(expected, matrix);
1486 
1487     if (mColorManagementUsed) {
1488         ColorTransformHelper::GammaColor(expected);
1489     }
1490 
1491     const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
1492                                  uint8_t(expected.b * 255), 255};
1493 
1494     // this is handwavy, but the precison loss scaled by 255 (8-bit per
1495     // channel) should be less than one
1496     const uint8_t tolerance = 1;
1497 
1498     Transaction().setColor(colorLayer, color).setColorTransform(colorLayer, matrix, vec3()).apply();
1499     {
1500         SCOPED_TRACE("new color");
1501         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
1502     }
1503 }
1504 
TEST_P(LayerRenderTypeTransactionTest,SetColorTransformOnParent)1505 TEST_P(LayerRenderTypeTransactionTest, SetColorTransformOnParent) {
1506     sp<SurfaceControl> parentLayer;
1507     sp<SurfaceControl> colorLayer;
1508     ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parent", 0 /* buffer width */,
1509                                                       0 /* buffer height */,
1510                                                       ISurfaceComposerClient::eFXSurfaceContainer));
1511     ASSERT_NO_FATAL_FAILURE(
1512             colorLayer = createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
1513                                      ISurfaceComposerClient::eFXSurfaceEffect, parentLayer.get()));
1514 
1515     Transaction()
1516             .setCrop(parentLayer, Rect(0, 0, 100, 100))
1517             .setCrop(colorLayer, Rect(0, 0, 32, 32))
1518             .setLayer(parentLayer, mLayerZBase + 1)
1519             .apply();
1520     {
1521         SCOPED_TRACE("default color");
1522         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1523     }
1524 
1525     const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
1526     half3 expected = color;
1527     mat3 matrix;
1528     matrix[0][0] = 0.3;
1529     matrix[1][0] = 0.59;
1530     matrix[2][0] = 0.11;
1531     matrix[0][1] = 0.3;
1532     matrix[1][1] = 0.59;
1533     matrix[2][1] = 0.11;
1534     matrix[0][2] = 0.3;
1535     matrix[1][2] = 0.59;
1536     matrix[2][2] = 0.11;
1537 
1538     // degamma before applying the matrix
1539     if (mColorManagementUsed) {
1540         ColorTransformHelper::DegammaColor(expected);
1541     }
1542 
1543     ColorTransformHelper::applyMatrix(expected, matrix);
1544 
1545     if (mColorManagementUsed) {
1546         ColorTransformHelper::GammaColor(expected);
1547     }
1548 
1549     const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
1550                                  uint8_t(expected.b * 255), 255};
1551 
1552     // this is handwavy, but the precison loss scaled by 255 (8-bit per
1553     // channel) should be less than one
1554     const uint8_t tolerance = 1;
1555 
1556     Transaction()
1557             .setColor(colorLayer, color)
1558             .setColorTransform(parentLayer, matrix, vec3())
1559             .apply();
1560     {
1561         SCOPED_TRACE("new color");
1562         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
1563     }
1564 }
1565 
TEST_P(LayerRenderTypeTransactionTest,SetColorTransformOnChildAndParent)1566 TEST_P(LayerRenderTypeTransactionTest, SetColorTransformOnChildAndParent) {
1567     sp<SurfaceControl> parentLayer;
1568     sp<SurfaceControl> colorLayer;
1569     ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parent", 0 /* buffer width */,
1570                                                       0 /* buffer height */,
1571                                                       ISurfaceComposerClient::eFXSurfaceContainer));
1572     ASSERT_NO_FATAL_FAILURE(
1573             colorLayer = createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
1574                                      ISurfaceComposerClient::eFXSurfaceEffect, parentLayer.get()));
1575 
1576     Transaction()
1577             .setCrop(parentLayer, Rect(0, 0, 100, 100))
1578             .setCrop(colorLayer, Rect(0, 0, 32, 32))
1579             .setLayer(parentLayer, mLayerZBase + 1)
1580             .apply();
1581     {
1582         SCOPED_TRACE("default color");
1583         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
1584     }
1585 
1586     const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
1587     half3 expected = color;
1588     mat3 matrixChild;
1589     matrixChild[0][0] = 0.3;
1590     matrixChild[1][0] = 0.59;
1591     matrixChild[2][0] = 0.11;
1592     matrixChild[0][1] = 0.3;
1593     matrixChild[1][1] = 0.59;
1594     matrixChild[2][1] = 0.11;
1595     matrixChild[0][2] = 0.3;
1596     matrixChild[1][2] = 0.59;
1597     matrixChild[2][2] = 0.11;
1598     mat3 matrixParent;
1599     matrixParent[0][0] = 0.2;
1600     matrixParent[1][0] = 0.4;
1601     matrixParent[2][0] = 0.10;
1602     matrixParent[0][1] = 0.2;
1603     matrixParent[1][1] = 0.4;
1604     matrixParent[2][1] = 0.10;
1605     matrixParent[0][2] = 0.2;
1606     matrixParent[1][2] = 0.4;
1607     matrixParent[2][2] = 0.10;
1608 
1609     // degamma before applying the matrix
1610     if (mColorManagementUsed) {
1611         ColorTransformHelper::DegammaColor(expected);
1612     }
1613 
1614     ColorTransformHelper::applyMatrix(expected, matrixChild);
1615     ColorTransformHelper::applyMatrix(expected, matrixParent);
1616 
1617     if (mColorManagementUsed) {
1618         ColorTransformHelper::GammaColor(expected);
1619     }
1620 
1621     const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
1622                                  uint8_t(expected.b * 255), 255};
1623 
1624     // this is handwavy, but the precison loss scaled by 255 (8-bit per
1625     // channel) should be less than one
1626     const uint8_t tolerance = 1;
1627 
1628     Transaction()
1629             .setColor(colorLayer, color)
1630             .setColorTransform(parentLayer, matrixParent, vec3())
1631             .setColorTransform(colorLayer, matrixChild, vec3())
1632             .apply();
1633     {
1634         SCOPED_TRACE("new color");
1635         getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
1636     }
1637 }
1638 } // namespace android
1639 
1640 // TODO(b/129481165): remove the #pragma below and fix conversion issues
1641 #pragma clang diagnostic pop // ignored "-Wconversion"
1642