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