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