C++程序
|
6063行
|
231.42 KB
/*
* Copyright (C) 2011 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 <algorithm>
#include <chrono>
#include <cinttypes>
#include <functional>
#include <limits>
#include <ostream>
#include <thread>
#include <gtest/gtest.h>
#include <android/native_window.h>
#include <binder/ProcessState.h>
#include <gui/BufferItemConsumer.h>
#include <gui/ISurfaceComposer.h>
#include <gui/LayerState.h>
#include <gui/Surface.h>
#include <gui/SurfaceComposerClient.h>
#include <hardware/hwcomposer_defs.h>
#include <private/android_filesystem_config.h>
#include <private/gui/ComposerService.h>
#include <ui/ColorSpace.h>
#include <ui/DisplayInfo.h>
#include <ui/Rect.h>
#include <utils/String8.h>
#include <math.h>
#include <math/vec3.h>
#include <sys/types.h>
#include <unistd.h>
#include "BufferGenerator.h"
namespace android {
namespace {
struct Color {
uint8_t r;
uint8_t g;
uint8_t b;
uint8_t a;
static const Color RED;
static const Color GREEN;
static const Color BLUE;
static const Color WHITE;
static const Color BLACK;
static const Color TRANSPARENT;
};
const Color Color::RED{255, 0, 0, 255};
const Color Color::GREEN{0, 255, 0, 255};
const Color Color::BLUE{0, 0, 255, 255};
const Color Color::WHITE{255, 255, 255, 255};
const Color Color::BLACK{0, 0, 0, 255};
const Color Color::TRANSPARENT{0, 0, 0, 0};
using android::hardware::graphics::common::V1_1::BufferUsage;
using namespace std::chrono_literals;
std::ostream& operator<<(std::ostream& os, const Color& color) {
os << int(color.r) << ", " << int(color.g) << ", " << int(color.b) << ", " << int(color.a);
return os;
}
// Fill a region with the specified color.
void fillANativeWindowBufferColor(const ANativeWindow_Buffer& buffer, const Rect& rect,
const Color& color) {
Rect r(0, 0, buffer.width, buffer.height);
if (!r.intersect(rect, &r)) {
return;
}
int32_t width = r.right - r.left;
int32_t height = r.bottom - r.top;
for (int32_t row = 0; row < height; row++) {
uint8_t* dst =
static_cast<uint8_t*>(buffer.bits) + (buffer.stride * (r.top + row) + r.left) * 4;
for (int32_t column = 0; column < width; column++) {
dst[0] = color.r;
dst[1] = color.g;
dst[2] = color.b;
dst[3] = color.a;
dst += 4;
}
}
}
// Fill a region with the specified color.
void fillGraphicBufferColor(const sp<GraphicBuffer>& buffer, const Rect& rect, const Color& color) {
Rect r(0, 0, buffer->width, buffer->height);
if (!r.intersect(rect, &r)) {
return;
}
int32_t width = r.right - r.left;
int32_t height = r.bottom - r.top;
uint8_t* pixels;
buffer->lock(GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN,
reinterpret_cast<void**>(&pixels));
for (int32_t row = 0; row < height; row++) {
uint8_t* dst = pixels + (buffer->getStride() * (r.top + row) + r.left) * 4;
for (int32_t column = 0; column < width; column++) {
dst[0] = color.r;
dst[1] = color.g;
dst[2] = color.b;
dst[3] = color.a;
dst += 4;
}
}
buffer->unlock();
}
// Check if a region has the specified color.
void expectBufferColor(const sp<GraphicBuffer>& outBuffer, uint8_t* pixels, const Rect& rect,
const Color& color, uint8_t tolerance) {
int32_t x = rect.left;
int32_t y = rect.top;
int32_t width = rect.right - rect.left;
int32_t height = rect.bottom - rect.top;
int32_t bufferWidth = int32_t(outBuffer->getWidth());
int32_t bufferHeight = int32_t(outBuffer->getHeight());
if (x + width > bufferWidth) {
x = std::min(x, bufferWidth);
width = bufferWidth - x;
}
if (y + height > bufferHeight) {
y = std::min(y, bufferHeight);
height = bufferHeight - y;
}
auto colorCompare = [tolerance](uint8_t a, uint8_t b) {
uint8_t tmp = a >= b ? a - b : b - a;
return tmp <= tolerance;
};
for (int32_t j = 0; j < height; j++) {
const uint8_t* src = pixels + (outBuffer->getStride() * (y + j) + x) * 4;
for (int32_t i = 0; i < width; i++) {
const uint8_t expected[4] = {color.r, color.g, color.b, color.a};
EXPECT_TRUE(std::equal(src, src + 4, expected, colorCompare))
<< "pixel @ (" << x + i << ", " << y + j << "): "
<< "expected (" << color << "), "
<< "got (" << Color{src[0], src[1], src[2], src[3]} << ")";
src += 4;
}
}
}
} // anonymous namespace
using Transaction = SurfaceComposerClient::Transaction;
// 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,
bool unlock = true) {
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;
}
}
if (unlock) {
ASSERT_EQ(NO_ERROR, s->unlockAndPost());
}
}
// A ScreenCapture is a screenshot from SurfaceFlinger that can be used to check
// individual pixel values for testing purposes.
class ScreenCapture : public RefBase {
public:
static void captureScreen(std::unique_ptr<ScreenCapture>* sc) {
captureScreen(sc, SurfaceComposerClient::getInternalDisplayToken());
}
static void captureScreen(std::unique_ptr<ScreenCapture>* sc, sp<IBinder> displayToken) {
const auto sf = ComposerService::getComposerService();
SurfaceComposerClient::Transaction().apply(true);
sp<GraphicBuffer> outBuffer;
ASSERT_EQ(NO_ERROR, sf->captureScreen(displayToken, &outBuffer, Rect(), 0, 0, false));
*sc = std::make_unique<ScreenCapture>(outBuffer);
}
static void captureLayers(std::unique_ptr<ScreenCapture>* sc, sp<IBinder>& parentHandle,
Rect crop = Rect::EMPTY_RECT, float frameScale = 1.0) {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
SurfaceComposerClient::Transaction().apply(true);
sp<GraphicBuffer> outBuffer;
ASSERT_EQ(NO_ERROR, sf->captureLayers(parentHandle, &outBuffer, crop, frameScale));
*sc = std::make_unique<ScreenCapture>(outBuffer);
}
static void captureChildLayers(std::unique_ptr<ScreenCapture>* sc, sp<IBinder>& parentHandle,
Rect crop = Rect::EMPTY_RECT, float frameScale = 1.0) {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
SurfaceComposerClient::Transaction().apply(true);
sp<GraphicBuffer> outBuffer;
ASSERT_EQ(NO_ERROR, sf->captureLayers(parentHandle, &outBuffer, crop, frameScale, true));
*sc = std::make_unique<ScreenCapture>(outBuffer);
}
static void captureChildLayersExcluding(
std::unique_ptr<ScreenCapture>* sc, sp<IBinder>& parentHandle,
std::unordered_set<sp<IBinder>, ISurfaceComposer::SpHash<IBinder>> excludeLayers) {
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
SurfaceComposerClient::Transaction().apply(true);
sp<GraphicBuffer> outBuffer;
ASSERT_EQ(NO_ERROR,
sf->captureLayers(parentHandle, &outBuffer, ui::Dataspace::V0_SRGB,
ui::PixelFormat::RGBA_8888, Rect::EMPTY_RECT, excludeLayers,
1.0f, true));
*sc = std::make_unique<ScreenCapture>(outBuffer);
}
void expectColor(const Rect& rect, const Color& color, uint8_t tolerance = 0) {
ASSERT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, mOutBuffer->getPixelFormat());
expectBufferColor(mOutBuffer, mPixels, rect, color, tolerance);
}
void expectBorder(const Rect& rect, const Color& color, uint8_t tolerance = 0) {
ASSERT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, mOutBuffer->getPixelFormat());
const bool leftBorder = rect.left > 0;
const bool topBorder = rect.top > 0;
const bool rightBorder = rect.right < int32_t(mOutBuffer->getWidth());
const bool bottomBorder = rect.bottom < int32_t(mOutBuffer->getHeight());
if (topBorder) {
Rect top(rect.left, rect.top - 1, rect.right, rect.top);
if (leftBorder) {
top.left -= 1;
}
if (rightBorder) {
top.right += 1;
}
expectColor(top, color, tolerance);
}
if (leftBorder) {
Rect left(rect.left - 1, rect.top, rect.left, rect.bottom);
expectColor(left, color, tolerance);
}
if (rightBorder) {
Rect right(rect.right, rect.top, rect.right + 1, rect.bottom);
expectColor(right, color, tolerance);
}
if (bottomBorder) {
Rect bottom(rect.left, rect.bottom, rect.right, rect.bottom + 1);
if (leftBorder) {
bottom.left -= 1;
}
if (rightBorder) {
bottom.right += 1;
}
expectColor(bottom, color, tolerance);
}
}
void expectQuadrant(const Rect& rect, const Color& topLeft, const Color& topRight,
const Color& bottomLeft, const Color& bottomRight, bool filtered = false,
uint8_t tolerance = 0) {
ASSERT_TRUE((rect.right - rect.left) % 2 == 0 && (rect.bottom - rect.top) % 2 == 0);
const int32_t centerX = rect.left + (rect.right - rect.left) / 2;
const int32_t centerY = rect.top + (rect.bottom - rect.top) / 2;
// avoid checking borders due to unspecified filtering behavior
const int32_t offsetX = filtered ? 2 : 0;
const int32_t offsetY = filtered ? 2 : 0;
expectColor(Rect(rect.left, rect.top, centerX - offsetX, centerY - offsetY), topLeft,
tolerance);
expectColor(Rect(centerX + offsetX, rect.top, rect.right, centerY - offsetY), topRight,
tolerance);
expectColor(Rect(rect.left, centerY + offsetY, centerX - offsetX, rect.bottom), bottomLeft,
tolerance);
expectColor(Rect(centerX + offsetX, centerY + offsetY, rect.right, rect.bottom),
bottomRight, tolerance);
}
void checkPixel(uint32_t x, uint32_t y, uint8_t r, uint8_t g, uint8_t b) {
ASSERT_EQ(HAL_PIXEL_FORMAT_RGBA_8888, mOutBuffer->getPixelFormat());
const uint8_t* pixel = mPixels + (4 * (y * mOutBuffer->getStride() + x));
if (r != pixel[0] || g != pixel[1] || b != pixel[2]) {
String8 err(String8::format("pixel @ (%3d, %3d): "
"expected [%3d, %3d, %3d], got [%3d, %3d, %3d]",
x, y, r, g, b, pixel[0], pixel[1], pixel[2]));
EXPECT_EQ(String8(), err) << err.string();
}
}
void expectFGColor(uint32_t x, uint32_t y) { checkPixel(x, y, 195, 63, 63); }
void expectBGColor(uint32_t x, uint32_t y) { checkPixel(x, y, 63, 63, 195); }
void expectChildColor(uint32_t x, uint32_t y) { checkPixel(x, y, 200, 200, 200); }
explicit ScreenCapture(const sp<GraphicBuffer>& outBuffer) : mOutBuffer(outBuffer) {
mOutBuffer->lock(GRALLOC_USAGE_SW_READ_OFTEN, reinterpret_cast<void**>(&mPixels));
}
~ScreenCapture() { mOutBuffer->unlock(); }
private:
sp<GraphicBuffer> mOutBuffer;
uint8_t* mPixels = nullptr;
};
class LayerTransactionTest : public ::testing::Test {
protected:
void SetUp() override {
mClient = new SurfaceComposerClient;
ASSERT_EQ(NO_ERROR, mClient->initCheck()) << "failed to create SurfaceComposerClient";
ASSERT_NO_FATAL_FAILURE(SetUpDisplay());
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
ASSERT_NO_FATAL_FAILURE(sf->getColorManagement(&mColorManagementUsed));
}
virtual void TearDown() {
mBlackBgSurface = 0;
mClient->dispose();
mClient = 0;
}
virtual sp<SurfaceControl> createLayer(const sp<SurfaceComposerClient>& client,
const char* name, uint32_t width, uint32_t height,
uint32_t flags = 0, SurfaceControl* parent = nullptr) {
auto layer =
createSurface(client, name, width, height, PIXEL_FORMAT_RGBA_8888, flags, parent);
Transaction t;
t.setLayerStack(layer, mDisplayLayerStack).setLayer(layer, mLayerZBase);
status_t error = t.apply();
if (error != NO_ERROR) {
ADD_FAILURE() << "failed to initialize SurfaceControl";
layer.clear();
}
return layer;
}
virtual sp<SurfaceControl> createSurface(const sp<SurfaceComposerClient>& client,
const char* name, uint32_t width, uint32_t height,
PixelFormat format, uint32_t flags,
SurfaceControl* parent = nullptr) {
auto layer = client->createSurface(String8(name), width, height, format, flags, parent);
EXPECT_NE(nullptr, layer.get()) << "failed to create SurfaceControl";
return layer;
}
virtual sp<SurfaceControl> createLayer(const char* name, uint32_t width, uint32_t height,
uint32_t flags = 0, SurfaceControl* parent = nullptr) {
return createLayer(mClient, name, width, height, flags, parent);
}
sp<SurfaceControl> createColorLayer(const char* name, const Color& color,
SurfaceControl* parent = nullptr) {
auto colorLayer = createSurface(mClient, name, 0 /* buffer width */, 0 /* buffer height */,
PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, parent);
asTransaction([&](Transaction& t) {
t.setColor(colorLayer, half3{color.r / 255.0f, color.g / 255.0f, color.b / 255.0f});
t.setAlpha(colorLayer, color.a / 255.0f);
});
return colorLayer;
}
ANativeWindow_Buffer getBufferQueueLayerBuffer(const sp<SurfaceControl>& layer) {
// wait for previous transactions (such as setSize) to complete
Transaction().apply(true);
ANativeWindow_Buffer buffer = {};
EXPECT_EQ(NO_ERROR, layer->getSurface()->lock(&buffer, nullptr));
return buffer;
}
void postBufferQueueLayerBuffer(const sp<SurfaceControl>& layer) {
ASSERT_EQ(NO_ERROR, layer->getSurface()->unlockAndPost());
// wait for the newly posted buffer to be latched
waitForLayerBuffers();
}
virtual void fillBufferQueueLayerColor(const sp<SurfaceControl>& layer, const Color& color,
int32_t bufferWidth, int32_t bufferHeight) {
ANativeWindow_Buffer buffer;
ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
fillANativeWindowBufferColor(buffer, Rect(0, 0, bufferWidth, bufferHeight), color);
postBufferQueueLayerBuffer(layer);
}
virtual void fillBufferStateLayerColor(const sp<SurfaceControl>& layer, const Color& color,
int32_t bufferWidth, int32_t bufferHeight) {
sp<GraphicBuffer> buffer =
new GraphicBuffer(bufferWidth, bufferHeight, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, bufferWidth, bufferHeight), color);
Transaction().setBuffer(layer, buffer).apply();
}
void fillLayerColor(uint32_t mLayerType, const sp<SurfaceControl>& layer, const Color& color,
int32_t bufferWidth, int32_t bufferHeight) {
switch (mLayerType) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
fillBufferQueueLayerColor(layer, color, bufferWidth, bufferHeight);
break;
case ISurfaceComposerClient::eFXSurfaceBufferState:
fillBufferStateLayerColor(layer, color, bufferWidth, bufferHeight);
break;
default:
ASSERT_TRUE(false) << "unsupported layer type: " << mLayerType;
}
}
void fillLayerQuadrant(uint32_t mLayerType, const sp<SurfaceControl>& layer,
int32_t bufferWidth, int32_t bufferHeight, const Color& topLeft,
const Color& topRight, const Color& bottomLeft,
const Color& bottomRight) {
switch (mLayerType) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
fillBufferQueueLayerQuadrant(layer, bufferWidth, bufferHeight, topLeft, topRight,
bottomLeft, bottomRight);
break;
case ISurfaceComposerClient::eFXSurfaceBufferState:
fillBufferStateLayerQuadrant(layer, bufferWidth, bufferHeight, topLeft, topRight,
bottomLeft, bottomRight);
break;
default:
ASSERT_TRUE(false) << "unsupported layer type: " << mLayerType;
}
}
virtual void fillBufferQueueLayerQuadrant(const sp<SurfaceControl>& layer, int32_t bufferWidth,
int32_t bufferHeight, const Color& topLeft,
const Color& topRight, const Color& bottomLeft,
const Color& bottomRight) {
ANativeWindow_Buffer buffer;
ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
ASSERT_TRUE(bufferWidth % 2 == 0 && bufferHeight % 2 == 0);
const int32_t halfW = bufferWidth / 2;
const int32_t halfH = bufferHeight / 2;
fillANativeWindowBufferColor(buffer, Rect(0, 0, halfW, halfH), topLeft);
fillANativeWindowBufferColor(buffer, Rect(halfW, 0, bufferWidth, halfH), topRight);
fillANativeWindowBufferColor(buffer, Rect(0, halfH, halfW, bufferHeight), bottomLeft);
fillANativeWindowBufferColor(buffer, Rect(halfW, halfH, bufferWidth, bufferHeight),
bottomRight);
postBufferQueueLayerBuffer(layer);
}
virtual void fillBufferStateLayerQuadrant(const sp<SurfaceControl>& layer, int32_t bufferWidth,
int32_t bufferHeight, const Color& topLeft,
const Color& topRight, const Color& bottomLeft,
const Color& bottomRight) {
sp<GraphicBuffer> buffer =
new GraphicBuffer(bufferWidth, bufferHeight, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
ASSERT_TRUE(bufferWidth % 2 == 0 && bufferHeight % 2 == 0);
const int32_t halfW = bufferWidth / 2;
const int32_t halfH = bufferHeight / 2;
fillGraphicBufferColor(buffer, Rect(0, 0, halfW, halfH), topLeft);
fillGraphicBufferColor(buffer, Rect(halfW, 0, bufferWidth, halfH), topRight);
fillGraphicBufferColor(buffer, Rect(0, halfH, halfW, bufferHeight), bottomLeft);
fillGraphicBufferColor(buffer, Rect(halfW, halfH, bufferWidth, bufferHeight), bottomRight);
Transaction().setBuffer(layer, buffer).setSize(layer, bufferWidth, bufferHeight).apply();
}
std::unique_ptr<ScreenCapture> screenshot() {
std::unique_ptr<ScreenCapture> screenshot;
ScreenCapture::captureScreen(&screenshot);
return screenshot;
}
void asTransaction(const std::function<void(Transaction&)>& exec) {
Transaction t;
exec(t);
t.apply(true);
}
static status_t getBuffer(sp<GraphicBuffer>* outBuffer, sp<Fence>* outFence) {
static BufferGenerator bufferGenerator;
return bufferGenerator.get(outBuffer, outFence);
}
sp<SurfaceComposerClient> mClient;
sp<IBinder> mDisplay;
uint32_t mDisplayWidth;
uint32_t mDisplayHeight;
uint32_t mDisplayLayerStack;
Rect mDisplayRect = Rect::INVALID_RECT;
// leave room for ~256 layers
const int32_t mLayerZBase = std::numeric_limits<int32_t>::max() - 256;
sp<SurfaceControl> mBlackBgSurface;
bool mColorManagementUsed;
private:
void SetUpDisplay() {
mDisplay = mClient->getInternalDisplayToken();
ASSERT_FALSE(mDisplay == nullptr) << "failed to get display";
// get display width/height
DisplayInfo info;
ASSERT_EQ(NO_ERROR, SurfaceComposerClient::getDisplayInfo(mDisplay, &info));
mDisplayWidth = info.w;
mDisplayHeight = info.h;
mDisplayRect =
Rect(static_cast<int32_t>(mDisplayWidth), static_cast<int32_t>(mDisplayHeight));
// After a new buffer is queued, SurfaceFlinger is notified and will
// latch the new buffer on next vsync. Let's heuristically wait for 3
// vsyncs.
mBufferPostDelay = int32_t(1e6 / info.fps) * 3;
mDisplayLayerStack = 0;
mBlackBgSurface =
createSurface(mClient, "BaseSurface", 0 /* buffer width */, 0 /* buffer height */,
PIXEL_FORMAT_RGBA_8888, ISurfaceComposerClient::eFXSurfaceColor);
// set layer stack (b/68888219)
Transaction t;
t.setDisplayLayerStack(mDisplay, mDisplayLayerStack);
t.setCrop_legacy(mBlackBgSurface, Rect(0, 0, mDisplayWidth, mDisplayHeight));
t.setLayerStack(mBlackBgSurface, mDisplayLayerStack);
t.setColor(mBlackBgSurface, half3{0, 0, 0});
t.setLayer(mBlackBgSurface, mLayerZBase);
t.apply();
}
void waitForLayerBuffers() {
// Request an empty transaction to get applied synchronously to ensure the buffer is
// latched.
Transaction().apply(true);
usleep(mBufferPostDelay);
}
int32_t mBufferPostDelay;
friend class LayerRenderPathTestHarness;
};
enum class RenderPath { SCREENSHOT, VIRTUAL_DISPLAY };
class LayerRenderPathTestHarness {
public:
LayerRenderPathTestHarness(LayerTransactionTest* delegate, RenderPath renderPath)
: mDelegate(delegate), mRenderPath(renderPath) {}
std::unique_ptr<ScreenCapture> getScreenCapture() {
switch (mRenderPath) {
case RenderPath::SCREENSHOT:
return mDelegate->screenshot();
case RenderPath::VIRTUAL_DISPLAY:
const auto mainDisplay = SurfaceComposerClient::getInternalDisplayToken();
DisplayInfo mainDisplayInfo;
SurfaceComposerClient::getDisplayInfo(mainDisplay, &mainDisplayInfo);
sp<IBinder> vDisplay;
sp<IGraphicBufferProducer> producer;
sp<IGraphicBufferConsumer> consumer;
sp<BufferItemConsumer> itemConsumer;
BufferQueue::createBufferQueue(&producer, &consumer);
consumer->setConsumerName(String8("Virtual disp consumer"));
consumer->setDefaultBufferSize(mainDisplayInfo.w, mainDisplayInfo.h);
itemConsumer = new BufferItemConsumer(consumer,
// Sample usage bits from screenrecord
GRALLOC_USAGE_HW_VIDEO_ENCODER |
GRALLOC_USAGE_SW_READ_OFTEN);
vDisplay = SurfaceComposerClient::createDisplay(String8("VirtualDisplay"),
false /*secure*/);
SurfaceComposerClient::Transaction t;
t.setDisplaySurface(vDisplay, producer);
t.setDisplayLayerStack(vDisplay, 0);
t.setDisplayProjection(vDisplay, mainDisplayInfo.orientation,
Rect(mainDisplayInfo.viewportW, mainDisplayInfo.viewportH),
Rect(mainDisplayInfo.w, mainDisplayInfo.h));
t.apply();
SurfaceComposerClient::Transaction().apply(true);
BufferItem item;
itemConsumer->acquireBuffer(&item, 0, true);
auto sc = std::make_unique<ScreenCapture>(item.mGraphicBuffer);
itemConsumer->releaseBuffer(item);
SurfaceComposerClient::destroyDisplay(vDisplay);
return sc;
}
}
protected:
LayerTransactionTest* mDelegate;
RenderPath mRenderPath;
};
class LayerTypeTransactionHarness : public LayerTransactionTest {
public:
LayerTypeTransactionHarness(uint32_t layerType) : mLayerType(layerType) {}
sp<SurfaceControl> createLayer(const char* name, uint32_t width, uint32_t height,
uint32_t flags = 0, SurfaceControl* parent = nullptr) {
// if the flags already have a layer type specified, return an error
if (flags & ISurfaceComposerClient::eFXSurfaceMask) {
return nullptr;
}
return LayerTransactionTest::createLayer(name, width, height, flags | mLayerType, parent);
}
void fillLayerColor(const sp<SurfaceControl>& layer, const Color& color, int32_t bufferWidth,
int32_t bufferHeight) {
ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerColor(mLayerType, layer, color,
bufferWidth, bufferHeight));
}
void fillLayerQuadrant(const sp<SurfaceControl>& layer, int32_t bufferWidth,
int32_t bufferHeight, const Color& topLeft, const Color& topRight,
const Color& bottomLeft, const Color& bottomRight) {
ASSERT_NO_FATAL_FAILURE(LayerTransactionTest::fillLayerQuadrant(mLayerType, layer,
bufferWidth, bufferHeight,
topLeft, topRight,
bottomLeft, bottomRight));
}
protected:
uint32_t mLayerType;
};
class LayerTypeTransactionTest : public LayerTypeTransactionHarness,
public ::testing::WithParamInterface<uint32_t> {
public:
LayerTypeTransactionTest() : LayerTypeTransactionHarness(GetParam()) {}
};
class LayerTypeAndRenderTypeTransactionTest
: public LayerTypeTransactionHarness,
public ::testing::WithParamInterface<std::tuple<uint32_t, RenderPath>> {
public:
LayerTypeAndRenderTypeTransactionTest()
: LayerTypeTransactionHarness(std::get<0>(GetParam())),
mRenderPathHarness(LayerRenderPathTestHarness(this, std::get<1>(GetParam()))) {}
std::unique_ptr<ScreenCapture> getScreenCapture() {
return mRenderPathHarness.getScreenCapture();
}
protected:
LayerRenderPathTestHarness mRenderPathHarness;
};
// Environment for starting up binder threads. This is required for testing
// virtual displays, as BufferQueue parameters may be queried over binder.
class BinderEnvironment : public ::testing::Environment {
public:
void SetUp() override { ProcessState::self()->startThreadPool(); }
};
::testing::Environment* const binderEnv =
::testing::AddGlobalTestEnvironment(new BinderEnvironment());
class LayerRenderTypeTransactionTest : public LayerTransactionTest,
public ::testing::WithParamInterface<RenderPath> {
public:
LayerRenderTypeTransactionTest() : mHarness(LayerRenderPathTestHarness(this, GetParam())) {}
std::unique_ptr<ScreenCapture> getScreenCapture() { return mHarness.getScreenCapture(); }
void setRelativeZBasicHelper(uint32_t layerType);
void setRelativeZGroupHelper(uint32_t layerType);
void setAlphaBasicHelper(uint32_t layerType);
void setBackgroundColorHelper(uint32_t layerType, bool priorColor, bool bufferFill, float alpha,
Color finalColor);
protected:
LayerRenderPathTestHarness mHarness;
};
INSTANTIATE_TEST_CASE_P(
LayerTypeAndRenderTypeTransactionTests, LayerTypeAndRenderTypeTransactionTest,
::testing::Combine(
::testing::Values(
static_cast<uint32_t>(ISurfaceComposerClient::eFXSurfaceBufferQueue),
static_cast<uint32_t>(ISurfaceComposerClient::eFXSurfaceBufferState)),
::testing::Values(RenderPath::VIRTUAL_DISPLAY, RenderPath::SCREENSHOT)));
INSTANTIATE_TEST_CASE_P(LayerRenderTypeTransactionTests, LayerRenderTypeTransactionTest,
::testing::Values(RenderPath::VIRTUAL_DISPLAY, RenderPath::SCREENSHOT));
INSTANTIATE_TEST_CASE_P(
LayerTypeTransactionTests, LayerTypeTransactionTest,
::testing::Values(static_cast<uint32_t>(ISurfaceComposerClient::eFXSurfaceBufferQueue),
static_cast<uint32_t>(ISurfaceComposerClient::eFXSurfaceBufferState)));
TEST_P(LayerRenderTypeTransactionTest, SetPositionBasic_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
{
SCOPED_TRACE("default position");
const Rect rect(0, 0, 32, 32);
auto shot = getScreenCapture();
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
Transaction().setPosition(layer, 5, 10).apply();
{
SCOPED_TRACE("new position");
const Rect rect(5, 10, 37, 42);
auto shot = getScreenCapture();
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetPositionRounding_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// GLES requires only 4 bits of subpixel precision during rasterization
// XXX GLES composition does not match HWC composition due to precision
// loss (b/69315223)
const float epsilon = 1.0f / 16.0f;
Transaction().setPosition(layer, 0.5f - epsilon, 0.5f - epsilon).apply();
{
SCOPED_TRACE("rounding down");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setPosition(layer, 0.5f + epsilon, 0.5f + epsilon).apply();
{
SCOPED_TRACE("rounding up");
getScreenCapture()->expectColor(Rect(1, 1, 33, 33), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetPositionOutOfBounds_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
Transaction().setPosition(layer, -32, -32).apply();
{
SCOPED_TRACE("negative coordinates");
getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
}
Transaction().setPosition(layer, mDisplayWidth, mDisplayHeight).apply();
{
SCOPED_TRACE("positive coordinates");
getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetPositionPartiallyOutOfBounds_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// partially out of bounds
Transaction().setPosition(layer, -30, -30).apply();
{
SCOPED_TRACE("negative coordinates");
getScreenCapture()->expectColor(Rect(0, 0, 2, 2), Color::RED);
}
Transaction().setPosition(layer, mDisplayWidth - 2, mDisplayHeight - 2).apply();
{
SCOPED_TRACE("positive coordinates");
getScreenCapture()->expectColor(Rect(mDisplayWidth - 2, mDisplayHeight - 2, mDisplayWidth,
mDisplayHeight),
Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetPositionWithResize_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setPosition is applied immediately by default, with or without resize
// pending
Transaction().setPosition(layer, 5, 10).setSize(layer, 64, 64).apply();
{
SCOPED_TRACE("resize pending");
auto shot = getScreenCapture();
const Rect rect(5, 10, 37, 42);
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 64, 64));
{
SCOPED_TRACE("resize applied");
getScreenCapture()->expectColor(Rect(5, 10, 69, 74), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetPositionWithNextResize_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// request setPosition to be applied with the next resize
Transaction().setPosition(layer, 5, 10).setGeometryAppliesWithResize(layer).apply();
{
SCOPED_TRACE("new position pending");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setPosition(layer, 15, 20).apply();
{
SCOPED_TRACE("pending new position modified");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setSize(layer, 64, 64).apply();
{
SCOPED_TRACE("resize pending");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
// finally resize and latch the buffer
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 64, 64));
{
SCOPED_TRACE("new position applied");
getScreenCapture()->expectColor(Rect(15, 20, 79, 84), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetPositionWithNextResizeScaleToWindow_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setPosition is not immediate even with SCALE_TO_WINDOW override
Transaction()
.setPosition(layer, 5, 10)
.setSize(layer, 64, 64)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.setGeometryAppliesWithResize(layer)
.apply();
{
SCOPED_TRACE("new position pending");
getScreenCapture()->expectColor(Rect(0, 0, 64, 64), Color::RED);
}
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 64, 64));
{
SCOPED_TRACE("new position applied");
getScreenCapture()->expectColor(Rect(5, 10, 69, 74), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetSizeBasic_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
Transaction().setSize(layer, 64, 64).apply();
{
SCOPED_TRACE("resize pending");
auto shot = getScreenCapture();
const Rect rect(0, 0, 32, 32);
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 64, 64));
{
SCOPED_TRACE("resize applied");
auto shot = getScreenCapture();
const Rect rect(0, 0, 64, 64);
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetSizeInvalid) {
// cannot test robustness against invalid sizes (zero or really huge)
}
TEST_P(LayerRenderTypeTransactionTest, SetSizeWithScaleToWindow_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setSize is immediate with SCALE_TO_WINDOW, unlike setPosition
Transaction()
.setSize(layer, 64, 64)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.apply();
getScreenCapture()->expectColor(Rect(0, 0, 64, 64), Color::RED);
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetZBasic) {
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerR, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerG, Color::GREEN, 32, 32));
Transaction().setLayer(layerR, mLayerZBase + 1).apply();
{
SCOPED_TRACE("layerR");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setLayer(layerG, mLayerZBase + 2).apply();
{
SCOPED_TRACE("layerG");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::GREEN);
}
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetZNegative) {
sp<SurfaceControl> parent =
LayerTransactionTest::createLayer("Parent", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceContainer);
Transaction().setCrop_legacy(parent, Rect(0, 0, mDisplayWidth, mDisplayHeight)).apply();
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerR, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerG, Color::GREEN, 32, 32));
Transaction()
.reparent(layerR, parent->getHandle())
.reparent(layerG, parent->getHandle())
.apply();
Transaction().setLayer(layerR, -1).setLayer(layerG, -2).apply();
{
SCOPED_TRACE("layerR");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setLayer(layerR, -3).apply();
{
SCOPED_TRACE("layerG");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::GREEN);
}
}
void LayerRenderTypeTransactionTest::setRelativeZBasicHelper(uint32_t layerType) {
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerR, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerG, Color::GREEN, 32, 32));
switch (layerType) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Transaction()
.setPosition(layerG, 16, 16)
.setRelativeLayer(layerG, layerR->getHandle(), 1)
.apply();
break;
case ISurfaceComposerClient::eFXSurfaceBufferState:
Transaction()
.setFrame(layerR, Rect(0, 0, 32, 32))
.setFrame(layerG, Rect(16, 16, 48, 48))
.setRelativeLayer(layerG, layerR->getHandle(), 1)
.apply();
break;
default:
ASSERT_FALSE(true) << "Unsupported layer type";
}
{
SCOPED_TRACE("layerG above");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
shot->expectColor(Rect(16, 16, 48, 48), Color::GREEN);
}
Transaction().setRelativeLayer(layerG, layerR->getHandle(), -1).apply();
{
SCOPED_TRACE("layerG below");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
shot->expectColor(Rect(32, 32, 48, 48), Color::GREEN);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetRelativeZBasic_BufferQueue) {
ASSERT_NO_FATAL_FAILURE(setRelativeZBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
}
TEST_P(LayerRenderTypeTransactionTest, SetRelativeZBasic_BufferState) {
ASSERT_NO_FATAL_FAILURE(setRelativeZBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
}
TEST_P(LayerTypeTransactionTest, SetRelativeZNegative) {
sp<SurfaceControl> parent =
LayerTransactionTest::createLayer("Parent", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceContainer);
Transaction().setCrop_legacy(parent, Rect(0, 0, mDisplayWidth, mDisplayHeight)).apply();
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
sp<SurfaceControl> layerB;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerR, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerG, Color::GREEN, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerB = createLayer("test B", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerB, Color::BLUE, 32, 32));
Transaction()
.reparent(layerB, parent->getHandle())
.apply();
// layerR = mLayerZBase, layerG = layerR - 1, layerB = -2
Transaction().setRelativeLayer(layerG, layerR->getHandle(), -1).setLayer(layerB, -2).apply();
std::unique_ptr<ScreenCapture> screenshot;
// only layerB is in this range
sp<IBinder> parentHandle = parent->getHandle();
ScreenCapture::captureLayers(&screenshot, parentHandle, Rect(0, 0, 32, 32));
screenshot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
}
TEST_P(LayerTypeTransactionTest, SetLayerAndRelative) {
sp<SurfaceControl> parent =
LayerTransactionTest::createLayer("Parent", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor);
sp<SurfaceControl> childLayer;
ASSERT_NO_FATAL_FAILURE(
childLayer = LayerTransactionTest::createLayer("childLayer", 0 /* buffer width */,
0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor,
parent.get()));
Transaction()
.setColor(childLayer, half3{1.0f, 0.0f, 0.0f})
.setColor(parent, half3{0.0f, 0.0f, 0.0f})
.show(childLayer)
.show(parent)
.setCrop_legacy(parent, Rect(0, 0, mDisplayWidth, mDisplayHeight))
.setCrop_legacy(childLayer, Rect(0, 0, 20, 30))
.apply();
Transaction()
.setRelativeLayer(childLayer, parent->getHandle(), -1)
.setLayer(childLayer, 1)
.apply();
{
SCOPED_TRACE("setLayer above");
// Set layer should get applied and place the child above.
std::unique_ptr<ScreenCapture> screenshot;
ScreenCapture::captureScreen(&screenshot);
screenshot->expectColor(Rect(0, 0, 20, 30), Color::RED);
}
Transaction()
.setLayer(childLayer, 1)
.setRelativeLayer(childLayer, parent->getHandle(), -1)
.apply();
{
SCOPED_TRACE("setRelative below");
// Set relative layer should get applied and place the child below.
std::unique_ptr<ScreenCapture> screenshot;
ScreenCapture::captureScreen(&screenshot);
screenshot->expectColor(Rect(0, 0, 20, 30), Color::BLACK);
}
}
TEST_P(LayerTypeTransactionTest, HideRelativeParentHidesLayer) {
sp<SurfaceControl> parent =
LayerTransactionTest::createLayer("Parent", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor);
sp<SurfaceControl> relativeParent =
LayerTransactionTest::createLayer("RelativeParent", 0 /* buffer width */,
0 /* buffer height */, ISurfaceComposerClient::eFXSurfaceColor);
sp<SurfaceControl> childLayer;
ASSERT_NO_FATAL_FAILURE(
childLayer = LayerTransactionTest::createLayer("childLayer", 0 /* buffer width */,
0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor,
parent.get()));
Transaction()
.setColor(childLayer, half3{1.0f, 0.0f, 0.0f})
.setColor(parent, half3{0.0f, 0.0f, 0.0f})
.setColor(relativeParent, half3{0.0f, 1.0f, 0.0f})
.show(childLayer)
.show(parent)
.show(relativeParent)
.setLayer(parent, mLayerZBase - 1)
.setLayer(relativeParent, mLayerZBase)
.apply();
Transaction()
.setRelativeLayer(childLayer, relativeParent->getHandle(), 1)
.apply();
{
SCOPED_TRACE("setLayer above");
// Set layer should get applied and place the child above.
std::unique_ptr<ScreenCapture> screenshot;
ScreenCapture::captureScreen(&screenshot);
screenshot->expectColor(Rect(0, 0, 20, 30), Color::RED);
}
Transaction()
.hide(relativeParent)
.apply();
{
SCOPED_TRACE("hide relative parent");
// The relative should no longer be visible.
std::unique_ptr<ScreenCapture> screenshot;
ScreenCapture::captureScreen(&screenshot);
screenshot->expectColor(Rect(0, 0, 20, 30), Color::BLACK);
}
}
void LayerRenderTypeTransactionTest::setRelativeZGroupHelper(uint32_t layerType) {
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
sp<SurfaceControl> layerB;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerR, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerG, Color::GREEN, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerB = createLayer("test", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layerB, Color::BLUE, 32, 32));
// layerR = 0, layerG = layerR + 3, layerB = 2
switch (layerType) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Transaction()
.setPosition(layerG, 8, 8)
.setRelativeLayer(layerG, layerR->getHandle(), 3)
.setPosition(layerB, 16, 16)
.setLayer(layerB, mLayerZBase + 2)
.apply();
break;
case ISurfaceComposerClient::eFXSurfaceBufferState:
Transaction()
.setFrame(layerR, Rect(0, 0, 32, 32))
.setFrame(layerG, Rect(8, 8, 40, 40))
.setRelativeLayer(layerG, layerR->getHandle(), 3)
.setFrame(layerB, Rect(16, 16, 48, 48))
.setLayer(layerB, mLayerZBase + 2)
.apply();
break;
default:
ASSERT_FALSE(true) << "Unsupported layer type";
}
{
SCOPED_TRACE("(layerR < layerG) < layerB");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
shot->expectColor(Rect(8, 8, 16, 16), Color::GREEN);
shot->expectColor(Rect(16, 16, 48, 48), Color::BLUE);
}
// layerR = 4, layerG = layerR + 3, layerB = 2
Transaction().setLayer(layerR, mLayerZBase + 4).apply();
{
SCOPED_TRACE("layerB < (layerR < layerG)");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 8, 8), Color::RED);
shot->expectColor(Rect(8, 8, 40, 40), Color::GREEN);
shot->expectColor(Rect(40, 40, 48, 48), Color::BLUE);
}
// layerR = 4, layerG = layerR - 3, layerB = 2
Transaction().setRelativeLayer(layerG, layerR->getHandle(), -3).apply();
{
SCOPED_TRACE("layerB < (layerG < layerR)");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
shot->expectColor(Rect(32, 32, 40, 40), Color::GREEN);
shot->expectColor(Rect(40, 40, 48, 48), Color::BLUE);
}
// restore to absolute z
// layerR = 4, layerG = 0, layerB = 2
Transaction().setLayer(layerG, mLayerZBase).apply();
{
SCOPED_TRACE("layerG < layerB < layerR");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
shot->expectColor(Rect(32, 32, 48, 48), Color::BLUE);
}
// layerR should not affect layerG anymore
// layerR = 1, layerG = 0, layerB = 2
Transaction().setLayer(layerR, mLayerZBase + 1).apply();
{
SCOPED_TRACE("layerG < layerR < layerB");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
shot->expectColor(Rect(16, 16, 48, 48), Color::BLUE);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetRelativeZGroup_BufferQueue) {
ASSERT_NO_FATAL_FAILURE(setRelativeZGroupHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
}
TEST_P(LayerRenderTypeTransactionTest, SetRelativeZGroup_BufferState) {
ASSERT_NO_FATAL_FAILURE(setRelativeZGroupHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetRelativeZBug64572777) {
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerR, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerG, Color::GREEN, 32, 32));
Transaction()
.setPosition(layerG, 16, 16)
.setRelativeLayer(layerG, layerR->getHandle(), 1)
.apply();
layerG.clear();
// layerG should have been removed
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetFlagsHidden) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED, 32, 32));
Transaction().setFlags(layer, layer_state_t::eLayerHidden, layer_state_t::eLayerHidden).apply();
{
SCOPED_TRACE("layer hidden");
getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
}
Transaction().setFlags(layer, 0, layer_state_t::eLayerHidden).apply();
{
SCOPED_TRACE("layer shown");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetFlagsOpaque) {
const Color translucentRed = {100, 0, 0, 100};
sp<SurfaceControl> layerR;
sp<SurfaceControl> layerG;
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerR, translucentRed, 32, 32));
ASSERT_NO_FATAL_FAILURE(layerG = createLayer("test G", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerG, Color::GREEN, 32, 32));
Transaction()
.setLayer(layerR, mLayerZBase + 1)
.setFlags(layerR, layer_state_t::eLayerOpaque, layer_state_t::eLayerOpaque)
.apply();
{
SCOPED_TRACE("layerR opaque");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {100, 0, 0, 255});
}
Transaction().setFlags(layerR, 0, layer_state_t::eLayerOpaque).apply();
{
SCOPED_TRACE("layerR translucent");
const uint8_t g = uint8_t(255 - translucentRed.a);
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {100, g, 0, 255});
}
}
TEST_P(LayerTypeTransactionTest, SetFlagsSecure) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED, 32, 32));
sp<ISurfaceComposer> composer = ComposerService::getComposerService();
sp<GraphicBuffer> outBuffer;
Transaction()
.setFlags(layer, layer_state_t::eLayerSecure, layer_state_t::eLayerSecure)
.apply(true);
ASSERT_EQ(PERMISSION_DENIED,
composer->captureScreen(mDisplay, &outBuffer, Rect(), 0, 0, false));
Transaction().setFlags(layer, 0, layer_state_t::eLayerSecure).apply(true);
ASSERT_EQ(NO_ERROR,
composer->captureScreen(mDisplay, &outBuffer, Rect(), 0, 0, false));
}
/** RAII Wrapper around get/seteuid */
class UIDFaker {
uid_t oldId;
public:
UIDFaker(uid_t uid) {
oldId = geteuid();
seteuid(uid);
}
~UIDFaker() {
seteuid(oldId);
}
};
TEST_F(LayerTransactionTest, SetFlagsSecureEUidSystem) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
sp<ISurfaceComposer> composer = ComposerService::getComposerService();
sp<GraphicBuffer> outBuffer;
Transaction()
.setFlags(layer, layer_state_t::eLayerSecure, layer_state_t::eLayerSecure)
.apply(true);
ASSERT_EQ(PERMISSION_DENIED,
composer->captureScreen(mDisplay, &outBuffer, Rect(), 0, 0, false));
UIDFaker f(AID_SYSTEM);
// By default the system can capture screenshots with secure layers but they
// will be blacked out
ASSERT_EQ(NO_ERROR,
composer->captureScreen(mDisplay, &outBuffer, Rect(), 0, 0, false));
{
SCOPED_TRACE("as system");
auto shot = screenshot();
shot->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
// Here we pass captureSecureLayers = true and since we are AID_SYSTEM we should be able
// to receive them...we are expected to take care with the results.
bool outCapturedSecureLayers;
ASSERT_EQ(NO_ERROR,
composer->captureScreen(mDisplay, &outBuffer, outCapturedSecureLayers,
ui::Dataspace::V0_SRGB, ui::PixelFormat::RGBA_8888, Rect(), 0,
0, false, ISurfaceComposer::eRotateNone, true));
ASSERT_EQ(true, outCapturedSecureLayers);
ScreenCapture sc(outBuffer);
sc.expectColor(Rect(0, 0, 32, 32), Color::RED);
}
TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintBasic_BufferQueue) {
const Rect top(0, 0, 32, 16);
const Rect bottom(0, 16, 32, 32);
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ANativeWindow_Buffer buffer;
ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
ASSERT_NO_FATAL_FAILURE(fillANativeWindowBufferColor(buffer, top, Color::TRANSPARENT));
ASSERT_NO_FATAL_FAILURE(fillANativeWindowBufferColor(buffer, bottom, Color::RED));
// setTransparentRegionHint always applies to the following buffer
Transaction().setTransparentRegionHint(layer, Region(top)).apply();
ASSERT_NO_FATAL_FAILURE(postBufferQueueLayerBuffer(layer));
{
SCOPED_TRACE("top transparent");
auto shot = getScreenCapture();
shot->expectColor(top, Color::BLACK);
shot->expectColor(bottom, Color::RED);
}
Transaction().setTransparentRegionHint(layer, Region(bottom)).apply();
{
SCOPED_TRACE("transparent region hint pending");
auto shot = getScreenCapture();
shot->expectColor(top, Color::BLACK);
shot->expectColor(bottom, Color::RED);
}
ASSERT_NO_FATAL_FAILURE(buffer = getBufferQueueLayerBuffer(layer));
ASSERT_NO_FATAL_FAILURE(fillANativeWindowBufferColor(buffer, top, Color::RED));
ASSERT_NO_FATAL_FAILURE(fillANativeWindowBufferColor(buffer, bottom, Color::TRANSPARENT));
ASSERT_NO_FATAL_FAILURE(postBufferQueueLayerBuffer(layer));
{
SCOPED_TRACE("bottom transparent");
auto shot = getScreenCapture();
shot->expectColor(top, Color::RED);
shot->expectColor(bottom, Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintBasic_BufferState) {
const Rect top(0, 0, 32, 16);
const Rect bottom(0, 16, 32, 32);
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
ASSERT_NO_FATAL_FAILURE(fillGraphicBufferColor(buffer, top, Color::TRANSPARENT));
ASSERT_NO_FATAL_FAILURE(fillGraphicBufferColor(buffer, bottom, Color::RED));
Transaction()
.setTransparentRegionHint(layer, Region(top))
.setBuffer(layer, buffer)
.setFrame(layer, Rect(0, 0, 32, 32))
.apply();
{
SCOPED_TRACE("top transparent");
auto shot = getScreenCapture();
shot->expectColor(top, Color::BLACK);
shot->expectColor(bottom, Color::RED);
}
Transaction().setTransparentRegionHint(layer, Region(bottom)).apply();
{
SCOPED_TRACE("transparent region hint intermediate");
auto shot = getScreenCapture();
shot->expectColor(top, Color::BLACK);
shot->expectColor(bottom, Color::BLACK);
}
buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
ASSERT_NO_FATAL_FAILURE(fillGraphicBufferColor(buffer, top, Color::RED));
ASSERT_NO_FATAL_FAILURE(fillGraphicBufferColor(buffer, bottom, Color::TRANSPARENT));
Transaction().setBuffer(layer, buffer).apply();
{
SCOPED_TRACE("bottom transparent");
auto shot = getScreenCapture();
shot->expectColor(top, Color::RED);
shot->expectColor(bottom, Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintOutOfBounds_BufferQueue) {
sp<SurfaceControl> layerTransparent;
sp<SurfaceControl> layerR;
ASSERT_NO_FATAL_FAILURE(layerTransparent = createLayer("test transparent", 32, 32));
ASSERT_NO_FATAL_FAILURE(layerR = createLayer("test R", 32, 32));
// check that transparent region hint is bound by the layer size
Transaction()
.setTransparentRegionHint(layerTransparent, Region(mDisplayRect))
.setPosition(layerR, 16, 16)
.setLayer(layerR, mLayerZBase + 1)
.apply();
ASSERT_NO_FATAL_FAILURE(
fillBufferQueueLayerColor(layerTransparent, Color::TRANSPARENT, 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layerR, Color::RED, 32, 32));
getScreenCapture()->expectColor(Rect(16, 16, 48, 48), Color::RED);
}
TEST_P(LayerRenderTypeTransactionTest, SetTransparentRegionHintOutOfBounds_BufferState) {
sp<SurfaceControl> layerTransparent;
sp<SurfaceControl> layerR;
ASSERT_NO_FATAL_FAILURE(layerTransparent = createLayer("test transparent", 32, 32));
ASSERT_NO_FATAL_FAILURE(
layerR = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
// check that transparent region hint is bound by the layer size
Transaction()
.setTransparentRegionHint(layerTransparent, Region(mDisplayRect))
.setFrame(layerR, Rect(16, 16, 48, 48))
.setLayer(layerR, mLayerZBase + 1)
.apply();
ASSERT_NO_FATAL_FAILURE(
fillBufferQueueLayerColor(layerTransparent, Color::TRANSPARENT, 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layerR, Color::RED, 32, 32));
getScreenCapture()->expectColor(Rect(16, 16, 48, 48), Color::RED);
}
void LayerRenderTypeTransactionTest::setAlphaBasicHelper(uint32_t layerType) {
sp<SurfaceControl> layer1;
sp<SurfaceControl> layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createLayer("test 1", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(layer2 = createLayer("test 2", 32, 32, layerType));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layer1, {64, 0, 0, 255}, 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layerType, layer2, {0, 64, 0, 255}, 32, 32));
switch (layerType) {
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
Transaction()
.setAlpha(layer1, 0.25f)
.setAlpha(layer2, 0.75f)
.setPosition(layer2, 16, 0)
.setLayer(layer2, mLayerZBase + 1)
.apply();
break;
case ISurfaceComposerClient::eFXSurfaceBufferState:
Transaction()
.setAlpha(layer1, 0.25f)
.setAlpha(layer2, 0.75f)
.setFrame(layer1, Rect(0, 0, 32, 32))
.setFrame(layer2, Rect(16, 0, 48, 32))
.setLayer(layer2, mLayerZBase + 1)
.apply();
break;
default:
ASSERT_FALSE(true) << "Unsupported layer type";
}
{
auto shot = getScreenCapture();
uint8_t r = 16; // 64 * 0.25f
uint8_t g = 48; // 64 * 0.75f
shot->expectColor(Rect(0, 0, 16, 32), {r, 0, 0, 255});
shot->expectColor(Rect(32, 0, 48, 32), {0, g, 0, 255});
r /= 4; // r * (1.0f - 0.75f)
shot->expectColor(Rect(16, 0, 32, 32), {r, g, 0, 255});
}
}
TEST_P(LayerRenderTypeTransactionTest, SetAlphaBasic_BufferQueue) {
ASSERT_NO_FATAL_FAILURE(setAlphaBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue));
}
TEST_P(LayerRenderTypeTransactionTest, SetAlphaBasic_BufferState) {
ASSERT_NO_FATAL_FAILURE(setAlphaBasicHelper(ISurfaceComposerClient::eFXSurfaceBufferState));
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetAlphaClamped) {
const Color color = {64, 0, 0, 255};
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, color, 32, 32));
Transaction().setAlpha(layer, 2.0f).apply();
{
SCOPED_TRACE("clamped to 1.0f");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), color);
}
Transaction().setAlpha(layer, -1.0f).apply();
{
SCOPED_TRACE("clamped to 0.0f");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetCornerRadius) {
sp<SurfaceControl> layer;
const uint8_t size = 64;
const uint8_t testArea = 4;
const float cornerRadius = 20.0f;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", size, size));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED, size, size));
Transaction()
.setCornerRadius(layer, cornerRadius)
.apply();
{
const uint8_t bottom = size - 1;
const uint8_t right = size - 1;
auto shot = getScreenCapture();
// Transparent corners
shot->expectColor(Rect(0, 0, testArea, testArea), Color::BLACK);
shot->expectColor(Rect(size - testArea, 0, right, testArea), Color::BLACK);
shot->expectColor(Rect(0, bottom - testArea, testArea, bottom), Color::BLACK);
shot->expectColor(Rect(size - testArea, bottom - testArea, right, bottom), Color::BLACK);
}
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetCornerRadiusChildCrop) {
sp<SurfaceControl> parent;
sp<SurfaceControl> child;
const uint8_t size = 64;
const uint8_t testArea = 4;
const float cornerRadius = 20.0f;
ASSERT_NO_FATAL_FAILURE(parent = createLayer("parent", size, size));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(parent, Color::RED, size, size));
ASSERT_NO_FATAL_FAILURE(child = createLayer("child", size, size / 2));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(child, Color::GREEN, size, size / 2));
Transaction()
.setCornerRadius(parent, cornerRadius)
.reparent(child, parent->getHandle())
.setPosition(child, 0, size / 2)
.apply();
{
const uint8_t bottom = size - 1;
const uint8_t right = size - 1;
auto shot = getScreenCapture();
// Top edge of child should not have rounded corners because it's translated in the parent
shot->expectColor(Rect(0, size / 2, right, static_cast<int>(bottom - cornerRadius)),
Color::GREEN);
// But bottom edges should have been clipped according to parent bounds
shot->expectColor(Rect(0, bottom - testArea, testArea, bottom), Color::BLACK);
shot->expectColor(Rect(right - testArea, bottom - testArea, right, bottom), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetColorBasic) {
sp<SurfaceControl> bufferLayer;
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(colorLayer =
createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor));
Transaction()
.setCrop_legacy(colorLayer, Rect(0, 0, 32, 32))
.setLayer(colorLayer, mLayerZBase + 1)
.apply();
{
SCOPED_TRACE("default color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
const Color expected = {15, 51, 85, 255};
// this is handwavy, but the precison loss scaled by 255 (8-bit per
// channel) should be less than one
const uint8_t tolerance = 1;
Transaction().setColor(colorLayer, color).apply();
{
SCOPED_TRACE("new color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expected, tolerance);
}
}
// RED: Color layer base color and BufferQueueLayer/BufferStateLayer fill
// BLUE: prior background color
// GREEN: final background color
// BLACK: no color or fill
void LayerRenderTypeTransactionTest::setBackgroundColorHelper(uint32_t layerType, bool priorColor,
bool bufferFill, float alpha,
Color finalColor) {
sp<SurfaceControl> layer;
int32_t width = 500;
int32_t height = 500;
Color fillColor = Color::RED;
Color priorBgColor = Color::BLUE;
Color expectedColor = Color::BLACK;
switch (layerType) {
case ISurfaceComposerClient::eFXSurfaceColor:
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 0, 0, layerType));
Transaction()
.setCrop_legacy(layer, Rect(0, 0, width, height))
.setColor(layer, half3(1.0f, 0, 0))
.apply();
expectedColor = fillColor;
break;
case ISurfaceComposerClient::eFXSurfaceBufferQueue:
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", width, height));
if (bufferFill) {
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, fillColor, width, height));
expectedColor = fillColor;
}
Transaction().setCrop_legacy(layer, Rect(0, 0, width, height)).apply();
break;
case ISurfaceComposerClient::eFXSurfaceBufferState:
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", width, height, layerType));
if (bufferFill) {
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, fillColor, width, height));
expectedColor = fillColor;
}
Transaction().setFrame(layer, Rect(0, 0, width, height)).apply();
break;
default:
GTEST_FAIL() << "Unknown layer type in setBackgroundColorHelper";
return;
}
if (priorColor && layerType != ISurfaceComposerClient::eFXSurfaceColor) {
Transaction()
.setBackgroundColor(layer, half3(0, 0, 1.0f), 1.0f, ui::Dataspace::UNKNOWN)
.apply();
if (!bufferFill) {
expectedColor = priorBgColor;
}
}
{
SCOPED_TRACE("default before setting background color layer");
screenshot()->expectColor(Rect(0, 0, width, height), expectedColor);
}
Transaction()
.setBackgroundColor(layer, half3(0, 1.0f, 0), alpha, ui::Dataspace::UNKNOWN)
.apply();
{
auto shot = screenshot();
shot->expectColor(Rect(0, 0, width, height), finalColor);
shot->expectBorder(Rect(0, 0, width, height), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetBackgroundColor_Color_NoEffect) {
bool priorColor = false;
bool bufferFill = false;
float alpha = 1.0f;
Color finalColor = Color::RED;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceColor,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferQueue_BufferFill_NoPriorColor_Basic) {
bool priorColor = false;
bool bufferFill = true;
float alpha = 1.0f;
Color finalColor = Color::RED;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferQueue_NoBufferFill_NoPriorColor_Basic) {
bool priorColor = false;
bool bufferFill = false;
float alpha = 1.0f;
Color finalColor = Color::GREEN;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest, SetBackgroundColor_BufferQueue_BufferFill_PriorColor_Basic) {
bool priorColor = true;
bool bufferFill = true;
float alpha = 1.0f;
Color finalColor = Color::RED;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferQueue_NoBufferFill_PriorColor_Basic) {
bool priorColor = true;
bool bufferFill = false;
float alpha = 1.0f;
Color finalColor = Color::GREEN;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferQueue_NoPriorColor_ZeroAlpha_NoEffect) {
bool priorColor = false;
bool bufferFill = false;
float alpha = 0;
Color finalColor = Color::BLACK;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferQueue_PriorColor_ZeroAlpha_DeleteBackground) {
bool priorColor = true;
bool bufferFill = false;
float alpha = 0;
Color finalColor = Color::BLACK;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferQueue,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferState_BufferFill_NoPriorColor_Basic) {
bool priorColor = false;
bool bufferFill = true;
float alpha = 1.0f;
Color finalColor = Color::RED;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferState_NoBufferFill_NoPriorColor_Basic) {
bool priorColor = false;
bool bufferFill = false;
float alpha = 1.0f;
Color finalColor = Color::GREEN;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferState_NoBufferFill_PriorColor_Basic) {
bool priorColor = true;
bool bufferFill = false;
float alpha = 1.0f;
Color finalColor = Color::GREEN;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferState_NoPriorColor_ZeroAlpha_NoEffect) {
bool priorColor = false;
bool bufferFill = false;
float alpha = 0;
Color finalColor = Color::BLACK;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest,
SetBackgroundColor_BufferState_PriorColor_ZeroAlpha_DeleteBackground) {
bool priorColor = true;
bool bufferFill = false;
float alpha = 0;
Color finalColor = Color::BLACK;
ASSERT_NO_FATAL_FAILURE(setBackgroundColorHelper(ISurfaceComposerClient::eFXSurfaceBufferState,
priorColor, bufferFill, alpha, finalColor));
}
TEST_P(LayerRenderTypeTransactionTest, SetColorClamped) {
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(colorLayer =
createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor));
Transaction()
.setCrop_legacy(colorLayer, Rect(0, 0, 32, 32))
.setColor(colorLayer, half3(2.0f, -1.0f, 0.0f))
.apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
TEST_P(LayerRenderTypeTransactionTest, SetColorWithAlpha) {
sp<SurfaceControl> bufferLayer;
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(colorLayer =
createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor));
Transaction().setCrop_legacy(colorLayer, Rect(0, 0, 32, 32)).apply();
const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
const float alpha = 0.25f;
const ubyte3 expected((vec3(color) * alpha + vec3(1.0f, 0.0f, 0.0f) * (1.0f - alpha)) * 255.0f);
// this is handwavy, but the precison loss scaled by 255 (8-bit per
// channel) should be less than one
const uint8_t tolerance = 1;
Transaction()
.setColor(colorLayer, color)
.setAlpha(colorLayer, alpha)
.setLayer(colorLayer, mLayerZBase + 1)
.apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {expected.r, expected.g, expected.b, 255},
tolerance);
}
TEST_P(LayerRenderTypeTransactionTest, SetColorWithParentAlpha_Bug74220420) {
sp<SurfaceControl> bufferLayer;
sp<SurfaceControl> parentLayer;
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test bg", 32, 32));
ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parentWithAlpha", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(colorLayer = createLayer("childWithColor", 0 /* buffer width */,
0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor));
Transaction().setCrop_legacy(colorLayer, Rect(0, 0, 32, 32)).apply();
const half3 color(15.0f / 255.0f, 51.0f / 255.0f, 85.0f / 255.0f);
const float alpha = 0.25f;
const ubyte3 expected((vec3(color) * alpha + vec3(1.0f, 0.0f, 0.0f) * (1.0f - alpha)) * 255.0f);
// this is handwavy, but the precision loss scaled by 255 (8-bit per
// channel) should be less than one
const uint8_t tolerance = 1;
Transaction()
.reparent(colorLayer, parentLayer->getHandle())
.setColor(colorLayer, color)
.setAlpha(parentLayer, alpha)
.setLayer(parentLayer, mLayerZBase + 1)
.apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), {expected.r, expected.g, expected.b, 255},
tolerance);
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetColorWithBuffer) {
sp<SurfaceControl> bufferLayer;
ASSERT_NO_FATAL_FAILURE(bufferLayer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(bufferLayer, Color::RED, 32, 32));
// color is ignored
Transaction().setColor(bufferLayer, half3(0.0f, 1.0f, 0.0f)).apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
TEST_P(LayerTypeAndRenderTypeTransactionTest, SetLayerStackBasic) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED, 32, 32));
Transaction().setLayerStack(layer, mDisplayLayerStack + 1).apply();
{
SCOPED_TRACE("non-existing layer stack");
getScreenCapture()->expectColor(mDisplayRect, Color::BLACK);
}
Transaction().setLayerStack(layer, mDisplayLayerStack).apply();
{
SCOPED_TRACE("original layer stack");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetMatrixBasic_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, 1.0f).setPosition(layer, 0, 0).apply();
{
SCOPED_TRACE("IDENTITY");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE);
}
Transaction().setMatrix(layer, -1.0f, 0.0f, 0.0f, 1.0f).setPosition(layer, 32, 0).apply();
{
SCOPED_TRACE("FLIP_H");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::GREEN, Color::RED,
Color::WHITE, Color::BLUE);
}
Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, -1.0f).setPosition(layer, 0, 32).apply();
{
SCOPED_TRACE("FLIP_V");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::WHITE,
Color::RED, Color::GREEN);
}
Transaction().setMatrix(layer, 0.0f, 1.0f, -1.0f, 0.0f).setPosition(layer, 32, 0).apply();
{
SCOPED_TRACE("ROT_90");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::RED,
Color::WHITE, Color::GREEN);
}
Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).setPosition(layer, 0, 0).apply();
{
SCOPED_TRACE("SCALE");
getScreenCapture()->expectQuadrant(Rect(0, 0, 64, 64), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE, true /* filtered */);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetMatrixBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
Transaction()
.setMatrix(layer, 1.0f, 0.0f, 0.0f, 1.0f)
.setFrame(layer, Rect(0, 0, 32, 32))
.apply();
{
SCOPED_TRACE("IDENTITY");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE);
}
Transaction().setMatrix(layer, -1.0f, 0.0f, 0.0f, 1.0f).apply();
{
SCOPED_TRACE("FLIP_H");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE);
}
Transaction().setMatrix(layer, 1.0f, 0.0f, 0.0f, -1.0f).apply();
{
SCOPED_TRACE("FLIP_V");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE);
}
Transaction().setMatrix(layer, 0.0f, 1.0f, -1.0f, 0.0f).apply();
{
SCOPED_TRACE("ROT_90");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE);
}
Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).apply();
{
SCOPED_TRACE("SCALE");
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetMatrixRot45_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
const float rot = M_SQRT1_2; // 45 degrees
const float trans = M_SQRT2 * 16.0f;
Transaction().setMatrix(layer, rot, rot, -rot, rot).setPosition(layer, trans, 0).apply();
auto shot = getScreenCapture();
// check a 8x8 region inside each color
auto get8x8Rect = [](int32_t centerX, int32_t centerY) {
const int32_t halfL = 4;
return Rect(centerX - halfL, centerY - halfL, centerX + halfL, centerY + halfL);
};
const int32_t unit = int32_t(trans / 2);
shot->expectColor(get8x8Rect(2 * unit, 1 * unit), Color::RED);
shot->expectColor(get8x8Rect(3 * unit, 2 * unit), Color::GREEN);
shot->expectColor(get8x8Rect(1 * unit, 2 * unit), Color::BLUE);
shot->expectColor(get8x8Rect(2 * unit, 3 * unit), Color::WHITE);
}
TEST_P(LayerRenderTypeTransactionTest, SetMatrixWithResize_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setMatrix is applied after any pending resize, unlike setPosition
Transaction().setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f).setSize(layer, 64, 64).apply();
{
SCOPED_TRACE("resize pending");
auto shot = getScreenCapture();
const Rect rect(0, 0, 32, 32);
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 64, 64));
{
SCOPED_TRACE("resize applied");
const Rect rect(0, 0, 128, 128);
getScreenCapture()->expectColor(rect, Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetMatrixWithScaleToWindow_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setMatrix is immediate with SCALE_TO_WINDOW, unlike setPosition
Transaction()
.setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f)
.setSize(layer, 64, 64)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.apply();
getScreenCapture()->expectColor(Rect(0, 0, 128, 128), Color::RED);
}
TEST_P(LayerRenderTypeTransactionTest, SetOverrideScalingModeBasic_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
// XXX SCALE_CROP is not respected; calling setSize and
// setOverrideScalingMode in separate transactions does not work
// (b/69315456)
Transaction()
.setSize(layer, 64, 16)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.apply();
{
SCOPED_TRACE("SCALE_TO_WINDOW");
getScreenCapture()->expectQuadrant(Rect(0, 0, 64, 16), Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE, true /* filtered */);
}
}
TEST_P(LayerTypeTransactionTest, RefreshRateIsInitialized) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
sp<IBinder> handle = layer->getHandle();
ASSERT_TRUE(handle != nullptr);
FrameStats frameStats;
mClient->getLayerFrameStats(handle, &frameStats);
ASSERT_GT(frameStats.refreshPeriodNano, static_cast<nsecs_t>(0));
}
TEST_P(LayerRenderTypeTransactionTest, SetCropBasic_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
const Rect crop(8, 8, 24, 24);
Transaction().setCrop_legacy(layer, crop).apply();
auto shot = getScreenCapture();
shot->expectColor(crop, Color::RED);
shot->expectBorder(crop, Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetCropBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
const Rect crop(8, 8, 24, 24);
Transaction().setCrop(layer, crop).apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetCropEmpty_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
{
SCOPED_TRACE("empty rect");
Transaction().setCrop_legacy(layer, Rect(8, 8, 8, 8)).apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
{
SCOPED_TRACE("negative rect");
Transaction().setCrop_legacy(layer, Rect(8, 8, 0, 0)).apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetCropEmpty_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
{
SCOPED_TRACE("empty rect");
Transaction().setCrop(layer, Rect(8, 8, 8, 8)).apply();
getScreenCapture()->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
}
{
SCOPED_TRACE("negative rect");
Transaction().setCrop(layer, Rect(8, 8, 0, 0)).apply();
getScreenCapture()->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetCropOutOfBounds_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
Transaction().setCrop_legacy(layer, Rect(-128, -64, 128, 64)).apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetCropOutOfBounds_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 64, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 64, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 16), Color::BLUE);
fillGraphicBufferColor(buffer, Rect(0, 16, 32, 64), Color::RED);
Transaction().setFrame(layer, Rect(0, 0, 64, 64)).apply();
Transaction().setBuffer(layer, buffer).apply();
// Partially out of bounds in the negative (upper left) direction
Transaction().setCrop(layer, Rect(-128, -128, 32, 16)).apply();
{
SCOPED_TRACE("out of bounds, negative (upper left) direction");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 64, 64), Color::BLUE);
shot->expectBorder(Rect(0, 0, 64, 64), Color::BLACK);
}
// Partially out of bounds in the positive (lower right) direction
Transaction().setCrop(layer, Rect(0, 16, 128, 128)).apply();
{
SCOPED_TRACE("out of bounds, positive (lower right) direction");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 64, 64), Color::RED);
shot->expectBorder(Rect(0, 0, 64, 64), Color::BLACK);
}
// Fully out of buffer space bounds
Transaction().setCrop(layer, Rect(-128, -128, -1, -1)).apply();
{
SCOPED_TRACE("Fully out of bounds");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 64, 16), Color::BLUE);
shot->expectColor(Rect(0, 16, 64, 64), Color::RED);
shot->expectBorder(Rect(0, 0, 64, 64), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetCropWithTranslation_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
const Point position(32, 32);
const Rect crop(8, 8, 24, 24);
Transaction().setPosition(layer, position.x, position.y).setCrop_legacy(layer, crop).apply();
auto shot = getScreenCapture();
shot->expectColor(crop + position, Color::RED);
shot->expectBorder(crop + position, Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetCropWithTranslation_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
const Rect frame(32, 32, 64, 64);
const Rect crop(8, 8, 24, 24);
Transaction().setFrame(layer, frame).setCrop(layer, crop).apply();
auto shot = getScreenCapture();
shot->expectColor(frame, Color::RED);
shot->expectBorder(frame, Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetCropWithScale_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// crop_legacy is affected by matrix
Transaction()
.setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f)
.setCrop_legacy(layer, Rect(8, 8, 24, 24))
.apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
shot->expectBorder(Rect(16, 16, 48, 48), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetCropWithResize_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setCrop_legacy is applied immediately by default, with or without resize pending
Transaction().setCrop_legacy(layer, Rect(8, 8, 24, 24)).setSize(layer, 16, 16).apply();
{
SCOPED_TRACE("resize pending");
auto shot = getScreenCapture();
shot->expectColor(Rect(8, 8, 24, 24), Color::RED);
shot->expectBorder(Rect(8, 8, 24, 24), Color::BLACK);
}
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 16, 16));
{
SCOPED_TRACE("resize applied");
auto shot = getScreenCapture();
shot->expectColor(Rect(8, 8, 16, 16), Color::RED);
shot->expectBorder(Rect(8, 8, 16, 16), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetCropWithNextResize_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// request setCrop_legacy to be applied with the next resize
Transaction()
.setCrop_legacy(layer, Rect(8, 8, 24, 24))
.setGeometryAppliesWithResize(layer)
.apply();
{
SCOPED_TRACE("waiting for next resize");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setCrop_legacy(layer, Rect(4, 4, 12, 12)).apply();
{
SCOPED_TRACE("pending crop modified");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
Transaction().setSize(layer, 16, 16).apply();
{
SCOPED_TRACE("resize pending");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
// finally resize
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 16, 16));
{
SCOPED_TRACE("new crop applied");
auto shot = getScreenCapture();
shot->expectColor(Rect(4, 4, 12, 12), Color::RED);
shot->expectBorder(Rect(4, 4, 12, 12), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetCropWithNextResizeScaleToWindow_BufferQueue) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
// setCrop_legacy is not immediate even with SCALE_TO_WINDOW override
Transaction()
.setCrop_legacy(layer, Rect(4, 4, 12, 12))
.setSize(layer, 16, 16)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.setGeometryAppliesWithResize(layer)
.apply();
{
SCOPED_TRACE("new crop pending");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 16, 16), Color::RED);
shot->expectBorder(Rect(0, 0, 16, 16), Color::BLACK);
}
// XXX crop is never latched without other geometry change (b/69315677)
Transaction().setPosition(layer, 1, 0).setGeometryAppliesWithResize(layer).apply();
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 16, 16));
Transaction().setPosition(layer, 0, 0).apply();
{
SCOPED_TRACE("new crop applied");
auto shot = getScreenCapture();
shot->expectColor(Rect(4, 4, 12, 12), Color::RED);
shot->expectBorder(Rect(4, 4, 12, 12), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
const Rect frame(8, 8, 24, 24);
Transaction().setFrame(layer, frame).apply();
auto shot = getScreenCapture();
shot->expectColor(frame, Color::RED);
shot->expectBorder(frame, Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameEmpty_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
{
SCOPED_TRACE("empty rect");
Transaction().setFrame(layer, Rect(8, 8, 8, 8)).apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
{
SCOPED_TRACE("negative rect");
Transaction().setFrame(layer, Rect(8, 8, 0, 0)).apply();
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultParentless_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 10, 10));
// A parentless layer will default to a frame with the same size as the buffer
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultBSParent_BufferState) {
sp<SurfaceControl> parent, child;
ASSERT_NO_FATAL_FAILURE(
parent = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(parent, Color::RED, 32, 32));
Transaction().setFrame(parent, Rect(0, 0, 32, 32)).apply();
ASSERT_NO_FATAL_FAILURE(
child = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(child, Color::BLUE, 10, 10));
Transaction().reparent(child, parent->getHandle()).apply();
// A layer will default to the frame of its parent
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameDefaultBQParent_BufferState) {
sp<SurfaceControl> parent, child;
ASSERT_NO_FATAL_FAILURE(parent = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(parent, Color::RED, 32, 32));
ASSERT_NO_FATAL_FAILURE(
child = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(child, Color::BLUE, 10, 10));
Transaction().reparent(child, parent->getHandle()).apply();
// A layer will default to the frame of its parent
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameUpdate_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
Transaction().setFrame(layer, Rect(0, 0, 32, 32)).apply();
std::this_thread::sleep_for(500ms);
Transaction().setFrame(layer, Rect(16, 16, 48, 48)).apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
shot->expectBorder(Rect(16, 16, 48, 48), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetFrameOutsideBounds_BufferState) {
sp<SurfaceControl> parent, child;
ASSERT_NO_FATAL_FAILURE(
parent = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(
child = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
Transaction().reparent(child, parent->getHandle()).apply();
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(parent, Color::RED, 32, 32));
Transaction().setFrame(parent, Rect(0, 0, 32, 32)).apply();
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(child, Color::BLUE, 10, 10));
Transaction().setFrame(child, Rect(0, 16, 32, 32)).apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 16), Color::RED);
shot->expectColor(Rect(0, 16, 32, 32), Color::BLUE);
shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetBufferBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetBufferMultipleBuffers_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
{
SCOPED_TRACE("set buffer 1");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::BLUE, 32, 32));
{
SCOPED_TRACE("set buffer 2");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLUE);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::RED, 32, 32));
{
SCOPED_TRACE("set buffer 3");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetBufferMultipleLayers_BufferState) {
sp<SurfaceControl> layer1;
ASSERT_NO_FATAL_FAILURE(
layer1 = createLayer("test", 64, 64, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<SurfaceControl> layer2;
ASSERT_NO_FATAL_FAILURE(
layer2 = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer1, Color::RED, 64, 64));
Transaction().setFrame(layer1, Rect(0, 0, 64, 64)).apply();
{
SCOPED_TRACE("set layer 1 buffer red");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 64, 64), Color::RED);
}
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer2, Color::BLUE, 32, 32));
Transaction().setFrame(layer2, Rect(0, 0, 32, 32)).apply();
{
SCOPED_TRACE("set layer 2 buffer blue");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
shot->expectColor(Rect(0, 32, 64, 64), Color::RED);
shot->expectColor(Rect(0, 32, 32, 64), Color::RED);
}
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer1, Color::GREEN, 64, 64));
{
SCOPED_TRACE("set layer 1 buffer green");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::BLUE);
shot->expectColor(Rect(0, 32, 64, 64), Color::GREEN);
shot->expectColor(Rect(0, 32, 32, 64), Color::GREEN);
}
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer2, Color::WHITE, 32, 32));
{
SCOPED_TRACE("set layer 2 buffer white");
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, 32, 32), Color::WHITE);
shot->expectColor(Rect(0, 32, 64, 64), Color::GREEN);
shot->expectColor(Rect(0, 32, 32, 64), Color::GREEN);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
std::array<sp<GraphicBuffer>, 10> buffers;
size_t idx = 0;
for (auto& buffer : buffers) {
buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
Color color = colors[idx % colors.size()];
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
idx++;
}
// Set each buffer twice. The first time adds it to the cache, the second time tests that the
// cache is working.
idx = 0;
for (auto& buffer : buffers) {
for (int i = 0; i < 2; i++) {
Transaction().setBuffer(layer, buffer).apply();
Color color = colors[idx % colors.size()];
auto shot = screenshot();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), color);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
idx++;
}
}
TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_LeastRecentlyUsed_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
std::array<sp<GraphicBuffer>, 70> buffers;
size_t idx = 0;
for (auto& buffer : buffers) {
buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
Color color = colors[idx % colors.size()];
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
idx++;
}
// Set each buffer twice. The first time adds it to the cache, the second time tests that the
// cache is working.
idx = 0;
for (auto& buffer : buffers) {
for (int i = 0; i < 2; i++) {
Transaction().setBuffer(layer, buffer).apply();
Color color = colors[idx % colors.size()];
auto shot = screenshot();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), color);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
idx++;
}
}
TEST_P(LayerRenderTypeTransactionTest, SetBufferCaching_DestroyedBuffer_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
std::array<Color, 4> colors = {Color::RED, Color::BLUE, Color::WHITE, Color::GREEN};
std::array<sp<GraphicBuffer>, 65> buffers;
size_t idx = 0;
for (auto& buffer : buffers) {
buffer = new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
Color color = colors[idx % colors.size()];
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), color);
idx++;
}
// Set each buffer twice. The first time adds it to the cache, the second time tests that the
// cache is working.
idx = 0;
for (auto& buffer : buffers) {
for (int i = 0; i < 2; i++) {
Transaction().setBuffer(layer, buffer).apply();
Color color = colors[idx % colors.size()];
auto shot = screenshot();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), color);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
if (idx == 0) {
buffers[0].clear();
}
idx++;
}
}
TEST_P(LayerRenderTypeTransactionTest, SetTransformRotate90_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
Transaction()
.setFrame(layer, Rect(0, 0, 32, 32))
.setTransform(layer, NATIVE_WINDOW_TRANSFORM_ROT_90)
.apply();
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::RED, Color::WHITE,
Color::GREEN, true /* filtered */);
}
TEST_P(LayerRenderTypeTransactionTest, SetTransformFlipH_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
Transaction()
.setFrame(layer, Rect(0, 0, 32, 32))
.setTransform(layer, NATIVE_WINDOW_TRANSFORM_FLIP_H)
.apply();
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::GREEN, Color::RED, Color::WHITE,
Color::BLUE, true /* filtered */);
}
TEST_P(LayerRenderTypeTransactionTest, SetTransformFlipV_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerQuadrant(layer, 32, 32, Color::RED, Color::GREEN,
Color::BLUE, Color::WHITE));
Transaction()
.setFrame(layer, Rect(0, 0, 32, 32))
.setTransform(layer, NATIVE_WINDOW_TRANSFORM_FLIP_V)
.apply();
getScreenCapture()->expectQuadrant(Rect(0, 0, 32, 32), Color::BLUE, Color::WHITE, Color::RED,
Color::GREEN, true /* filtered */);
}
TEST_F(LayerTransactionTest, SetTransformToDisplayInverse_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
Transaction().setTransformToDisplayInverse(layer, false).apply();
ASSERT_NO_FATAL_FAILURE(fillBufferStateLayerColor(layer, Color::GREEN, 32, 32));
Transaction().setTransformToDisplayInverse(layer, true).apply();
}
TEST_P(LayerRenderTypeTransactionTest, SetFenceBasic_BufferState) {
sp<SurfaceControl> layer;
Transaction transaction;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
sp<Fence> fence;
if (getBuffer(nullptr, &fence) != NO_ERROR) {
GTEST_SUCCEED() << "test not supported";
return;
}
Transaction().setBuffer(layer, buffer).setAcquireFence(layer, fence).apply();
status_t status = fence->wait(1000);
ASSERT_NE(static_cast<status_t>(Fence::Status::Unsignaled), status);
std::this_thread::sleep_for(200ms);
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetFenceNull_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
sp<Fence> fence = Fence::NO_FENCE;
Transaction()
.setBuffer(layer, buffer)
.setAcquireFence(layer, fence)
.apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetDataspaceBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
Transaction()
.setBuffer(layer, buffer)
.setDataspace(layer, ui::Dataspace::UNKNOWN)
.apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetHdrMetadataBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
HdrMetadata hdrMetadata;
hdrMetadata.validTypes = 0;
Transaction()
.setBuffer(layer, buffer)
.setHdrMetadata(layer, hdrMetadata)
.apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetSurfaceDamageRegionBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
Region region;
region.set(32, 32);
Transaction()
.setBuffer(layer, buffer)
.setSurfaceDamageRegion(layer, region)
.apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_P(LayerRenderTypeTransactionTest, SetApiBasic_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
sp<GraphicBuffer> buffer =
new GraphicBuffer(32, 32, PIXEL_FORMAT_RGBA_8888, 1,
BufferUsage::CPU_READ_OFTEN | BufferUsage::CPU_WRITE_OFTEN |
BufferUsage::COMPOSER_OVERLAY,
"test");
fillGraphicBufferColor(buffer, Rect(0, 0, 32, 32), Color::RED);
Transaction()
.setBuffer(layer, buffer)
.setApi(layer, NATIVE_WINDOW_API_CPU)
.apply();
auto shot = getScreenCapture();
shot->expectColor(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::RED);
shot->expectBorder(Rect(0, 0, mDisplayWidth, mDisplayHeight), Color::BLACK);
}
TEST_F(LayerTransactionTest, SetSidebandStreamNull_BufferState) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(
layer = createLayer("test", 32, 32, ISurfaceComposerClient::eFXSurfaceBufferState));
// verify this doesn't cause a crash
Transaction().setSidebandStream(layer, nullptr).apply();
}
TEST_F(LayerTransactionTest, ReparentToSelf) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(layer, Color::RED, 32, 32));
Transaction().reparent(layer, layer->getHandle()).apply();
{
// We expect the transaction to be silently dropped, but for SurfaceFlinger
// to still be functioning.
SCOPED_TRACE("after reparent to self");
const Rect rect(0, 0, 32, 32);
auto shot = screenshot();
shot->expectColor(rect, Color::RED);
shot->expectBorder(rect, Color::BLACK);
}
}
class ColorTransformHelper {
public:
static void DegammaColorSingle(half& s) {
if (s <= 0.03928f)
s = s / 12.92f;
else
s = pow((s + 0.055f) / 1.055f, 2.4f);
}
static void DegammaColor(half3& color) {
DegammaColorSingle(color.r);
DegammaColorSingle(color.g);
DegammaColorSingle(color.b);
}
static void GammaColorSingle(half& s) {
if (s <= 0.0031308f) {
s = s * 12.92f;
} else {
s = 1.055f * pow(s, (1.0f / 2.4f)) - 0.055f;
}
}
static void GammaColor(half3& color) {
GammaColorSingle(color.r);
GammaColorSingle(color.g);
GammaColorSingle(color.b);
}
static void applyMatrix(half3& color, const mat3& mat) {
half3 ret = half3(0);
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
ret[i] = ret[i] + color[j] * mat[j][i];
}
}
color = ret;
}
};
TEST_P(LayerRenderTypeTransactionTest, SetColorTransformBasic) {
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(colorLayer =
createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor));
Transaction()
.setCrop_legacy(colorLayer, Rect(0, 0, 32, 32))
.setLayer(colorLayer, mLayerZBase + 1)
.apply();
{
SCOPED_TRACE("default color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
half3 expected = color;
mat3 matrix;
matrix[0][0] = 0.3; matrix[1][0] = 0.59; matrix[2][0] = 0.11;
matrix[0][1] = 0.3; matrix[1][1] = 0.59; matrix[2][1] = 0.11;
matrix[0][2] = 0.3; matrix[1][2] = 0.59; matrix[2][2] = 0.11;
// degamma before applying the matrix
if (mColorManagementUsed) {
ColorTransformHelper::DegammaColor(expected);
}
ColorTransformHelper::applyMatrix(expected, matrix);
if (mColorManagementUsed) {
ColorTransformHelper::GammaColor(expected);
}
const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
uint8_t(expected.b * 255), 255};
// this is handwavy, but the precison loss scaled by 255 (8-bit per
// channel) should be less than one
const uint8_t tolerance = 1;
Transaction().setColor(colorLayer, color)
.setColorTransform(colorLayer, matrix, vec3()).apply();
{
SCOPED_TRACE("new color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetColorTransformOnParent) {
sp<SurfaceControl> parentLayer;
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parent", 0 /* buffer width */,
0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceContainer));
ASSERT_NO_FATAL_FAILURE(
colorLayer = createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor, parentLayer.get()));
Transaction()
.setCrop_legacy(parentLayer, Rect(0, 0, 100, 100))
.setCrop_legacy(colorLayer, Rect(0, 0, 32, 32))
.setLayer(parentLayer, mLayerZBase + 1)
.apply();
{
SCOPED_TRACE("default color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
half3 expected = color;
mat3 matrix;
matrix[0][0] = 0.3; matrix[1][0] = 0.59; matrix[2][0] = 0.11;
matrix[0][1] = 0.3; matrix[1][1] = 0.59; matrix[2][1] = 0.11;
matrix[0][2] = 0.3; matrix[1][2] = 0.59; matrix[2][2] = 0.11;
// degamma before applying the matrix
if (mColorManagementUsed) {
ColorTransformHelper::DegammaColor(expected);
}
ColorTransformHelper::applyMatrix(expected, matrix);
if (mColorManagementUsed) {
ColorTransformHelper::GammaColor(expected);
}
const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
uint8_t(expected.b * 255), 255};
// this is handwavy, but the precison loss scaled by 255 (8-bit per
// channel) should be less than one
const uint8_t tolerance = 1;
Transaction()
.setColor(colorLayer, color)
.setColorTransform(parentLayer, matrix, vec3())
.apply();
{
SCOPED_TRACE("new color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
}
}
TEST_P(LayerRenderTypeTransactionTest, SetColorTransformOnChildAndParent) {
sp<SurfaceControl> parentLayer;
sp<SurfaceControl> colorLayer;
ASSERT_NO_FATAL_FAILURE(parentLayer = createLayer("parent", 0 /* buffer width */,
0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceContainer));
ASSERT_NO_FATAL_FAILURE(
colorLayer = createLayer("test", 0 /* buffer width */, 0 /* buffer height */,
ISurfaceComposerClient::eFXSurfaceColor, parentLayer.get()));
Transaction()
.setCrop_legacy(parentLayer, Rect(0, 0, 100, 100))
.setCrop_legacy(colorLayer, Rect(0, 0, 32, 32))
.setLayer(parentLayer, mLayerZBase + 1)
.apply();
{
SCOPED_TRACE("default color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), Color::BLACK);
}
const half3 color(50.0f / 255.0f, 100.0f / 255.0f, 150.0f / 255.0f);
half3 expected = color;
mat3 matrixChild;
matrixChild[0][0] = 0.3; matrixChild[1][0] = 0.59; matrixChild[2][0] = 0.11;
matrixChild[0][1] = 0.3; matrixChild[1][1] = 0.59; matrixChild[2][1] = 0.11;
matrixChild[0][2] = 0.3; matrixChild[1][2] = 0.59; matrixChild[2][2] = 0.11;
mat3 matrixParent;
matrixParent[0][0] = 0.2; matrixParent[1][0] = 0.4; matrixParent[2][0] = 0.10;
matrixParent[0][1] = 0.2; matrixParent[1][1] = 0.4; matrixParent[2][1] = 0.10;
matrixParent[0][2] = 0.2; matrixParent[1][2] = 0.4; matrixParent[2][2] = 0.10;
// degamma before applying the matrix
if (mColorManagementUsed) {
ColorTransformHelper::DegammaColor(expected);
}
ColorTransformHelper::applyMatrix(expected, matrixChild);
ColorTransformHelper::applyMatrix(expected, matrixParent);
if (mColorManagementUsed) {
ColorTransformHelper::GammaColor(expected);
}
const Color expectedColor = {uint8_t(expected.r * 255), uint8_t(expected.g * 255),
uint8_t(expected.b * 255), 255};
// this is handwavy, but the precison loss scaled by 255 (8-bit per
// channel) should be less than one
const uint8_t tolerance = 1;
Transaction()
.setColor(colorLayer, color)
.setColorTransform(parentLayer, matrixParent, vec3())
.setColorTransform(colorLayer, matrixChild, vec3())
.apply();
{
SCOPED_TRACE("new color");
getScreenCapture()->expectColor(Rect(0, 0, 32, 32), expectedColor, tolerance);
}
}
struct CallbackData {
CallbackData() = default;
CallbackData(nsecs_t time, const sp<Fence>& fence,
const std::vector<SurfaceControlStats>& stats)
: latchTime(time), presentFence(fence), surfaceControlStats(stats) {}
nsecs_t latchTime;
sp<Fence> presentFence;
std::vector<SurfaceControlStats> surfaceControlStats;
};
class ExpectedResult {
public:
enum Transaction {
NOT_PRESENTED = 0,
PRESENTED,
};
enum Buffer {
NOT_ACQUIRED = 0,
ACQUIRED,
};
enum PreviousBuffer {
NOT_RELEASED = 0,
RELEASED,
UNKNOWN,
};
void reset() {
mTransactionResult = ExpectedResult::Transaction::NOT_PRESENTED;
mExpectedSurfaceResults.clear();
}
void addSurface(ExpectedResult::Transaction transactionResult, const sp<SurfaceControl>& layer,
ExpectedResult::Buffer bufferResult = ACQUIRED,
ExpectedResult::PreviousBuffer previousBufferResult = NOT_RELEASED) {
mTransactionResult = transactionResult;
mExpectedSurfaceResults.emplace(std::piecewise_construct, std::forward_as_tuple(layer),
std::forward_as_tuple(bufferResult, previousBufferResult));
}
void addSurfaces(ExpectedResult::Transaction transactionResult,
const std::vector<sp<SurfaceControl>>& layers,
ExpectedResult::Buffer bufferResult = ACQUIRED,
ExpectedResult::PreviousBuffer previousBufferResult = NOT_RELEASED) {
for (const auto& layer : layers) {
addSurface(transactionResult, layer, bufferResult, previousBufferResult);
}
}
void addExpectedPresentTime(nsecs_t expectedPresentTime) {
mExpectedPresentTime = expectedPresentTime;
}
void verifyCallbackData(const CallbackData& callbackData) const {
const auto& [latchTime, presentFence, surfaceControlStats] = callbackData;
if (mTransactionResult == ExpectedResult::Transaction::PRESENTED) {
ASSERT_GE(latchTime, 0) << "bad latch time";
ASSERT_NE(presentFence, nullptr);
if (mExpectedPresentTime >= 0) {
ASSERT_EQ(presentFence->wait(3000), NO_ERROR);
ASSERT_GE(presentFence->getSignalTime(), mExpectedPresentTime - nsecs_t(5 * 1e6));
// if the panel is running at 30 hz, at the worst case, our expected time just
// misses vsync and we have to wait another 33.3ms
ASSERT_LE(presentFence->getSignalTime(),
mExpectedPresentTime + nsecs_t(66.666666 * 1e6));
}
} else {
ASSERT_EQ(presentFence, nullptr) << "transaction shouldn't have been presented";
ASSERT_EQ(latchTime, -1) << "unpresented transactions shouldn't be latched";
}
ASSERT_EQ(surfaceControlStats.size(), mExpectedSurfaceResults.size())
<< "wrong number of surfaces";
for (const auto& stats : surfaceControlStats) {
ASSERT_NE(stats.surfaceControl, nullptr) << "returned null surface control";
const auto& expectedSurfaceResult = mExpectedSurfaceResults.find(stats.surfaceControl);
ASSERT_NE(expectedSurfaceResult, mExpectedSurfaceResults.end())
<< "unexpected surface control";
expectedSurfaceResult->second.verifySurfaceControlStats(stats, latchTime);
}
}
private:
class ExpectedSurfaceResult {
public:
ExpectedSurfaceResult(ExpectedResult::Buffer bufferResult,
ExpectedResult::PreviousBuffer previousBufferResult)
: mBufferResult(bufferResult), mPreviousBufferResult(previousBufferResult) {}
void verifySurfaceControlStats(const SurfaceControlStats& surfaceControlStats,
nsecs_t latchTime) const {
const auto& [surfaceControl, acquireTime, previousReleaseFence] = surfaceControlStats;
ASSERT_EQ(acquireTime > 0, mBufferResult == ExpectedResult::Buffer::ACQUIRED)
<< "bad acquire time";
ASSERT_LE(acquireTime, latchTime) << "acquire time should be <= latch time";
if (mPreviousBufferResult == ExpectedResult::PreviousBuffer::RELEASED) {
ASSERT_NE(previousReleaseFence, nullptr)
<< "failed to set release prev buffer fence";
} else if (mPreviousBufferResult == ExpectedResult::PreviousBuffer::NOT_RELEASED) {
ASSERT_EQ(previousReleaseFence, nullptr)
<< "should not have set released prev buffer fence";
}
}
private:
ExpectedResult::Buffer mBufferResult;
ExpectedResult::PreviousBuffer mPreviousBufferResult;
};
struct SCHash {
std::size_t operator()(const sp<SurfaceControl>& sc) const {
return std::hash<IBinder*>{}(sc->getHandle().get());
}
};
ExpectedResult::Transaction mTransactionResult = ExpectedResult::Transaction::NOT_PRESENTED;
nsecs_t mExpectedPresentTime = -1;
std::unordered_map<sp<SurfaceControl>, ExpectedSurfaceResult, SCHash> mExpectedSurfaceResults;
};
class CallbackHelper {
public:
static void function(void* callbackContext, nsecs_t latchTime, const sp<Fence>& presentFence,
const std::vector<SurfaceControlStats>& stats) {
if (!callbackContext) {
ALOGE("failed to get callback context");
}
CallbackHelper* helper = static_cast<CallbackHelper*>(callbackContext);
std::lock_guard lock(helper->mMutex);
helper->mCallbackDataQueue.emplace(latchTime, presentFence, stats);
helper->mConditionVariable.notify_all();
}
void getCallbackData(CallbackData* outData) {
std::unique_lock lock(mMutex);
if (mCallbackDataQueue.empty()) {
ASSERT_NE(mConditionVariable.wait_for(lock, std::chrono::seconds(3)),
std::cv_status::timeout)
<< "did not receive callback";
}
*outData = std::move(mCallbackDataQueue.front());
mCallbackDataQueue.pop();
}
void verifyFinalState() {
// Wait to see if there are extra callbacks
std::this_thread::sleep_for(500ms);
std::lock_guard lock(mMutex);
EXPECT_EQ(mCallbackDataQueue.size(), 0) << "extra callbacks received";
mCallbackDataQueue = {};
}
void* getContext() { return static_cast<void*>(this); }
std::mutex mMutex;
std::condition_variable mConditionVariable;
std::queue<CallbackData> mCallbackDataQueue;
};
class LayerCallbackTest : public LayerTransactionTest {
public:
virtual sp<SurfaceControl> createBufferStateLayer() {
return createLayer(mClient, "test", 0, 0, ISurfaceComposerClient::eFXSurfaceBufferState);
}
static int fillTransaction(Transaction& transaction, CallbackHelper* callbackHelper,
const sp<SurfaceControl>& layer = nullptr, bool setBuffer = true,
bool setBackgroundColor = false) {
if (layer) {
sp<GraphicBuffer> buffer;
sp<Fence> fence;
if (setBuffer) {
int err = getBuffer(&buffer, &fence);
if (err != NO_ERROR) {
return err;
}
transaction.setBuffer(layer, buffer);
transaction.setAcquireFence(layer, fence);
}
if (setBackgroundColor) {
transaction.setBackgroundColor(layer, /*color*/ half3(1.0f, 0, 0), /*alpha*/ 1.0f,
ui::Dataspace::UNKNOWN);
}
}
transaction.addTransactionCompletedCallback(callbackHelper->function,
callbackHelper->getContext());
return NO_ERROR;
}
static void waitForCallback(CallbackHelper& helper, const ExpectedResult& expectedResult,
bool finalState = false) {
CallbackData callbackData;
ASSERT_NO_FATAL_FAILURE(helper.getCallbackData(&callbackData));
EXPECT_NO_FATAL_FAILURE(expectedResult.verifyCallbackData(callbackData));
if (finalState) {
ASSERT_NO_FATAL_FAILURE(helper.verifyFinalState());
}
}
static void waitForCallbacks(CallbackHelper& helper,
const std::vector<ExpectedResult>& expectedResults,
bool finalState = false) {
for (const auto& expectedResult : expectedResults) {
waitForCallback(helper, expectedResult);
}
if (finalState) {
ASSERT_NO_FATAL_FAILURE(helper.verifyFinalState());
}
}
};
TEST_F(LayerCallbackTest, BufferColor) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer, true, true);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, NoBufferNoColor) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer, false, false);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.setFrame(layer, Rect(0, 0, 32, 32)).apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::NOT_PRESENTED, layer,
ExpectedResult::Buffer::NOT_ACQUIRED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, BufferNoColor) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer, true, false);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.setFrame(layer, Rect(0, 0, 32, 32)).apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, NoBufferColor) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer, false, true);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.setFrame(layer, Rect(0, 0, 32, 32)).apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer,
ExpectedResult::Buffer::NOT_ACQUIRED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, NoStateChange) {
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.apply();
ExpectedResult expected;
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, OffScreen) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.setFrame(layer, Rect(-100, -100, 100, 100)).apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, MergeBufferNoColor) {
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createBufferStateLayer());
ASSERT_NO_FATAL_FAILURE(layer2 = createBufferStateLayer());
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2});
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, MergeNoBufferColor) {
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createBufferStateLayer());
ASSERT_NO_FATAL_FAILURE(layer2 = createBufferStateLayer());
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
int err = fillTransaction(transaction1, &callback1, layer1, false, true);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2, false, true);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2},
ExpectedResult::Buffer::NOT_ACQUIRED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, MergeOneBufferOneColor) {
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createBufferStateLayer());
ASSERT_NO_FATAL_FAILURE(layer2 = createBufferStateLayer());
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2, false, true);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer1);
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer2,
ExpectedResult::Buffer::NOT_ACQUIRED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, Merge_SameCallback) {
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createBufferStateLayer());
ASSERT_NO_FATAL_FAILURE(layer2 = createBufferStateLayer());
Transaction transaction1, transaction2;
CallbackHelper callback;
int err = fillTransaction(transaction1, &callback, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction2.merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2});
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, Merge_SameLayer) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
int err = fillTransaction(transaction1, &callback1, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction2.merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, Merge_DifferentClients) {
sp<SurfaceComposerClient> client1(new SurfaceComposerClient),
client2(new SurfaceComposerClient);
ASSERT_EQ(NO_ERROR, client1->initCheck()) << "failed to create SurfaceComposerClient";
ASSERT_EQ(NO_ERROR, client2->initCheck()) << "failed to create SurfaceComposerClient";
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createLayer(client1, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(layer2 = createLayer(client2, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2});
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, MultipleTransactions) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
for (size_t i = 0; i < 10; i++) {
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer,
ExpectedResult::Buffer::ACQUIRED,
(i == 0) ? ExpectedResult::PreviousBuffer::NOT_RELEASED
: ExpectedResult::PreviousBuffer::RELEASED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected));
}
ASSERT_NO_FATAL_FAILURE(callback.verifyFinalState());
}
TEST_F(LayerCallbackTest, MultipleTransactions_NoStateChange) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
for (size_t i = 0; i < 10; i++) {
ExpectedResult expected;
if (i == 0) {
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
} else {
int err = fillTransaction(transaction, &callback);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
}
transaction.apply();
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected));
}
ASSERT_NO_FATAL_FAILURE(callback.verifyFinalState());
}
TEST_F(LayerCallbackTest, MultipleTransactions_SameStateChange) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
for (size_t i = 0; i < 10; i++) {
if (i == 0) {
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
} else {
int err = fillTransaction(transaction, &callback);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
}
transaction.setFrame(layer, Rect(0, 0, 32, 32)).apply();
ExpectedResult expected;
expected.addSurface((i == 0) ? ExpectedResult::Transaction::PRESENTED
: ExpectedResult::Transaction::NOT_PRESENTED,
layer,
(i == 0) ? ExpectedResult::Buffer::ACQUIRED
: ExpectedResult::Buffer::NOT_ACQUIRED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, i == 0));
}
ASSERT_NO_FATAL_FAILURE(callback.verifyFinalState());
}
TEST_F(LayerCallbackTest, MultipleTransactions_Merge) {
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createBufferStateLayer());
ASSERT_NO_FATAL_FAILURE(layer2 = createBufferStateLayer());
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
for (size_t i = 0; i < 10; i++) {
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2},
ExpectedResult::Buffer::ACQUIRED,
(i == 0) ? ExpectedResult::PreviousBuffer::NOT_RELEASED
: ExpectedResult::PreviousBuffer::RELEASED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected));
}
ASSERT_NO_FATAL_FAILURE(callback1.verifyFinalState());
ASSERT_NO_FATAL_FAILURE(callback2.verifyFinalState());
}
TEST_F(LayerCallbackTest, MultipleTransactions_Merge_DifferentClients) {
sp<SurfaceComposerClient> client1(new SurfaceComposerClient),
client2(new SurfaceComposerClient);
ASSERT_EQ(NO_ERROR, client1->initCheck()) << "failed to create SurfaceComposerClient";
ASSERT_EQ(NO_ERROR, client2->initCheck()) << "failed to create SurfaceComposerClient";
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createLayer(client1, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(layer2 = createLayer(client2, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
for (size_t i = 0; i < 10; i++) {
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2},
ExpectedResult::Buffer::ACQUIRED,
(i == 0) ? ExpectedResult::PreviousBuffer::NOT_RELEASED
: ExpectedResult::PreviousBuffer::RELEASED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected));
}
ASSERT_NO_FATAL_FAILURE(callback1.verifyFinalState());
ASSERT_NO_FATAL_FAILURE(callback2.verifyFinalState());
}
TEST_F(LayerCallbackTest, MultipleTransactions_Merge_DifferentClients_NoStateChange) {
sp<SurfaceComposerClient> client1(new SurfaceComposerClient),
client2(new SurfaceComposerClient);
ASSERT_EQ(NO_ERROR, client1->initCheck()) << "failed to create SurfaceComposerClient";
ASSERT_EQ(NO_ERROR, client2->initCheck()) << "failed to create SurfaceComposerClient";
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createLayer(client1, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(layer2 = createLayer(client2, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
// Normal call to set up test
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2});
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
expected.reset();
// Test
err = fillTransaction(transaction1, &callback1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction2.merge(std::move(transaction1)).apply();
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, MultipleTransactions_Merge_DifferentClients_SameStateChange) {
sp<SurfaceComposerClient> client1(new SurfaceComposerClient),
client2(new SurfaceComposerClient);
ASSERT_EQ(NO_ERROR, client1->initCheck()) << "failed to create SurfaceComposerClient";
ASSERT_EQ(NO_ERROR, client2->initCheck()) << "failed to create SurfaceComposerClient";
sp<SurfaceControl> layer1, layer2;
ASSERT_NO_FATAL_FAILURE(layer1 = createLayer(client1, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
ASSERT_NO_FATAL_FAILURE(layer2 = createLayer(client2, "test", 0, 0,
ISurfaceComposerClient::eFXSurfaceBufferState));
Transaction transaction1, transaction2;
CallbackHelper callback1, callback2;
// Normal call to set up test
int err = fillTransaction(transaction1, &callback1, layer1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2, layer2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction1.setFrame(layer1, Rect(0, 0, 32, 32));
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
ExpectedResult expected;
expected.addSurfaces(ExpectedResult::Transaction::PRESENTED, {layer1, layer2});
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
expected.reset();
// Test
err = fillTransaction(transaction1, &callback1);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
err = fillTransaction(transaction2, &callback2);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction2.setFrame(layer2, Rect(32, 32, 64, 64)).merge(std::move(transaction1)).apply();
expected.addSurface(ExpectedResult::Transaction::NOT_PRESENTED, layer2,
ExpectedResult::Buffer::NOT_ACQUIRED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected, true));
}
TEST_F(LayerCallbackTest, MultipleTransactions_SingleFrame) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
std::vector<ExpectedResult> expectedResults(50);
for (auto& expected : expectedResults) {
expected.reset();
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer,
ExpectedResult::Buffer::ACQUIRED,
ExpectedResult::PreviousBuffer::UNKNOWN);
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.apply();
}
EXPECT_NO_FATAL_FAILURE(waitForCallbacks(callback, expectedResults, true));
}
TEST_F(LayerCallbackTest, MultipleTransactions_SingleFrame_NoStateChange) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
// Normal call to set up test
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
// Test
std::vector<ExpectedResult> expectedResults(50);
for (auto& expected : expectedResults) {
expected.reset();
err = fillTransaction(transaction, &callback);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.apply();
}
EXPECT_NO_FATAL_FAILURE(waitForCallbacks(callback, expectedResults, true));
}
TEST_F(LayerCallbackTest, MultipleTransactions_SingleFrame_SameStateChange) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
// Normal call to set up test
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.setFrame(layer, Rect(0, 0, 32, 32)).apply();
ExpectedResult expectedResult;
expectedResult.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expectedResult, true));
// Test
std::vector<ExpectedResult> expectedResults(50);
for (auto& expected : expectedResults) {
expected.reset();
expected.addSurface(ExpectedResult::Transaction::NOT_PRESENTED, layer,
ExpectedResult::Buffer::NOT_ACQUIRED);
err = fillTransaction(transaction, &callback);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
transaction.setFrame(layer, Rect(0, 0, 32, 32)).apply();
}
EXPECT_NO_FATAL_FAILURE(waitForCallbacks(callback, expectedResults, true));
}
TEST_F(LayerCallbackTest, DesiredPresentTime) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
// Try to present 100ms in the future
nsecs_t time = systemTime() + (100 * 1e6);
transaction.setDesiredPresentTime(time);
transaction.apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
expected.addExpectedPresentTime(time);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
TEST_F(LayerCallbackTest, DesiredPresentTime_Multiple) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback1;
int err = fillTransaction(transaction, &callback1, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
// Try to present 100ms in the future
nsecs_t time = systemTime() + (100 * 1e6);
transaction.setDesiredPresentTime(time);
transaction.apply();
ExpectedResult expected1;
expected1.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
expected1.addExpectedPresentTime(time);
CallbackHelper callback2;
err = fillTransaction(transaction, &callback2, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
// Try to present 33ms after the first frame
time += (33.3 * 1e6);
transaction.setDesiredPresentTime(time);
transaction.apply();
ExpectedResult expected2;
expected2.addSurface(ExpectedResult::Transaction::PRESENTED, layer,
ExpectedResult::Buffer::ACQUIRED,
ExpectedResult::PreviousBuffer::RELEASED);
expected2.addExpectedPresentTime(time);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected1, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected2, true));
}
TEST_F(LayerCallbackTest, DesiredPresentTime_OutOfOrder) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback1;
int err = fillTransaction(transaction, &callback1, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
// Try to present 100ms in the future
nsecs_t time = systemTime() + (100 * 1e6);
transaction.setDesiredPresentTime(time);
transaction.apply();
ExpectedResult expected1;
expected1.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
expected1.addExpectedPresentTime(time);
CallbackHelper callback2;
err = fillTransaction(transaction, &callback2, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
// Try to present 33ms before the previous frame
time -= (33.3 * 1e6);
transaction.setDesiredPresentTime(time);
transaction.apply();
ExpectedResult expected2;
expected2.addSurface(ExpectedResult::Transaction::PRESENTED, layer,
ExpectedResult::Buffer::ACQUIRED,
ExpectedResult::PreviousBuffer::RELEASED);
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback1, expected1, true));
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback2, expected2, true));
}
TEST_F(LayerCallbackTest, DesiredPresentTime_Past) {
sp<SurfaceControl> layer;
ASSERT_NO_FATAL_FAILURE(layer = createBufferStateLayer());
Transaction transaction;
CallbackHelper callback;
int err = fillTransaction(transaction, &callback, layer);
if (err) {
GTEST_SUCCEED() << "test not supported";
return;
}
// Try to present 100ms in the past
nsecs_t time = systemTime() - (100 * 1e6);
transaction.setDesiredPresentTime(time);
transaction.apply();
ExpectedResult expected;
expected.addSurface(ExpectedResult::Transaction::PRESENTED, layer);
expected.addExpectedPresentTime(systemTime());
EXPECT_NO_FATAL_FAILURE(waitForCallback(callback, expected, true));
}
class LayerUpdateTest : public LayerTransactionTest {
protected:
virtual void SetUp() {
LayerTransactionTest::SetUp();
ASSERT_EQ(NO_ERROR, mClient->initCheck());
const auto display = SurfaceComposerClient::getInternalDisplayToken();
ASSERT_FALSE(display == nullptr);
DisplayInfo info;
ASSERT_EQ(NO_ERROR, SurfaceComposerClient::getDisplayInfo(display, &info));
ssize_t displayWidth = info.w;
ssize_t displayHeight = info.h;
// Background surface
mBGSurfaceControl = createLayer(String8("BG Test Surface"), displayWidth,
displayHeight, 0);
ASSERT_TRUE(mBGSurfaceControl != nullptr);
ASSERT_TRUE(mBGSurfaceControl->isValid());
fillSurfaceRGBA8(mBGSurfaceControl, 63, 63, 195);
// Foreground surface
mFGSurfaceControl = createLayer(String8("FG Test Surface"), 64, 64, 0);
ASSERT_TRUE(mFGSurfaceControl != nullptr);
ASSERT_TRUE(mFGSurfaceControl->isValid());
fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
// Synchronization surface
mSyncSurfaceControl = createLayer(String8("Sync Test Surface"), 1, 1, 0);
ASSERT_TRUE(mSyncSurfaceControl != nullptr);
ASSERT_TRUE(mSyncSurfaceControl->isValid());
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
asTransaction([&](Transaction& t) {
t.setDisplayLayerStack(display, 0);
t.setLayer(mBGSurfaceControl, INT32_MAX - 2).show(mBGSurfaceControl);
t.setLayer(mFGSurfaceControl, INT32_MAX - 1)
.setPosition(mFGSurfaceControl, 64, 64)
.show(mFGSurfaceControl);
t.setLayer(mSyncSurfaceControl, INT32_MAX - 1)
.setPosition(mSyncSurfaceControl, displayWidth - 2, displayHeight - 2)
.show(mSyncSurfaceControl);
});
}
virtual void TearDown() {
LayerTransactionTest::TearDown();
mBGSurfaceControl = 0;
mFGSurfaceControl = 0;
mSyncSurfaceControl = 0;
}
void waitForPostedBuffers() {
// Since the sync surface is in synchronous mode (i.e. double buffered)
// posting three buffers to it should ensure that at least two
// SurfaceFlinger::handlePageFlip calls have been made, which should
// guaranteed that a buffer posted to another Surface has been retired.
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
}
sp<SurfaceControl> mBGSurfaceControl;
sp<SurfaceControl> mFGSurfaceControl;
// This surface is used to ensure that the buffers posted to
// mFGSurfaceControl have been picked up by SurfaceFlinger.
sp<SurfaceControl> mSyncSurfaceControl;
};
TEST_F(LayerUpdateTest, RelativesAreNotDetached) {
std::unique_ptr<ScreenCapture> sc;
sp<SurfaceControl> relative = createLayer(String8("relativeTestSurface"), 10, 10, 0);
fillSurfaceRGBA8(relative, 10, 10, 10);
waitForPostedBuffers();
Transaction{}
.setRelativeLayer(relative, mFGSurfaceControl->getHandle(), 1)
.setPosition(relative, 64, 64)
.apply();
{
// The relative should be on top of the FG control.
ScreenCapture::captureScreen(&sc);
sc->checkPixel(64, 64, 10, 10, 10);
}
Transaction{}.detachChildren(mFGSurfaceControl).apply();
{
// Nothing should change at this point.
ScreenCapture::captureScreen(&sc);
sc->checkPixel(64, 64, 10, 10, 10);
}
Transaction{}.hide(relative).apply();
{
// Ensure that the relative was actually hidden, rather than
// being left in the detached but visible state.
ScreenCapture::captureScreen(&sc);
sc->expectFGColor(64, 64);
}
}
class GeometryLatchingTest : public LayerUpdateTest {
protected:
void EXPECT_INITIAL_STATE(const char* trace) {
SCOPED_TRACE(trace);
ScreenCapture::captureScreen(&sc);
// We find the leading edge of the FG surface.
sc->expectFGColor(127, 127);
sc->expectBGColor(128, 128);
}
void lockAndFillFGBuffer() { fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63, false); }
void unlockFGBuffer() {
sp<Surface> s = mFGSurfaceControl->getSurface();
ASSERT_EQ(NO_ERROR, s->unlockAndPost());
waitForPostedBuffers();
}
void completeFGResize() {
fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
waitForPostedBuffers();
}
void restoreInitialState() {
asTransaction([&](Transaction& t) {
t.setSize(mFGSurfaceControl, 64, 64);
t.setPosition(mFGSurfaceControl, 64, 64);
t.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 64, 64));
});
EXPECT_INITIAL_STATE("After restoring initial state");
}
std::unique_ptr<ScreenCapture> sc;
};
class CropLatchingTest : public GeometryLatchingTest {
protected:
void EXPECT_CROPPED_STATE(const char* trace) {
SCOPED_TRACE(trace);
ScreenCapture::captureScreen(&sc);
// The edge should be moved back one pixel by our crop.
sc->expectFGColor(126, 126);
sc->expectBGColor(127, 127);
sc->expectBGColor(128, 128);
}
void EXPECT_RESIZE_STATE(const char* trace) {
SCOPED_TRACE(trace);
ScreenCapture::captureScreen(&sc);
// The FG is now resized too 128,128 at 64,64
sc->expectFGColor(64, 64);
sc->expectFGColor(191, 191);
sc->expectBGColor(192, 192);
}
};
TEST_F(LayerUpdateTest, DeferredTransactionTest) {
std::unique_ptr<ScreenCapture> sc;
{
SCOPED_TRACE("before anything");
ScreenCapture::captureScreen(&sc);
sc->expectBGColor(32, 32);
sc->expectFGColor(96, 96);
sc->expectBGColor(160, 160);
}
// set up two deferred transactions on different frames
asTransaction([&](Transaction& t) {
t.setAlpha(mFGSurfaceControl, 0.75);
t.deferTransactionUntil_legacy(mFGSurfaceControl, mSyncSurfaceControl->getHandle(),
mSyncSurfaceControl->getSurface()->getNextFrameNumber());
});
asTransaction([&](Transaction& t) {
t.setPosition(mFGSurfaceControl, 128, 128);
t.deferTransactionUntil_legacy(mFGSurfaceControl, mSyncSurfaceControl->getHandle(),
mSyncSurfaceControl->getSurface()->getNextFrameNumber() + 1);
});
{
SCOPED_TRACE("before any trigger");
ScreenCapture::captureScreen(&sc);
sc->expectBGColor(32, 32);
sc->expectFGColor(96, 96);
sc->expectBGColor(160, 160);
}
// should trigger the first deferred transaction, but not the second one
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
{
SCOPED_TRACE("after first trigger");
ScreenCapture::captureScreen(&sc);
sc->expectBGColor(32, 32);
sc->checkPixel(96, 96, 162, 63, 96);
sc->expectBGColor(160, 160);
}
// should show up immediately since it's not deferred
asTransaction([&](Transaction& t) { t.setAlpha(mFGSurfaceControl, 1.0); });
// trigger the second deferred transaction
fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31);
{
SCOPED_TRACE("after second trigger");
ScreenCapture::captureScreen(&sc);
sc->expectBGColor(32, 32);
sc->expectBGColor(96, 96);
sc->expectFGColor(160, 160);
}
}
TEST_F(LayerUpdateTest, LayerWithNoBuffersResizesImmediately) {
std::unique_ptr<ScreenCapture> sc;
sp<SurfaceControl> childNoBuffer =
createSurface(mClient, "Bufferless child", 0 /* buffer width */, 0 /* buffer height */,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
sp<SurfaceControl> childBuffer = createSurface(mClient, "Buffered child", 20, 20,
PIXEL_FORMAT_RGBA_8888, 0, childNoBuffer.get());
fillSurfaceRGBA8(childBuffer, 200, 200, 200);
SurfaceComposerClient::Transaction{}
.setCrop_legacy(childNoBuffer, Rect(0, 0, 10, 10))
.show(childNoBuffer)
.show(childBuffer)
.apply(true);
{
ScreenCapture::captureScreen(&sc);
sc->expectChildColor(73, 73);
sc->expectFGColor(74, 74);
}
SurfaceComposerClient::Transaction{}
.setCrop_legacy(childNoBuffer, Rect(0, 0, 20, 20))
.apply(true);
{
ScreenCapture::captureScreen(&sc);
sc->expectChildColor(73, 73);
sc->expectChildColor(74, 74);
}
}
TEST_F(LayerUpdateTest, MergingTransactions) {
std::unique_ptr<ScreenCapture> sc;
{
SCOPED_TRACE("before move");
ScreenCapture::captureScreen(&sc);
sc->expectBGColor(0, 12);
sc->expectFGColor(75, 75);
sc->expectBGColor(145, 145);
}
Transaction t1, t2;
t1.setPosition(mFGSurfaceControl, 128, 128);
t2.setPosition(mFGSurfaceControl, 0, 0);
// We expect that the position update from t2 now
// overwrites the position update from t1.
t1.merge(std::move(t2));
t1.apply();
{
ScreenCapture::captureScreen(&sc);
sc->expectFGColor(1, 1);
}
}
class ChildLayerTest : public LayerUpdateTest {
protected:
void SetUp() override {
LayerUpdateTest::SetUp();
mChild = createSurface(mClient, "Child surface", 10, 15, PIXEL_FORMAT_RGBA_8888, 0,
mFGSurfaceControl.get());
fillSurfaceRGBA8(mChild, 200, 200, 200);
{
SCOPED_TRACE("before anything");
mCapture = screenshot();
mCapture->expectChildColor(64, 64);
}
}
void TearDown() override {
LayerUpdateTest::TearDown();
mChild = 0;
}
sp<SurfaceControl> mChild;
std::unique_ptr<ScreenCapture> mCapture;
};
TEST_F(ChildLayerTest, ChildLayerPositioning) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 10, 10);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
asTransaction([&](Transaction& t) { t.setPosition(mFGSurfaceControl, 0, 0); });
{
mCapture = screenshot();
// Top left of foreground should now be at 0, 0
mCapture->expectFGColor(0, 0);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(10, 10);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(20, 20);
}
}
TEST_F(ChildLayerTest, ChildLayerCropping) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
t.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 5, 5));
});
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(4, 4);
mCapture->expectBGColor(5, 5);
}
}
TEST_F(ChildLayerTest, ChildLayerConstraints) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mFGSurfaceControl, 0, 0);
t.setPosition(mChild, 63, 63);
});
{
mCapture = screenshot();
mCapture->expectFGColor(0, 0);
// Last pixel in foreground should now be the child.
mCapture->expectChildColor(63, 63);
// But the child should be constrained and the next pixel
// must be the background
mCapture->expectBGColor(64, 64);
}
}
TEST_F(ChildLayerTest, ChildLayerScaling) {
asTransaction([&](Transaction& t) { t.setPosition(mFGSurfaceControl, 0, 0); });
// Find the boundary between the parent and child
{
mCapture = screenshot();
mCapture->expectChildColor(9, 9);
mCapture->expectFGColor(10, 10);
}
asTransaction([&](Transaction& t) { t.setMatrix(mFGSurfaceControl, 2.0, 0, 0, 2.0); });
// The boundary should be twice as far from the origin now.
// The pixels from the last test should all be child now
{
mCapture = screenshot();
mCapture->expectChildColor(9, 9);
mCapture->expectChildColor(10, 10);
mCapture->expectChildColor(19, 19);
mCapture->expectFGColor(20, 20);
}
}
// A child with a scale transform should be cropped by its parent bounds.
TEST_F(ChildLayerTest, ChildLayerScalingCroppedByParent) {
asTransaction([&](Transaction& t) {
t.setPosition(mFGSurfaceControl, 0, 0);
t.setPosition(mChild, 0, 0);
});
// Find the boundary between the parent and child.
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(9, 9);
mCapture->expectFGColor(10, 10);
}
asTransaction([&](Transaction& t) { t.setMatrix(mChild, 10.0, 0, 0, 10.0); });
// The child should fill its parent bounds and be cropped by it.
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(63, 63);
mCapture->expectBGColor(64, 64);
}
}
TEST_F(ChildLayerTest, ChildLayerAlpha) {
fillSurfaceRGBA8(mBGSurfaceControl, 0, 0, 254);
fillSurfaceRGBA8(mFGSurfaceControl, 254, 0, 0);
fillSurfaceRGBA8(mChild, 0, 254, 0);
waitForPostedBuffers();
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
});
{
mCapture = screenshot();
// Unblended child color
mCapture->checkPixel(0, 0, 0, 254, 0);
}
asTransaction([&](Transaction& t) { t.setAlpha(mChild, 0.5); });
{
mCapture = screenshot();
// Child and BG blended.
mCapture->checkPixel(0, 0, 127, 127, 0);
}
asTransaction([&](Transaction& t) { t.setAlpha(mFGSurfaceControl, 0.5); });
{
mCapture = screenshot();
// Child and BG blended.
mCapture->checkPixel(0, 0, 95, 64, 95);
}
}
TEST_F(ChildLayerTest, ReparentChildren) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 10, 10);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
asTransaction([&](Transaction& t) {
t.reparentChildren(mFGSurfaceControl, mBGSurfaceControl->getHandle());
});
{
mCapture = screenshot();
mCapture->expectFGColor(64, 64);
// In reparenting we should have exposed the entire foreground surface.
mCapture->expectFGColor(74, 74);
// And the child layer should now begin at 10, 10 (since the BG
// layer is at (0, 0)).
mCapture->expectBGColor(9, 9);
mCapture->expectChildColor(10, 10);
}
}
TEST_F(ChildLayerTest, ChildrenSurviveParentDestruction) {
sp<SurfaceControl> mGrandChild =
createSurface(mClient, "Grand Child", 10, 10, PIXEL_FORMAT_RGBA_8888, 0, mChild.get());
fillSurfaceRGBA8(mGrandChild, 111, 111, 111);
{
SCOPED_TRACE("Grandchild visible");
ScreenCapture::captureScreen(&mCapture);
mCapture->checkPixel(64, 64, 111, 111, 111);
}
mChild.clear();
{
SCOPED_TRACE("After destroying child");
ScreenCapture::captureScreen(&mCapture);
mCapture->expectFGColor(64, 64);
}
asTransaction([&](Transaction& t) {
t.reparent(mGrandChild, mFGSurfaceControl->getHandle());
});
{
SCOPED_TRACE("After reparenting grandchild");
ScreenCapture::captureScreen(&mCapture);
mCapture->checkPixel(64, 64, 111, 111, 111);
}
}
TEST_F(ChildLayerTest, DetachChildrenSameClient) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 10, 10);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
asTransaction([&](Transaction& t) { t.detachChildren(mFGSurfaceControl); });
asTransaction([&](Transaction& t) { t.hide(mChild); });
// Since the child has the same client as the parent, it will not get
// detached and will be hidden.
{
mCapture = screenshot();
mCapture->expectFGColor(64, 64);
mCapture->expectFGColor(74, 74);
mCapture->expectFGColor(84, 84);
}
}
TEST_F(ChildLayerTest, DetachChildrenDifferentClient) {
sp<SurfaceComposerClient> mNewComposerClient = new SurfaceComposerClient;
sp<SurfaceControl> mChildNewClient =
createSurface(mNewComposerClient, "New Child Test Surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
ASSERT_TRUE(mChildNewClient->isValid());
fillSurfaceRGBA8(mChildNewClient, 200, 200, 200);
asTransaction([&](Transaction& t) {
t.hide(mChild);
t.show(mChildNewClient);
t.setPosition(mChildNewClient, 10, 10);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
asTransaction([&](Transaction& t) { t.detachChildren(mFGSurfaceControl); });
asTransaction([&](Transaction& t) { t.hide(mChildNewClient); });
// Nothing should have changed.
{
mCapture = screenshot();
mCapture->expectFGColor(64, 64);
mCapture->expectChildColor(74, 74);
mCapture->expectFGColor(84, 84);
}
}
TEST_F(ChildLayerTest, DetachChildrenThenAttach) {
sp<SurfaceComposerClient> newComposerClient = new SurfaceComposerClient;
sp<SurfaceControl> childNewClient =
newComposerClient->createSurface(String8("New Child Test Surface"), 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
ASSERT_TRUE(childNewClient != nullptr);
ASSERT_TRUE(childNewClient->isValid());
fillSurfaceRGBA8(childNewClient, 200, 200, 200);
Transaction()
.hide(mChild)
.show(childNewClient)
.setPosition(childNewClient, 10, 10)
.setPosition(mFGSurfaceControl, 64, 64)
.apply();
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
Transaction().detachChildren(mFGSurfaceControl).apply();
Transaction().hide(childNewClient).apply();
// Nothing should have changed.
{
mCapture = screenshot();
mCapture->expectFGColor(64, 64);
mCapture->expectChildColor(74, 74);
mCapture->expectFGColor(84, 84);
}
sp<SurfaceControl> newParentSurface = createLayer(String8("New Parent Surface"), 32, 32, 0);
fillLayerColor(ISurfaceComposerClient::eFXSurfaceBufferQueue, newParentSurface, Color::RED, 32,
32);
Transaction()
.setLayer(newParentSurface, INT32_MAX - 1)
.show(newParentSurface)
.setPosition(newParentSurface, 20, 20)
.reparent(childNewClient, newParentSurface->getHandle())
.apply();
{
mCapture = screenshot();
// Child is now hidden.
mCapture->expectColor(Rect(20, 20, 52, 52), Color::RED);
}
}
TEST_F(ChildLayerTest, DetachChildrenWithDeferredTransaction) {
sp<SurfaceComposerClient> newComposerClient = new SurfaceComposerClient;
sp<SurfaceControl> childNewClient =
newComposerClient->createSurface(String8("New Child Test Surface"), 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
ASSERT_TRUE(childNewClient != nullptr);
ASSERT_TRUE(childNewClient->isValid());
fillSurfaceRGBA8(childNewClient, 200, 200, 200);
Transaction()
.hide(mChild)
.show(childNewClient)
.setPosition(childNewClient, 10, 10)
.setPosition(mFGSurfaceControl, 64, 64)
.apply();
{
mCapture = screenshot();
Rect rect = Rect(74, 74, 84, 84);
mCapture->expectBorder(rect, Color{195, 63, 63, 255});
mCapture->expectColor(rect, Color{200, 200, 200, 255});
}
Transaction()
.deferTransactionUntil_legacy(childNewClient, mFGSurfaceControl->getHandle(),
mFGSurfaceControl->getSurface()->getNextFrameNumber())
.apply();
Transaction().detachChildren(mFGSurfaceControl).apply();
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(mFGSurfaceControl, Color::RED, 32, 32));
// BufferLayer can still dequeue buffers even though there's a detached layer with a
// deferred transaction.
{
SCOPED_TRACE("new buffer");
mCapture = screenshot();
Rect rect = Rect(74, 74, 84, 84);
mCapture->expectBorder(rect, Color::RED);
mCapture->expectColor(rect, Color{200, 200, 200, 255});
}
}
TEST_F(ChildLayerTest, ChildrenInheritNonTransformScalingFromParent) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
});
{
mCapture = screenshot();
// We've positioned the child in the top left.
mCapture->expectChildColor(0, 0);
// But it's only 10x15.
mCapture->expectFGColor(10, 15);
}
asTransaction([&](Transaction& t) {
t.setOverrideScalingMode(mFGSurfaceControl, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
// We cause scaling by 2.
t.setSize(mFGSurfaceControl, 128, 128);
});
{
mCapture = screenshot();
// We've positioned the child in the top left.
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(10, 10);
mCapture->expectChildColor(19, 29);
// And now it should be scaled all the way to 20x30
mCapture->expectFGColor(20, 30);
}
}
// Regression test for b/37673612
TEST_F(ChildLayerTest, ChildrenWithParentBufferTransform) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
});
{
mCapture = screenshot();
// We've positioned the child in the top left.
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(9, 14);
// But it's only 10x15.
mCapture->expectFGColor(10, 15);
}
// We set things up as in b/37673612 so that there is a mismatch between the buffer size and
// the WM specified state size.
asTransaction([&](Transaction& t) { t.setSize(mFGSurfaceControl, 128, 64); });
sp<Surface> s = mFGSurfaceControl->getSurface();
auto anw = static_cast<ANativeWindow*>(s.get());
native_window_set_buffers_transform(anw, NATIVE_WINDOW_TRANSFORM_ROT_90);
native_window_set_buffers_dimensions(anw, 64, 128);
fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
waitForPostedBuffers();
{
// The child should still be in the same place and not have any strange scaling as in
// b/37673612.
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectFGColor(10, 10);
}
}
// A child with a buffer transform from its parents should be cropped by its parent bounds.
TEST_F(ChildLayerTest, ChildCroppedByParentWithBufferTransform) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
t.setSize(mChild, 100, 100);
});
fillSurfaceRGBA8(mChild, 200, 200, 200);
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(63, 63);
mCapture->expectBGColor(64, 64);
}
asTransaction([&](Transaction& t) { t.setSize(mFGSurfaceControl, 128, 64); });
sp<Surface> s = mFGSurfaceControl->getSurface();
auto anw = static_cast<ANativeWindow*>(s.get());
// Apply a 90 transform on the buffer.
native_window_set_buffers_transform(anw, NATIVE_WINDOW_TRANSFORM_ROT_90);
native_window_set_buffers_dimensions(anw, 64, 128);
fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
waitForPostedBuffers();
// The child should be cropped by the new parent bounds.
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(99, 63);
mCapture->expectFGColor(100, 63);
mCapture->expectBGColor(128, 64);
}
}
// A child with a scale transform from its parents should be cropped by its parent bounds.
TEST_F(ChildLayerTest, ChildCroppedByParentWithBufferScale) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
t.setSize(mChild, 200, 200);
});
fillSurfaceRGBA8(mChild, 200, 200, 200);
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(63, 63);
mCapture->expectBGColor(64, 64);
}
asTransaction([&](Transaction& t) {
t.setOverrideScalingMode(mFGSurfaceControl, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
// Set a scaling by 2.
t.setSize(mFGSurfaceControl, 128, 128);
});
// Child should inherit its parents scale but should be cropped by its parent bounds.
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(127, 127);
mCapture->expectBGColor(128, 128);
}
}
// Regression test for b/127368943
// Child should ignore the buffer transform but apply parent scale transform.
TEST_F(ChildLayerTest, ChildrenWithParentBufferTransformAndScale) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
});
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(9, 14);
mCapture->expectFGColor(10, 15);
}
// Change the size of the foreground to 128 * 64 so we can test rotation as well.
asTransaction([&](Transaction& t) {
t.setOverrideScalingMode(mFGSurfaceControl, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW);
t.setSize(mFGSurfaceControl, 128, 64);
});
sp<Surface> s = mFGSurfaceControl->getSurface();
auto anw = static_cast<ANativeWindow*>(s.get());
// Apply a 90 transform on the buffer and submit a buffer half the expected size so that we
// have an effective scale of 2.0 applied to the buffer along with a rotation transform.
native_window_set_buffers_transform(anw, NATIVE_WINDOW_TRANSFORM_ROT_90);
native_window_set_buffers_dimensions(anw, 32, 64);
fillSurfaceRGBA8(mFGSurfaceControl, 195, 63, 63);
waitForPostedBuffers();
// The child should ignore the buffer transform but apply the 2.0 scale from parent.
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(19, 29);
mCapture->expectFGColor(20, 30);
}
}
TEST_F(ChildLayerTest, Bug36858924) {
// Destroy the child layer
mChild.clear();
// Now recreate it as hidden
mChild = createSurface(mClient, "Child surface", 10, 10, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eHidden, mFGSurfaceControl.get());
// Show the child layer in a deferred transaction
asTransaction([&](Transaction& t) {
t.deferTransactionUntil_legacy(mChild, mFGSurfaceControl->getHandle(),
mFGSurfaceControl->getSurface()->getNextFrameNumber());
t.show(mChild);
});
// Render the foreground surface a few times
//
// Prior to the bugfix for b/36858924, this would usually hang while trying to fill the third
// frame because SurfaceFlinger would never process the deferred transaction and would therefore
// never acquire/release the first buffer
ALOGI("Filling 1");
fillSurfaceRGBA8(mFGSurfaceControl, 0, 255, 0);
ALOGI("Filling 2");
fillSurfaceRGBA8(mFGSurfaceControl, 0, 0, 255);
ALOGI("Filling 3");
fillSurfaceRGBA8(mFGSurfaceControl, 255, 0, 0);
ALOGI("Filling 4");
fillSurfaceRGBA8(mFGSurfaceControl, 0, 255, 0);
}
TEST_F(ChildLayerTest, Reparent) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 10, 10);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
asTransaction([&](Transaction& t) { t.reparent(mChild, mBGSurfaceControl->getHandle()); });
{
mCapture = screenshot();
mCapture->expectFGColor(64, 64);
// In reparenting we should have exposed the entire foreground surface.
mCapture->expectFGColor(74, 74);
// And the child layer should now begin at 10, 10 (since the BG
// layer is at (0, 0)).
mCapture->expectBGColor(9, 9);
mCapture->expectChildColor(10, 10);
}
}
TEST_F(ChildLayerTest, ReparentToNoParent) {
asTransaction([&](Transaction& t) {
t.show(mChild);
t.setPosition(mChild, 10, 10);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// But 10 pixels in we should see the child surface
mCapture->expectChildColor(74, 74);
// And 10 more pixels we should be back to the foreground surface
mCapture->expectFGColor(84, 84);
}
asTransaction([&](Transaction& t) { t.reparent(mChild, nullptr); });
{
mCapture = screenshot();
// The surface should now be offscreen.
mCapture->expectFGColor(64, 64);
mCapture->expectFGColor(74, 74);
mCapture->expectFGColor(84, 84);
}
}
TEST_F(ChildLayerTest, ReparentFromNoParent) {
sp<SurfaceControl> newSurface = createLayer(String8("New Surface"), 10, 10, 0);
ASSERT_TRUE(newSurface != nullptr);
ASSERT_TRUE(newSurface->isValid());
fillSurfaceRGBA8(newSurface, 63, 195, 63);
asTransaction([&](Transaction& t) {
t.hide(mChild);
t.show(newSurface);
t.setPosition(newSurface, 10, 10);
t.setLayer(newSurface, INT32_MAX - 2);
t.setPosition(mFGSurfaceControl, 64, 64);
});
{
mCapture = screenshot();
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// At 10, 10 we should see the new surface
mCapture->checkPixel(10, 10, 63, 195, 63);
}
asTransaction([&](Transaction& t) { t.reparent(newSurface, mFGSurfaceControl->getHandle()); });
{
mCapture = screenshot();
// newSurface will now be a child of mFGSurface so it will be 10, 10 offset from
// mFGSurface, putting it at 74, 74.
mCapture->expectFGColor(64, 64);
mCapture->checkPixel(74, 74, 63, 195, 63);
mCapture->expectFGColor(84, 84);
}
}
TEST_F(ChildLayerTest, NestedChildren) {
sp<SurfaceControl> grandchild = createSurface(mClient, "Grandchild surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mChild.get());
fillSurfaceRGBA8(grandchild, 50, 50, 50);
{
mCapture = screenshot();
// Expect the grandchild to begin at 64, 64 because it's a child of mChild layer
// which begins at 64, 64
mCapture->checkPixel(64, 64, 50, 50, 50);
}
}
TEST_F(ChildLayerTest, ChildLayerRelativeLayer) {
sp<SurfaceControl> relative = createLayer(String8("Relative surface"), 128, 128, 0);
fillSurfaceRGBA8(relative, 255, 255, 255);
Transaction t;
t.setLayer(relative, INT32_MAX)
.setRelativeLayer(mChild, relative->getHandle(), 1)
.setPosition(mFGSurfaceControl, 0, 0)
.apply(true);
// We expect that the child should have been elevated above our
// INT_MAX layer even though it's not a child of it.
{
mCapture = screenshot();
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(9, 9);
mCapture->checkPixel(10, 10, 255, 255, 255);
}
}
class BoundlessLayerTest : public LayerUpdateTest {
protected:
std::unique_ptr<ScreenCapture> mCapture;
};
// Verify setting a size on a buffer layer has no effect.
TEST_F(BoundlessLayerTest, BufferLayerIgnoresSize) {
sp<SurfaceControl> bufferLayer =
createSurface(mClient, "BufferLayer", 45, 45, PIXEL_FORMAT_RGBA_8888, 0,
mFGSurfaceControl.get());
ASSERT_TRUE(bufferLayer->isValid());
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(bufferLayer, Color::BLACK, 30, 30));
asTransaction([&](Transaction& t) { t.show(bufferLayer); });
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Foreground Surface bounds must be color layer
mCapture->expectColor(Rect(64, 64, 94, 94), Color::BLACK);
// Buffer layer should not extend past buffer bounds
mCapture->expectFGColor(95, 95);
}
}
// Verify a boundless color layer will fill its parent bounds. The parent has a buffer size
// which will crop the color layer.
TEST_F(BoundlessLayerTest, BoundlessColorLayerFillsParentBufferBounds) {
sp<SurfaceControl> colorLayer =
createSurface(mClient, "ColorLayer", 0, 0, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, mFGSurfaceControl.get());
ASSERT_TRUE(colorLayer->isValid());
asTransaction([&](Transaction& t) {
t.setColor(colorLayer, half3{0, 0, 0});
t.show(colorLayer);
});
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Foreground Surface bounds must be color layer
mCapture->expectColor(Rect(64, 64, 128, 128), Color::BLACK);
// Color layer should not extend past foreground bounds
mCapture->expectBGColor(129, 129);
}
}
// Verify a boundless color layer will fill its parent bounds. The parent has no buffer but has
// a crop which will be used to crop the color layer.
TEST_F(BoundlessLayerTest, BoundlessColorLayerFillsParentCropBounds) {
sp<SurfaceControl> cropLayer = createSurface(mClient, "CropLayer", 0, 0, PIXEL_FORMAT_RGBA_8888,
0 /* flags */, mFGSurfaceControl.get());
ASSERT_TRUE(cropLayer->isValid());
sp<SurfaceControl> colorLayer =
createSurface(mClient, "ColorLayer", 0, 0, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, cropLayer.get());
ASSERT_TRUE(colorLayer->isValid());
asTransaction([&](Transaction& t) {
t.setCrop_legacy(cropLayer, Rect(5, 5, 10, 10));
t.setColor(colorLayer, half3{0, 0, 0});
t.show(cropLayer);
t.show(colorLayer);
});
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// 5 pixels from the foreground we should see the child surface
mCapture->expectColor(Rect(69, 69, 74, 74), Color::BLACK);
// 10 pixels from the foreground we should be back to the foreground surface
mCapture->expectFGColor(74, 74);
}
}
// Verify for boundless layer with no children, their transforms have no effect.
TEST_F(BoundlessLayerTest, BoundlessColorLayerTransformHasNoEffect) {
sp<SurfaceControl> colorLayer =
createSurface(mClient, "ColorLayer", 0, 0, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, mFGSurfaceControl.get());
ASSERT_TRUE(colorLayer->isValid());
asTransaction([&](Transaction& t) {
t.setPosition(colorLayer, 320, 320);
t.setMatrix(colorLayer, 2, 0, 0, 2);
t.setColor(colorLayer, half3{0, 0, 0});
t.show(colorLayer);
});
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Foreground Surface bounds must be color layer
mCapture->expectColor(Rect(64, 64, 128, 128), Color::BLACK);
// Color layer should not extend past foreground bounds
mCapture->expectBGColor(129, 129);
}
}
// Verify for boundless layer with children, their transforms have an effect.
TEST_F(BoundlessLayerTest, IntermediateBoundlessLayerCanSetTransform) {
sp<SurfaceControl> boundlessLayerRightShift =
createSurface(mClient, "BoundlessLayerRightShift", 0, 0, PIXEL_FORMAT_RGBA_8888,
0 /* flags */, mFGSurfaceControl.get());
ASSERT_TRUE(boundlessLayerRightShift->isValid());
sp<SurfaceControl> boundlessLayerDownShift =
createSurface(mClient, "BoundlessLayerLeftShift", 0, 0, PIXEL_FORMAT_RGBA_8888,
0 /* flags */, boundlessLayerRightShift.get());
ASSERT_TRUE(boundlessLayerDownShift->isValid());
sp<SurfaceControl> colorLayer =
createSurface(mClient, "ColorLayer", 0, 0, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, boundlessLayerDownShift.get());
ASSERT_TRUE(colorLayer->isValid());
asTransaction([&](Transaction& t) {
t.setPosition(boundlessLayerRightShift, 32, 0);
t.show(boundlessLayerRightShift);
t.setPosition(boundlessLayerDownShift, 0, 32);
t.show(boundlessLayerDownShift);
t.setCrop_legacy(colorLayer, Rect(0, 0, 64, 64));
t.setColor(colorLayer, half3{0, 0, 0});
t.show(colorLayer);
});
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Top left of foreground must now be visible
mCapture->expectFGColor(64, 64);
// Foreground Surface bounds must be color layer
mCapture->expectColor(Rect(96, 96, 128, 128), Color::BLACK);
// Color layer should not extend past foreground bounds
mCapture->expectBGColor(129, 129);
}
}
// Verify child layers do not get clipped if they temporarily move into the negative
// coordinate space as the result of an intermediate transformation.
TEST_F(BoundlessLayerTest, IntermediateBoundlessLayerDoNotCrop) {
sp<SurfaceControl> boundlessLayer =
mClient->createSurface(String8("BoundlessLayer"), 0, 0, PIXEL_FORMAT_RGBA_8888,
0 /* flags */, mFGSurfaceControl.get());
ASSERT_TRUE(boundlessLayer != nullptr);
ASSERT_TRUE(boundlessLayer->isValid());
sp<SurfaceControl> colorLayer =
mClient->createSurface(String8("ColorLayer"), 0, 0, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, boundlessLayer.get());
ASSERT_TRUE(colorLayer != nullptr);
ASSERT_TRUE(colorLayer->isValid());
asTransaction([&](Transaction& t) {
// shift child layer off bounds. If this layer was not boundless, we will
// expect the child layer to be cropped.
t.setPosition(boundlessLayer, 32, 32);
t.show(boundlessLayer);
t.setCrop_legacy(colorLayer, Rect(0, 0, 64, 64));
// undo shift by parent
t.setPosition(colorLayer, -32, -32);
t.setColor(colorLayer, half3{0, 0, 0});
t.show(colorLayer);
});
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Foreground Surface bounds must be color layer
mCapture->expectColor(Rect(64, 64, 128, 128), Color::BLACK);
// Color layer should not extend past foreground bounds
mCapture->expectBGColor(129, 129);
}
}
// Verify for boundless root layers with children, their transforms have an effect.
TEST_F(BoundlessLayerTest, RootBoundlessLayerCanSetTransform) {
sp<SurfaceControl> rootBoundlessLayer = createSurface(mClient, "RootBoundlessLayer", 0, 0,
PIXEL_FORMAT_RGBA_8888, 0 /* flags */);
ASSERT_TRUE(rootBoundlessLayer->isValid());
sp<SurfaceControl> colorLayer =
createSurface(mClient, "ColorLayer", 0, 0, PIXEL_FORMAT_RGBA_8888,
ISurfaceComposerClient::eFXSurfaceColor, rootBoundlessLayer.get());
ASSERT_TRUE(colorLayer->isValid());
asTransaction([&](Transaction& t) {
t.setLayer(rootBoundlessLayer, INT32_MAX - 1);
t.setPosition(rootBoundlessLayer, 32, 32);
t.show(rootBoundlessLayer);
t.setCrop_legacy(colorLayer, Rect(0, 0, 64, 64));
t.setColor(colorLayer, half3{0, 0, 0});
t.show(colorLayer);
t.hide(mFGSurfaceControl);
});
{
mCapture = screenshot();
// Top left of background must now be visible
mCapture->expectBGColor(0, 0);
// Top left of foreground must now be visible
mCapture->expectBGColor(31, 31);
// Foreground Surface bounds must be color layer
mCapture->expectColor(Rect(32, 32, 96, 96), Color::BLACK);
// Color layer should not extend past foreground bounds
mCapture->expectBGColor(97, 97);
}
}
class ScreenCaptureTest : public LayerUpdateTest {
protected:
std::unique_ptr<ScreenCapture> mCapture;
};
TEST_F(ScreenCaptureTest, CaptureSingleLayer) {
auto bgHandle = mBGSurfaceControl->getHandle();
ScreenCapture::captureLayers(&mCapture, bgHandle);
mCapture->expectBGColor(0, 0);
// Doesn't capture FG layer which is at 64, 64
mCapture->expectBGColor(64, 64);
}
TEST_F(ScreenCaptureTest, CaptureLayerWithChild) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
SurfaceComposerClient::Transaction().show(child).apply(true);
// Captures mFGSurfaceControl layer and its child.
ScreenCapture::captureLayers(&mCapture, fgHandle);
mCapture->expectFGColor(10, 10);
mCapture->expectChildColor(0, 0);
}
TEST_F(ScreenCaptureTest, CaptureLayerChildOnly) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
SurfaceComposerClient::Transaction().show(child).apply(true);
// Captures mFGSurfaceControl's child
ScreenCapture::captureChildLayers(&mCapture, fgHandle);
mCapture->checkPixel(10, 10, 0, 0, 0);
mCapture->expectChildColor(0, 0);
}
TEST_F(ScreenCaptureTest, CaptureLayerExclude) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
sp<SurfaceControl> child2 = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child2, 200, 0, 200);
SurfaceComposerClient::Transaction()
.show(child)
.show(child2)
.setLayer(child, 1)
.setLayer(child2, 2)
.apply(true);
// Child2 would be visible but its excluded, so we should see child1 color instead.
ScreenCapture::captureChildLayersExcluding(&mCapture, fgHandle, {child2->getHandle()});
mCapture->checkPixel(10, 10, 0, 0, 0);
mCapture->checkPixel(0, 0, 200, 200, 200);
}
// Like the last test but verifies that children are also exclude.
TEST_F(ScreenCaptureTest, CaptureLayerExcludeTree) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
sp<SurfaceControl> child2 = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child2, 200, 0, 200);
sp<SurfaceControl> child3 = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, child2.get());
fillSurfaceRGBA8(child2, 200, 0, 200);
SurfaceComposerClient::Transaction()
.show(child)
.show(child2)
.show(child3)
.setLayer(child, 1)
.setLayer(child2, 2)
.apply(true);
// Child2 would be visible but its excluded, so we should see child1 color instead.
ScreenCapture::captureChildLayersExcluding(&mCapture, fgHandle, {child2->getHandle()});
mCapture->checkPixel(10, 10, 0, 0, 0);
mCapture->checkPixel(0, 0, 200, 200, 200);
}
TEST_F(ScreenCaptureTest, CaptureTransparent) {
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
SurfaceComposerClient::Transaction().show(child).apply(true);
auto childHandle = child->getHandle();
// Captures child
ScreenCapture::captureLayers(&mCapture, childHandle, {0, 0, 10, 20});
mCapture->expectColor(Rect(0, 0, 9, 9), {200, 200, 200, 255});
// Area outside of child's bounds is transparent.
mCapture->expectColor(Rect(0, 10, 9, 19), {0, 0, 0, 0});
}
TEST_F(ScreenCaptureTest, DontCaptureRelativeOutsideTree) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
ASSERT_NE(nullptr, child.get()) << "failed to create surface";
sp<SurfaceControl> relative = createLayer(String8("Relative surface"), 10, 10, 0);
fillSurfaceRGBA8(child, 200, 200, 200);
fillSurfaceRGBA8(relative, 100, 100, 100);
SurfaceComposerClient::Transaction()
.show(child)
// Set relative layer above fg layer so should be shown above when computing all layers.
.setRelativeLayer(relative, fgHandle, 1)
.show(relative)
.apply(true);
// Captures mFGSurfaceControl layer and its child. Relative layer shouldn't be captured.
ScreenCapture::captureLayers(&mCapture, fgHandle);
mCapture->expectFGColor(10, 10);
mCapture->expectChildColor(0, 0);
}
TEST_F(ScreenCaptureTest, CaptureRelativeInTree) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
sp<SurfaceControl> relative = createSurface(mClient, "Relative surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
fillSurfaceRGBA8(relative, 100, 100, 100);
SurfaceComposerClient::Transaction()
.show(child)
// Set relative layer below fg layer but relative to child layer so it should be shown
// above child layer.
.setLayer(relative, -1)
.setRelativeLayer(relative, child->getHandle(), 1)
.show(relative)
.apply(true);
// Captures mFGSurfaceControl layer and its children. Relative layer is a child of fg so its
// relative value should be taken into account, placing it above child layer.
ScreenCapture::captureLayers(&mCapture, fgHandle);
mCapture->expectFGColor(10, 10);
// Relative layer is showing on top of child layer
mCapture->expectColor(Rect(0, 0, 9, 9), {100, 100, 100, 255});
}
// In the following tests we verify successful skipping of a parent layer,
// so we use the same verification logic and only change how we mutate
// the parent layer to verify that various properties are ignored.
class ScreenCaptureChildOnlyTest : public LayerUpdateTest {
public:
void SetUp() override {
LayerUpdateTest::SetUp();
mChild = createSurface(mClient, "Child surface", 10, 10, PIXEL_FORMAT_RGBA_8888, 0,
mFGSurfaceControl.get());
fillSurfaceRGBA8(mChild, 200, 200, 200);
SurfaceComposerClient::Transaction().show(mChild).apply(true);
}
void verify(std::function<void()> verifyStartingState) {
// Verify starting state before a screenshot is taken.
verifyStartingState();
// Verify child layer does not inherit any of the properties of its
// parent when its screenshot is captured.
auto fgHandle = mFGSurfaceControl->getHandle();
ScreenCapture::captureChildLayers(&mCapture, fgHandle);
mCapture->checkPixel(10, 10, 0, 0, 0);
mCapture->expectChildColor(0, 0);
// Verify all assumptions are still true after the screenshot is taken.
verifyStartingState();
}
std::unique_ptr<ScreenCapture> mCapture;
sp<SurfaceControl> mChild;
};
// Regression test b/76099859
TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresParentVisibility) {
SurfaceComposerClient::Transaction().hide(mFGSurfaceControl).apply(true);
// Even though the parent is hidden we should still capture the child.
// Before and after reparenting, verify child is properly hidden
// when rendering full-screen.
verify([&] { screenshot()->expectBGColor(64, 64); });
}
TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresParentCrop) {
SurfaceComposerClient::Transaction()
.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 1, 1))
.apply(true);
// Even though the parent is cropped out we should still capture the child.
// Before and after reparenting, verify child is cropped by parent.
verify([&] { screenshot()->expectBGColor(65, 65); });
}
// Regression test b/124372894
TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresTransform) {
SurfaceComposerClient::Transaction().setMatrix(mFGSurfaceControl, 2, 0, 0, 2).apply(true);
// We should not inherit the parent scaling.
// Before and after reparenting, verify child is properly scaled.
verify([&] { screenshot()->expectChildColor(80, 80); });
}
TEST_F(ScreenCaptureTest, CaptureLayerWithGrandchild) {
auto fgHandle = mFGSurfaceControl->getHandle();
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
sp<SurfaceControl> grandchild = createSurface(mClient, "Grandchild surface", 5, 5,
PIXEL_FORMAT_RGBA_8888, 0, child.get());
fillSurfaceRGBA8(grandchild, 50, 50, 50);
SurfaceComposerClient::Transaction()
.show(child)
.setPosition(grandchild, 5, 5)
.show(grandchild)
.apply(true);
// Captures mFGSurfaceControl, its child, and the grandchild.
ScreenCapture::captureLayers(&mCapture, fgHandle);
mCapture->expectFGColor(10, 10);
mCapture->expectChildColor(0, 0);
mCapture->checkPixel(5, 5, 50, 50, 50);
}
TEST_F(ScreenCaptureTest, CaptureChildOnly) {
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
auto childHandle = child->getHandle();
SurfaceComposerClient::Transaction().setPosition(child, 5, 5).show(child).apply(true);
// Captures only the child layer, and not the parent.
ScreenCapture::captureLayers(&mCapture, childHandle);
mCapture->expectChildColor(0, 0);
mCapture->expectChildColor(9, 9);
}
TEST_F(ScreenCaptureTest, CaptureGrandchildOnly) {
sp<SurfaceControl> child = createSurface(mClient, "Child surface", 10, 10,
PIXEL_FORMAT_RGBA_8888, 0, mFGSurfaceControl.get());
fillSurfaceRGBA8(child, 200, 200, 200);
auto childHandle = child->getHandle();
sp<SurfaceControl> grandchild = createSurface(mClient, "Grandchild surface", 5, 5,
PIXEL_FORMAT_RGBA_8888, 0, child.get());
fillSurfaceRGBA8(grandchild, 50, 50, 50);
SurfaceComposerClient::Transaction()
.show(child)
.setPosition(grandchild, 5, 5)
.show(grandchild)
.apply(true);
auto grandchildHandle = grandchild->getHandle();
// Captures only the grandchild.
ScreenCapture::captureLayers(&mCapture, grandchildHandle);
mCapture->checkPixel(0, 0, 50, 50, 50);
mCapture->checkPixel(4, 4, 50, 50, 50);
}
TEST_F(ScreenCaptureTest, CaptureCrop) {
sp<SurfaceControl> redLayer = createLayer(String8("Red surface"), 60, 60, 0);
sp<SurfaceControl> blueLayer = createSurface(mClient, "Blue surface", 30, 30,
PIXEL_FORMAT_RGBA_8888, 0, redLayer.get());
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(redLayer, Color::RED, 60, 60));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(blueLayer, Color::BLUE, 30, 30));
SurfaceComposerClient::Transaction()
.setLayer(redLayer, INT32_MAX - 1)
.show(redLayer)
.show(blueLayer)
.apply(true);
auto redLayerHandle = redLayer->getHandle();
// Capturing full screen should have both red and blue are visible.
ScreenCapture::captureLayers(&mCapture, redLayerHandle);
mCapture->expectColor(Rect(0, 0, 29, 29), Color::BLUE);
// red area below the blue area
mCapture->expectColor(Rect(0, 30, 59, 59), Color::RED);
// red area to the right of the blue area
mCapture->expectColor(Rect(30, 0, 59, 59), Color::RED);
const Rect crop = Rect(0, 0, 30, 30);
ScreenCapture::captureLayers(&mCapture, redLayerHandle, crop);
// Capturing the cropped screen, cropping out the shown red area, should leave only the blue
// area visible.
mCapture->expectColor(Rect(0, 0, 29, 29), Color::BLUE);
mCapture->checkPixel(30, 30, 0, 0, 0);
}
TEST_F(ScreenCaptureTest, CaptureSize) {
sp<SurfaceControl> redLayer = createLayer(String8("Red surface"), 60, 60, 0);
sp<SurfaceControl> blueLayer = createSurface(mClient, "Blue surface", 30, 30,
PIXEL_FORMAT_RGBA_8888, 0, redLayer.get());
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(redLayer, Color::RED, 60, 60));
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(blueLayer, Color::BLUE, 30, 30));
SurfaceComposerClient::Transaction()
.setLayer(redLayer, INT32_MAX - 1)
.show(redLayer)
.show(blueLayer)
.apply(true);
auto redLayerHandle = redLayer->getHandle();
// Capturing full screen should have both red and blue are visible.
ScreenCapture::captureLayers(&mCapture, redLayerHandle);
mCapture->expectColor(Rect(0, 0, 29, 29), Color::BLUE);
// red area below the blue area
mCapture->expectColor(Rect(0, 30, 59, 59), Color::RED);
// red area to the right of the blue area
mCapture->expectColor(Rect(30, 0, 59, 59), Color::RED);
ScreenCapture::captureLayers(&mCapture, redLayerHandle, Rect::EMPTY_RECT, 0.5);
// Capturing the downsized area (30x30) should leave both red and blue but in a smaller area.
mCapture->expectColor(Rect(0, 0, 14, 14), Color::BLUE);
// red area below the blue area
mCapture->expectColor(Rect(0, 15, 29, 29), Color::RED);
// red area to the right of the blue area
mCapture->expectColor(Rect(15, 0, 29, 29), Color::RED);
mCapture->checkPixel(30, 30, 0, 0, 0);
}
TEST_F(ScreenCaptureTest, CaptureInvalidLayer) {
sp<SurfaceControl> redLayer = createLayer(String8("Red surface"), 60, 60, 0);
ASSERT_NO_FATAL_FAILURE(fillBufferQueueLayerColor(redLayer, Color::RED, 60, 60));
auto redLayerHandle = redLayer->getHandle();
redLayer.clear();
SurfaceComposerClient::Transaction().apply(true);
sp<GraphicBuffer> outBuffer;
// Layer was deleted so captureLayers should fail with NAME_NOT_FOUND
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
ASSERT_EQ(NAME_NOT_FOUND, sf->captureLayers(redLayerHandle, &outBuffer, Rect::EMPTY_RECT, 1.0));
}
class DereferenceSurfaceControlTest : public LayerTransactionTest {
protected:
void SetUp() override {
LayerTransactionTest::SetUp();
bgLayer = createLayer("BG layer", 20, 20);
fillBufferQueueLayerColor(bgLayer, Color::RED, 20, 20);
fgLayer = createLayer("FG layer", 20, 20);
fillBufferQueueLayerColor(fgLayer, Color::BLUE, 20, 20);
Transaction().setLayer(fgLayer, mLayerZBase + 1).apply();
{
SCOPED_TRACE("before anything");
auto shot = screenshot();
shot->expectColor(Rect(0, 0, 20, 20), Color::BLUE);
}
}
void TearDown() override {
LayerTransactionTest::TearDown();
bgLayer = 0;
fgLayer = 0;
}
sp<SurfaceControl> bgLayer;
sp<SurfaceControl> fgLayer;
};
TEST_F(DereferenceSurfaceControlTest, LayerNotInTransaction) {
fgLayer = nullptr;
{
SCOPED_TRACE("after setting null");
auto shot = screenshot();
shot->expectColor(Rect(0, 0, 20, 20), Color::RED);
}
}
TEST_F(DereferenceSurfaceControlTest, LayerInTransaction) {
auto transaction = Transaction().show(fgLayer);
fgLayer = nullptr;
{
SCOPED_TRACE("after setting null");
auto shot = screenshot();
shot->expectColor(Rect(0, 0, 20, 20), Color::BLUE);
}
}
class MultiDisplayLayerBoundsTest : public LayerTransactionTest {
protected:
virtual void SetUp() {
LayerTransactionTest::SetUp();
ASSERT_EQ(NO_ERROR, mClient->initCheck());
mMainDisplay = SurfaceComposerClient::getInternalDisplayToken();
SurfaceComposerClient::getDisplayInfo(mMainDisplay, &mMainDisplayInfo);
sp<IGraphicBufferConsumer> consumer;
BufferQueue::createBufferQueue(&mProducer, &consumer);
consumer->setConsumerName(String8("Virtual disp consumer"));
consumer->setDefaultBufferSize(mMainDisplayInfo.w, mMainDisplayInfo.h);
}
virtual void TearDown() {
SurfaceComposerClient::destroyDisplay(mVirtualDisplay);
LayerTransactionTest::TearDown();
mColorLayer = 0;
}
void createDisplay(const Rect& layerStackRect, uint32_t layerStack) {
mVirtualDisplay =
SurfaceComposerClient::createDisplay(String8("VirtualDisplay"), false /*secure*/);
asTransaction([&](Transaction& t) {
t.setDisplaySurface(mVirtualDisplay, mProducer);
t.setDisplayLayerStack(mVirtualDisplay, layerStack);
t.setDisplayProjection(mVirtualDisplay, mMainDisplayInfo.orientation, layerStackRect,
Rect(mMainDisplayInfo.w, mMainDisplayInfo.h));
});
}
void createColorLayer(uint32_t layerStack) {
mColorLayer =
createSurface(mClient, "ColorLayer", 0 /* buffer width */, 0 /* buffer height */,
PIXEL_FORMAT_RGBA_8888, ISurfaceComposerClient::eFXSurfaceColor);
ASSERT_TRUE(mColorLayer != nullptr);
ASSERT_TRUE(mColorLayer->isValid());
asTransaction([&](Transaction& t) {
t.setLayerStack(mColorLayer, layerStack);
t.setCrop_legacy(mColorLayer, Rect(0, 0, 30, 40));
t.setLayer(mColorLayer, INT32_MAX - 2);
t.setColor(mColorLayer,
half3{mExpectedColor.r / 255.0f, mExpectedColor.g / 255.0f,
mExpectedColor.b / 255.0f});
t.show(mColorLayer);
});
}
DisplayInfo mMainDisplayInfo;
sp<IBinder> mMainDisplay;
sp<IBinder> mVirtualDisplay;
sp<IGraphicBufferProducer> mProducer;
sp<SurfaceControl> mColorLayer;
Color mExpectedColor = {63, 63, 195, 255};
};
TEST_F(MultiDisplayLayerBoundsTest, RenderLayerInVirtualDisplay) {
createDisplay({mMainDisplayInfo.viewportW, mMainDisplayInfo.viewportH}, 1 /* layerStack */);
createColorLayer(1 /* layerStack */);
asTransaction([&](Transaction& t) { t.setPosition(mColorLayer, 10, 10); });
// Verify color layer does not render on main display.
std::unique_ptr<ScreenCapture> sc;
ScreenCapture::captureScreen(&sc, mMainDisplay);
sc->expectColor(Rect(10, 10, 40, 50), {0, 0, 0, 255});
sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
// Verify color layer renders correctly on virtual display.
ScreenCapture::captureScreen(&sc, mVirtualDisplay);
sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
sc->expectColor(Rect(1, 1, 9, 9), {0, 0, 0, 0});
}
TEST_F(MultiDisplayLayerBoundsTest, RenderLayerInMirroredVirtualDisplay) {
// Create a display and set its layer stack to the main display's layer stack so
// the contents of the main display are mirrored on to the virtual display.
// Assumption here is that the new mirrored display has the same viewport as the
// primary display that it is mirroring.
createDisplay({mMainDisplayInfo.viewportW, mMainDisplayInfo.viewportH}, 0 /* layerStack */);
createColorLayer(0 /* layerStack */);
asTransaction([&](Transaction& t) { t.setPosition(mColorLayer, 10, 10); });
// Verify color layer renders correctly on main display and it is mirrored on the
// virtual display.
std::unique_ptr<ScreenCapture> sc;
ScreenCapture::captureScreen(&sc, mMainDisplay);
sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
ScreenCapture::captureScreen(&sc, mVirtualDisplay);
sc->expectColor(Rect(10, 10, 40, 50), mExpectedColor);
sc->expectColor(Rect(0, 0, 9, 9), {0, 0, 0, 255});
}
class DisplayActiveConfigTest : public ::testing::Test {
protected:
void SetUp() override {
mDisplayToken = SurfaceComposerClient::getInternalDisplayToken();
SurfaceComposerClient::getDisplayConfigs(mDisplayToken, &mDisplayconfigs);
EXPECT_GT(mDisplayconfigs.size(), 0);
// set display power to on to make sure config can be changed
SurfaceComposerClient::setDisplayPowerMode(mDisplayToken, HWC_POWER_MODE_NORMAL);
}
sp<IBinder> mDisplayToken;
Vector<DisplayInfo> mDisplayconfigs;
};
TEST_F(DisplayActiveConfigTest, allConfigsAllowed) {
std::vector<int32_t> allowedConfigs;
// Add all configs to the allowed configs
for (int i = 0; i < mDisplayconfigs.size(); i++) {
allowedConfigs.push_back(i);
}
status_t res = SurfaceComposerClient::setAllowedDisplayConfigs(mDisplayToken, allowedConfigs);
EXPECT_EQ(res, NO_ERROR);
std::vector<int32_t> outConfigs;
res = SurfaceComposerClient::getAllowedDisplayConfigs(mDisplayToken, &outConfigs);
EXPECT_EQ(res, NO_ERROR);
EXPECT_EQ(allowedConfigs, outConfigs);
}
TEST_F(DisplayActiveConfigTest, changeAllowedConfig) {
// we need at least 2 configs available for this test
if (mDisplayconfigs.size() <= 1) return;
int activeConfig = SurfaceComposerClient::getActiveConfig(mDisplayToken);
// We want to set the allowed config to everything but the active config
std::vector<int32_t> allowedConfigs;
for (int i = 0; i < mDisplayconfigs.size(); i++) {
if (i != activeConfig) {
allowedConfigs.push_back(i);
}
}
status_t res = SurfaceComposerClient::setAllowedDisplayConfigs(mDisplayToken, allowedConfigs);
EXPECT_EQ(res, NO_ERROR);
// Allow some time for the config change
std::this_thread::sleep_for(200ms);
int newActiveConfig = SurfaceComposerClient::getActiveConfig(mDisplayToken);
EXPECT_NE(activeConfig, newActiveConfig);
// Make sure the new config is part of allowed config
EXPECT_TRUE(std::find(allowedConfigs.begin(), allowedConfigs.end(), newActiveConfig) !=
allowedConfigs.end());
}
class RelativeZTest : public LayerTransactionTest {
protected:
virtual void SetUp() {
LayerTransactionTest::SetUp();
ASSERT_EQ(NO_ERROR, mClient->initCheck());
const auto display = SurfaceComposerClient::getInternalDisplayToken();
ASSERT_FALSE(display == nullptr);
// Back layer
mBackgroundLayer = createColorLayer("Background layer", Color::RED);
// Front layer
mForegroundLayer = createColorLayer("Foreground layer", Color::GREEN);
asTransaction([&](Transaction& t) {
t.setDisplayLayerStack(display, 0);
t.setLayer(mBackgroundLayer, INT32_MAX - 2).show(mBackgroundLayer);
t.setLayer(mForegroundLayer, INT32_MAX - 1).show(mForegroundLayer);
});
}
virtual void TearDown() {
LayerTransactionTest::TearDown();
mBackgroundLayer = 0;
mForegroundLayer = 0;
}
sp<SurfaceControl> mBackgroundLayer;
sp<SurfaceControl> mForegroundLayer;
};
// When a layer is reparented offscreen, remove relative z order if the relative parent
// is still onscreen so that the layer is not drawn.
TEST_F(RelativeZTest, LayerRemoved) {
std::unique_ptr<ScreenCapture> sc;
// Background layer (RED)
// Child layer (WHITE) (relative to foregroud layer)
// Foregroud layer (GREEN)
sp<SurfaceControl> childLayer =
createColorLayer("Child layer", Color::BLUE, mBackgroundLayer.get());
Transaction{}
.setRelativeLayer(childLayer, mForegroundLayer->getHandle(), 1)
.show(childLayer)
.apply();
{
// The childLayer should be in front of the FG control.
ScreenCapture::captureScreen(&sc);
sc->checkPixel(1, 1, Color::BLUE.r, Color::BLUE.g, Color::BLUE.b);
}
// Background layer (RED)
// Foregroud layer (GREEN)
Transaction{}.reparent(childLayer, nullptr).apply();
// Background layer (RED)
// Child layer (WHITE)
// Foregroud layer (GREEN)
Transaction{}.reparent(childLayer, mBackgroundLayer->getHandle()).apply();
{
// The relative z info for child layer should be reset, leaving FG control on top.
ScreenCapture::captureScreen(&sc);
sc->checkPixel(1, 1, Color::GREEN.r, Color::GREEN.g, Color::GREEN.b);
}
}
// When a layer is reparented offscreen, preseve relative z order if the relative parent
// is also offscreen. Regression test b/132613412
TEST_F(RelativeZTest, LayerRemovedOffscreenRelativeParent) {
std::unique_ptr<ScreenCapture> sc;
// Background layer (RED)
// Foregroud layer (GREEN)
// child level 1 (WHITE)
// child level 2a (BLUE)
// child level 3 (GREEN) (relative to child level 2b)
// child level 2b (BLACK)
sp<SurfaceControl> childLevel1 =
createColorLayer("child level 1", Color::WHITE, mForegroundLayer.get());
sp<SurfaceControl> childLevel2a =
createColorLayer("child level 2a", Color::BLUE, childLevel1.get());
sp<SurfaceControl> childLevel2b =
createColorLayer("child level 2b", Color::BLACK, childLevel1.get());
sp<SurfaceControl> childLevel3 =
createColorLayer("child level 3", Color::GREEN, childLevel2a.get());
Transaction{}
.setRelativeLayer(childLevel3, childLevel2b->getHandle(), 1)
.show(childLevel2a)
.show(childLevel2b)
.show(childLevel3)
.apply();
{
// The childLevel3 should be in front of childLevel2b.
ScreenCapture::captureScreen(&sc);
sc->checkPixel(1, 1, Color::GREEN.r, Color::GREEN.g, Color::GREEN.b);
}
// Background layer (RED)
// Foregroud layer (GREEN)
Transaction{}.reparent(childLevel1, nullptr).apply();
// Background layer (RED)
// Foregroud layer (GREEN)
// child level 1 (WHITE)
// child level 2 back (BLUE)
// child level 3 (GREEN) (relative to child level 2b)
// child level 2 front (BLACK)
Transaction{}.reparent(childLevel1, mForegroundLayer->getHandle()).apply();
{
// Nothing should change at this point since relative z info was preserved.
ScreenCapture::captureScreen(&sc);
sc->checkPixel(1, 1, Color::GREEN.r, Color::GREEN.g, Color::GREEN.b);
}
}
} // namespace android