blast: Append "_legacy" to old buffer state values
As we move from BufferQueueLayer to BufferStateLayer, some
layer state fields are used by both layer types and some
are used exclusively by one type of layer. Append "_legacy"
to all fields that are NOT used by BufferStateLayer.
Bug: 80477568
Test: Transaction_test.cpp
Change-Id: Id8bf27f5b68c00592136e4336442a5d388f35779
diff --git a/cmds/surfacereplayer/replayer/Replayer.cpp b/cmds/surfacereplayer/replayer/Replayer.cpp
index 4140f40..d9ff4ba 100644
--- a/cmds/surfacereplayer/replayer/Replayer.cpp
+++ b/cmds/surfacereplayer/replayer/Replayer.cpp
@@ -489,7 +489,7 @@
Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(),
cc.rectangle().bottom());
- t.setCrop(mLayers[id], r);
+ t.setCrop_legacy(mLayers[id], r);
}
void Replayer::setFinalCrop(SurfaceComposerClient::Transaction& t,
@@ -499,7 +499,7 @@
fcc.rectangle().bottom());
Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(),
fcc.rectangle().bottom());
- t.setFinalCrop(mLayers[id], r);
+ t.setFinalCrop_legacy(mLayers[id], r);
}
void Replayer::setMatrix(SurfaceComposerClient::Transaction& t,
@@ -570,7 +570,7 @@
auto handle = mLayers[dtc.layer_id()]->getHandle();
- t.deferTransactionUntil(mLayers[id], handle, dtc.frame_number());
+ t.deferTransactionUntil_legacy(mLayers[id], handle, dtc.frame_number());
}
void Replayer::setDisplaySurface(SurfaceComposerClient::Transaction& t,
diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp
index 01acc2d..0414a48 100644
--- a/libs/gui/LayerState.cpp
+++ b/libs/gui/LayerState.cpp
@@ -37,13 +37,13 @@
output.writeUint32(mask);
*reinterpret_cast<layer_state_t::matrix22_t *>(
output.writeInplace(sizeof(layer_state_t::matrix22_t))) = matrix;
- output.write(crop);
- output.write(finalCrop);
- output.writeStrongBinder(barrierHandle);
+ output.write(crop_legacy);
+ output.write(finalCrop_legacy);
+ output.writeStrongBinder(barrierHandle_legacy);
output.writeStrongBinder(reparentHandle);
- output.writeUint64(frameNumber);
+ output.writeUint64(frameNumber_legacy);
output.writeInt32(overrideScalingMode);
- output.writeStrongBinder(IInterface::asBinder(barrierGbp));
+ output.writeStrongBinder(IInterface::asBinder(barrierGbp_legacy));
output.writeStrongBinder(relativeLayerHandle);
output.writeStrongBinder(parentHandleForChild);
output.writeFloat(color.r);
@@ -72,14 +72,13 @@
} else {
return BAD_VALUE;
}
- input.read(crop);
- input.read(finalCrop);
- barrierHandle = input.readStrongBinder();
+ input.read(crop_legacy);
+ input.read(finalCrop_legacy);
+ barrierHandle_legacy = input.readStrongBinder();
reparentHandle = input.readStrongBinder();
- frameNumber = input.readUint64();
+ frameNumber_legacy = input.readUint64();
overrideScalingMode = input.readInt32();
- barrierGbp =
- interface_cast<IGraphicBufferProducer>(input.readStrongBinder());
+ barrierGbp_legacy = interface_cast<IGraphicBufferProducer>(input.readStrongBinder());
relativeLayerHandle = input.readStrongBinder();
parentHandleForChild = input.readStrongBinder();
color.r = input.readFloat();
@@ -194,19 +193,19 @@
what |= eLayerStackChanged;
layerStack = other.layerStack;
}
- if (other.what & eCropChanged) {
- what |= eCropChanged;
- crop = other.crop;
+ if (other.what & eCropChanged_legacy) {
+ what |= eCropChanged_legacy;
+ crop_legacy = other.crop_legacy;
}
- if (other.what & eDeferTransaction) {
- what |= eDeferTransaction;
- barrierHandle = other.barrierHandle;
- barrierGbp = other.barrierGbp;
- frameNumber = other.frameNumber;
+ if (other.what & eDeferTransaction_legacy) {
+ what |= eDeferTransaction_legacy;
+ barrierHandle_legacy = other.barrierHandle_legacy;
+ barrierGbp_legacy = other.barrierGbp_legacy;
+ frameNumber_legacy = other.frameNumber_legacy;
}
- if (other.what & eFinalCropChanged) {
- what |= eFinalCropChanged;
- finalCrop = other.finalCrop;
+ if (other.what & eFinalCropChanged_legacy) {
+ what |= eFinalCropChanged_legacy;
+ finalCrop_legacy = other.finalCrop_legacy;
}
if (other.what & eOverrideScalingModeChanged) {
what |= eOverrideScalingModeChanged;
diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp
index fc076d2..3ff0ec2 100644
--- a/libs/gui/SurfaceComposerClient.cpp
+++ b/libs/gui/SurfaceComposerClient.cpp
@@ -344,54 +344,57 @@
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop(
+SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop_legacy(
const sp<SurfaceControl>& sc, const Rect& crop) {
layer_state_t* s = getLayerState(sc);
if (!s) {
mStatus = BAD_INDEX;
return *this;
}
- s->what |= layer_state_t::eCropChanged;
- s->crop = crop;
+ s->what |= layer_state_t::eCropChanged_legacy;
+ s->crop_legacy = crop;
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFinalCrop(const sp<SurfaceControl>& sc, const Rect& crop) {
+SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFinalCrop_legacy(
+ const sp<SurfaceControl>& sc, const Rect& crop) {
layer_state_t* s = getLayerState(sc);
if (!s) {
mStatus = BAD_INDEX;
return *this;
}
- s->what |= layer_state_t::eFinalCropChanged;
- s->finalCrop = crop;
+ s->what |= layer_state_t::eFinalCropChanged_legacy;
+ s->finalCrop_legacy = crop;
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::deferTransactionUntil(
- const sp<SurfaceControl>& sc,
- const sp<IBinder>& handle, uint64_t frameNumber) {
+SurfaceComposerClient::Transaction&
+SurfaceComposerClient::Transaction::deferTransactionUntil_legacy(const sp<SurfaceControl>& sc,
+ const sp<IBinder>& handle,
+ uint64_t frameNumber) {
layer_state_t* s = getLayerState(sc);
if (!s) {
mStatus = BAD_INDEX;
return *this;
}
- s->what |= layer_state_t::eDeferTransaction;
- s->barrierHandle = handle;
- s->frameNumber = frameNumber;
+ s->what |= layer_state_t::eDeferTransaction_legacy;
+ s->barrierHandle_legacy = handle;
+ s->frameNumber_legacy = frameNumber;
return *this;
}
-SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::deferTransactionUntil(
- const sp<SurfaceControl>& sc,
- const sp<Surface>& barrierSurface, uint64_t frameNumber) {
+SurfaceComposerClient::Transaction&
+SurfaceComposerClient::Transaction::deferTransactionUntil_legacy(const sp<SurfaceControl>& sc,
+ const sp<Surface>& barrierSurface,
+ uint64_t frameNumber) {
layer_state_t* s = getLayerState(sc);
if (!s) {
mStatus = BAD_INDEX;
return *this;
}
- s->what |= layer_state_t::eDeferTransaction;
- s->barrierGbp = barrierSurface->getIGraphicBufferProducer();
- s->frameNumber = frameNumber;
+ s->what |= layer_state_t::eDeferTransaction_legacy;
+ s->barrierGbp_legacy = barrierSurface->getIGraphicBufferProducer();
+ s->frameNumber_legacy = frameNumber;
return *this;
}
diff --git a/libs/gui/include/gui/LayerState.h b/libs/gui/include/gui/LayerState.h
index a343c2f..b88b7fe 100644
--- a/libs/gui/include/gui/LayerState.h
+++ b/libs/gui/include/gui/LayerState.h
@@ -51,9 +51,9 @@
eTransparentRegionChanged = 0x00000020,
eFlagsChanged = 0x00000040,
eLayerStackChanged = 0x00000080,
- eCropChanged = 0x00000100,
- eDeferTransaction = 0x00000200,
- eFinalCropChanged = 0x00000400,
+ eCropChanged_legacy = 0x00000100,
+ eDeferTransaction_legacy = 0x00000200,
+ eFinalCropChanged_legacy = 0x00000400,
eOverrideScalingModeChanged = 0x00000800,
eGeometryAppliesWithResize = 0x00001000,
eReparentChildren = 0x00002000,
@@ -76,9 +76,9 @@
flags(0),
mask(0),
reserved(0),
- crop(Rect::INVALID_RECT),
- finalCrop(Rect::INVALID_RECT),
- frameNumber(0),
+ crop_legacy(Rect::INVALID_RECT),
+ finalCrop_legacy(Rect::INVALID_RECT),
+ frameNumber_legacy(0),
overrideScalingMode(-1) {
matrix.dsdx = matrix.dtdy = 1.0f;
matrix.dsdy = matrix.dtdx = 0.0f;
@@ -107,14 +107,14 @@
uint8_t mask;
uint8_t reserved;
matrix22_t matrix;
- Rect crop;
- Rect finalCrop;
- sp<IBinder> barrierHandle;
+ Rect crop_legacy;
+ Rect finalCrop_legacy;
+ sp<IBinder> barrierHandle_legacy;
sp<IBinder> reparentHandle;
- uint64_t frameNumber;
+ uint64_t frameNumber_legacy;
int32_t overrideScalingMode;
- sp<IGraphicBufferProducer> barrierGbp;
+ sp<IGraphicBufferProducer> barrierGbp_legacy;
sp<IBinder> relativeLayerHandle;
diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h
index 34708c7..278a642 100644
--- a/libs/gui/include/gui/SurfaceComposerClient.h
+++ b/libs/gui/include/gui/SurfaceComposerClient.h
@@ -200,22 +200,21 @@
float alpha);
Transaction& setMatrix(const sp<SurfaceControl>& sc,
float dsdx, float dtdx, float dtdy, float dsdy);
- Transaction& setCrop(const sp<SurfaceControl>& sc, const Rect& crop);
- Transaction& setFinalCrop(const sp<SurfaceControl>& sc, const Rect& crop);
+ Transaction& setCrop_legacy(const sp<SurfaceControl>& sc, const Rect& crop);
+ Transaction& setFinalCrop_legacy(const sp<SurfaceControl>& sc, const Rect& crop);
Transaction& setLayerStack(const sp<SurfaceControl>& sc, uint32_t layerStack);
// Defers applying any changes made in this transaction until the Layer
// identified by handle reaches the given frameNumber. If the Layer identified
// by handle is removed, then we will apply this transaction regardless of
// what frame number has been reached.
- Transaction& deferTransactionUntil(const sp<SurfaceControl>& sc,
- const sp<IBinder>& handle,
- uint64_t frameNumber);
- // A variant of deferTransactionUntil which identifies the Layer we wait for by
+ Transaction& deferTransactionUntil_legacy(const sp<SurfaceControl>& sc,
+ const sp<IBinder>& handle, uint64_t frameNumber);
+ // A variant of deferTransactionUntil_legacy which identifies the Layer we wait for by
// Surface instead of Handle. Useful for clients which may not have the
// SurfaceControl for some of their Surfaces. Otherwise behaves identically.
- Transaction& deferTransactionUntil(const sp<SurfaceControl>& sc,
- const sp<Surface>& barrierSurface,
- uint64_t frameNumber);
+ Transaction& deferTransactionUntil_legacy(const sp<SurfaceControl>& sc,
+ const sp<Surface>& barrierSurface,
+ uint64_t frameNumber);
// Reparents all children of this layer to the new parent handle.
Transaction& reparentChildren(const sp<SurfaceControl>& sc,
const sp<IBinder>& newParentHandle);
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp
index 7246c8e..6484245 100644
--- a/services/surfaceflinger/BufferLayer.cpp
+++ b/services/surfaceflinger/BufferLayer.cpp
@@ -518,7 +518,7 @@
// FIXME: postedRegion should be dirty & bounds
// transform the dirty region to window-manager space
- return getTransform().transform(Region(Rect(s.active.w, s.active.h)));
+ return getTransform().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h)));
}
// transaction
@@ -641,9 +641,9 @@
Transform t = getTransform();
Rect win = bounds;
- if (!s.finalCrop.isEmpty()) {
+ if (!s.finalCrop_legacy.isEmpty()) {
win = t.transform(win);
- if (!win.intersect(s.finalCrop, &win)) {
+ if (!win.intersect(s.finalCrop_legacy, &win)) {
win.clear();
}
win = t.inverse().transform(win);
@@ -652,10 +652,10 @@
}
}
- float left = float(win.left) / float(s.active.w);
- float top = float(win.top) / float(s.active.h);
- float right = float(win.right) / float(s.active.w);
- float bottom = float(win.bottom) / float(s.active.h);
+ float left = float(win.left) / float(s.active_legacy.w);
+ float top = float(win.top) / float(s.active_legacy.h);
+ float right = float(win.right) / float(s.active_legacy.w);
+ float bottom = float(win.bottom) / float(s.active_legacy.h);
// TODO: we probably want to generate the texture coords with the mesh
// here we assume that we only have 4 vertices
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
index d5a94b7..1bf9cf2 100644
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ b/services/surfaceflinger/BufferQueueLayer.cpp
@@ -38,7 +38,7 @@
mActiveBufferSlot(BufferQueue::INVALID_BUFFER_SLOT),
mQueuedFrames(0),
mSidebandStreamChanged(false) {
- mCurrentState.requested = mCurrentState.active;
+ mCurrentState.requested_legacy = mCurrentState.active_legacy;
}
// -----------------------------------------------------------------------
@@ -219,7 +219,7 @@
recomputeVisibleRegions = true;
const State& s(getDrawingState());
- return getTransform().transform(Region(Rect(s.active.w, s.active.h)));
+ return getTransform().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h)));
}
return {};
}
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index b58269e..eeee0ae 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -99,19 +99,19 @@
mName = name;
mTransactionName = String8("TX - ") + mName;
- mCurrentState.active.w = w;
- mCurrentState.active.h = h;
+ mCurrentState.active_legacy.w = w;
+ mCurrentState.active_legacy.h = h;
mCurrentState.flags = layerFlags;
- mCurrentState.active.transform.set(0, 0);
- mCurrentState.crop.makeInvalid();
- mCurrentState.finalCrop.makeInvalid();
- mCurrentState.requestedFinalCrop = mCurrentState.finalCrop;
- mCurrentState.requestedCrop = mCurrentState.crop;
+ mCurrentState.active_legacy.transform.set(0, 0);
+ mCurrentState.crop_legacy.makeInvalid();
+ mCurrentState.finalCrop_legacy.makeInvalid();
+ mCurrentState.requestedFinalCrop_legacy = mCurrentState.finalCrop_legacy;
+ mCurrentState.requestedCrop_legacy = mCurrentState.crop_legacy;
mCurrentState.z = 0;
mCurrentState.color.a = 1.0f;
mCurrentState.layerStack = 0;
mCurrentState.sequence = 0;
- mCurrentState.requested = mCurrentState.active;
+ mCurrentState.requested_legacy = mCurrentState.active_legacy;
mCurrentState.appId = 0;
mCurrentState.type = 0;
@@ -293,17 +293,17 @@
Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const {
const Layer::State& s(getDrawingState());
- Rect win(s.active.w, s.active.h);
+ Rect win(s.active_legacy.w, s.active_legacy.h);
- if (!s.crop.isEmpty()) {
- win.intersect(s.crop, &win);
+ if (!s.crop_legacy.isEmpty()) {
+ win.intersect(s.crop_legacy, &win);
}
Transform t = getTransform();
win = t.transform(win);
- if (!s.finalCrop.isEmpty()) {
- win.intersect(s.finalCrop, &win);
+ if (!s.finalCrop_legacy.isEmpty()) {
+ win.intersect(s.finalCrop_legacy, &win);
}
const sp<Layer>& p = mDrawingParent.promote();
@@ -322,7 +322,7 @@
}
if (reduceTransparentRegion) {
- auto const screenTransparentRegion = t.transform(s.activeTransparentRegion);
+ auto const screenTransparentRegion = t.transform(s.activeTransparentRegion_legacy);
win = reduce(win, screenTransparentRegion);
}
@@ -331,15 +331,15 @@
FloatRect Layer::computeBounds() const {
const Layer::State& s(getDrawingState());
- return computeBounds(s.activeTransparentRegion);
+ return computeBounds(s.activeTransparentRegion_legacy);
}
FloatRect Layer::computeBounds(const Region& activeTransparentRegion) const {
const Layer::State& s(getDrawingState());
- Rect win(s.active.w, s.active.h);
+ Rect win(s.active_legacy.w, s.active_legacy.h);
- if (!s.crop.isEmpty()) {
- win.intersect(s.crop, &win);
+ if (!s.crop_legacy.isEmpty()) {
+ win.intersect(s.crop_legacy, &win);
}
const auto& p = mDrawingParent.promote();
@@ -351,15 +351,14 @@
parentBounds = p->computeBounds(Region());
}
- Transform t = s.active.transform;
+ Transform t = s.active_legacy.transform;
-
- if (p != nullptr || !s.finalCrop.isEmpty()) {
+ if (p != nullptr || !s.finalCrop_legacy.isEmpty()) {
floatWin = t.transform(floatWin);
floatWin = floatWin.intersect(parentBounds);
- if (!s.finalCrop.isEmpty()) {
- floatWin = floatWin.intersect(s.finalCrop.toFloatRect());
+ if (!s.finalCrop_legacy.isEmpty()) {
+ floatWin = floatWin.intersect(s.finalCrop_legacy.toFloatRect());
}
floatWin = t.inverse().transform(floatWin);
}
@@ -380,9 +379,9 @@
// FIXME: the 3 lines below can produce slightly incorrect clipping when we have
// a viewport clipping and a window transform. we should use floating point to fix this.
- Rect activeCrop(s.active.w, s.active.h);
- if (!s.crop.isEmpty()) {
- activeCrop.intersect(s.crop, &activeCrop);
+ Rect activeCrop(s.active_legacy.w, s.active_legacy.h);
+ if (!s.crop_legacy.isEmpty()) {
+ activeCrop.intersect(s.crop_legacy, &activeCrop);
}
Transform t = getTransform();
@@ -390,8 +389,8 @@
if (!activeCrop.intersect(display->getViewport(), &activeCrop)) {
activeCrop.clear();
}
- if (!s.finalCrop.isEmpty()) {
- if (!activeCrop.intersect(s.finalCrop, &activeCrop)) {
+ if (!s.finalCrop_legacy.isEmpty()) {
+ if (!activeCrop.intersect(s.finalCrop_legacy, &activeCrop)) {
activeCrop.clear();
}
}
@@ -425,12 +424,12 @@
// transform.inverse().transform(transform.transform(Rect)) != Rect
// in which case we need to make sure the final rect is clipped to the
// display bounds.
- if (!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) {
+ if (!activeCrop.intersect(Rect(s.active_legacy.w, s.active_legacy.h), &activeCrop)) {
activeCrop.clear();
}
// subtract the transparent region and snap to the bounds
- activeCrop = reduce(activeCrop, s.activeTransparentRegion);
+ activeCrop = reduce(activeCrop, s.activeTransparentRegion_legacy);
// Transform the window crop to match the buffer coordinate system,
// which means using the inverse of the current transform set on the
@@ -450,8 +449,8 @@
invTransform = (Transform(invTransformOrient) * Transform(invTransform)).getOrientation();
}
- int winWidth = s.active.w;
- int winHeight = s.active.h;
+ int winWidth = s.active_legacy.w;
+ int winHeight = s.active_legacy.h;
if (invTransform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
// If the activeCrop has been rotate the ends are rotated but not
// the space itself so when transforming ends back we can't rely on
@@ -463,10 +462,10 @@
if (is_h_flipped == is_v_flipped) {
invTransform ^= NATIVE_WINDOW_TRANSFORM_FLIP_V | NATIVE_WINDOW_TRANSFORM_FLIP_H;
}
- winWidth = s.active.h;
- winHeight = s.active.w;
+ winWidth = s.active_legacy.h;
+ winHeight = s.active_legacy.w;
}
- const Rect winCrop = activeCrop.transform(invTransform, s.active.w, s.active.h);
+ const Rect winCrop = activeCrop.transform(invTransform, s.active_legacy.w, s.active_legacy.h);
// below, crop is intersected with winCrop expressed in crop's coordinate space
float xScale = crop.getWidth() / float(winWidth);
@@ -519,10 +518,10 @@
// apply the layer's transform, followed by the display's global transform
// here we're guaranteed that the layer's transform preserves rects
- Region activeTransparentRegion(s.activeTransparentRegion);
+ Region activeTransparentRegion(s.activeTransparentRegion_legacy);
Transform t = getTransform();
- if (!s.crop.isEmpty()) {
- Rect activeCrop(s.crop);
+ if (!s.crop_legacy.isEmpty()) {
+ Rect activeCrop(s.crop_legacy);
activeCrop = t.transform(activeCrop);
if (!activeCrop.intersect(display->getViewport(), &activeCrop)) {
activeCrop.clear();
@@ -534,22 +533,23 @@
// transform.inverse().transform(transform.transform(Rect)) != Rect
// in which case we need to make sure the final rect is clipped to the
// display bounds.
- if (!activeCrop.intersect(Rect(s.active.w, s.active.h), &activeCrop)) {
+ if (!activeCrop.intersect(Rect(s.active_legacy.w, s.active_legacy.h), &activeCrop)) {
activeCrop.clear();
}
// mark regions outside the crop as transparent
- activeTransparentRegion.orSelf(Rect(0, 0, s.active.w, activeCrop.top));
- activeTransparentRegion.orSelf(Rect(0, activeCrop.bottom, s.active.w, s.active.h));
+ activeTransparentRegion.orSelf(Rect(0, 0, s.active_legacy.w, activeCrop.top));
+ activeTransparentRegion.orSelf(
+ Rect(0, activeCrop.bottom, s.active_legacy.w, s.active_legacy.h));
activeTransparentRegion.orSelf(Rect(0, activeCrop.top, activeCrop.left, activeCrop.bottom));
activeTransparentRegion.orSelf(
- Rect(activeCrop.right, activeCrop.top, s.active.w, activeCrop.bottom));
+ Rect(activeCrop.right, activeCrop.top, s.active_legacy.w, activeCrop.bottom));
}
// computeBounds returns a FloatRect to provide more accuracy during the
// transformation. We then round upon constructing 'frame'.
Rect frame{t.transform(computeBounds(activeTransparentRegion))};
- if (!s.finalCrop.isEmpty()) {
- if (!frame.intersect(s.finalCrop, &frame)) {
+ if (!s.finalCrop_legacy.isEmpty()) {
+ if (!frame.intersect(s.finalCrop_legacy, &frame)) {
frame.clear();
}
}
@@ -682,16 +682,16 @@
// Apply the layer's transform, followed by the display's global transform
// Here we're guaranteed that the layer's transform preserves rects
- Rect win(s.active.w, s.active.h);
- if (!s.crop.isEmpty()) {
- win.intersect(s.crop, &win);
+ Rect win(s.active_legacy.w, s.active_legacy.h);
+ if (!s.crop_legacy.isEmpty()) {
+ win.intersect(s.crop_legacy, &win);
}
// Subtract the transparent region and snap to the bounds
- Rect bounds = reduce(win, s.activeTransparentRegion);
+ Rect bounds = reduce(win, s.activeTransparentRegion_legacy);
Rect frame(getTransform().transform(bounds));
frame.intersect(display->getViewport(), &frame);
- if (!s.finalCrop.isEmpty()) {
- frame.intersect(s.finalCrop, &frame);
+ if (!s.finalCrop_legacy.isEmpty()) {
+ frame.intersect(s.finalCrop_legacy, &frame);
}
auto& displayTransform = display->getTransform();
auto position = displayTransform.transform(frame);
@@ -844,11 +844,11 @@
rt = layerTransform.transform(rt);
}
- if (!s.finalCrop.isEmpty()) {
- boundPoint(<, s.finalCrop);
- boundPoint(&lb, s.finalCrop);
- boundPoint(&rb, s.finalCrop);
- boundPoint(&rt, s.finalCrop);
+ if (!s.finalCrop_legacy.isEmpty()) {
+ boundPoint(<, s.finalCrop_legacy);
+ boundPoint(&lb, s.finalCrop_legacy);
+ boundPoint(&rb, s.finalCrop_legacy);
+ boundPoint(&rt, s.finalCrop_legacy);
}
Mesh::VertexArray<vec2> position(mesh.getPositionArray<vec2>());
@@ -898,22 +898,22 @@
// If this transaction is waiting on the receipt of a frame, generate a sync
// point and send it to the remote layer.
- if (mCurrentState.barrierLayer != nullptr) {
- sp<Layer> barrierLayer = mCurrentState.barrierLayer.promote();
+ if (mCurrentState.barrierLayer_legacy != nullptr) {
+ sp<Layer> barrierLayer = mCurrentState.barrierLayer_legacy.promote();
if (barrierLayer == nullptr) {
ALOGE("[%s] Unable to promote barrier Layer.", mName.string());
// If we can't promote the layer we are intended to wait on,
// then it is expired or otherwise invalid. Allow this transaction
// to be applied as per normal (no synchronization).
- mCurrentState.barrierLayer = nullptr;
+ mCurrentState.barrierLayer_legacy = nullptr;
} else {
- auto syncPoint = std::make_shared<SyncPoint>(mCurrentState.frameNumber);
+ auto syncPoint = std::make_shared<SyncPoint>(mCurrentState.frameNumber_legacy);
if (barrierLayer->addSyncPoint(syncPoint)) {
mRemoteSyncPoints.push_back(std::move(syncPoint));
} else {
// We already missed the frame we're supposed to synchronize
// on, so go ahead and apply the state update
- mCurrentState.barrierLayer = nullptr;
+ mCurrentState.barrierLayer_legacy = nullptr;
}
}
@@ -935,7 +935,7 @@
bool Layer::applyPendingStates(State* stateToCommit) {
bool stateUpdateAvailable = false;
while (!mPendingStates.empty()) {
- if (mPendingStates[0].barrierLayer != nullptr) {
+ if (mPendingStates[0].barrierLayer_legacy != nullptr) {
if (mRemoteSyncPoints.empty()) {
// If we don't have a sync point for this, apply it anyway. It
// will be visually wrong, but it should keep us from getting
@@ -946,7 +946,8 @@
continue;
}
- if (mRemoteSyncPoints.front()->getFrameNumber() != mPendingStates[0].frameNumber) {
+ if (mRemoteSyncPoints.front()->getFrameNumber() !=
+ mPendingStates[0].frameNumber_legacy) {
ALOGE("[%s] Unexpected sync point frame number found", mName.string());
// Signal our end of the sync point and then dispose of it
@@ -994,7 +995,8 @@
const Layer::State& s(getDrawingState());
- const bool sizeChanged = (c.requested.w != s.requested.w) || (c.requested.h != s.requested.h);
+ const bool sizeChanged = (c.requested_legacy.w != s.requested_legacy.w) ||
+ (c.requested_legacy.h != s.requested_legacy.h);
if (sizeChanged) {
// the size changed, we need to ask our client to request a new buffer
@@ -1004,16 +1006,17 @@
" requested={ wh={%4u,%4u} }}\n"
" drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) }\n"
" requested={ wh={%4u,%4u} }}\n",
- this, getName().string(), mCurrentTransform,
- getEffectiveScalingMode(), c.active.w, c.active.h, c.crop.left, c.crop.top,
- c.crop.right, c.crop.bottom, c.crop.getWidth(), c.crop.getHeight(), c.requested.w,
- c.requested.h, s.active.w, s.active.h, s.crop.left, s.crop.top, s.crop.right,
- s.crop.bottom, s.crop.getWidth(), s.crop.getHeight(), s.requested.w,
- s.requested.h);
+ this, getName().string(), mCurrentTransform, getEffectiveScalingMode(),
+ c.active_legacy.w, c.active_legacy.h, c.crop_legacy.left, c.crop_legacy.top,
+ c.crop_legacy.right, c.crop_legacy.bottom, c.crop_legacy.getWidth(),
+ c.crop_legacy.getHeight(), c.requested_legacy.w, c.requested_legacy.h,
+ s.active_legacy.w, s.active_legacy.h, s.crop_legacy.left, s.crop_legacy.top,
+ s.crop_legacy.right, s.crop_legacy.bottom, s.crop_legacy.getWidth(),
+ s.crop_legacy.getHeight(), s.requested_legacy.w, s.requested_legacy.h);
// record the new size, form this point on, when the client request
// a buffer, it'll get the new size.
- setDefaultBufferSize(c.requested.w, c.requested.h);
+ setDefaultBufferSize(c.requested_legacy.w, c.requested_legacy.h);
}
// Don't let Layer::doTransaction update the drawing state
@@ -1034,7 +1037,8 @@
// resizePending state is to avoid applying the state of the new buffer
// to the old buffer. However in the state where we don't have an old buffer
// there is no such concern but we may still be being used as a parent layer.
- const bool resizePending = ((c.requested.w != c.active.w) || (c.requested.h != c.active.h)) &&
+ const bool resizePending = ((c.requested_legacy.w != c.active_legacy.w) ||
+ (c.requested_legacy.h != c.active_legacy.h)) &&
(getBE().compositionInfo.mBuffer != nullptr);
if (!isFixedSize()) {
if (resizePending && getBE().compositionInfo.hwc.sidebandStream == nullptr) {
@@ -1061,18 +1065,18 @@
// Careful that "c" and editCurrentState may not begin as equivalent due to
// applyPendingStates in the presence of deferred transactions.
if (mFreezeGeometryUpdates) {
- float tx = c.active.transform.tx();
- float ty = c.active.transform.ty();
- c.active = c.requested;
- c.active.transform.set(tx, ty);
- editCurrentState.active = c.active;
+ float tx = c.active_legacy.transform.tx();
+ float ty = c.active_legacy.transform.ty();
+ c.active_legacy = c.requested_legacy;
+ c.active_legacy.transform.set(tx, ty);
+ editCurrentState.active_legacy = c.active_legacy;
} else {
- editCurrentState.active = editCurrentState.requested;
- c.active = c.requested;
+ editCurrentState.active_legacy = editCurrentState.requested_legacy;
+ c.active_legacy = c.requested_legacy;
}
}
- if (s.active != c.active) {
+ if (s.active_legacy != c.active_legacy) {
// invalidate and recompute the visible regions if needed
flags |= Layer::eVisibleRegion;
}
@@ -1083,8 +1087,9 @@
this->contentDirty = true;
// we may use linear filtering, if the matrix scales us
- const uint8_t type = c.active.transform.getType();
- mNeedsFiltering = (!c.active.transform.preserveRects() || (type >= Transform::SCALE));
+ const uint8_t type = c.active_legacy.transform.getType();
+ mNeedsFiltering =
+ (!c.active_legacy.transform.preserveRects() || (type >= Transform::SCALE));
}
// If the layer is hidden, signal and clear out all local sync points so
@@ -1112,20 +1117,21 @@
}
bool Layer::setPosition(float x, float y, bool immediate) {
- if (mCurrentState.requested.transform.tx() == x && mCurrentState.requested.transform.ty() == y)
+ if (mCurrentState.requested_legacy.transform.tx() == x &&
+ mCurrentState.requested_legacy.transform.ty() == y)
return false;
mCurrentState.sequence++;
// We update the requested and active position simultaneously because
// we want to apply the position portion of the transform matrix immediately,
// but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
- mCurrentState.requested.transform.set(x, y);
+ mCurrentState.requested_legacy.transform.set(x, y);
if (immediate && !mFreezeGeometryUpdates) {
// Here we directly update the active state
// unlike other setters, because we store it within
// the transform, but use different latching rules.
// b/38182305
- mCurrentState.active.transform.set(x, y);
+ mCurrentState.active_legacy.transform.set(x, y);
}
mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate;
@@ -1225,9 +1231,10 @@
}
bool Layer::setSize(uint32_t w, uint32_t h) {
- if (mCurrentState.requested.w == w && mCurrentState.requested.h == h) return false;
- mCurrentState.requested.w = w;
- mCurrentState.requested.h = h;
+ if (mCurrentState.requested_legacy.w == w && mCurrentState.requested_legacy.h == h)
+ return false;
+ mCurrentState.requested_legacy.w = w;
+ mCurrentState.requested_legacy.h = h;
mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
@@ -1265,13 +1272,14 @@
return false;
}
mCurrentState.sequence++;
- mCurrentState.requested.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx, matrix.dsdy);
+ mCurrentState.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx,
+ matrix.dsdy);
mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setTransparentRegionHint(const Region& transparent) {
- mCurrentState.requestedTransparentRegion = transparent;
+ mCurrentState.requestedTransparentRegion_legacy = transparent;
mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
@@ -1286,12 +1294,12 @@
return true;
}
-bool Layer::setCrop(const Rect& crop, bool immediate) {
- if (mCurrentState.requestedCrop == crop) return false;
+bool Layer::setCrop_legacy(const Rect& crop, bool immediate) {
+ if (mCurrentState.requestedCrop_legacy == crop) return false;
mCurrentState.sequence++;
- mCurrentState.requestedCrop = crop;
+ mCurrentState.requestedCrop_legacy = crop;
if (immediate && !mFreezeGeometryUpdates) {
- mCurrentState.crop = crop;
+ mCurrentState.crop_legacy = crop;
}
mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate;
@@ -1300,12 +1308,12 @@
return true;
}
-bool Layer::setFinalCrop(const Rect& crop, bool immediate) {
- if (mCurrentState.requestedFinalCrop == crop) return false;
+bool Layer::setFinalCrop_legacy(const Rect& crop, bool immediate) {
+ if (mCurrentState.requestedFinalCrop_legacy == crop) return false;
mCurrentState.sequence++;
- mCurrentState.requestedFinalCrop = crop;
+ mCurrentState.requestedFinalCrop_legacy = crop;
if (immediate && !mFreezeGeometryUpdates) {
- mCurrentState.finalCrop = crop;
+ mCurrentState.finalCrop_legacy = crop;
}
mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate;
@@ -1345,24 +1353,23 @@
return p->getLayerStack();
}
-void Layer::deferTransactionUntil(const sp<Layer>& barrierLayer, uint64_t frameNumber) {
- mCurrentState.barrierLayer = barrierLayer;
- mCurrentState.frameNumber = frameNumber;
+void Layer::deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber) {
+ mCurrentState.barrierLayer_legacy = barrierLayer;
+ mCurrentState.frameNumber_legacy = frameNumber;
// We don't set eTransactionNeeded, because just receiving a deferral
// request without any other state updates shouldn't actually induce a delay
mCurrentState.modified = true;
pushPendingState();
- mCurrentState.barrierLayer = nullptr;
- mCurrentState.frameNumber = 0;
+ mCurrentState.barrierLayer_legacy = nullptr;
+ mCurrentState.frameNumber_legacy = 0;
mCurrentState.modified = false;
}
-void Layer::deferTransactionUntil(const sp<IBinder>& barrierHandle, uint64_t frameNumber) {
+void Layer::deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle, uint64_t frameNumber) {
sp<Handle> handle = static_cast<Handle*>(barrierHandle.get());
- deferTransactionUntil(handle->owner.promote(), frameNumber);
+ deferTransactionUntil_legacy(handle->owner.promote(), frameNumber);
}
-
// ----------------------------------------------------------------------------
// pageflip handling...
// ----------------------------------------------------------------------------
@@ -1415,25 +1422,25 @@
sp<Layer> parent = getParent();
info.mParentName = (parent == nullptr ? std::string("none") : parent->getName().string());
info.mType = String8(getTypeId());
- info.mTransparentRegion = ds.activeTransparentRegion;
+ info.mTransparentRegion = ds.activeTransparentRegion_legacy;
info.mVisibleRegion = visibleRegion;
info.mSurfaceDamageRegion = surfaceDamageRegion;
info.mLayerStack = getLayerStack();
- info.mX = ds.active.transform.tx();
- info.mY = ds.active.transform.ty();
+ info.mX = ds.active_legacy.transform.tx();
+ info.mY = ds.active_legacy.transform.ty();
info.mZ = ds.z;
- info.mWidth = ds.active.w;
- info.mHeight = ds.active.h;
- info.mCrop = ds.crop;
- info.mFinalCrop = ds.finalCrop;
+ info.mWidth = ds.active_legacy.w;
+ info.mHeight = ds.active_legacy.h;
+ info.mCrop = ds.crop_legacy;
+ info.mFinalCrop = ds.finalCrop_legacy;
info.mColor = ds.color;
info.mFlags = ds.flags;
info.mPixelFormat = getPixelFormat();
info.mDataSpace = static_cast<android_dataspace>(mCurrentDataSpace);
- info.mMatrix[0][0] = ds.active.transform[0][0];
- info.mMatrix[0][1] = ds.active.transform[0][1];
- info.mMatrix[1][0] = ds.active.transform[1][0];
- info.mMatrix[1][1] = ds.active.transform[1][1];
+ info.mMatrix[0][0] = ds.active_legacy.transform[0][0];
+ info.mMatrix[0][1] = ds.active_legacy.transform[0][1];
+ info.mMatrix[1][0] = ds.active_legacy.transform[1][0];
+ info.mMatrix[1][1] = ds.active_legacy.transform[1][1];
{
sp<const GraphicBuffer> buffer = mActiveBuffer;
if (buffer != 0) {
@@ -1882,14 +1889,14 @@
bufferHeight = p->getBE().compositionInfo.mBuffer->getWidth();
bufferWidth = p->getBE().compositionInfo.mBuffer->getHeight();
}
- float sx = p->getDrawingState().active.w / static_cast<float>(bufferWidth);
- float sy = p->getDrawingState().active.h / static_cast<float>(bufferHeight);
+ float sx = p->getDrawingState().active_legacy.w / static_cast<float>(bufferWidth);
+ float sy = p->getDrawingState().active_legacy.h / static_cast<float>(bufferHeight);
Transform extraParentScaling;
extraParentScaling.set(sx, 0, 0, sy);
t = t * extraParentScaling;
}
}
- return t * getDrawingState().active.transform;
+ return t * getDrawingState().active_legacy.transform;
}
half Layer::getAlpha() const {
@@ -1918,7 +1925,7 @@
const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
const State& state = useDrawing ? mDrawingState : mCurrentState;
- Transform requestedTransform = state.active.transform;
+ Transform requestedTransform = state.active_legacy.transform;
Transform transform = getTransform();
layerInfo->set_id(sequence);
@@ -1936,7 +1943,7 @@
}
}
- LayerProtoHelper::writeToProto(state.activeTransparentRegion,
+ LayerProtoHelper::writeToProto(state.activeTransparentRegion_legacy,
layerInfo->mutable_transparent_region());
LayerProtoHelper::writeToProto(visibleRegion, layerInfo->mutable_visible_region());
LayerProtoHelper::writeToProto(surfaceDamageRegion, layerInfo->mutable_damage_region());
@@ -1953,11 +1960,11 @@
requestedPosition->set_y(requestedTransform.ty());
SizeProto* size = layerInfo->mutable_size();
- size->set_w(state.active.w);
- size->set_h(state.active.h);
+ size->set_w(state.active_legacy.w);
+ size->set_h(state.active_legacy.h);
- LayerProtoHelper::writeToProto(state.crop, layerInfo->mutable_crop());
- LayerProtoHelper::writeToProto(state.finalCrop, layerInfo->mutable_final_crop());
+ LayerProtoHelper::writeToProto(state.crop_legacy, layerInfo->mutable_crop());
+ LayerProtoHelper::writeToProto(state.finalCrop_legacy, layerInfo->mutable_final_crop());
layerInfo->set_is_opaque(isOpaque(state));
layerInfo->set_invalidate(contentDirty);
@@ -1998,11 +2005,11 @@
layerInfo->set_curr_frame(mCurrentFrameNumber);
for (const auto& pendingState : mPendingStates) {
- auto barrierLayer = pendingState.barrierLayer.promote();
+ auto barrierLayer = pendingState.barrierLayer_legacy.promote();
if (barrierLayer != nullptr) {
BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();
barrierLayerProto->set_id(barrierLayer->sequence);
- barrierLayerProto->set_frame_number(pendingState.frameNumber);
+ barrierLayerProto->set_frame_number(pendingState.frameNumber_legacy);
}
}
}
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 94f086c..96ec84b 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -111,8 +111,8 @@
};
struct State {
- Geometry active;
- Geometry requested;
+ Geometry active_legacy;
+ Geometry requested_legacy;
int32_t z;
// The identifier of the layer stack this layer belongs to. A layer can
@@ -128,23 +128,23 @@
bool modified;
// Crop is expressed in layer space coordinate.
- Rect crop;
- Rect requestedCrop;
+ Rect crop_legacy;
+ Rect requestedCrop_legacy;
// finalCrop is expressed in display space coordinate.
- Rect finalCrop;
- Rect requestedFinalCrop;
+ Rect finalCrop_legacy;
+ Rect requestedFinalCrop_legacy;
// If set, defers this state update until the identified Layer
// receives a frame with the given frameNumber
- wp<Layer> barrierLayer;
- uint64_t frameNumber;
+ wp<Layer> barrierLayer_legacy;
+ uint64_t frameNumber_legacy;
// the transparentRegion hint is a bit special, it's latched only
// when we receive a buffer -- this is because it's "content"
// dependent.
- Region activeTransparentRegion;
- Region requestedTransparentRegion;
+ Region activeTransparentRegion_legacy;
+ Region requestedTransparentRegion_legacy;
int32_t appId;
int32_t type;
@@ -207,9 +207,9 @@
// space for top-level layers.
bool setPosition(float x, float y, bool immediate);
// Buffer space
- bool setCrop(const Rect& crop, bool immediate);
+ bool setCrop_legacy(const Rect& crop, bool immediate);
// Parent buffer space/display space
- bool setFinalCrop(const Rect& crop, bool immediate);
+ bool setFinalCrop_legacy(const Rect& crop, bool immediate);
// TODO(b/38182121): Could we eliminate the various latching modes by
// using the layer hierarchy?
@@ -223,8 +223,8 @@
bool setFlags(uint8_t flags, uint8_t mask);
bool setLayerStack(uint32_t layerStack);
uint32_t getLayerStack() const;
- void deferTransactionUntil(const sp<IBinder>& barrierHandle, uint64_t frameNumber);
- void deferTransactionUntil(const sp<Layer>& barrierLayer, uint64_t frameNumber);
+ void deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle, uint64_t frameNumber);
+ void deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber);
bool setOverrideScalingMode(int32_t overrideScalingMode);
void setInfo(int32_t type, int32_t appId);
bool reparentChildren(const sp<IBinder>& layer);
diff --git a/services/surfaceflinger/LayerRejecter.cpp b/services/surfaceflinger/LayerRejecter.cpp
index 381ea4a..fd0ca82 100644
--- a/services/surfaceflinger/LayerRejecter.cpp
+++ b/services/surfaceflinger/LayerRejecter.cpp
@@ -65,20 +65,21 @@
int actualScalingMode = mOverrideScalingMode >= 0 ? mOverrideScalingMode : item.mScalingMode;
bool isFixedSize = actualScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE;
- if (mFront.active != mFront.requested) {
- if (isFixedSize || (bufWidth == mFront.requested.w && bufHeight == mFront.requested.h)) {
+ if (mFront.active_legacy != mFront.requested_legacy) {
+ if (isFixedSize ||
+ (bufWidth == mFront.requested_legacy.w && bufHeight == mFront.requested_legacy.h)) {
// Here we pretend the transaction happened by updating the
// current and drawing states. Drawing state is only accessed
// in this thread, no need to have it locked
- mFront.active = mFront.requested;
+ mFront.active_legacy = mFront.requested_legacy;
// We also need to update the current state so that
// we don't end-up overwriting the drawing state with
// this stale current state during the next transaction
//
// NOTE: We don't need to hold the transaction lock here
- // because State::active is only accessed from this thread.
- mCurrent.active = mFront.active;
+ // because State::active_legacy is only accessed from this thread.
+ mCurrent.active_legacy = mFront.active_legacy;
mCurrent.modified = true;
// recompute visible region
@@ -86,14 +87,14 @@
mFreezeGeometryUpdates = false;
- if (mFront.crop != mFront.requestedCrop) {
- mFront.crop = mFront.requestedCrop;
- mCurrent.crop = mFront.requestedCrop;
+ if (mFront.crop_legacy != mFront.requestedCrop_legacy) {
+ mFront.crop_legacy = mFront.requestedCrop_legacy;
+ mCurrent.crop_legacy = mFront.requestedCrop_legacy;
mRecomputeVisibleRegions = true;
}
- if (mFront.finalCrop != mFront.requestedFinalCrop) {
- mFront.finalCrop = mFront.requestedFinalCrop;
- mCurrent.finalCrop = mFront.requestedFinalCrop;
+ if (mFront.finalCrop_legacy != mFront.requestedFinalCrop_legacy) {
+ mFront.finalCrop_legacy = mFront.requestedFinalCrop_legacy;
+ mCurrent.finalCrop_legacy = mFront.requestedFinalCrop_legacy;
mRecomputeVisibleRegions = true;
}
}
@@ -102,19 +103,20 @@
"[%s] latchBuffer/reject: buffer (%ux%u, tr=%02x), scalingMode=%d\n"
" drawing={ active ={ wh={%4u,%4u} crop={%4d,%4d,%4d,%4d} (%4d,%4d) "
"}\n"
- " requested={ wh={%4u,%4u} }}\n",
- mName, bufWidth, bufHeight, item.mTransform, item.mScalingMode, mFront.active.w,
- mFront.active.h, mFront.crop.left, mFront.crop.top, mFront.crop.right,
- mFront.crop.bottom, mFront.crop.getWidth(), mFront.crop.getHeight(),
- mFront.requested.w, mFront.requested.h);
+ " requested_legacy={ wh={%4u,%4u} }}\n",
+ mName, bufWidth, bufHeight, item.mTransform, item.mScalingMode,
+ mFront.active_legacy.w, mFront.active_legacy.h, mFront.crop_legacy.left,
+ mFront.crop_legacy.top, mFront.crop_legacy.right, mFront.crop_legacy.bottom,
+ mFront.crop_legacy.getWidth(), mFront.crop_legacy.getHeight(),
+ mFront.requested_legacy.w, mFront.requested_legacy.h);
}
if (!isFixedSize && !mStickyTransformSet) {
- if (mFront.active.w != bufWidth || mFront.active.h != bufHeight) {
+ if (mFront.active_legacy.w != bufWidth || mFront.active_legacy.h != bufHeight) {
// reject this buffer
ALOGE("[%s] rejecting buffer: "
- "bufWidth=%d, bufHeight=%d, front.active.{w=%d, h=%d}",
- mName, bufWidth, bufHeight, mFront.active.w, mFront.active.h);
+ "bufWidth=%d, bufHeight=%d, front.active_legacy.{w=%d, h=%d}",
+ mName, bufWidth, bufHeight, mFront.active_legacy.w, mFront.active_legacy.h);
return true;
}
}
@@ -127,16 +129,17 @@
// We latch the transparent region here, instead of above where we latch
// the rest of the geometry because it is only content but not necessarily
// resize dependent.
- if (!mFront.activeTransparentRegion.isTriviallyEqual(mFront.requestedTransparentRegion)) {
- mFront.activeTransparentRegion = mFront.requestedTransparentRegion;
+ if (!mFront.activeTransparentRegion_legacy.isTriviallyEqual(
+ mFront.requestedTransparentRegion_legacy)) {
+ mFront.activeTransparentRegion_legacy = mFront.requestedTransparentRegion_legacy;
// We also need to update the current state so that
// we don't end-up overwriting the drawing state with
// this stale current state during the next transaction
//
// NOTE: We don't need to hold the transaction lock here
- // because State::active is only accessed from this thread.
- mCurrent.activeTransparentRegion = mFront.activeTransparentRegion;
+ // because State::active_legacy is only accessed from this thread.
+ mCurrent.activeTransparentRegion_legacy = mFront.activeTransparentRegion_legacy;
// recompute visible region
mRecomputeVisibleRegions = true;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 64520d0..64f1eaf 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -2766,7 +2766,7 @@
if (translucent) {
if (tr.preserveRects()) {
// transform the transparent region
- transparentRegion = tr.transform(s.activeTransparentRegion);
+ transparentRegion = tr.transform(s.activeTransparentRegion_legacy);
} else {
// transformation too complex, can't do the
// transparent region optimization.
@@ -3400,7 +3400,7 @@
// If we are deferring transaction, make sure to push the pending state, as otherwise the
// pending state will also be deferred.
- if (what & layer_state_t::eDeferTransaction) {
+ if (what & layer_state_t::eDeferTransaction_legacy) {
layer->pushPendingState();
}
@@ -3485,12 +3485,12 @@
if (layer->setFlags(s.flags, s.mask))
flags |= eTraversalNeeded;
}
- if (what & layer_state_t::eCropChanged) {
- if (layer->setCrop(s.crop, !geometryAppliesWithResize))
+ if (what & layer_state_t::eCropChanged_legacy) {
+ if (layer->setCrop_legacy(s.crop_legacy, !geometryAppliesWithResize))
flags |= eTraversalNeeded;
}
- if (what & layer_state_t::eFinalCropChanged) {
- if (layer->setFinalCrop(s.finalCrop, !geometryAppliesWithResize))
+ if (what & layer_state_t::eFinalCropChanged_legacy) {
+ if (layer->setFinalCrop_legacy(s.finalCrop_legacy, !geometryAppliesWithResize))
flags |= eTraversalNeeded;
}
if (what & layer_state_t::eLayerStackChanged) {
@@ -3512,15 +3512,15 @@
flags |= eTransactionNeeded|eTraversalNeeded|eDisplayLayerStackChanged;
}
}
- if (what & layer_state_t::eDeferTransaction) {
- if (s.barrierHandle != nullptr) {
- layer->deferTransactionUntil(s.barrierHandle, s.frameNumber);
- } else if (s.barrierGbp != nullptr) {
- const sp<IGraphicBufferProducer>& gbp = s.barrierGbp;
+ if (what & layer_state_t::eDeferTransaction_legacy) {
+ if (s.barrierHandle_legacy != nullptr) {
+ layer->deferTransactionUntil_legacy(s.barrierHandle_legacy, s.frameNumber_legacy);
+ } else if (s.barrierGbp_legacy != nullptr) {
+ const sp<IGraphicBufferProducer>& gbp = s.barrierGbp_legacy;
if (authenticateSurfaceTextureLocked(gbp)) {
const auto& otherLayer =
(static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
- layer->deferTransactionUntil(otherLayer, s.frameNumber);
+ layer->deferTransactionUntil_legacy(otherLayer, s.frameNumber_legacy);
} else {
ALOGE("Attempt to defer transaction to to an"
" unrecognized GraphicBufferProducer");
@@ -4864,10 +4864,10 @@
const Transform& getTransform() const override { return mTransform; }
Rect getBounds() const override {
const Layer::State& layerState(mLayer->getDrawingState());
- return Rect(layerState.active.w, layerState.active.h);
+ return Rect(layerState.active_legacy.w, layerState.active_legacy.h);
}
- int getHeight() const override { return mLayer->getDrawingState().active.h; }
- int getWidth() const override { return mLayer->getDrawingState().active.w; }
+ int getHeight() const override { return mLayer->getDrawingState().active_legacy.h; }
+ int getWidth() const override { return mLayer->getDrawingState().active_legacy.w; }
bool isSecure() const override { return false; }
bool needsFiltering() const override { return false; }
Rect getSourceCrop() const override {
@@ -4935,12 +4935,12 @@
Rect crop(sourceCrop);
if (sourceCrop.width() <= 0) {
crop.left = 0;
- crop.right = parent->getCurrentState().active.w;
+ crop.right = parent->getCurrentState().active_legacy.w;
}
if (sourceCrop.height() <= 0) {
crop.top = 0;
- crop.bottom = parent->getCurrentState().active.h;
+ crop.bottom = parent->getCurrentState().active_legacy.h;
}
int32_t reqWidth = crop.width() * frameScale;
diff --git a/services/surfaceflinger/SurfaceInterceptor.cpp b/services/surfaceflinger/SurfaceInterceptor.cpp
index e70506d..c42213a 100644
--- a/services/surfaceflinger/SurfaceInterceptor.cpp
+++ b/services/surfaceflinger/SurfaceInterceptor.cpp
@@ -99,18 +99,20 @@
transaction->set_animation(layer->mTransactionFlags & BnSurfaceComposer::eAnimation);
const int32_t layerId(getLayerId(layer));
- addPositionLocked(transaction, layerId, layer->mCurrentState.active.transform.tx(),
- layer->mCurrentState.active.transform.ty());
+ addPositionLocked(transaction, layerId, layer->mCurrentState.active_legacy.transform.tx(),
+ layer->mCurrentState.active_legacy.transform.ty());
addDepthLocked(transaction, layerId, layer->mCurrentState.z);
addAlphaLocked(transaction, layerId, layer->mCurrentState.color.a);
- addTransparentRegionLocked(transaction, layerId, layer->mCurrentState.activeTransparentRegion);
+ addTransparentRegionLocked(transaction, layerId,
+ layer->mCurrentState.activeTransparentRegion_legacy);
addLayerStackLocked(transaction, layerId, layer->mCurrentState.layerStack);
- addCropLocked(transaction, layerId, layer->mCurrentState.crop);
- if (layer->mCurrentState.barrierLayer != nullptr) {
- addDeferTransactionLocked(transaction, layerId, layer->mCurrentState.barrierLayer.promote(),
- layer->mCurrentState.frameNumber);
+ addCropLocked(transaction, layerId, layer->mCurrentState.crop_legacy);
+ if (layer->mCurrentState.barrierLayer_legacy != nullptr) {
+ addDeferTransactionLocked(transaction, layerId,
+ layer->mCurrentState.barrierLayer_legacy.promote(),
+ layer->mCurrentState.frameNumber_legacy);
}
- addFinalCropLocked(transaction, layerId, layer->mCurrentState.finalCrop);
+ addFinalCropLocked(transaction, layerId, layer->mCurrentState.finalCrop_legacy);
addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode());
addFlagsLocked(transaction, layerId, layer->mCurrentState.flags);
}
@@ -353,25 +355,26 @@
if (state.what & layer_state_t::eLayerStackChanged) {
addLayerStackLocked(transaction, layerId, state.layerStack);
}
- if (state.what & layer_state_t::eCropChanged) {
- addCropLocked(transaction, layerId, state.crop);
+ if (state.what & layer_state_t::eCropChanged_legacy) {
+ addCropLocked(transaction, layerId, state.crop_legacy);
}
- if (state.what & layer_state_t::eDeferTransaction) {
+ if (state.what & layer_state_t::eDeferTransaction_legacy) {
sp<Layer> otherLayer = nullptr;
- if (state.barrierHandle != nullptr) {
- otherLayer = static_cast<Layer::Handle*>(state.barrierHandle.get())->owner.promote();
- } else if (state.barrierGbp != nullptr) {
- auto const& gbp = state.barrierGbp;
+ if (state.barrierHandle_legacy != nullptr) {
+ otherLayer =
+ static_cast<Layer::Handle*>(state.barrierHandle_legacy.get())->owner.promote();
+ } else if (state.barrierGbp_legacy != nullptr) {
+ auto const& gbp = state.barrierGbp_legacy;
if (mFlinger->authenticateSurfaceTextureLocked(gbp)) {
otherLayer = (static_cast<MonitoredProducer*>(gbp.get()))->getLayer();
} else {
ALOGE("Attempt to defer transaction to to an unrecognized GraphicBufferProducer");
}
}
- addDeferTransactionLocked(transaction, layerId, otherLayer, state.frameNumber);
+ addDeferTransactionLocked(transaction, layerId, otherLayer, state.frameNumber_legacy);
}
- if (state.what & layer_state_t::eFinalCropChanged) {
- addFinalCropLocked(transaction, layerId, state.finalCrop);
+ if (state.what & layer_state_t::eFinalCropChanged_legacy) {
+ addFinalCropLocked(transaction, layerId, state.finalCrop_legacy);
}
if (state.what & layer_state_t::eOverrideScalingModeChanged) {
addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode);
@@ -422,8 +425,8 @@
SurfaceCreation* creation(increment->mutable_surface_creation());
creation->set_id(getLayerId(layer));
creation->set_name(getLayerName(layer));
- creation->set_w(layer->mCurrentState.active.w);
- creation->set_h(layer->mCurrentState.active.h);
+ creation->set_w(layer->mCurrentState.active_legacy.w);
+ creation->set_h(layer->mCurrentState.active_legacy.h);
}
void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
diff --git a/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp b/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp
index 135d2af..8ac2c87 100644
--- a/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp
+++ b/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp
@@ -320,11 +320,11 @@
}
void SurfaceInterceptorTest::cropUpdate(Transaction& t) {
- t.setCrop(mBGSurfaceControl, CROP_UPDATE);
+ t.setCrop_legacy(mBGSurfaceControl, CROP_UPDATE);
}
void SurfaceInterceptorTest::finalCropUpdate(Transaction& t) {
- t.setFinalCrop(mBGSurfaceControl, CROP_UPDATE);
+ t.setFinalCrop_legacy(mBGSurfaceControl, CROP_UPDATE);
}
void SurfaceInterceptorTest::matrixUpdate(Transaction& t) {
@@ -357,7 +357,8 @@
}
void SurfaceInterceptorTest::deferredTransactionUpdate(Transaction& t) {
- t.deferTransactionUntil(mBGSurfaceControl, mBGSurfaceControl->getHandle(), DEFERRED_UPDATE);
+ t.deferTransactionUntil_legacy(mBGSurfaceControl, mBGSurfaceControl->getHandle(),
+ DEFERRED_UPDATE);
}
void SurfaceInterceptorTest::displayCreation(Transaction&) {
diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp
index 5108279..2ce32b5 100644
--- a/services/surfaceflinger/tests/Transaction_test.cpp
+++ b/services/surfaceflinger/tests/Transaction_test.cpp
@@ -1188,7 +1188,7 @@
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
const Rect crop(8, 8, 24, 24);
- Transaction().setCrop(layer, crop).apply();
+ Transaction().setCrop_legacy(layer, crop).apply();
auto shot = screenshot();
shot->expectColor(crop, Color::RED);
shot->expectBorder(crop, Color::BLACK);
@@ -1201,13 +1201,13 @@
{
SCOPED_TRACE("empty rect");
- Transaction().setCrop(layer, Rect(8, 8, 8, 8)).apply();
+ Transaction().setCrop_legacy(layer, Rect(8, 8, 8, 8)).apply();
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
{
SCOPED_TRACE("negative rect");
- Transaction().setCrop(layer, Rect(8, 8, 0, 0)).apply();
+ Transaction().setCrop_legacy(layer, Rect(8, 8, 0, 0)).apply();
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
}
@@ -1217,7 +1217,7 @@
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
- Transaction().setCrop(layer, Rect(-128, -64, 128, 64)).apply();
+ Transaction().setCrop_legacy(layer, Rect(-128, -64, 128, 64)).apply();
auto shot = screenshot();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
@@ -1230,7 +1230,7 @@
const Point position(32, 32);
const Rect crop(8, 8, 24, 24);
- Transaction().setPosition(layer, position.x, position.y).setCrop(layer, crop).apply();
+ Transaction().setPosition(layer, position.x, position.y).setCrop_legacy(layer, crop).apply();
auto shot = screenshot();
shot->expectColor(crop + position, Color::RED);
shot->expectBorder(crop + position, Color::BLACK);
@@ -1244,7 +1244,7 @@
// crop is affected by matrix
Transaction()
.setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f)
- .setCrop(layer, Rect(8, 8, 24, 24))
+ .setCrop_legacy(layer, Rect(8, 8, 24, 24))
.apply();
auto shot = screenshot();
shot->expectColor(Rect(16, 16, 48, 48), Color::RED);
@@ -1256,8 +1256,8 @@
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
- // setCrop is applied immediately by default, with or without resize pending
- Transaction().setCrop(layer, Rect(8, 8, 24, 24)).setSize(layer, 16, 16).apply();
+ // 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 = screenshot();
@@ -1279,14 +1279,17 @@
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
- // request setCrop to be applied with the next resize
- Transaction().setCrop(layer, Rect(8, 8, 24, 24)).setGeometryAppliesWithResize(layer).apply();
+ // 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");
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
- Transaction().setCrop(layer, Rect(4, 4, 12, 12)).apply();
+ Transaction().setCrop_legacy(layer, Rect(4, 4, 12, 12)).apply();
{
SCOPED_TRACE("pending crop modified");
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
@@ -1313,9 +1316,9 @@
ASSERT_NO_FATAL_FAILURE(layer = createLayer("test", 32, 32));
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
- // setCrop is not immediate even with SCALE_TO_WINDOW override
+ // setCrop_legacy is not immediate even with SCALE_TO_WINDOW override
Transaction()
- .setCrop(layer, Rect(4, 4, 12, 12))
+ .setCrop_legacy(layer, Rect(4, 4, 12, 12))
.setSize(layer, 16, 16)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.setGeometryAppliesWithResize(layer)
@@ -1346,7 +1349,7 @@
const Rect crop(8, 8, 24, 24);
// same as in SetCropBasic
- Transaction().setFinalCrop(layer, crop).apply();
+ Transaction().setFinalCrop_legacy(layer, crop).apply();
auto shot = screenshot();
shot->expectColor(crop, Color::RED);
shot->expectBorder(crop, Color::BLACK);
@@ -1360,13 +1363,13 @@
// same as in SetCropEmpty
{
SCOPED_TRACE("empty rect");
- Transaction().setFinalCrop(layer, Rect(8, 8, 8, 8)).apply();
+ Transaction().setFinalCrop_legacy(layer, Rect(8, 8, 8, 8)).apply();
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
{
SCOPED_TRACE("negative rect");
- Transaction().setFinalCrop(layer, Rect(8, 8, 0, 0)).apply();
+ Transaction().setFinalCrop_legacy(layer, Rect(8, 8, 0, 0)).apply();
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
}
@@ -1377,7 +1380,7 @@
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
// same as in SetCropOutOfBounds
- Transaction().setFinalCrop(layer, Rect(-128, -64, 128, 64)).apply();
+ Transaction().setFinalCrop_legacy(layer, Rect(-128, -64, 128, 64)).apply();
auto shot = screenshot();
shot->expectColor(Rect(0, 0, 32, 32), Color::RED);
shot->expectBorder(Rect(0, 0, 32, 32), Color::BLACK);
@@ -1389,7 +1392,7 @@
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
// final crop is applied post-translation
- Transaction().setPosition(layer, 16, 16).setFinalCrop(layer, Rect(8, 8, 24, 24)).apply();
+ Transaction().setPosition(layer, 16, 16).setFinalCrop_legacy(layer, Rect(8, 8, 24, 24)).apply();
auto shot = screenshot();
shot->expectColor(Rect(16, 16, 24, 24), Color::RED);
shot->expectBorder(Rect(16, 16, 24, 24), Color::BLACK);
@@ -1403,7 +1406,7 @@
// final crop is not affected by matrix
Transaction()
.setMatrix(layer, 2.0f, 0.0f, 0.0f, 2.0f)
- .setFinalCrop(layer, Rect(8, 8, 24, 24))
+ .setFinalCrop_legacy(layer, Rect(8, 8, 24, 24))
.apply();
auto shot = screenshot();
shot->expectColor(Rect(8, 8, 24, 24), Color::RED);
@@ -1416,7 +1419,7 @@
ASSERT_NO_FATAL_FAILURE(fillLayerColor(layer, Color::RED));
// same as in SetCropWithResize
- Transaction().setFinalCrop(layer, Rect(8, 8, 24, 24)).setSize(layer, 16, 16).apply();
+ Transaction().setFinalCrop_legacy(layer, Rect(8, 8, 24, 24)).setSize(layer, 16, 16).apply();
{
SCOPED_TRACE("resize pending");
auto shot = screenshot();
@@ -1440,7 +1443,7 @@
// same as in SetCropWithNextResize
Transaction()
- .setFinalCrop(layer, Rect(8, 8, 24, 24))
+ .setFinalCrop_legacy(layer, Rect(8, 8, 24, 24))
.setGeometryAppliesWithResize(layer)
.apply();
{
@@ -1448,7 +1451,7 @@
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
}
- Transaction().setFinalCrop(layer, Rect(4, 4, 12, 12)).apply();
+ Transaction().setFinalCrop_legacy(layer, Rect(4, 4, 12, 12)).apply();
{
SCOPED_TRACE("pending final crop modified");
screenshot()->expectColor(Rect(0, 0, 32, 32), Color::RED);
@@ -1477,7 +1480,7 @@
// same as in SetCropWithNextResizeScaleToWindow
Transaction()
- .setFinalCrop(layer, Rect(4, 4, 12, 12))
+ .setFinalCrop_legacy(layer, Rect(4, 4, 12, 12))
.setSize(layer, 16, 16)
.setOverrideScalingMode(layer, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW)
.setGeometryAppliesWithResize(layer)
@@ -1649,8 +1652,8 @@
asTransaction([&](Transaction& t) {
t.setSize(mFGSurfaceControl, 64, 64);
t.setPosition(mFGSurfaceControl, 64, 64);
- t.setCrop(mFGSurfaceControl, Rect(0, 0, 64, 64));
- t.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1));
+ t.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 64, 64));
+ t.setFinalCrop_legacy(mFGSurfaceControl, Rect(0, 0, -1, -1));
});
EXPECT_INITIAL_STATE("After restoring initial state");
@@ -1686,7 +1689,7 @@
// Normally the crop applies immediately even while a resize is pending.
asTransaction([&](Transaction& t) {
t.setSize(mFGSurfaceControl, 128, 128);
- t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ t.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
});
EXPECT_CROPPED_STATE("after setting crop (without geometryAppliesWithResize)");
@@ -1700,7 +1703,7 @@
asTransaction([&](Transaction& t) {
t.setSize(mFGSurfaceControl, 128, 128);
t.setGeometryAppliesWithResize(mFGSurfaceControl);
- t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ t.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
});
EXPECT_INITIAL_STATE("after setting crop (with geometryAppliesWithResize)");
@@ -1729,14 +1732,14 @@
// set up two deferred transactions on different frames
asTransaction([&](Transaction& t) {
t.setAlpha(mFGSurfaceControl, 0.75);
- t.deferTransactionUntil(mFGSurfaceControl, mSyncSurfaceControl->getHandle(),
- mSyncSurfaceControl->getSurface()->getNextFrameNumber());
+ t.deferTransactionUntil_legacy(mFGSurfaceControl, mSyncSurfaceControl->getHandle(),
+ mSyncSurfaceControl->getSurface()->getNextFrameNumber());
});
asTransaction([&](Transaction& t) {
t.setPosition(mFGSurfaceControl, 128, 128);
- t.deferTransactionUntil(mFGSurfaceControl, mSyncSurfaceControl->getHandle(),
- mSyncSurfaceControl->getSurface()->getNextFrameNumber() + 1);
+ t.deferTransactionUntil_legacy(mFGSurfaceControl, mSyncSurfaceControl->getHandle(),
+ mSyncSurfaceControl->getSurface()->getNextFrameNumber() + 1);
});
{
@@ -1881,7 +1884,7 @@
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
- t.setCrop(mFGSurfaceControl, Rect(0, 0, 5, 5));
+ t.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 5, 5));
});
{
@@ -1897,7 +1900,7 @@
t.show(mChild);
t.setPosition(mChild, 0, 0);
t.setPosition(mFGSurfaceControl, 0, 0);
- t.setFinalCrop(mFGSurfaceControl, Rect(0, 0, 5, 5));
+ t.setFinalCrop_legacy(mFGSurfaceControl, Rect(0, 0, 5, 5));
});
{
@@ -2166,8 +2169,8 @@
// Show the child layer in a deferred transaction
asTransaction([&](Transaction& t) {
- t.deferTransactionUntil(mChild, mFGSurfaceControl->getHandle(),
- mFGSurfaceControl->getSurface()->getNextFrameNumber());
+ t.deferTransactionUntil_legacy(mChild, mFGSurfaceControl->getHandle(),
+ mFGSurfaceControl->getSurface()->getNextFrameNumber());
t.show(mChild);
});
@@ -2465,8 +2468,9 @@
}
TEST_F(ScreenCaptureChildOnlyTest, CaptureLayerIgnoresParentCrop) {
-
- SurfaceComposerClient::Transaction().setCrop(mFGSurfaceControl, Rect(0, 0, 1, 1)).apply(true);
+ 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.
verify();
diff --git a/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp b/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp
index 070bd51..7fafab9 100644
--- a/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp
+++ b/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp
@@ -624,7 +624,7 @@
{
TransactionScope ts(*sFakeComposer);
Rect cropRect(16, 16, 32, 32);
- ts.setCrop(mFGSurfaceControl, cropRect);
+ ts.setCrop_legacy(mFGSurfaceControl, cropRect);
}
ASSERT_EQ(2, sFakeComposer->getFrameCount());
@@ -639,7 +639,7 @@
{
TransactionScope ts(*sFakeComposer);
Rect cropRect(32, 32, 32 + 64, 32 + 64);
- ts.setFinalCrop(mFGSurfaceControl, cropRect);
+ ts.setFinalCrop_legacy(mFGSurfaceControl, cropRect);
}
ASSERT_EQ(2, sFakeComposer->getFrameCount());
@@ -657,7 +657,7 @@
{
TransactionScope ts(*sFakeComposer);
Rect cropRect(16, 16, 32, 32);
- ts.setFinalCrop(mFGSurfaceControl, cropRect);
+ ts.setFinalCrop_legacy(mFGSurfaceControl, cropRect);
}
ASSERT_EQ(2, sFakeComposer->getFrameCount());
@@ -847,18 +847,16 @@
{
TransactionScope ts(*sFakeComposer);
ts.setAlpha(mFGSurfaceControl, 0.75);
- ts.deferTransactionUntil(mFGSurfaceControl,
- syncSurfaceControl->getHandle(),
- syncSurfaceControl->getSurface()->getNextFrameNumber());
+ ts.deferTransactionUntil_legacy(mFGSurfaceControl, syncSurfaceControl->getHandle(),
+ syncSurfaceControl->getSurface()->getNextFrameNumber());
}
EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
{
TransactionScope ts(*sFakeComposer);
ts.setPosition(mFGSurfaceControl, 128, 128);
- ts.deferTransactionUntil(mFGSurfaceControl,
- syncSurfaceControl->getHandle(),
- syncSurfaceControl->getSurface()->getNextFrameNumber() + 1);
+ ts.deferTransactionUntil_legacy(mFGSurfaceControl, syncSurfaceControl->getHandle(),
+ syncSurfaceControl->getSurface()->getNextFrameNumber() + 1);
}
EXPECT_EQ(4, sFakeComposer->getFrameCount());
EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame()));
@@ -981,7 +979,7 @@
ts.show(mChild);
ts.setPosition(mChild, 0, 0);
ts.setPosition(mFGSurfaceControl, 0, 0);
- ts.setCrop(mFGSurfaceControl, Rect(0, 0, 5, 5));
+ ts.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 5, 5));
}
// NOTE: The foreground surface would be occluded by the child
// now, but is included in the stack because the child is
@@ -1000,7 +998,7 @@
ts.show(mChild);
ts.setPosition(mChild, 0, 0);
ts.setPosition(mFGSurfaceControl, 0, 0);
- ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, 5, 5));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(0, 0, 5, 5));
}
auto referenceFrame = mBaseFrame;
referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5};
@@ -1238,8 +1236,8 @@
// Show the child layer in a deferred transaction
{
TransactionScope ts(*sFakeComposer);
- ts.deferTransactionUntil(mChild, mFGSurfaceControl->getHandle(),
- mFGSurfaceControl->getSurface()->getNextFrameNumber());
+ ts.deferTransactionUntil_legacy(mChild, mFGSurfaceControl->getHandle(),
+ mFGSurfaceControl->getSurface()->getNextFrameNumber());
ts.show(mChild);
}
@@ -1355,8 +1353,8 @@
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 64, 64);
ts.setPosition(mFGSurfaceControl, 64, 64);
- ts.setCrop(mFGSurfaceControl, Rect(0, 0, 64, 64));
- ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1));
+ ts.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 64, 64));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(0, 0, -1, -1));
}
};
@@ -1400,7 +1398,7 @@
{
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
- ts.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63));
+ ts.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 63, 63));
}
auto referenceFrame1 = mBaseFrame;
@@ -1414,7 +1412,7 @@
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
ts.setGeometryAppliesWithResize(mFGSurfaceControl);
- ts.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63));
+ ts.setCrop_legacy(mFGSurfaceControl, Rect(0, 0, 63, 63));
}
EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame()));
@@ -1432,7 +1430,7 @@
{
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
- ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
}
auto referenceFrame1 = mBaseFrame;
@@ -1447,7 +1445,7 @@
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
ts.setGeometryAppliesWithResize(mFGSurfaceControl);
- ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
}
EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame()));
@@ -1468,7 +1466,7 @@
{
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
- ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
}
auto referenceFrame1 = mBaseFrame;
@@ -1487,7 +1485,7 @@
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
ts.setGeometryAppliesWithResize(mFGSurfaceControl);
- ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
}
EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame()));
@@ -1516,12 +1514,12 @@
TransactionScope ts(*sFakeComposer);
ts.setSize(mFGSurfaceControl, 128, 128);
ts.setGeometryAppliesWithResize(mFGSurfaceControl);
- ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(64, 64, 127, 127));
}
{
TransactionScope ts(*sFakeComposer);
- ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1));
+ ts.setFinalCrop_legacy(mFGSurfaceControl, Rect(0, 0, -1, -1));
}
EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame()));