blob: 0cc763c740649d194a53d9e9b8641228bbeb4cbe [file] [log] [blame]
/*
* Copyright (C) 2016 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <frameworks/native/cmds/surfacereplayer/proto/src/trace.pb.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <gtest/gtest.h>
#include <android/native_window.h>
#include <gui/ISurfaceComposer.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
#include <private/gui/ComposerService.h>
#include <private/gui/LayerState.h>
#include <ui/DisplayInfo.h>
#include <fstream>
#include <random>
#include <thread>
namespace android {
constexpr int32_t SCALING_UPDATE = 1;
constexpr uint32_t BUFFER_UPDATES = 18;
constexpr uint32_t LAYER_UPDATE = INT_MAX - 2;
constexpr uint32_t SIZE_UPDATE = 134;
constexpr uint32_t STACK_UPDATE = 1;
constexpr uint64_t DEFERRED_UPDATE = 13;
constexpr float ALPHA_UPDATE = 0.29f;
constexpr float POSITION_UPDATE = 121;
const Rect CROP_UPDATE(16, 16, 32, 32);
const String8 DISPLAY_NAME("SurfaceInterceptor Display Test");
constexpr auto LAYER_NAME = "Layer Create and Delete Test";
constexpr auto DEFAULT_FILENAME = "/data/SurfaceTrace.dat";
// Fill an RGBA_8888 formatted surface with a single color.
static void fillSurfaceRGBA8(const sp<SurfaceControl>& sc, uint8_t r, uint8_t g, uint8_t b) {
ANativeWindow_Buffer outBuffer;
sp<Surface> s = sc->getSurface();
ASSERT_TRUE(s != nullptr);
ASSERT_EQ(NO_ERROR, s->lock(&outBuffer, nullptr));
uint8_t* img = reinterpret_cast<uint8_t*>(outBuffer.bits);
for (int y = 0; y < outBuffer.height; y++) {
for (int x = 0; x < outBuffer.width; x++) {
uint8_t* pixel = img + (4 * (y*outBuffer.stride + x));
pixel[0] = r;
pixel[1] = g;
pixel[2] = b;
pixel[3] = 255;
}
}
ASSERT_EQ(NO_ERROR, s->unlockAndPost());
}
static status_t readProtoFile(Trace* trace) {
status_t err = NO_ERROR;
int fd = open(DEFAULT_FILENAME, O_RDONLY);
{
google::protobuf::io::FileInputStream f(fd);
if (fd && !trace->ParseFromZeroCopyStream(&f)) {
err = PERMISSION_DENIED;
}
}
close(fd);
return err;
}
static void enableInterceptor() {
system("service call SurfaceFlinger 1020 i32 1 > /dev/null");
}
static void disableInterceptor() {
system("service call SurfaceFlinger 1020 i32 0 > /dev/null");
}
int32_t getSurfaceId(const std::string& surfaceName) {
enableInterceptor();
disableInterceptor();
Trace capturedTrace;
readProtoFile(&capturedTrace);
int32_t layerId = 0;
for (const auto& increment : *capturedTrace.mutable_increment()) {
if (increment.increment_case() == increment.kSurfaceCreation) {
if (increment.surface_creation().name() == surfaceName) {
layerId = increment.surface_creation().id();
break;
}
}
}
return layerId;
}
int32_t getDisplayId(const std::string& displayName) {
enableInterceptor();
disableInterceptor();
Trace capturedTrace;
readProtoFile(&capturedTrace);
int32_t displayId = 0;
for (const auto& increment : *capturedTrace.mutable_increment()) {
if (increment.increment_case() == increment.kDisplayCreation) {
if (increment.display_creation().name() == displayName) {
displayId = increment.display_creation().id();
break;
}
}
}
return displayId;
}
class SurfaceInterceptorTest : public ::testing::Test {
protected:
virtual void SetUp() {
// Allow SurfaceInterceptor write to /data
system("setenforce 0");
mComposerClient = new SurfaceComposerClient;
ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
ISurfaceComposer::eDisplayIdMain));
DisplayInfo info;
SurfaceComposerClient::getDisplayInfo(display, &info);
ssize_t displayWidth = info.w;
ssize_t displayHeight = info.h;
// Background surface
mBGSurfaceControl = mComposerClient->createSurface(
String8("BG Interceptor Test Surface"), displayWidth, displayHeight,
PIXEL_FORMAT_RGBA_8888, 0);
ASSERT_TRUE(mBGSurfaceControl != NULL);
ASSERT_TRUE(mBGSurfaceControl->isValid());
mBGLayerId = getSurfaceId("BG Interceptor Test Surface");
SurfaceComposerClient::openGlobalTransaction();
mComposerClient->setDisplayLayerStack(display, 0);
ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT_MAX-3));
ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show());
SurfaceComposerClient::closeGlobalTransaction(true);
}
virtual void TearDown() {
mComposerClient->dispose();
mBGSurfaceControl.clear();
mComposerClient.clear();
}
sp<SurfaceComposerClient> mComposerClient;
sp<SurfaceControl> mBGSurfaceControl;
int32_t mBGLayerId;
// Used to verify creation and destruction of surfaces and displays
int32_t mTargetId;
public:
void captureTest(void (SurfaceInterceptorTest::* action)(void),
bool (SurfaceInterceptorTest::* verification)(Trace *));
void captureTest(void (SurfaceInterceptorTest::* action)(void),
SurfaceChange::SurfaceChangeCase changeCase);
void captureTest(void (SurfaceInterceptorTest::* action)(void),
Increment::IncrementCase incrementCase);
void runInTransaction(void (SurfaceInterceptorTest::* action)(void), bool intercepted = false);
// Verification of changes to a surface
bool positionUpdateFound(const SurfaceChange& change, bool foundPosition);
bool sizeUpdateFound(const SurfaceChange& change, bool foundSize);
bool alphaUpdateFound(const SurfaceChange& change, bool foundAlpha);
bool layerUpdateFound(const SurfaceChange& change, bool foundLayer);
bool cropUpdateFound(const SurfaceChange& change, bool foundCrop);
bool finalCropUpdateFound(const SurfaceChange& change, bool foundFinalCrop);
bool matrixUpdateFound(const SurfaceChange& change, bool foundMatrix);
bool scalingModeUpdateFound(const SurfaceChange& change, bool foundScalingMode);
bool transparentRegionHintUpdateFound(const SurfaceChange& change, bool foundTransparentRegion);
bool layerStackUpdateFound(const SurfaceChange& change, bool foundLayerStack);
bool hiddenFlagUpdateFound(const SurfaceChange& change, bool foundHiddenFlag);
bool opaqueFlagUpdateFound(const SurfaceChange& change, bool foundOpaqueFlag);
bool secureFlagUpdateFound(const SurfaceChange& change, bool foundSecureFlag);
bool deferredTransactionUpdateFound(const SurfaceChange& change, bool foundDeferred);
bool surfaceUpdateFound(Trace* trace, SurfaceChange::SurfaceChangeCase changeCase);
void assertAllUpdatesFound(Trace* trace);
// Verification of creation and deletion of a surface
bool surfaceCreationFound(const Increment& increment, bool foundSurface);
bool surfaceDeletionFound(const Increment& increment, bool foundSurface);
bool displayCreationFound(const Increment& increment, bool foundDisplay);
bool displayDeletionFound(const Increment& increment, bool foundDisplay);
bool singleIncrementFound(Trace* trace, Increment::IncrementCase incrementCase);
// Verification of buffer updates
bool bufferUpdatesFound(Trace* trace);
// Perform each of the possible changes to a surface
void positionUpdate();
void sizeUpdate();
void alphaUpdate();
void layerUpdate();
void cropUpdate();
void finalCropUpdate();
void matrixUpdate();
void overrideScalingModeUpdate();
void transparentRegionHintUpdate();
void layerStackUpdate();
void hiddenFlagUpdate();
void opaqueFlagUpdate();
void secureFlagUpdate();
void deferredTransactionUpdate();
void runAllUpdates();
void surfaceCreation();
void nBufferUpdates();
void displayCreation();
void displayDeletion();
};
void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void),
bool (SurfaceInterceptorTest::* verification)(Trace *))
{
runInTransaction(action, true);
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
ASSERT_TRUE((this->*verification)(&capturedTrace));
}
void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void),
Increment::IncrementCase incrementCase)
{
runInTransaction(action, true);
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
ASSERT_TRUE(singleIncrementFound(&capturedTrace, incrementCase));
}
void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void),
SurfaceChange::SurfaceChangeCase changeCase)
{
runInTransaction(action, true);
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
ASSERT_TRUE(surfaceUpdateFound(&capturedTrace, changeCase));
}
void SurfaceInterceptorTest::runInTransaction(void (SurfaceInterceptorTest::* action)(void),
bool intercepted)
{
if (intercepted) {
enableInterceptor();
}
SurfaceComposerClient::openGlobalTransaction();
(this->*action)();
SurfaceComposerClient::closeGlobalTransaction(true);
if (intercepted) {
disableInterceptor();
}
}
void SurfaceInterceptorTest::positionUpdate() {
mBGSurfaceControl->setPosition(POSITION_UPDATE, POSITION_UPDATE);
}
void SurfaceInterceptorTest::sizeUpdate() {
mBGSurfaceControl->setSize(SIZE_UPDATE, SIZE_UPDATE);
}
void SurfaceInterceptorTest::alphaUpdate() {
mBGSurfaceControl->setAlpha(ALPHA_UPDATE);
}
void SurfaceInterceptorTest::layerUpdate() {
mBGSurfaceControl->setLayer(LAYER_UPDATE);
}
void SurfaceInterceptorTest::cropUpdate() {
mBGSurfaceControl->setCrop(CROP_UPDATE);
}
void SurfaceInterceptorTest::finalCropUpdate() {
mBGSurfaceControl->setFinalCrop(CROP_UPDATE);
}
void SurfaceInterceptorTest::matrixUpdate() {
mBGSurfaceControl->setMatrix(M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2, M_SQRT1_2);
}
void SurfaceInterceptorTest::overrideScalingModeUpdate() {
mBGSurfaceControl->setOverrideScalingMode(SCALING_UPDATE);
}
void SurfaceInterceptorTest::transparentRegionHintUpdate() {
Region region(CROP_UPDATE);
mBGSurfaceControl->setTransparentRegionHint(region);
}
void SurfaceInterceptorTest::layerStackUpdate() {
mBGSurfaceControl->setLayerStack(STACK_UPDATE);
}
void SurfaceInterceptorTest::hiddenFlagUpdate() {
mBGSurfaceControl->setFlags(layer_state_t::eLayerHidden, layer_state_t::eLayerHidden);
}
void SurfaceInterceptorTest::opaqueFlagUpdate() {
mBGSurfaceControl->setFlags(layer_state_t::eLayerOpaque, layer_state_t::eLayerOpaque);
}
void SurfaceInterceptorTest::secureFlagUpdate() {
mBGSurfaceControl->setFlags(layer_state_t::eLayerSecure, layer_state_t::eLayerSecure);
}
void SurfaceInterceptorTest::deferredTransactionUpdate() {
mBGSurfaceControl->deferTransactionUntil(mBGSurfaceControl->getHandle(), DEFERRED_UPDATE);
}
void SurfaceInterceptorTest::displayCreation() {
sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, true);
SurfaceComposerClient::destroyDisplay(testDisplay);
}
void SurfaceInterceptorTest::displayDeletion() {
sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, false);
mTargetId = getDisplayId(DISPLAY_NAME.string());
SurfaceComposerClient::destroyDisplay(testDisplay);
}
void SurfaceInterceptorTest::runAllUpdates() {
runInTransaction(&SurfaceInterceptorTest::positionUpdate);
runInTransaction(&SurfaceInterceptorTest::sizeUpdate);
runInTransaction(&SurfaceInterceptorTest::alphaUpdate);
runInTransaction(&SurfaceInterceptorTest::layerUpdate);
runInTransaction(&SurfaceInterceptorTest::cropUpdate);
runInTransaction(&SurfaceInterceptorTest::finalCropUpdate);
runInTransaction(&SurfaceInterceptorTest::matrixUpdate);
runInTransaction(&SurfaceInterceptorTest::overrideScalingModeUpdate);
runInTransaction(&SurfaceInterceptorTest::transparentRegionHintUpdate);
runInTransaction(&SurfaceInterceptorTest::layerStackUpdate);
runInTransaction(&SurfaceInterceptorTest::hiddenFlagUpdate);
runInTransaction(&SurfaceInterceptorTest::opaqueFlagUpdate);
runInTransaction(&SurfaceInterceptorTest::secureFlagUpdate);
runInTransaction(&SurfaceInterceptorTest::deferredTransactionUpdate);
}
void SurfaceInterceptorTest::surfaceCreation() {
mComposerClient->createSurface(String8(LAYER_NAME), SIZE_UPDATE, SIZE_UPDATE,
PIXEL_FORMAT_RGBA_8888, 0);
}
void SurfaceInterceptorTest::nBufferUpdates() {
std::random_device rd;
std::mt19937_64 gen(rd());
// This makes testing fun
std::uniform_int_distribution<uint8_t> dis;
for (uint32_t i = 0; i < BUFFER_UPDATES; ++i) {
fillSurfaceRGBA8(mBGSurfaceControl, dis(gen), dis(gen), dis(gen));
}
}
bool SurfaceInterceptorTest::positionUpdateFound(const SurfaceChange& change, bool foundPosition) {
// There should only be one position transaction with x and y = POSITION_UPDATE
bool hasX(change.position().x() == POSITION_UPDATE);
bool hasY(change.position().y() == POSITION_UPDATE);
if (hasX && hasY && !foundPosition) {
foundPosition = true;
}
// Failed because the position update was found a second time
else if (hasX && hasY && foundPosition) {
[] () { FAIL(); }();
}
return foundPosition;
}
bool SurfaceInterceptorTest::sizeUpdateFound(const SurfaceChange& change, bool foundSize) {
bool hasWidth(change.size().h() == SIZE_UPDATE);
bool hasHeight(change.size().w() == SIZE_UPDATE);
if (hasWidth && hasHeight && !foundSize) {
foundSize = true;
}
else if (hasWidth && hasHeight && foundSize) {
[] () { FAIL(); }();
}
return foundSize;
}
bool SurfaceInterceptorTest::alphaUpdateFound(const SurfaceChange& change, bool foundAlpha) {
bool hasAlpha(change.alpha().alpha() == ALPHA_UPDATE);
if (hasAlpha && !foundAlpha) {
foundAlpha = true;
}
else if (hasAlpha && foundAlpha) {
[] () { FAIL(); }();
}
return foundAlpha;
}
bool SurfaceInterceptorTest::layerUpdateFound(const SurfaceChange& change, bool foundLayer) {
bool hasLayer(change.layer().layer() == LAYER_UPDATE);
if (hasLayer && !foundLayer) {
foundLayer = true;
}
else if (hasLayer && foundLayer) {
[] () { FAIL(); }();
}
return foundLayer;
}
bool SurfaceInterceptorTest::cropUpdateFound(const SurfaceChange& change, bool foundCrop) {
bool hasLeft(change.crop().rectangle().left() == CROP_UPDATE.left);
bool hasTop(change.crop().rectangle().top() == CROP_UPDATE.top);
bool hasRight(change.crop().rectangle().right() == CROP_UPDATE.right);
bool hasBottom(change.crop().rectangle().bottom() == CROP_UPDATE.bottom);
if (hasLeft && hasRight && hasTop && hasBottom && !foundCrop) {
foundCrop = true;
}
else if (hasLeft && hasRight && hasTop && hasBottom && foundCrop) {
[] () { FAIL(); }();
}
return foundCrop;
}
bool SurfaceInterceptorTest::finalCropUpdateFound(const SurfaceChange& change,
bool foundFinalCrop)
{
bool hasLeft(change.final_crop().rectangle().left() == CROP_UPDATE.left);
bool hasTop(change.final_crop().rectangle().top() == CROP_UPDATE.top);
bool hasRight(change.final_crop().rectangle().right() == CROP_UPDATE.right);
bool hasBottom(change.final_crop().rectangle().bottom() == CROP_UPDATE.bottom);
if (hasLeft && hasRight && hasTop && hasBottom && !foundFinalCrop) {
foundFinalCrop = true;
}
else if (hasLeft && hasRight && hasTop && hasBottom && foundFinalCrop) {
[] () { FAIL(); }();
}
return foundFinalCrop;
}
bool SurfaceInterceptorTest::matrixUpdateFound(const SurfaceChange& change, bool foundMatrix) {
bool hasSx((float)change.matrix().dsdx() == (float)M_SQRT1_2);
bool hasTx((float)change.matrix().dtdx() == (float)M_SQRT1_2);
bool hasSy((float)change.matrix().dsdy() == (float)-M_SQRT1_2);
bool hasTy((float)change.matrix().dtdy() == (float)M_SQRT1_2);
if (hasSx && hasTx && hasSy && hasTy && !foundMatrix) {
foundMatrix = true;
}
else if (hasSx && hasTx && hasSy && hasTy && foundMatrix) {
[] () { FAIL(); }();
}
return foundMatrix;
}
bool SurfaceInterceptorTest::scalingModeUpdateFound(const SurfaceChange& change,
bool foundScalingMode)
{
bool hasScalingUpdate(change.override_scaling_mode().override_scaling_mode() == SCALING_UPDATE);
if (hasScalingUpdate && !foundScalingMode) {
foundScalingMode = true;
}
else if (hasScalingUpdate && foundScalingMode) {
[] () { FAIL(); }();
}
return foundScalingMode;
}
bool SurfaceInterceptorTest::transparentRegionHintUpdateFound(const SurfaceChange& change,
bool foundTransparentRegion)
{
auto traceRegion = change.transparent_region_hint().region(0);
bool hasLeft(traceRegion.left() == CROP_UPDATE.left);
bool hasTop(traceRegion.top() == CROP_UPDATE.top);
bool hasRight(traceRegion.right() == CROP_UPDATE.right);
bool hasBottom(traceRegion.bottom() == CROP_UPDATE.bottom);
if (hasLeft && hasRight && hasTop && hasBottom && !foundTransparentRegion) {
foundTransparentRegion = true;
}
else if (hasLeft && hasRight && hasTop && hasBottom && foundTransparentRegion) {
[] () { FAIL(); }();
}
return foundTransparentRegion;
}
bool SurfaceInterceptorTest::layerStackUpdateFound(const SurfaceChange& change,
bool foundLayerStack)
{
bool hasLayerStackUpdate(change.layer_stack().layer_stack() == STACK_UPDATE);
if (hasLayerStackUpdate && !foundLayerStack) {
foundLayerStack = true;
}
else if (hasLayerStackUpdate && foundLayerStack) {
[] () { FAIL(); }();
}
return foundLayerStack;
}
bool SurfaceInterceptorTest::hiddenFlagUpdateFound(const SurfaceChange& change,
bool foundHiddenFlag)
{
bool hasHiddenFlag(change.hidden_flag().hidden_flag());
if (hasHiddenFlag && !foundHiddenFlag) {
foundHiddenFlag = true;
}
else if (hasHiddenFlag && foundHiddenFlag) {
[] () { FAIL(); }();
}
return foundHiddenFlag;
}
bool SurfaceInterceptorTest::opaqueFlagUpdateFound(const SurfaceChange& change,
bool foundOpaqueFlag)
{
bool hasOpaqueFlag(change.opaque_flag().opaque_flag());
if (hasOpaqueFlag && !foundOpaqueFlag) {
foundOpaqueFlag = true;
}
else if (hasOpaqueFlag && foundOpaqueFlag) {
[] () { FAIL(); }();
}
return foundOpaqueFlag;
}
bool SurfaceInterceptorTest::secureFlagUpdateFound(const SurfaceChange& change,
bool foundSecureFlag)
{
bool hasSecureFlag(change.secure_flag().secure_flag());
if (hasSecureFlag && !foundSecureFlag) {
foundSecureFlag = true;
}
else if (hasSecureFlag && foundSecureFlag) {
[] () { FAIL(); }();
}
return foundSecureFlag;
}
bool SurfaceInterceptorTest::deferredTransactionUpdateFound(const SurfaceChange& change,
bool foundDeferred)
{
bool hasId(change.deferred_transaction().layer_id() == mBGLayerId);
bool hasFrameNumber(change.deferred_transaction().frame_number() == DEFERRED_UPDATE);
if (hasId && hasFrameNumber && !foundDeferred) {
foundDeferred = true;
}
else if (hasId && hasFrameNumber && foundDeferred) {
[] () { FAIL(); }();
}
return foundDeferred;
}
bool SurfaceInterceptorTest::surfaceUpdateFound(Trace* trace,
SurfaceChange::SurfaceChangeCase changeCase)
{
bool foundUpdate = false;
for (const auto& increment : *trace->mutable_increment()) {
if (increment.increment_case() == increment.kTransaction) {
for (const auto& change : increment.transaction().surface_change()) {
if (change.id() == mBGLayerId && change.SurfaceChange_case() == changeCase) {
switch (changeCase) {
case SurfaceChange::SurfaceChangeCase::kPosition:
// foundUpdate is sent for the tests to fail on duplicated increments
foundUpdate = positionUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kSize:
foundUpdate = sizeUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kAlpha:
foundUpdate = alphaUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kLayer:
foundUpdate = layerUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kCrop:
foundUpdate = cropUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kFinalCrop:
foundUpdate = finalCropUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kMatrix:
foundUpdate = matrixUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode:
foundUpdate = scalingModeUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint:
foundUpdate = transparentRegionHintUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kLayerStack:
foundUpdate = layerStackUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kHiddenFlag:
foundUpdate = hiddenFlagUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kOpaqueFlag:
foundUpdate = opaqueFlagUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kSecureFlag:
foundUpdate = secureFlagUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::kDeferredTransaction:
foundUpdate = deferredTransactionUpdateFound(change, foundUpdate);
break;
case SurfaceChange::SurfaceChangeCase::SURFACECHANGE_NOT_SET:
break;
}
}
}
}
}
return foundUpdate;
}
void SurfaceInterceptorTest::assertAllUpdatesFound(Trace* trace) {
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kPosition));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kSize));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kAlpha));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kLayer));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kCrop));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kFinalCrop));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kMatrix));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kOverrideScalingMode));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kTransparentRegionHint));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kLayerStack));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kHiddenFlag));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kOpaqueFlag));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kSecureFlag));
ASSERT_TRUE(surfaceUpdateFound(trace, SurfaceChange::SurfaceChangeCase::kDeferredTransaction));
}
bool SurfaceInterceptorTest::surfaceCreationFound(const Increment& increment, bool foundSurface) {
bool isMatch(increment.surface_creation().name() == LAYER_NAME &&
increment.surface_creation().w() == SIZE_UPDATE &&
increment.surface_creation().h() == SIZE_UPDATE);
if (isMatch && !foundSurface) {
foundSurface = true;
}
else if (isMatch && foundSurface) {
[] () { FAIL(); }();
}
return foundSurface;
}
bool SurfaceInterceptorTest::surfaceDeletionFound(const Increment& increment, bool foundSurface) {
bool isMatch(increment.surface_deletion().id() == mTargetId);
if (isMatch && !foundSurface) {
foundSurface = true;
}
else if (isMatch && foundSurface) {
[] () { FAIL(); }();
}
return foundSurface;
}
bool SurfaceInterceptorTest::displayCreationFound(const Increment& increment, bool foundDisplay) {
bool isMatch(increment.display_creation().name() == DISPLAY_NAME.string() &&
increment.display_creation().is_secure());
if (isMatch && !foundDisplay) {
foundDisplay = true;
}
else if (isMatch && foundDisplay) {
[] () { FAIL(); }();
}
return foundDisplay;
}
bool SurfaceInterceptorTest::displayDeletionFound(const Increment& increment, bool foundDisplay) {
bool isMatch(increment.display_deletion().id() == mTargetId);
if (isMatch && !foundDisplay) {
foundDisplay = true;
}
else if (isMatch && foundDisplay) {
[] () { FAIL(); }();
}
return foundDisplay;
}
bool SurfaceInterceptorTest::singleIncrementFound(Trace* trace,
Increment::IncrementCase incrementCase)
{
bool foundIncrement = false;
for (const auto& increment : *trace->mutable_increment()) {
if (increment.increment_case() == incrementCase) {
switch (incrementCase) {
case Increment::IncrementCase::kSurfaceCreation:
foundIncrement = surfaceCreationFound(increment, foundIncrement);
break;
case Increment::IncrementCase::kSurfaceDeletion:
foundIncrement = surfaceDeletionFound(increment, foundIncrement);
break;
case Increment::IncrementCase::kDisplayCreation:
foundIncrement = displayCreationFound(increment, foundIncrement);
break;
case Increment::IncrementCase::kDisplayDeletion:
foundIncrement = displayDeletionFound(increment, foundIncrement);
break;
default:
/* code */
break;
}
}
}
return foundIncrement;
}
bool SurfaceInterceptorTest::bufferUpdatesFound(Trace* trace) {
uint32_t updates = 0;
for (const auto& inc : *trace->mutable_increment()) {
if (inc.increment_case() == inc.kBufferUpdate && inc.buffer_update().id() == mBGLayerId) {
updates++;
}
}
return updates == BUFFER_UPDATES;
}
TEST_F(SurfaceInterceptorTest, InterceptPositionUpdateWorks) {
captureTest(&SurfaceInterceptorTest::positionUpdate,
SurfaceChange::SurfaceChangeCase::kPosition);
}
TEST_F(SurfaceInterceptorTest, InterceptSizeUpdateWorks) {
captureTest(&SurfaceInterceptorTest::sizeUpdate, SurfaceChange::SurfaceChangeCase::kSize);
}
TEST_F(SurfaceInterceptorTest, InterceptAlphaUpdateWorks) {
captureTest(&SurfaceInterceptorTest::alphaUpdate, SurfaceChange::SurfaceChangeCase::kAlpha);
}
TEST_F(SurfaceInterceptorTest, InterceptLayerUpdateWorks) {
captureTest(&SurfaceInterceptorTest::layerUpdate, SurfaceChange::SurfaceChangeCase::kLayer);
}
TEST_F(SurfaceInterceptorTest, InterceptCropUpdateWorks) {
captureTest(&SurfaceInterceptorTest::cropUpdate, SurfaceChange::SurfaceChangeCase::kCrop);
}
TEST_F(SurfaceInterceptorTest, InterceptFinalCropUpdateWorks) {
captureTest(&SurfaceInterceptorTest::finalCropUpdate,
SurfaceChange::SurfaceChangeCase::kFinalCrop);
}
TEST_F(SurfaceInterceptorTest, InterceptMatrixUpdateWorks) {
captureTest(&SurfaceInterceptorTest::matrixUpdate, SurfaceChange::SurfaceChangeCase::kMatrix);
}
TEST_F(SurfaceInterceptorTest, InterceptOverrideScalingModeUpdateWorks) {
captureTest(&SurfaceInterceptorTest::overrideScalingModeUpdate,
SurfaceChange::SurfaceChangeCase::kOverrideScalingMode);
}
TEST_F(SurfaceInterceptorTest, InterceptTransparentRegionHintUpdateWorks) {
captureTest(&SurfaceInterceptorTest::transparentRegionHintUpdate,
SurfaceChange::SurfaceChangeCase::kTransparentRegionHint);
}
TEST_F(SurfaceInterceptorTest, InterceptLayerStackUpdateWorks) {
captureTest(&SurfaceInterceptorTest::layerStackUpdate,
SurfaceChange::SurfaceChangeCase::kLayerStack);
}
TEST_F(SurfaceInterceptorTest, InterceptHiddenFlagUpdateWorks) {
captureTest(&SurfaceInterceptorTest::hiddenFlagUpdate,
SurfaceChange::SurfaceChangeCase::kHiddenFlag);
}
TEST_F(SurfaceInterceptorTest, InterceptOpaqueFlagUpdateWorks) {
captureTest(&SurfaceInterceptorTest::opaqueFlagUpdate,
SurfaceChange::SurfaceChangeCase::kOpaqueFlag);
}
TEST_F(SurfaceInterceptorTest, InterceptSecureFlagUpdateWorks) {
captureTest(&SurfaceInterceptorTest::secureFlagUpdate,
SurfaceChange::SurfaceChangeCase::kSecureFlag);
}
TEST_F(SurfaceInterceptorTest, InterceptDeferredTransactionUpdateWorks) {
captureTest(&SurfaceInterceptorTest::deferredTransactionUpdate,
SurfaceChange::SurfaceChangeCase::kDeferredTransaction);
}
TEST_F(SurfaceInterceptorTest, InterceptAllUpdatesWorks) {
enableInterceptor();
runAllUpdates();
disableInterceptor();
// Find all of the updates in the single trace
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
assertAllUpdatesFound(&capturedTrace);
}
TEST_F(SurfaceInterceptorTest, InterceptSurfaceCreationWorks) {
captureTest(&SurfaceInterceptorTest::surfaceCreation,
Increment::IncrementCase::kSurfaceCreation);
}
TEST_F(SurfaceInterceptorTest, InterceptSurfaceDeletionWorks) {
sp<SurfaceControl> layerToDelete = mComposerClient->createSurface(String8(LAYER_NAME),
SIZE_UPDATE, SIZE_UPDATE, PIXEL_FORMAT_RGBA_8888, 0);
this->mTargetId = getSurfaceId(LAYER_NAME);
enableInterceptor();
mComposerClient->destroySurface(layerToDelete->getHandle());
disableInterceptor();
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
ASSERT_TRUE(singleIncrementFound(&capturedTrace, Increment::IncrementCase::kSurfaceDeletion));
}
TEST_F(SurfaceInterceptorTest, InterceptDisplayCreationWorks) {
captureTest(&SurfaceInterceptorTest::displayCreation,
Increment::IncrementCase::kDisplayCreation);
}
TEST_F(SurfaceInterceptorTest, InterceptDisplayDeletionWorks) {
captureTest(&SurfaceInterceptorTest::displayDeletion,
Increment::IncrementCase::kDisplayDeletion);
}
TEST_F(SurfaceInterceptorTest, InterceptBufferUpdateWorks) {
captureTest(&SurfaceInterceptorTest::nBufferUpdates,
&SurfaceInterceptorTest::bufferUpdatesFound);
}
// If the interceptor is enabled while buffer updates are being pushed, the interceptor should
// first create a snapshot of the existing displays and surfaces and then start capturing
// the buffer updates
TEST_F(SurfaceInterceptorTest, InterceptWhileBufferUpdatesWorks) {
std::thread bufferUpdates(&SurfaceInterceptorTest::nBufferUpdates, this);
enableInterceptor();
disableInterceptor();
bufferUpdates.join();
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
const auto& firstIncrement = capturedTrace.mutable_increment(0);
ASSERT_EQ(firstIncrement->increment_case(), Increment::IncrementCase::kDisplayCreation);
}
TEST_F(SurfaceInterceptorTest, InterceptSimultaneousUpdatesWorks) {
enableInterceptor();
std::thread bufferUpdates(&SurfaceInterceptorTest::nBufferUpdates, this);
std::thread surfaceUpdates(&SurfaceInterceptorTest::runAllUpdates, this);
runInTransaction(&SurfaceInterceptorTest::surfaceCreation);
bufferUpdates.join();
surfaceUpdates.join();
disableInterceptor();
Trace capturedTrace;
ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace));
assertAllUpdatesFound(&capturedTrace);
ASSERT_TRUE(bufferUpdatesFound(&capturedTrace));
ASSERT_TRUE(singleIncrementFound(&capturedTrace, Increment::IncrementCase::kSurfaceCreation));
}
}