1/*
2 * Copyright (C) 2016 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#include <frameworks/native/cmds/surfacereplayer/proto/src/trace.pb.h>
18#include <google/protobuf/io/zero_copy_stream_impl.h>
19
20#include <gtest/gtest.h>
21
22#include <android/native_window.h>
23
24#include <gui/ISurfaceComposer.h>
25#include <gui/Surface.h>
26#include <gui/SurfaceComposerClient.h>
27#include <private/gui/ComposerService.h>
28#include <private/gui/LayerState.h>
29#include <ui/DisplayInfo.h>
30
31#include <fstream>
32#include <random>
33#include <thread>
34
35namespace android {
36
37constexpr int32_t SCALING_UPDATE = 1;
38constexpr uint32_t BUFFER_UPDATES = 18;
39constexpr uint32_t LAYER_UPDATE = INT_MAX - 2;
40constexpr uint32_t SIZE_UPDATE = 134;
41constexpr uint32_t STACK_UPDATE = 1;
42constexpr uint64_t DEFERRED_UPDATE = 13;
43constexpr float ALPHA_UPDATE = 0.29f;
44constexpr float POSITION_UPDATE = 121;
45const Rect CROP_UPDATE(16, 16, 32, 32);
46
47const String8 DISPLAY_NAME("SurfaceInterceptor Display Test");
48constexpr auto LAYER_NAME = "Layer Create and Delete Test";
49
50constexpr auto DEFAULT_FILENAME = "/data/SurfaceTrace.dat";
51
52// Fill an RGBA_8888 formatted surface with a single color.
53static void fillSurfaceRGBA8(const sp<SurfaceControl>& sc, uint8_t r, uint8_t g, uint8_t b) {
54    ANativeWindow_Buffer outBuffer;
55    sp<Surface> s = sc->getSurface();
56    ASSERT_TRUE(s != nullptr);
57    ASSERT_EQ(NO_ERROR, s->lock(&outBuffer, nullptr));
58    uint8_t* img = reinterpret_cast<uint8_t*>(outBuffer.bits);
59    for (int y = 0; y < outBuffer.height; y++) {
60        for (int x = 0; x < outBuffer.width; x++) {
61            uint8_t* pixel = img + (4 * (y*outBuffer.stride + x));
62            pixel[0] = r;
63            pixel[1] = g;
64            pixel[2] = b;
65            pixel[3] = 255;
66        }
67    }
68    ASSERT_EQ(NO_ERROR, s->unlockAndPost());
69}
70
71static status_t readProtoFile(Trace* trace) {
72    status_t err = NO_ERROR;
73
74    int fd = open(DEFAULT_FILENAME, O_RDONLY);
75    {
76        google::protobuf::io::FileInputStream f(fd);
77        if (fd && !trace->ParseFromZeroCopyStream(&f)) {
78            err = PERMISSION_DENIED;
79        }
80    }
81    close(fd);
82
83    return err;
84}
85
86static void enableInterceptor() {
87    system("service call SurfaceFlinger 1020 i32 1 > /dev/null");
88}
89
90static void disableInterceptor() {
91    system("service call SurfaceFlinger 1020 i32 0 > /dev/null");
92}
93
94int32_t getSurfaceId(const std::string& surfaceName) {
95    enableInterceptor();
96    disableInterceptor();
97    Trace capturedTrace;
98    readProtoFile(&capturedTrace);
99    int32_t layerId = 0;
100    for (const auto& increment : *capturedTrace.mutable_increment()) {
101        if (increment.increment_case() == increment.kSurfaceCreation) {
102            if (increment.surface_creation().name() == surfaceName) {
103                layerId = increment.surface_creation().id();
104                break;
105            }
106        }
107    }
108    return layerId;
109}
110
111int32_t getDisplayId(const std::string& displayName) {
112    enableInterceptor();
113    disableInterceptor();
114    Trace capturedTrace;
115    readProtoFile(&capturedTrace);
116    int32_t displayId = 0;
117    for (const auto& increment : *capturedTrace.mutable_increment()) {
118        if (increment.increment_case() == increment.kDisplayCreation) {
119            if (increment.display_creation().name() == displayName) {
120                displayId = increment.display_creation().id();
121                break;
122            }
123        }
124    }
125    return displayId;
126}
127
128class SurfaceInterceptorTest : public ::testing::Test {
129protected:
130    virtual void SetUp() {
131        // Allow SurfaceInterceptor write to /data
132        system("setenforce 0");
133
134        mComposerClient = new SurfaceComposerClient;
135        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
136
137        sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
138                ISurfaceComposer::eDisplayIdMain));
139        DisplayInfo info;
140        SurfaceComposerClient::getDisplayInfo(display, &info);
141        ssize_t displayWidth = info.w;
142        ssize_t displayHeight = info.h;
143
144        // Background surface
145        mBGSurfaceControl = mComposerClient->createSurface(
146                String8("BG Interceptor Test Surface"), displayWidth, displayHeight,
147                PIXEL_FORMAT_RGBA_8888, 0);
148        ASSERT_TRUE(mBGSurfaceControl != NULL);
149        ASSERT_TRUE(mBGSurfaceControl->isValid());
150        mBGLayerId = getSurfaceId("BG Interceptor Test Surface");
151
152        SurfaceComposerClient::openGlobalTransaction();
153        mComposerClient->setDisplayLayerStack(display, 0);
154        ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT_MAX-3));
155        ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show());
156        SurfaceComposerClient::closeGlobalTransaction(true);
157    }
158
159    virtual void TearDown() {
160        mComposerClient->dispose();
161        mBGSurfaceControl.clear();
162        mComposerClient.clear();
163    }
164
165    sp<SurfaceComposerClient> mComposerClient;
166    sp<SurfaceControl> mBGSurfaceControl;
167    int32_t mBGLayerId;
168    // Used to verify creation and destruction of surfaces and displays
169    int32_t mTargetId;
170
171public:
172    void captureTest(void (SurfaceInterceptorTest::* action)(void),
173            bool (SurfaceInterceptorTest::* verification)(Trace *));
174    void captureTest(void (SurfaceInterceptorTest::* action)(void),
175            SurfaceChange::SurfaceChangeCase changeCase);
176    void captureTest(void (SurfaceInterceptorTest::* action)(void),
177            Increment::IncrementCase incrementCase);
178    void runInTransaction(void (SurfaceInterceptorTest::* action)(void), bool intercepted = false);
179
180    // Verification of changes to a surface
181    bool positionUpdateFound(const SurfaceChange& change, bool foundPosition);
182    bool sizeUpdateFound(const SurfaceChange& change, bool foundSize);
183    bool alphaUpdateFound(const SurfaceChange& change, bool foundAlpha);
184    bool layerUpdateFound(const SurfaceChange& change, bool foundLayer);
185    bool cropUpdateFound(const SurfaceChange& change, bool foundCrop);
186    bool finalCropUpdateFound(const SurfaceChange& change, bool foundFinalCrop);
187    bool matrixUpdateFound(const SurfaceChange& change, bool foundMatrix);
188    bool scalingModeUpdateFound(const SurfaceChange& change, bool foundScalingMode);
189    bool transparentRegionHintUpdateFound(const SurfaceChange& change, bool foundTransparentRegion);
190    bool layerStackUpdateFound(const SurfaceChange& change, bool foundLayerStack);
191    bool hiddenFlagUpdateFound(const SurfaceChange& change, bool foundHiddenFlag);
192    bool opaqueFlagUpdateFound(const SurfaceChange& change, bool foundOpaqueFlag);
193    bool secureFlagUpdateFound(const SurfaceChange& change, bool foundSecureFlag);
194    bool deferredTransactionUpdateFound(const SurfaceChange& change, bool foundDeferred);
195    bool surfaceUpdateFound(Trace* trace, SurfaceChange::SurfaceChangeCase changeCase);
196    void assertAllUpdatesFound(Trace* trace);
197
198    // Verification of creation and deletion of a surface
199    bool surfaceCreationFound(const Increment& increment, bool foundSurface);
200    bool surfaceDeletionFound(const Increment& increment, bool foundSurface);
201    bool displayCreationFound(const Increment& increment, bool foundDisplay);
202    bool displayDeletionFound(const Increment& increment, bool foundDisplay);
203    bool singleIncrementFound(Trace* trace, Increment::IncrementCase incrementCase);
204
205    // Verification of buffer updates
206    bool bufferUpdatesFound(Trace* trace);
207
208    // Perform each of the possible changes to a surface
209    void positionUpdate();
210    void sizeUpdate();
211    void alphaUpdate();
212    void layerUpdate();
213    void cropUpdate();
214    void finalCropUpdate();
215    void matrixUpdate();
216    void overrideScalingModeUpdate();
217    void transparentRegionHintUpdate();
218    void layerStackUpdate();
219    void hiddenFlagUpdate();
220    void opaqueFlagUpdate();
221    void secureFlagUpdate();
222    void deferredTransactionUpdate();
223    void runAllUpdates();
224    void surfaceCreation();
225    void nBufferUpdates();
226    void displayCreation();
227    void displayDeletion();
228};
229
230void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void),
231        bool (SurfaceInterceptorTest::* verification)(Trace *))
232{
233    runInTransaction(action, true);
234    Trace capturedTrace;
235    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
236    ASSERT_TRUE((this->*verification)(&capturedTrace));
237}
238
239void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void),
240        Increment::IncrementCase incrementCase)
241{
242    runInTransaction(action, true);
243    Trace capturedTrace;
244    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
245    ASSERT_TRUE(singleIncrementFound(&capturedTrace, incrementCase));
246}
247
248void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void),
249        SurfaceChange::SurfaceChangeCase changeCase)
250{
251    runInTransaction(action, true);
252    Trace capturedTrace;
253    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
254    ASSERT_TRUE(surfaceUpdateFound(&capturedTrace, changeCase));
255}
256
257void SurfaceInterceptorTest::runInTransaction(void (SurfaceInterceptorTest::* action)(void),
258        bool intercepted)
259{
260    if (intercepted) {
261        enableInterceptor();
262    }
263    SurfaceComposerClient::openGlobalTransaction();
264    (this->*action)();
265    SurfaceComposerClient::closeGlobalTransaction(true);
266    if (intercepted) {
267        disableInterceptor();
268    }
269}
270
271void SurfaceInterceptorTest::positionUpdate() {
272    mBGSurfaceControl->setPosition(POSITION_UPDATE, POSITION_UPDATE);
273}
274
275void SurfaceInterceptorTest::sizeUpdate() {
276    mBGSurfaceControl->setSize(SIZE_UPDATE, SIZE_UPDATE);
277}
278
279void SurfaceInterceptorTest::alphaUpdate() {
280    mBGSurfaceControl->setAlpha(ALPHA_UPDATE);
281}
282
283void SurfaceInterceptorTest::layerUpdate() {
284    mBGSurfaceControl->setLayer(LAYER_UPDATE);
285}
286
287void SurfaceInterceptorTest::cropUpdate() {
288    mBGSurfaceControl->setCrop(CROP_UPDATE);
289}
290
291void SurfaceInterceptorTest::finalCropUpdate() {
292    mBGSurfaceControl->setFinalCrop(CROP_UPDATE);
293}
294
295void SurfaceInterceptorTest::matrixUpdate() {
296    mBGSurfaceControl->setMatrix(M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2, M_SQRT1_2);
297}
298
299void SurfaceInterceptorTest::overrideScalingModeUpdate() {
300    mBGSurfaceControl->setOverrideScalingMode(SCALING_UPDATE);
301}
302
303void SurfaceInterceptorTest::transparentRegionHintUpdate() {
304    Region region(CROP_UPDATE);
305    mBGSurfaceControl->setTransparentRegionHint(region);
306}
307
308void SurfaceInterceptorTest::layerStackUpdate() {
309    mBGSurfaceControl->setLayerStack(STACK_UPDATE);
310}
311
312void SurfaceInterceptorTest::hiddenFlagUpdate() {
313    mBGSurfaceControl->setFlags(layer_state_t::eLayerHidden, layer_state_t::eLayerHidden);
314}
315
316void SurfaceInterceptorTest::opaqueFlagUpdate() {
317    mBGSurfaceControl->setFlags(layer_state_t::eLayerOpaque, layer_state_t::eLayerOpaque);
318}
319
320void SurfaceInterceptorTest::secureFlagUpdate() {
321    mBGSurfaceControl->setFlags(layer_state_t::eLayerSecure, layer_state_t::eLayerSecure);
322}
323
324void SurfaceInterceptorTest::deferredTransactionUpdate() {
325    mBGSurfaceControl->deferTransactionUntil(mBGSurfaceControl->getHandle(), DEFERRED_UPDATE);
326}
327
328void SurfaceInterceptorTest::displayCreation() {
329    sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, true);
330    SurfaceComposerClient::destroyDisplay(testDisplay);
331}
332
333void SurfaceInterceptorTest::displayDeletion() {
334    sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, false);
335    mTargetId = getDisplayId(DISPLAY_NAME.string());
336    SurfaceComposerClient::destroyDisplay(testDisplay);
337}
338
339void SurfaceInterceptorTest::runAllUpdates() {
340    runInTransaction(&SurfaceInterceptorTest::positionUpdate);
341    runInTransaction(&SurfaceInterceptorTest::sizeUpdate);
342    runInTransaction(&SurfaceInterceptorTest::alphaUpdate);
343    runInTransaction(&SurfaceInterceptorTest::layerUpdate);
344    runInTransaction(&SurfaceInterceptorTest::cropUpdate);
345    runInTransaction(&SurfaceInterceptorTest::finalCropUpdate);
346    runInTransaction(&SurfaceInterceptorTest::matrixUpdate);
347    runInTransaction(&SurfaceInterceptorTest::overrideScalingModeUpdate);
348    runInTransaction(&SurfaceInterceptorTest::transparentRegionHintUpdate);
349    runInTransaction(&SurfaceInterceptorTest::layerStackUpdate);
350    runInTransaction(&SurfaceInterceptorTest::hiddenFlagUpdate);
351    runInTransaction(&SurfaceInterceptorTest::opaqueFlagUpdate);
352    runInTransaction(&SurfaceInterceptorTest::secureFlagUpdate);
353    runInTransaction(&SurfaceInterceptorTest::deferredTransactionUpdate);
354}
355
356void SurfaceInterceptorTest::surfaceCreation() {
357    mComposerClient->createSurface(String8(LAYER_NAME), SIZE_UPDATE, SIZE_UPDATE,
358            PIXEL_FORMAT_RGBA_8888, 0);
359}
360
361void SurfaceInterceptorTest::nBufferUpdates() {
362    std::random_device rd;
363    std::mt19937_64 gen(rd());
364    // This makes testing fun
365    std::uniform_int_distribution<uint8_t> dis;
366    for (uint32_t i = 0; i < BUFFER_UPDATES; ++i) {
367        fillSurfaceRGBA8(mBGSurfaceControl, dis(gen), dis(gen), dis(gen));
368    }
369}
370
371bool SurfaceInterceptorTest::positionUpdateFound(const SurfaceChange& change, bool foundPosition) {
372    // There should only be one position transaction with x and y = POSITION_UPDATE
373    bool hasX(change.position().x() == POSITION_UPDATE);
374    bool hasY(change.position().y() == POSITION_UPDATE);
375    if (hasX && hasY && !foundPosition) {
376        foundPosition = true;
377    }
378    // Failed because the position update was found a second time
379    else if (hasX && hasY && foundPosition) {
380        [] () { FAIL(); }();
381    }
382    return foundPosition;
383}
384
385bool SurfaceInterceptorTest::sizeUpdateFound(const SurfaceChange& change, bool foundSize) {
386    bool hasWidth(change.size().h() == SIZE_UPDATE);
387    bool hasHeight(change.size().w() == SIZE_UPDATE);
388    if (hasWidth && hasHeight && !foundSize) {
389        foundSize = true;
390    }
391    else if (hasWidth && hasHeight && foundSize) {
392        [] () { FAIL(); }();
393    }
394    return foundSize;
395}
396
397bool SurfaceInterceptorTest::alphaUpdateFound(const SurfaceChange& change, bool foundAlpha) {
398    bool hasAlpha(change.alpha().alpha() == ALPHA_UPDATE);
399    if (hasAlpha && !foundAlpha) {
400        foundAlpha = true;
401    }
402    else if (hasAlpha && foundAlpha) {
403        [] () { FAIL(); }();
404    }
405    return foundAlpha;
406}
407
408bool SurfaceInterceptorTest::layerUpdateFound(const SurfaceChange& change, bool foundLayer) {
409    bool hasLayer(change.layer().layer() == LAYER_UPDATE);
410    if (hasLayer && !foundLayer) {
411        foundLayer = true;
412    }
413    else if (hasLayer && foundLayer) {
414        [] () { FAIL(); }();
415    }
416    return foundLayer;
417}
418
419bool SurfaceInterceptorTest::cropUpdateFound(const SurfaceChange& change, bool foundCrop) {
420    bool hasLeft(change.crop().rectangle().left() == CROP_UPDATE.left);
421    bool hasTop(change.crop().rectangle().top() == CROP_UPDATE.top);
422    bool hasRight(change.crop().rectangle().right() == CROP_UPDATE.right);
423    bool hasBottom(change.crop().rectangle().bottom() == CROP_UPDATE.bottom);
424    if (hasLeft && hasRight && hasTop && hasBottom && !foundCrop) {
425        foundCrop = true;
426    }
427    else if (hasLeft && hasRight && hasTop && hasBottom && foundCrop) {
428        [] () { FAIL(); }();
429    }
430    return foundCrop;
431}
432
433bool SurfaceInterceptorTest::finalCropUpdateFound(const SurfaceChange& change,
434        bool foundFinalCrop)
435{
436    bool hasLeft(change.final_crop().rectangle().left() == CROP_UPDATE.left);
437    bool hasTop(change.final_crop().rectangle().top() == CROP_UPDATE.top);
438    bool hasRight(change.final_crop().rectangle().right() == CROP_UPDATE.right);
439    bool hasBottom(change.final_crop().rectangle().bottom() == CROP_UPDATE.bottom);
440    if (hasLeft && hasRight && hasTop && hasBottom && !foundFinalCrop) {
441        foundFinalCrop = true;
442    }
443    else if (hasLeft && hasRight && hasTop && hasBottom && foundFinalCrop) {
444        [] () { FAIL(); }();
445    }
446    return foundFinalCrop;
447}
448
449bool SurfaceInterceptorTest::matrixUpdateFound(const SurfaceChange& change, bool foundMatrix) {
450    bool hasSx((float)change.matrix().dsdx() == (float)M_SQRT1_2);
451    bool hasTx((float)change.matrix().dtdx() == (float)M_SQRT1_2);
452    bool hasSy((float)change.matrix().dsdy() == (float)-M_SQRT1_2);
453    bool hasTy((float)change.matrix().dtdy() == (float)M_SQRT1_2);
454    if (hasSx && hasTx && hasSy && hasTy && !foundMatrix) {
455        foundMatrix = true;
456    }
457    else if (hasSx && hasTx && hasSy && hasTy && foundMatrix) {
458        [] () { FAIL(); }();
459    }
460    return foundMatrix;
461}
462
463bool SurfaceInterceptorTest::scalingModeUpdateFound(const SurfaceChange& change,
464        bool foundScalingMode)
465{
466    bool hasScalingUpdate(change.override_scaling_mode().override_scaling_mode() == SCALING_UPDATE);
467    if (hasScalingUpdate && !foundScalingMode) {
468        foundScalingMode = true;
469    }
470    else if (hasScalingUpdate && foundScalingMode) {
471        [] () { FAIL(); }();
472    }
473    return foundScalingMode;
474}
475
476bool SurfaceInterceptorTest::transparentRegionHintUpdateFound(const SurfaceChange& change,
477        bool foundTransparentRegion)
478{
479    auto traceRegion = change.transparent_region_hint().region(0);
480    bool hasLeft(traceRegion.left() == CROP_UPDATE.left);
481    bool hasTop(traceRegion.top() == CROP_UPDATE.top);
482    bool hasRight(traceRegion.right() == CROP_UPDATE.right);
483    bool hasBottom(traceRegion.bottom() == CROP_UPDATE.bottom);
484    if (hasLeft && hasRight && hasTop && hasBottom && !foundTransparentRegion) {
485        foundTransparentRegion = true;
486    }
487    else if (hasLeft && hasRight && hasTop && hasBottom && foundTransparentRegion) {
488        [] () { FAIL(); }();
489    }
490    return foundTransparentRegion;
491}
492
493bool SurfaceInterceptorTest::layerStackUpdateFound(const SurfaceChange& change,
494        bool foundLayerStack)
495{
496    bool hasLayerStackUpdate(change.layer_stack().layer_stack() == STACK_UPDATE);
497    if (hasLayerStackUpdate && !foundLayerStack) {
498        foundLayerStack = true;
499    }
500    else if (hasLayerStackUpdate && foundLayerStack) {
501        [] () { FAIL(); }();
502    }
503    return foundLayerStack;
504}
505
506bool SurfaceInterceptorTest::hiddenFlagUpdateFound(const SurfaceChange& change,
507        bool foundHiddenFlag)
508{
509    bool hasHiddenFlag(change.hidden_flag().hidden_flag());
510    if (hasHiddenFlag && !foundHiddenFlag) {
511        foundHiddenFlag = true;
512    }
513    else if (hasHiddenFlag && foundHiddenFlag) {
514        [] () { FAIL(); }();
515    }
516    return foundHiddenFlag;
517}
518
519bool SurfaceInterceptorTest::opaqueFlagUpdateFound(const SurfaceChange& change,
520        bool foundOpaqueFlag)
521{
522    bool hasOpaqueFlag(change.opaque_flag().opaque_flag());
523    if (hasOpaqueFlag && !foundOpaqueFlag) {
524        foundOpaqueFlag = true;
525    }
526    else if (hasOpaqueFlag && foundOpaqueFlag) {
527        [] () { FAIL(); }();
528    }
529    return foundOpaqueFlag;
530}
531
532bool SurfaceInterceptorTest::secureFlagUpdateFound(const SurfaceChange& change,
533        bool foundSecureFlag)
534{
535    bool hasSecureFlag(change.secure_flag().secure_flag());
536    if (hasSecureFlag && !foundSecureFlag) {
537        foundSecureFlag = true;
538    }
539    else if (hasSecureFlag && foundSecureFlag) {
540        [] () { FAIL(); }();
541    }
542    return foundSecureFlag;
543}
544
545bool SurfaceInterceptorTest::deferredTransactionUpdateFound(const SurfaceChange& change,
546        bool foundDeferred)
547{
548    bool hasId(change.deferred_transaction().layer_id() == mBGLayerId);
549    bool hasFrameNumber(change.deferred_transaction().frame_number() == DEFERRED_UPDATE);
550    if (hasId && hasFrameNumber && !foundDeferred) {
551        foundDeferred = true;
552    }
553    else if (hasId && hasFrameNumber && foundDeferred) {
554        [] () { FAIL(); }();
555    }
556    return foundDeferred;
557}
558
559bool SurfaceInterceptorTest::surfaceUpdateFound(Trace* trace,
560        SurfaceChange::SurfaceChangeCase changeCase)
561{
562    bool foundUpdate = false;
563    for (const auto& increment : *trace->mutable_increment()) {
564        if (increment.increment_case() == increment.kTransaction) {
565            for (const auto& change : increment.transaction().surface_change()) {
566                if (change.id() == mBGLayerId && change.SurfaceChange_case() == changeCase) {
567                    switch (changeCase) {
568                        case SurfaceChange::SurfaceChangeCase::kPosition:
569                            // foundUpdate is sent for the tests to fail on duplicated increments
570                            foundUpdate = positionUpdateFound(change, foundUpdate);
571                            break;
572                        case SurfaceChange::SurfaceChangeCase::kSize:
573                            foundUpdate = sizeUpdateFound(change, foundUpdate);
574                            break;
575                        case SurfaceChange::SurfaceChangeCase::kAlpha:
576                            foundUpdate = alphaUpdateFound(change, foundUpdate);
577                            break;
578                        case SurfaceChange::SurfaceChangeCase::kLayer:
579                            foundUpdate = layerUpdateFound(change, foundUpdate);
580                            break;
581                        case SurfaceChange::SurfaceChangeCase::kCrop:
582                            foundUpdate = cropUpdateFound(change, foundUpdate);
583                            break;
584                        case SurfaceChange::SurfaceChangeCase::kFinalCrop:
585                            foundUpdate = finalCropUpdateFound(change, foundUpdate);
586                            break;
587                        case SurfaceChange::SurfaceChangeCase::kMatrix:
588                            foundUpdate = matrixUpdateFound(change, foundUpdate);
589                            break;
590                        case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode:
591                            foundUpdate = scalingModeUpdateFound(change, foundUpdate);
592                            break;
593                        case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint:
594                            foundUpdate = transparentRegionHintUpdateFound(change, foundUpdate);
595                            break;
596                        case SurfaceChange::SurfaceChangeCase::kLayerStack:
597                            foundUpdate = layerStackUpdateFound(change, foundUpdate);
598                            break;
599                        case SurfaceChange::SurfaceChangeCase::kHiddenFlag:
600                            foundUpdate = hiddenFlagUpdateFound(change, foundUpdate);
601                            break;
602                        case SurfaceChange::SurfaceChangeCase::kOpaqueFlag:
603                            foundUpdate = opaqueFlagUpdateFound(change, foundUpdate);
604                            break;
605                        case SurfaceChange::SurfaceChangeCase::kSecureFlag:
606                            foundUpdate = secureFlagUpdateFound(change, foundUpdate);
607                            break;
608                        case SurfaceChange::SurfaceChangeCase::kDeferredTransaction:
609                            foundUpdate = deferredTransactionUpdateFound(change, foundUpdate);
610                            break;
611                        case SurfaceChange::SurfaceChangeCase::SURFACECHANGE_NOT_SET:
612                            break;
613                    }
614                }
615            }
616        }
617    }
618    return foundUpdate;
619}
620
621void SurfaceInterceptorTest::assertAllUpdatesFound(Trace* trace) {
622    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kPosition));
623    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kSize));
624    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kAlpha));
625    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kLayer));
626    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kCrop));
627    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kFinalCrop));
628    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kMatrix));
629    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kOverrideScalingMode));
630    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kTransparentRegionHint));
631    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kLayerStack));
632    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kHiddenFlag));
633    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kOpaqueFlag));
634    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kSecureFlag));
635    ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kDeferredTransaction));
636}
637
638bool SurfaceInterceptorTest::surfaceCreationFound(const Increment& increment, bool foundSurface) {
639    bool isMatch(increment.surface_creation().name() == LAYER_NAME &&
640            increment.surface_creation().w() == SIZE_UPDATE &&
641            increment.surface_creation().h() == SIZE_UPDATE);
642    if (isMatch && !foundSurface) {
643        foundSurface = true;
644    }
645    else if (isMatch && foundSurface) {
646        [] () { FAIL(); }();
647    }
648    return foundSurface;
649}
650
651bool SurfaceInterceptorTest::surfaceDeletionFound(const Increment& increment, bool foundSurface) {
652    bool isMatch(increment.surface_deletion().id() == mTargetId);
653    if (isMatch && !foundSurface) {
654        foundSurface = true;
655    }
656    else if (isMatch && foundSurface) {
657        [] () { FAIL(); }();
658    }
659    return foundSurface;
660}
661
662bool SurfaceInterceptorTest::displayCreationFound(const Increment& increment, bool foundDisplay) {
663    bool isMatch(increment.display_creation().name() == DISPLAY_NAME.string() &&
664            increment.display_creation().is_secure());
665    if (isMatch && !foundDisplay) {
666        foundDisplay = true;
667    }
668    else if (isMatch && foundDisplay) {
669        [] () { FAIL(); }();
670    }
671    return foundDisplay;
672}
673
674bool SurfaceInterceptorTest::displayDeletionFound(const Increment& increment, bool foundDisplay) {
675    bool isMatch(increment.display_deletion().id() == mTargetId);
676    if (isMatch && !foundDisplay) {
677        foundDisplay = true;
678    }
679    else if (isMatch && foundDisplay) {
680        [] () { FAIL(); }();
681    }
682    return foundDisplay;
683}
684
685bool SurfaceInterceptorTest::singleIncrementFound(Trace* trace,
686        Increment::IncrementCase incrementCase)
687{
688    bool foundIncrement = false;
689    for (const auto& increment : *trace->mutable_increment()) {
690        if (increment.increment_case() == incrementCase) {
691            switch (incrementCase) {
692                case Increment::IncrementCase::kSurfaceCreation:
693                    foundIncrement = surfaceCreationFound(increment, foundIncrement);
694                    break;
695                case Increment::IncrementCase::kSurfaceDeletion:
696                    foundIncrement = surfaceDeletionFound(increment, foundIncrement);
697                    break;
698                case Increment::IncrementCase::kDisplayCreation:
699                    foundIncrement = displayCreationFound(increment, foundIncrement);
700                    break;
701                case Increment::IncrementCase::kDisplayDeletion:
702                    foundIncrement = displayDeletionFound(increment, foundIncrement);
703                    break;
704                default:
705                    /* code */
706                    break;
707            }
708        }
709    }
710    return foundIncrement;
711}
712
713bool SurfaceInterceptorTest::bufferUpdatesFound(Trace* trace) {
714    uint32_t updates = 0;
715    for (const auto& inc : *trace->mutable_increment()) {
716        if (inc.increment_case() == inc.kBufferUpdate && inc.buffer_update().id() == mBGLayerId) {
717            updates++;
718        }
719    }
720    return updates == BUFFER_UPDATES;
721}
722
723TEST_F(SurfaceInterceptorTest, InterceptPositionUpdateWorks) {
724    captureTest(&SurfaceInterceptorTest::positionUpdate,
725            SurfaceChange::SurfaceChangeCase::kPosition);
726}
727
728TEST_F(SurfaceInterceptorTest, InterceptSizeUpdateWorks) {
729    captureTest(&SurfaceInterceptorTest::sizeUpdate, SurfaceChange::SurfaceChangeCase::kSize);
730}
731
732TEST_F(SurfaceInterceptorTest, InterceptAlphaUpdateWorks) {
733    captureTest(&SurfaceInterceptorTest::alphaUpdate, SurfaceChange::SurfaceChangeCase::kAlpha);
734}
735
736TEST_F(SurfaceInterceptorTest, InterceptLayerUpdateWorks) {
737    captureTest(&SurfaceInterceptorTest::layerUpdate, SurfaceChange::SurfaceChangeCase::kLayer);
738}
739
740TEST_F(SurfaceInterceptorTest, InterceptCropUpdateWorks) {
741    captureTest(&SurfaceInterceptorTest::cropUpdate, SurfaceChange::SurfaceChangeCase::kCrop);
742}
743
744TEST_F(SurfaceInterceptorTest, InterceptFinalCropUpdateWorks) {
745    captureTest(&SurfaceInterceptorTest::finalCropUpdate,
746            SurfaceChange::SurfaceChangeCase::kFinalCrop);
747}
748
749TEST_F(SurfaceInterceptorTest, InterceptMatrixUpdateWorks) {
750    captureTest(&SurfaceInterceptorTest::matrixUpdate, SurfaceChange::SurfaceChangeCase::kMatrix);
751}
752
753TEST_F(SurfaceInterceptorTest, InterceptOverrideScalingModeUpdateWorks) {
754    captureTest(&SurfaceInterceptorTest::overrideScalingModeUpdate,
755            SurfaceChange::SurfaceChangeCase::kOverrideScalingMode);
756}
757
758TEST_F(SurfaceInterceptorTest, InterceptTransparentRegionHintUpdateWorks) {
759    captureTest(&SurfaceInterceptorTest::transparentRegionHintUpdate,
760            SurfaceChange::SurfaceChangeCase::kTransparentRegionHint);
761}
762
763TEST_F(SurfaceInterceptorTest, InterceptLayerStackUpdateWorks) {
764    captureTest(&SurfaceInterceptorTest::layerStackUpdate,
765            SurfaceChange::SurfaceChangeCase::kLayerStack);
766}
767
768TEST_F(SurfaceInterceptorTest, InterceptHiddenFlagUpdateWorks) {
769    captureTest(&SurfaceInterceptorTest::hiddenFlagUpdate,
770            SurfaceChange::SurfaceChangeCase::kHiddenFlag);
771}
772
773TEST_F(SurfaceInterceptorTest, InterceptOpaqueFlagUpdateWorks) {
774    captureTest(&SurfaceInterceptorTest::opaqueFlagUpdate,
775            SurfaceChange::SurfaceChangeCase::kOpaqueFlag);
776}
777
778TEST_F(SurfaceInterceptorTest, InterceptSecureFlagUpdateWorks) {
779    captureTest(&SurfaceInterceptorTest::secureFlagUpdate,
780            SurfaceChange::SurfaceChangeCase::kSecureFlag);
781}
782
783TEST_F(SurfaceInterceptorTest, InterceptDeferredTransactionUpdateWorks) {
784    captureTest(&SurfaceInterceptorTest::deferredTransactionUpdate,
785            SurfaceChange::SurfaceChangeCase::kDeferredTransaction);
786}
787
788TEST_F(SurfaceInterceptorTest, InterceptAllUpdatesWorks) {
789    enableInterceptor();
790    runAllUpdates();
791    disableInterceptor();
792
793    // Find all of the updates in the single trace
794    Trace capturedTrace;
795    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
796    assertAllUpdatesFound(&capturedTrace);
797}
798
799TEST_F(SurfaceInterceptorTest, InterceptSurfaceCreationWorks) {
800    captureTest(&SurfaceInterceptorTest::surfaceCreation,
801            Increment::IncrementCase::kSurfaceCreation);
802}
803
804TEST_F(SurfaceInterceptorTest, InterceptSurfaceDeletionWorks) {
805    sp<SurfaceControl> layerToDelete = mComposerClient->createSurface(String8(LAYER_NAME),
806            SIZE_UPDATE, SIZE_UPDATE, PIXEL_FORMAT_RGBA_8888, 0);
807    this->mTargetId = getSurfaceId(LAYER_NAME);
808    enableInterceptor();
809    mComposerClient->destroySurface(layerToDelete->getHandle());
810    disableInterceptor();
811
812    Trace capturedTrace;
813    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
814    ASSERT_TRUE(singleIncrementFound(&capturedTrace, Increment::IncrementCase::kSurfaceDeletion));
815}
816
817TEST_F(SurfaceInterceptorTest, InterceptDisplayCreationWorks) {
818    captureTest(&SurfaceInterceptorTest::displayCreation,
819            Increment::IncrementCase::kDisplayCreation);
820}
821
822TEST_F(SurfaceInterceptorTest, InterceptDisplayDeletionWorks) {
823    captureTest(&SurfaceInterceptorTest::displayDeletion,
824            Increment::IncrementCase::kDisplayDeletion);
825}
826
827TEST_F(SurfaceInterceptorTest, InterceptBufferUpdateWorks) {
828    captureTest(&SurfaceInterceptorTest::nBufferUpdates,
829            &SurfaceInterceptorTest::bufferUpdatesFound);
830}
831
832// If the interceptor is enabled while buffer updates are being pushed, the interceptor should
833// first create a snapshot of the existing displays and surfaces and then start capturing
834// the buffer updates
835TEST_F(SurfaceInterceptorTest, InterceptWhileBufferUpdatesWorks) {
836    std::thread bufferUpdates(&SurfaceInterceptorTest::nBufferUpdates, this);
837    enableInterceptor();
838    disableInterceptor();
839    bufferUpdates.join();
840
841    Trace capturedTrace;
842    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
843    const auto& firstIncrement = capturedTrace.mutable_increment(0);
844    ASSERT_EQ(firstIncrement->increment_case(), Increment::IncrementCase::kDisplayCreation);
845}
846
847TEST_F(SurfaceInterceptorTest, InterceptSimultaneousUpdatesWorks) {
848    enableInterceptor();
849    std::thread bufferUpdates(&SurfaceInterceptorTest::nBufferUpdates, this);
850    std::thread surfaceUpdates(&SurfaceInterceptorTest::runAllUpdates, this);
851    runInTransaction(&SurfaceInterceptorTest::surfaceCreation);
852    bufferUpdates.join();
853    surfaceUpdates.join();
854    disableInterceptor();
855
856    Trace capturedTrace;
857    ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
858
859    assertAllUpdatesFound(&capturedTrace);
860    ASSERT_TRUE(bufferUpdatesFound(&capturedTrace));
861    ASSERT_TRUE(singleIncrementFound(&capturedTrace, Increment::IncrementCase::kSurfaceCreation));
862}
863
864}
865