Changed ProjectionSpace struct to a class with getters
Bug:186475872
Test: atest ProjectionSpaceTest
Change-Id: Ib633044f637d491a7aca3fdf5f780cbde0ead5b4
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h
index 58bb41a..a63145a 100644
--- a/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h
+++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h
@@ -28,51 +28,36 @@
// Geometrical space to which content is projected.
// For example, this can be the layer space or the physical display space.
-struct ProjectionSpace {
+class ProjectionSpace {
+public:
ProjectionSpace() = default;
- ProjectionSpace(ui::Size size, Rect content)
- : bounds(std::move(size)), content(std::move(content)) {}
-
- // Bounds of this space. Always starts at (0,0).
- Rect bounds;
-
- // Rect onto which content is projected.
- Rect content;
-
- // The orientation of this space. This value is meaningful only in relation to the rotation
- // of another projection space and it's used to determine the rotating transformation when
- // mapping between the two.
- // As a convention when using this struct orientation = 0 for the "oriented*" projection
- // spaces. For example when the display is rotated 90 degress counterclockwise, the orientation
- // of the display space will become 90, while the orientation of the layer stack space will
- // remain the same.
- ui::Rotation orientation = ui::ROTATION_0;
+ ProjectionSpace(ui::Size size, Rect content) : mBounds(size), mContent(std::move(content)) {}
// Returns a transform which maps this.content into destination.content
// and also rotates according to this.orientation and destination.orientation
ui::Transform getTransform(const ProjectionSpace& destination) const {
- ui::Rotation rotation = destination.orientation - orientation;
+ ui::Rotation rotation = destination.getOrientation() - mOrientation;
// Compute a transformation which rotates the destination in a way it has the same
// orientation as us.
const uint32_t inverseRotationFlags = ui::Transform::toRotationFlags(-rotation);
ui::Transform inverseRotatingTransform;
- inverseRotatingTransform.set(inverseRotationFlags, destination.bounds.width(),
- destination.bounds.height());
+ inverseRotatingTransform.set(inverseRotationFlags, destination.getBounds().width,
+ destination.getBounds().height);
// The destination content rotated so it has the same orientation as us.
- Rect orientedDestContent = inverseRotatingTransform.transform(destination.content);
+ Rect orientedDestContent = inverseRotatingTransform.transform(destination.getContent());
// Compute translation from the source content to (0, 0).
- const float sourceX = content.left;
- const float sourceY = content.top;
+ const float sourceX = mContent.left;
+ const float sourceY = mContent.top;
ui::Transform sourceTranslation;
sourceTranslation.set(-sourceX, -sourceY);
// Compute scaling transform which maps source content to destination content, assuming
// they are both at (0, 0).
ui::Transform scale;
- const float scaleX = static_cast<float>(orientedDestContent.width()) / content.width();
- const float scaleY = static_cast<float>(orientedDestContent.height()) / content.height();
+ const float scaleX = static_cast<float>(orientedDestContent.width()) / mContent.width();
+ const float scaleY = static_cast<float>(orientedDestContent.height()) / mContent.height();
scale.set(scaleX, 0, 0, scaleY);
// Compute translation from (0, 0) to the orientated destination content.
@@ -83,8 +68,8 @@
// Compute rotation transform.
const uint32_t orientationFlags = ui::Transform::toRotationFlags(rotation);
- auto orientedDestWidth = destination.bounds.width();
- auto orientedDestHeight = destination.bounds.height();
+ auto orientedDestWidth = destination.getBounds().width;
+ auto orientedDestHeight = destination.getBounds().height;
if (rotation == ui::ROTATION_90 || rotation == ui::ROTATION_270) {
std::swap(orientedDestWidth, orientedDestHeight);
}
@@ -98,9 +83,39 @@
}
bool operator==(const ProjectionSpace& other) const {
- return bounds == other.bounds && content == other.content &&
- orientation == other.orientation;
+ return mBounds == other.mBounds && mContent == other.mContent &&
+ mOrientation == other.mOrientation;
}
+
+ void setBounds(ui::Size newBounds) { mBounds = std::move(newBounds); }
+
+ void setContent(Rect newContent) { mContent = std::move(newContent); }
+
+ void setOrientation(ui::Rotation newOrientation) { mOrientation = newOrientation; }
+
+ Rect getBoundsAsRect() const { return Rect(mBounds.getWidth(), mBounds.getHeight()); }
+
+ const ui::Size& getBounds() const { return mBounds; }
+
+ const Rect& getContent() const { return mContent; }
+
+ ui::Rotation getOrientation() const { return mOrientation; }
+
+private:
+ // Bounds of this space. Always starts at (0,0).
+ ui::Size mBounds = ui::Size();
+
+ // Rect onto which content is projected.
+ Rect mContent = Rect();
+
+ // The orientation of this space. This value is meaningful only in relation to the rotation
+ // of another projection space and it's used to determine the rotating transformation when
+ // mapping between the two.
+ // As a convention when using this struct orientation = 0 for the "oriented*" projection
+ // spaces. For example when the display is rotated 90 degress counterclockwise, the orientation
+ // of the display space will become 90, while the orientation of the layer stack space will
+ // remain the same.
+ ui::Rotation mOrientation = ui::ROTATION_0;
};
} // namespace compositionengine
@@ -108,8 +123,8 @@
inline std::string to_string(const android::compositionengine::ProjectionSpace& space) {
return android::base::
StringPrintf("ProjectionSpace(bounds = %s, content = %s, orientation = %s)",
- to_string(space.bounds).c_str(), to_string(space.content).c_str(),
- toCString(space.orientation));
+ to_string(space.getBoundsAsRect()).c_str(),
+ to_string(space.getContent()).c_str(), toCString(space.getOrientation()));
}
// Defining PrintTo helps with Google Tests.
diff --git a/services/surfaceflinger/CompositionEngine/src/Display.cpp b/services/surfaceflinger/CompositionEngine/src/Display.cpp
index 6b9ea87..02fa49f 100644
--- a/services/surfaceflinger/CompositionEngine/src/Display.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/Display.cpp
@@ -53,7 +53,7 @@
mId = args.id;
mPowerAdvisor = args.powerAdvisor;
editState().isSecure = args.isSecure;
- editState().displaySpace.bounds = Rect(args.pixels);
+ editState().displaySpace.setBounds(args.pixels);
setName(args.name);
}
diff --git a/services/surfaceflinger/CompositionEngine/src/Output.cpp b/services/surfaceflinger/CompositionEngine/src/Output.cpp
index 1747294..535458e 100644
--- a/services/surfaceflinger/CompositionEngine/src/Output.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/Output.cpp
@@ -156,38 +156,40 @@
const Rect& orientedDisplaySpaceRect) {
auto& outputState = editState();
- outputState.displaySpace.orientation = orientation;
- LOG_FATAL_IF(outputState.displaySpace.bounds == Rect::INVALID_RECT,
+ outputState.displaySpace.setOrientation(orientation);
+ LOG_FATAL_IF(outputState.displaySpace.getBoundsAsRect() == Rect::INVALID_RECT,
"The display bounds are unknown.");
// Compute orientedDisplaySpace
- ui::Size orientedSize = outputState.displaySpace.bounds.getSize();
+ ui::Size orientedSize = outputState.displaySpace.getBounds();
if (orientation == ui::ROTATION_90 || orientation == ui::ROTATION_270) {
std::swap(orientedSize.width, orientedSize.height);
}
- outputState.orientedDisplaySpace.bounds = Rect(orientedSize);
- outputState.orientedDisplaySpace.content = orientedDisplaySpaceRect;
+ outputState.orientedDisplaySpace.setBounds(orientedSize);
+ outputState.orientedDisplaySpace.setContent(orientedDisplaySpaceRect);
// Compute displaySpace.content
const uint32_t transformOrientationFlags = ui::Transform::toRotationFlags(orientation);
ui::Transform rotation;
if (transformOrientationFlags != ui::Transform::ROT_INVALID) {
- const auto displaySize = outputState.displaySpace.bounds;
+ const auto displaySize = outputState.displaySpace.getBoundsAsRect();
rotation.set(transformOrientationFlags, displaySize.width(), displaySize.height());
}
- outputState.displaySpace.content = rotation.transform(orientedDisplaySpaceRect);
+ outputState.displaySpace.setContent(rotation.transform(orientedDisplaySpaceRect));
// Compute framebufferSpace
- outputState.framebufferSpace.orientation = orientation;
- LOG_FATAL_IF(outputState.framebufferSpace.bounds == Rect::INVALID_RECT,
+ outputState.framebufferSpace.setOrientation(orientation);
+ LOG_FATAL_IF(outputState.framebufferSpace.getBoundsAsRect() == Rect::INVALID_RECT,
"The framebuffer bounds are unknown.");
- const auto scale =
- getScale(outputState.displaySpace.bounds, outputState.framebufferSpace.bounds);
- outputState.framebufferSpace.content = outputState.displaySpace.content.scale(scale.x, scale.y);
+ const auto scale = getScale(outputState.displaySpace.getBoundsAsRect(),
+ outputState.framebufferSpace.getBoundsAsRect());
+ outputState.framebufferSpace.setContent(
+ outputState.displaySpace.getContent().scale(scale.x, scale.y));
// Compute layerStackSpace
- outputState.layerStackSpace.content = layerStackSpaceRect;
- outputState.layerStackSpace.bounds = layerStackSpaceRect;
+ outputState.layerStackSpace.setContent(layerStackSpaceRect);
+ outputState.layerStackSpace.setBounds(
+ ui::Size(layerStackSpaceRect.getWidth(), layerStackSpaceRect.getHeight()));
outputState.transform = outputState.layerStackSpace.getTransform(outputState.displaySpace);
outputState.needsFiltering = outputState.transform.needsBilinearFiltering();
@@ -200,21 +202,21 @@
auto& state = editState();
// Update framebuffer space
- const Rect newBounds(size);
- state.framebufferSpace.bounds = newBounds;
+ const ui::Size newBounds(size);
+ state.framebufferSpace.setBounds(newBounds);
// Update display space
- state.displaySpace.bounds = newBounds;
+ state.displaySpace.setBounds(newBounds);
state.transform = state.layerStackSpace.getTransform(state.displaySpace);
// Update oriented display space
- const auto orientation = state.displaySpace.orientation;
+ const auto orientation = state.displaySpace.getOrientation();
ui::Size orientedSize = size;
if (orientation == ui::ROTATION_90 || orientation == ui::ROTATION_270) {
std::swap(orientedSize.width, orientedSize.height);
}
- const Rect newOrientedBounds(orientedSize);
- state.orientedDisplaySpace.bounds = newOrientedBounds;
+ const ui::Size newOrientedBounds(orientedSize);
+ state.orientedDisplaySpace.setBounds(newOrientedBounds);
if (mPlanner) {
mPlanner->setDisplaySize(size);
@@ -349,7 +351,7 @@
void Output::setRenderSurface(std::unique_ptr<compositionengine::RenderSurface> surface) {
mRenderSurface = std::move(surface);
const auto size = mRenderSurface->getSize();
- editState().framebufferSpace.bounds = Rect(size);
+ editState().framebufferSpace.setBounds(size);
if (mPlanner) {
mPlanner->setDisplaySize(size);
}
@@ -370,7 +372,7 @@
Region Output::getDirtyRegion() const {
const auto& outputState = getState();
- return outputState.dirtyRegion.intersect(outputState.layerStackSpace.content);
+ return outputState.dirtyRegion.intersect(outputState.layerStackSpace.getContent());
}
bool Output::includesLayer(ui::LayerFilter filter) const {
@@ -450,7 +452,7 @@
// Compute the resulting coverage for this output, and store it for later
const ui::Transform& tr = outputState.transform;
- Region undefinedRegion{outputState.displaySpace.bounds};
+ Region undefinedRegion{outputState.displaySpace.getBoundsAsRect()};
undefinedRegion.subtractSelf(tr.transform(coverage.aboveOpaqueLayers));
outputState.undefinedRegion = undefinedRegion;
@@ -647,7 +649,7 @@
// TODO(b/121291683): Why does this not use visibleRegion? (see outputSpaceVisibleRegion below)
const auto& outputState = getState();
Region drawRegion(outputState.transform.transform(visibleNonTransparentRegion));
- drawRegion.andSelf(outputState.displaySpace.bounds);
+ drawRegion.andSelf(outputState.displaySpace.getBoundsAsRect());
if (drawRegion.isEmpty()) {
return;
}
@@ -665,7 +667,7 @@
outputLayerState.visibleNonTransparentRegion = visibleNonTransparentRegion;
outputLayerState.coveredRegion = coveredRegion;
outputLayerState.outputSpaceVisibleRegion = outputState.transform.transform(
- visibleNonShadowRegion.intersect(outputState.layerStackSpace.content));
+ visibleNonShadowRegion.intersect(outputState.layerStackSpace.getContent()));
outputLayerState.shadowRegion = shadowRegion;
}
@@ -1038,10 +1040,10 @@
ALOGV("hasClientComposition");
renderengine::DisplaySettings clientCompositionDisplay;
- clientCompositionDisplay.physicalDisplay = outputState.framebufferSpace.content;
- clientCompositionDisplay.clip = outputState.layerStackSpace.content;
+ clientCompositionDisplay.physicalDisplay = outputState.framebufferSpace.getContent();
+ clientCompositionDisplay.clip = outputState.layerStackSpace.getContent();
clientCompositionDisplay.orientation =
- ui::Transform::toRotationFlags(outputState.displaySpace.orientation);
+ ui::Transform::toRotationFlags(outputState.displaySpace.getOrientation());
clientCompositionDisplay.outputDataspace = mDisplayColorProfile->hasWideColorGamut()
? outputState.dataspace
: ui::Dataspace::UNKNOWN;
@@ -1135,7 +1137,7 @@
ALOGV("Rendering client layers");
const auto& outputState = getState();
- const Region viewportRegion(outputState.layerStackSpace.content);
+ const Region viewportRegion(outputState.layerStackSpace.getContent());
bool firstLayer = true;
bool disableBlurs = false;
@@ -1198,7 +1200,7 @@
outputState.needsFiltering,
.isSecure = outputState.isSecure,
.supportsProtectedContent = supportsProtectedContent,
- .viewport = outputState.layerStackSpace.content,
+ .viewport = outputState.layerStackSpace.getContent(),
.dataspace = outputDataspace,
.realContentIsVisible = realContentIsVisible,
.clearContent = !clientComposition,
@@ -1305,7 +1307,7 @@
void Output::dirtyEntireOutput() {
auto& outputState = editState();
- outputState.dirtyRegion.set(outputState.displaySpace.bounds);
+ outputState.dirtyRegion.set(outputState.displaySpace.getBoundsAsRect());
}
void Output::chooseCompositionStrategy() {
diff --git a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
index 56e9d27..ecfd901 100644
--- a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
@@ -79,7 +79,7 @@
FloatRect activeCropFloat =
reduce(layerState.geomLayerBounds, layerState.transparentRegionHint);
- const Rect& viewport = getOutput().getState().layerStackSpace.content;
+ const Rect& viewport = getOutput().getState().layerStackSpace.getContent();
const ui::Transform& layerTransform = layerState.geomLayerTransform;
const ui::Transform& inverseLayerTransform = layerState.geomInverseLayerTransform;
// Transform to screen space.
@@ -136,7 +136,7 @@
* buffer
*/
uint32_t invTransformOrient =
- ui::Transform::toRotationFlags(outputState.displaySpace.orientation);
+ ui::Transform::toRotationFlags(outputState.displaySpace.getOrientation());
// calculate the inverse transform
if (invTransformOrient & HAL_TRANSFORM_ROT_90) {
invTransformOrient ^= HAL_TRANSFORM_FLIP_V | HAL_TRANSFORM_FLIP_H;
@@ -192,7 +192,7 @@
Rect activeCrop = layerState.geomCrop;
if (!activeCrop.isEmpty() && bufferSize.isValid()) {
activeCrop = layerTransform.transform(activeCrop);
- if (!activeCrop.intersect(outputState.layerStackSpace.content, &activeCrop)) {
+ if (!activeCrop.intersect(outputState.layerStackSpace.getContent(), &activeCrop)) {
activeCrop.clear();
}
activeCrop = inverseLayerTransform.transform(activeCrop, true);
@@ -228,7 +228,7 @@
geomLayerBounds.bottom += outset;
}
Rect frame{layerTransform.transform(reduce(geomLayerBounds, activeTransparentRegion))};
- if (!frame.intersect(outputState.layerStackSpace.content, &frame)) {
+ if (!frame.intersect(outputState.layerStackSpace.getContent(), &frame)) {
frame.clear();
}
const ui::Transform displayTransform{outputState.transform};
@@ -628,7 +628,7 @@
const auto& outputState = getOutput().getState();
Rect frame = layerFEState->cursorFrame;
- frame.intersect(outputState.layerStackSpace.content, &frame);
+ frame.intersect(outputState.layerStackSpace.getContent(), &frame);
Rect position = outputState.transform.transform(frame);
if (auto error = hwcLayer->setCursorPosition(position.left, position.top);
diff --git a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp
index 5bbd58e..e6b716e 100644
--- a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp
+++ b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp
@@ -159,13 +159,13 @@
void CachedSet::render(renderengine::RenderEngine& renderEngine, TexturePool& texturePool,
const OutputCompositionState& outputState) {
ATRACE_CALL();
- const Rect& viewport = outputState.layerStackSpace.content;
+ const Rect& viewport = outputState.layerStackSpace.getContent();
const ui::Dataspace& outputDataspace = outputState.dataspace;
const ui::Transform::RotationFlags orientation =
- ui::Transform::toRotationFlags(outputState.framebufferSpace.orientation);
+ ui::Transform::toRotationFlags(outputState.framebufferSpace.getOrientation());
renderengine::DisplaySettings displaySettings{
- .physicalDisplay = outputState.framebufferSpace.content,
+ .physicalDisplay = outputState.framebufferSpace.getContent(),
.clip = viewport,
.outputDataspace = outputDataspace,
.orientation = orientation,
@@ -282,7 +282,7 @@
mOutputSpace = outputState.framebufferSpace;
mTexture = texture;
mTexture->setReadyFence(mDrawFence);
- mOutputSpace.orientation = outputState.framebufferSpace.orientation;
+ mOutputSpace.setOrientation(outputState.framebufferSpace.getOrientation());
mOutputDataspace = outputDataspace;
mOrientation = orientation;
mSkipCount = 0;
diff --git a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp
index f2978f9..ed235b8 100644
--- a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp
@@ -876,7 +876,7 @@
mDisplay->editState().isEnabled = true;
mDisplay->editState().usesClientComposition = false;
- mDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
+ mDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
mDisplay->editState().dirtyRegion = Region::INVALID_REGION;
mDisplay->finishFrame({});
@@ -894,7 +894,7 @@
gpuDisplay->editState().isEnabled = true;
gpuDisplay->editState().usesClientComposition = false;
- gpuDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
+ gpuDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
gpuDisplay->editState().dirtyRegion = Region::INVALID_REGION;
gpuDisplay->finishFrame({});
@@ -912,9 +912,8 @@
gpuDisplay->editState().isEnabled = true;
gpuDisplay->editState().usesClientComposition = false;
- gpuDisplay->editState().layerStackSpace.content = Rect(0, 0, 1, 1);
+ gpuDisplay->editState().layerStackSpace.setContent(Rect(0, 0, 1, 1));
gpuDisplay->editState().dirtyRegion = Region(Rect(0, 0, 1, 1));
-
gpuDisplay->finishFrame({});
}
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp
index c8c6012..53b71b7 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp
@@ -158,7 +158,7 @@
mLayerFEState.geomBufferSize = Rect{0, 0, 1920, 1080};
mLayerFEState.geomBufferTransform = TR_IDENT;
- mOutputState.layerStackSpace.content = Rect{0, 0, 1920, 1080};
+ mOutputState.layerStackSpace.setContent(Rect{0, 0, 1920, 1080});
}
FloatRect calculateOutputSourceCrop() {
@@ -229,7 +229,7 @@
mLayerFEState.geomBufferUsesDisplayInverseTransform = entry.bufferInvDisplay;
mLayerFEState.geomBufferTransform = entry.buffer;
- mOutputState.displaySpace.orientation = toRotation(entry.display);
+ mOutputState.displaySpace.setOrientation(toRotation(entry.display));
EXPECT_THAT(calculateOutputSourceCrop(), entry.expected) << "entry " << i;
}
@@ -243,7 +243,7 @@
}
TEST_F(OutputLayerSourceCropTest, viewportAffectsCrop) {
- mOutputState.layerStackSpace.content = Rect{0, 0, 960, 540};
+ mOutputState.layerStackSpace.setContent(Rect{0, 0, 960, 540});
const FloatRect expected{0.f, 0.f, 960.f, 540.f};
EXPECT_THAT(calculateOutputSourceCrop(), expected);
@@ -265,7 +265,7 @@
mLayerFEState.geomCrop = Rect{0, 0, 1920, 1080};
mLayerFEState.geomLayerBounds = FloatRect{0.f, 0.f, 1920.f, 1080.f};
- mOutputState.layerStackSpace.content = Rect{0, 0, 1920, 1080};
+ mOutputState.layerStackSpace.setContent(Rect{0, 0, 1920, 1080});
mOutputState.transform = ui::Transform{TR_IDENT};
}
@@ -313,7 +313,7 @@
}
TEST_F(OutputLayerDisplayFrameTest, viewportAffectsFrame) {
- mOutputState.layerStackSpace.content = Rect{0, 0, 960, 540};
+ mOutputState.layerStackSpace.setContent(Rect{0, 0, 960, 540});
const Rect expected{0, 0, 960, 540};
EXPECT_THAT(calculateOutputDisplayFrame(), expected);
}
@@ -399,7 +399,7 @@
mLayerFEState.geomLayerTransform.set(entry.layer, 1920, 1080);
mLayerFEState.geomBufferTransform = entry.buffer;
- mOutputState.displaySpace.orientation = toRotation(entry.display);
+ mOutputState.displaySpace.setOrientation(toRotation(entry.display));
mOutputState.transform = ui::Transform{entry.display};
const auto actual = mOutputLayer.calculateOutputRelativeBufferTransform(entry.display);
@@ -511,7 +511,7 @@
mLayerFEState.geomLayerTransform.set(entry.layer, 1920, 1080);
mLayerFEState.geomBufferTransform = entry.buffer;
- mOutputState.displaySpace.orientation = toRotation(entry.display);
+ mOutputState.displaySpace.setOrientation(toRotation(entry.display));
mOutputState.transform = ui::Transform{entry.display};
const auto actual = mOutputLayer.calculateOutputRelativeBufferTransform(entry.internal);
@@ -942,7 +942,7 @@
// This test simulates a scenario where displayInstallOrientation is set to
// ROT_90. This only has an effect on the transform; orientation stays 0 (see
// DisplayDevice::setProjection).
- mOutputState.displaySpace.orientation = ui::ROTATION_0;
+ mOutputState.displaySpace.setOrientation(ui::ROTATION_0);
mOutputState.transform = ui::Transform{TR_ROT_90};
// Buffers are pre-rotated based on the transform hint (ROT_90); their
// geomBufferTransform is set to the inverse transform.
@@ -1237,7 +1237,7 @@
mLayerFEState.cursorFrame = kDefaultCursorFrame;
- mOutputState.layerStackSpace.content = kDefaultDisplayViewport;
+ mOutputState.layerStackSpace.setContent(kDefaultDisplayViewport);
mOutputState.transform = ui::Transform{kDefaultTransform};
}
diff --git a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
index a904c7d..244a20a 100644
--- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp
@@ -143,7 +143,8 @@
std::unique_ptr<DisplayColorProfile>(mDisplayColorProfile));
mOutput->setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
- mOutput->editState().displaySpace.bounds = kDefaultDisplaySize;
+ mOutput->editState().displaySpace.setBounds(
+ ui::Size(kDefaultDisplaySize.getWidth(), kDefaultDisplaySize.getHeight()));
EXPECT_CALL(mCompositionEngine, getRenderEngine()).WillRepeatedly(ReturnRef(mRenderEngine));
}
@@ -289,8 +290,10 @@
TEST_F(OutputTest, setProjectionWorks) {
const Rect displayRect{0, 0, 1000, 2000};
- mOutput->editState().displaySpace.bounds = displayRect;
- mOutput->editState().framebufferSpace.bounds = displayRect;
+ mOutput->editState().displaySpace.setBounds(
+ ui::Size(displayRect.getWidth(), displayRect.getHeight()));
+ mOutput->editState().framebufferSpace.setBounds(
+ ui::Size(displayRect.getWidth(), displayRect.getHeight()));
const ui::Rotation orientation = ui::ROTATION_90;
const Rect frame{50, 60, 100, 100};
@@ -298,28 +301,29 @@
mOutput->setProjection(orientation, viewport, frame);
- EXPECT_EQ(orientation, mOutput->getState().displaySpace.orientation);
- EXPECT_EQ(frame, mOutput->getState().orientedDisplaySpace.content);
- EXPECT_EQ(viewport, mOutput->getState().layerStackSpace.content);
+ EXPECT_EQ(orientation, mOutput->getState().displaySpace.getOrientation());
+ EXPECT_EQ(frame, mOutput->getState().orientedDisplaySpace.getContent());
+ EXPECT_EQ(viewport, mOutput->getState().layerStackSpace.getContent());
const auto state = mOutput->getState();
- EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.orientation);
- EXPECT_EQ(viewport, state.layerStackSpace.content);
- EXPECT_EQ(viewport, state.layerStackSpace.bounds);
+ EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.getOrientation());
+ EXPECT_EQ(viewport, state.layerStackSpace.getContent());
+ EXPECT_EQ(Rect(0, 0, 20, 20), state.layerStackSpace.getBoundsAsRect());
- EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.orientation);
- EXPECT_EQ(frame, state.orientedDisplaySpace.content);
- EXPECT_EQ(Rect(0, 0, 2000, 1000), state.orientedDisplaySpace.bounds);
+ EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.getOrientation());
+ EXPECT_EQ(frame, state.orientedDisplaySpace.getContent());
+ EXPECT_EQ(Rect(0, 0, 2000, 1000), state.orientedDisplaySpace.getBoundsAsRect());
- EXPECT_EQ(displayRect, state.displaySpace.bounds);
- EXPECT_EQ(Rect(900, 50, 940, 100), state.displaySpace.content);
- EXPECT_EQ(orientation, state.displaySpace.orientation);
+ EXPECT_EQ(displayRect, state.displaySpace.getBoundsAsRect());
+ EXPECT_EQ(Rect(900, 50, 940, 100), state.displaySpace.getContent());
+ EXPECT_EQ(orientation, state.displaySpace.getOrientation());
- EXPECT_EQ(displayRect, state.framebufferSpace.bounds);
- EXPECT_EQ(Rect(900, 50, 940, 100), state.framebufferSpace.content);
- EXPECT_EQ(orientation, state.framebufferSpace.orientation);
+ EXPECT_EQ(displayRect, state.framebufferSpace.getBoundsAsRect());
+ EXPECT_EQ(Rect(900, 50, 940, 100), state.framebufferSpace.getContent());
+ EXPECT_EQ(orientation, state.framebufferSpace.getOrientation());
- EXPECT_EQ(state.displaySpace.content, state.transform.transform(state.layerStackSpace.content));
+ EXPECT_EQ(state.displaySpace.getContent(),
+ state.transform.transform(state.layerStackSpace.getContent()));
EXPECT_EQ(ui::Transform::ROT_90, mOutput->getTransformHint());
}
@@ -327,8 +331,10 @@
TEST_F(OutputTest, setProjectionWithSmallFramebufferWorks) {
const Rect displayRect{0, 0, 1000, 2000};
const Rect framebufferRect{0, 0, 500, 1000};
- mOutput->editState().displaySpace.bounds = displayRect;
- mOutput->editState().framebufferSpace.bounds = framebufferRect;
+ mOutput->editState().displaySpace.setBounds(
+ ui::Size(displayRect.getWidth(), displayRect.getHeight()));
+ mOutput->editState().framebufferSpace.setBounds(
+ ui::Size(framebufferRect.getWidth(), framebufferRect.getHeight()));
const ui::Rotation orientation = ui::ROTATION_90;
const Rect frame{50, 60, 100, 100};
@@ -336,28 +342,29 @@
mOutput->setProjection(orientation, viewport, frame);
- EXPECT_EQ(orientation, mOutput->getState().displaySpace.orientation);
- EXPECT_EQ(frame, mOutput->getState().orientedDisplaySpace.content);
- EXPECT_EQ(viewport, mOutput->getState().layerStackSpace.content);
+ EXPECT_EQ(orientation, mOutput->getState().displaySpace.getOrientation());
+ EXPECT_EQ(frame, mOutput->getState().orientedDisplaySpace.getContent());
+ EXPECT_EQ(viewport, mOutput->getState().layerStackSpace.getContent());
const auto state = mOutput->getState();
- EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.orientation);
- EXPECT_EQ(viewport, state.layerStackSpace.content);
- EXPECT_EQ(viewport, state.layerStackSpace.bounds);
+ EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.getOrientation());
+ EXPECT_EQ(viewport, state.layerStackSpace.getContent());
+ EXPECT_EQ(Rect(0, 0, 20, 20), state.layerStackSpace.getBoundsAsRect());
- EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.orientation);
- EXPECT_EQ(frame, state.orientedDisplaySpace.content);
- EXPECT_EQ(Rect(0, 0, 2000, 1000), state.orientedDisplaySpace.bounds);
+ EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.getOrientation());
+ EXPECT_EQ(frame, state.orientedDisplaySpace.getContent());
+ EXPECT_EQ(Rect(0, 0, 2000, 1000), state.orientedDisplaySpace.getBoundsAsRect());
- EXPECT_EQ(displayRect, state.displaySpace.bounds);
- EXPECT_EQ(Rect(900, 50, 940, 100), state.displaySpace.content);
- EXPECT_EQ(orientation, state.displaySpace.orientation);
+ EXPECT_EQ(displayRect, state.displaySpace.getBoundsAsRect());
+ EXPECT_EQ(Rect(900, 50, 940, 100), state.displaySpace.getContent());
+ EXPECT_EQ(orientation, state.displaySpace.getOrientation());
- EXPECT_EQ(framebufferRect, state.framebufferSpace.bounds);
- EXPECT_EQ(Rect(450, 25, 470, 50), state.framebufferSpace.content);
- EXPECT_EQ(orientation, state.framebufferSpace.orientation);
+ EXPECT_EQ(framebufferRect, state.framebufferSpace.getBoundsAsRect());
+ EXPECT_EQ(Rect(450, 25, 470, 50), state.framebufferSpace.getContent());
+ EXPECT_EQ(orientation, state.framebufferSpace.getOrientation());
- EXPECT_EQ(state.displaySpace.content, state.transform.transform(state.layerStackSpace.content));
+ EXPECT_EQ(state.displaySpace.getContent(),
+ state.transform.transform(state.layerStackSpace.getContent()));
}
/*
@@ -365,16 +372,16 @@
*/
TEST_F(OutputTest, setDisplaySpaceSizeUpdatesOutputStateAndDirtiesEntireOutput) {
- mOutput->editState().layerStackSpace.content = Rect(0, 0, 2000, 1000);
- mOutput->editState().layerStackSpace.bounds = Rect(0, 0, 2000, 1000);
- mOutput->editState().orientedDisplaySpace.content = Rect(0, 0, 1800, 900);
- mOutput->editState().orientedDisplaySpace.bounds = Rect(0, 0, 2000, 1000);
- mOutput->editState().framebufferSpace.content = Rect(0, 0, 900, 1800);
- mOutput->editState().framebufferSpace.bounds = Rect(0, 0, 1000, 2000);
- mOutput->editState().framebufferSpace.orientation = ui::ROTATION_90;
- mOutput->editState().displaySpace.content = Rect(0, 0, 900, 1800);
- mOutput->editState().displaySpace.bounds = Rect(0, 0, 1000, 2000);
- mOutput->editState().displaySpace.orientation = ui::ROTATION_90;
+ mOutput->editState().layerStackSpace.setContent(Rect(0, 0, 2000, 1000));
+ mOutput->editState().layerStackSpace.setBounds(ui::Size(2000, 1000));
+ mOutput->editState().orientedDisplaySpace.setContent(Rect(0, 0, 1800, 900));
+ mOutput->editState().orientedDisplaySpace.setBounds(ui::Size(2000, 1000));
+ mOutput->editState().framebufferSpace.setContent(Rect(0, 0, 900, 1800));
+ mOutput->editState().framebufferSpace.setBounds(ui::Size(1000, 2000));
+ mOutput->editState().framebufferSpace.setOrientation(ui::ROTATION_90);
+ mOutput->editState().displaySpace.setContent(Rect(0, 0, 900, 1800));
+ mOutput->editState().displaySpace.setBounds(ui::Size(1000, 2000));
+ mOutput->editState().displaySpace.setOrientation(ui::ROTATION_90);
const ui::Size newDisplaySize{500, 1000};
@@ -385,20 +392,21 @@
const auto state = mOutput->getState();
const Rect displayRect(newDisplaySize);
- EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.orientation);
- EXPECT_EQ(Rect(0, 0, 2000, 1000), state.layerStackSpace.content);
- EXPECT_EQ(Rect(0, 0, 2000, 1000), state.layerStackSpace.bounds);
+ EXPECT_EQ(ui::ROTATION_0, state.layerStackSpace.getOrientation());
+ EXPECT_EQ(Rect(0, 0, 2000, 1000), state.layerStackSpace.getContent());
+ EXPECT_EQ(Rect(0, 0, 2000, 1000), state.layerStackSpace.getBoundsAsRect());
- EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.orientation);
- EXPECT_EQ(Rect(0, 0, 1000, 500), state.orientedDisplaySpace.bounds);
+ EXPECT_EQ(ui::ROTATION_0, state.orientedDisplaySpace.getOrientation());
+ EXPECT_EQ(Rect(0, 0, 1000, 500), state.orientedDisplaySpace.getBoundsAsRect());
- EXPECT_EQ(displayRect, state.displaySpace.bounds);
- EXPECT_EQ(ui::ROTATION_90, state.displaySpace.orientation);
+ EXPECT_EQ(displayRect, state.displaySpace.getBoundsAsRect());
+ EXPECT_EQ(ui::ROTATION_90, state.displaySpace.getOrientation());
- EXPECT_EQ(displayRect, state.framebufferSpace.bounds);
- EXPECT_EQ(ui::ROTATION_90, state.framebufferSpace.orientation);
+ EXPECT_EQ(displayRect, state.framebufferSpace.getBoundsAsRect());
+ EXPECT_EQ(ui::ROTATION_90, state.framebufferSpace.getOrientation());
- EXPECT_EQ(state.displaySpace.content, state.transform.transform(state.layerStackSpace.content));
+ EXPECT_EQ(state.displaySpace.getContent(),
+ state.transform.transform(state.layerStackSpace.getContent()));
EXPECT_THAT(state.dirtyRegion, RegionEq(Region(displayRect)));
}
@@ -562,7 +570,7 @@
mOutput->setRenderSurface(std::unique_ptr<RenderSurface>(renderSurface));
- EXPECT_EQ(Rect(newDisplaySize), mOutput->getState().framebufferSpace.bounds);
+ EXPECT_EQ(Rect(newDisplaySize), mOutput->getState().framebufferSpace.getBoundsAsRect());
}
/*
@@ -571,7 +579,7 @@
TEST_F(OutputTest, getDirtyRegion) {
const Rect viewport{100, 200};
- mOutput->editState().layerStackSpace.content = viewport;
+ mOutput->editState().layerStackSpace.setContent(viewport);
mOutput->editState().dirtyRegion.set(50, 300);
// The dirty region should be clipped to the display bounds.
@@ -1055,7 +1063,8 @@
OutputRebuildLayerStacksTest() {
mOutput.mState.isEnabled = true;
mOutput.mState.transform = kIdentityTransform;
- mOutput.mState.displaySpace.bounds = kOutputBounds;
+ mOutput.mState.displaySpace.setBounds(
+ ui::Size(kOutputBounds.getWidth(), kOutputBounds.getHeight()));
mRefreshArgs.updatingOutputGeometryThisFrame = true;
@@ -1258,8 +1267,8 @@
EXPECT_CALL(mOutput, getOutputLayerOrderedByZByIndex(0u))
.WillRepeatedly(Return(&mLayer.outputLayer));
- mOutput.mState.displaySpace.bounds = Rect(0, 0, 200, 300);
- mOutput.mState.layerStackSpace.content = Rect(0, 0, 200, 300);
+ mOutput.mState.displaySpace.setBounds(ui::Size(200, 300));
+ mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 200, 300));
mOutput.mState.transform = ui::Transform(TR_IDENT, 200, 300);
mLayer.layerFEState.isVisible = true;
@@ -1339,7 +1348,7 @@
}
TEST_F(OutputEnsureOutputLayerIfVisibleTest, takesNotSoEarlyOutifDrawRegionEmpty) {
- mOutput.mState.displaySpace.bounds = Rect(0, 0, 0, 0);
+ mOutput.mState.displaySpace.setBounds(ui::Size(0, 0));
ensureOutputLayerIfVisible();
}
@@ -1536,7 +1545,7 @@
mLayer.layerFEState.contentDirty = true;
mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
- mOutput.mState.layerStackSpace.content = Rect(0, 0, 300, 200);
+ mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 300, 200));
mOutput.mState.transform = ui::Transform(TR_ROT_90, 200, 300);
EXPECT_CALL(mOutput, getOutputLayerCount()).WillOnce(Return(0u));
@@ -1562,7 +1571,7 @@
mLayer.layerFEState.contentDirty = true;
mLayer.layerFEState.geomLayerTransform = ui::Transform(TR_IDENT, 100, 200);
- mOutput.mState.layerStackSpace.content = Rect(0, 0, 300, 200);
+ mOutput.mState.layerStackSpace.setContent(Rect(0, 0, 300, 200));
mOutput.mState.transform = ui::Transform(TR_ROT_90, 200, 300);
EXPECT_CALL(mOutput, ensureOutputLayer(Eq(0u), Eq(mLayer.layerFE)))
@@ -2977,11 +2986,11 @@
mOutput.setRenderSurfaceForTest(std::unique_ptr<RenderSurface>(mRenderSurface));
mOutput.cacheClientCompositionRequests(MAX_CLIENT_COMPOSITION_CACHE_SIZE);
- mOutput.mState.orientedDisplaySpace.content = kDefaultOutputFrame;
- mOutput.mState.layerStackSpace.content = kDefaultOutputViewport;
- mOutput.mState.framebufferSpace.content = kDefaultOutputDestinationClip;
- mOutput.mState.displaySpace.content = kDefaultOutputDestinationClip;
- mOutput.mState.displaySpace.orientation = kDefaultOutputOrientation;
+ mOutput.mState.orientedDisplaySpace.setContent(kDefaultOutputFrame);
+ mOutput.mState.layerStackSpace.setContent(kDefaultOutputViewport);
+ mOutput.mState.framebufferSpace.setContent(kDefaultOutputDestinationClip);
+ mOutput.mState.displaySpace.setContent(kDefaultOutputDestinationClip);
+ mOutput.mState.displaySpace.setOrientation(kDefaultOutputOrientation);
mOutput.mState.transform = ui::Transform{kDefaultOutputOrientationFlags};
mOutput.mState.dataspace = kDefaultOutputDataspace;
mOutput.mState.colorTransformMatrix = kDefaultColorTransformMat;
@@ -3703,12 +3712,12 @@
struct GenerateClientCompositionRequestsTest_ThreeLayers
: public GenerateClientCompositionRequestsTest {
GenerateClientCompositionRequestsTest_ThreeLayers() {
- mOutput.mState.orientedDisplaySpace.content = kDisplayFrame;
- mOutput.mState.layerStackSpace.content = kDisplayViewport;
- mOutput.mState.displaySpace.content = kDisplayDestinationClip;
+ mOutput.mState.orientedDisplaySpace.setContent(kDisplayFrame);
+ mOutput.mState.layerStackSpace.setContent(kDisplayViewport);
+ mOutput.mState.displaySpace.setContent(kDisplayDestinationClip);
mOutput.mState.transform =
ui::Transform{ui::Transform::toRotationFlags(kDisplayOrientation)};
- mOutput.mState.displaySpace.orientation = kDisplayOrientation;
+ mOutput.mState.displaySpace.setOrientation(kDisplayOrientation);
mOutput.mState.needsFiltering = false;
mOutput.mState.isSecure = false;
@@ -4275,11 +4284,11 @@
const ui::Rotation kPortraitOrientation = ui::ROTATION_90;
constexpr ui::Dataspace kOutputDataspace = ui::Dataspace::DISPLAY_P3;
- mOutput.mState.orientedDisplaySpace.content = kPortraitFrame;
- mOutput.mState.layerStackSpace.content = kPortraitViewport;
- mOutput.mState.displaySpace.content = kPortraitDestinationClip;
+ mOutput.mState.orientedDisplaySpace.setContent(kPortraitFrame);
+ mOutput.mState.layerStackSpace.setContent(kPortraitViewport);
+ mOutput.mState.displaySpace.setContent(kPortraitDestinationClip);
mOutput.mState.transform = ui::Transform{ui::Transform::toRotationFlags(kPortraitOrientation)};
- mOutput.mState.displaySpace.orientation = kPortraitOrientation;
+ mOutput.mState.displaySpace.setOrientation(kPortraitOrientation);
mOutput.mState.needsFiltering = false;
mOutput.mState.isSecure = true;
diff --git a/services/surfaceflinger/CompositionEngine/tests/ProjectionSpaceTest.cpp b/services/surfaceflinger/CompositionEngine/tests/ProjectionSpaceTest.cpp
index 704f5a8..19b3928 100644
--- a/services/surfaceflinger/CompositionEngine/tests/ProjectionSpaceTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/ProjectionSpaceTest.cpp
@@ -53,40 +53,40 @@
TEST(ProjectionSpaceTest, getTransformToSelfIsIdentity) {
ProjectionSpace space;
- space.content = Rect(100, 200);
- space.bounds = Rect(100, 200);
+ space.setContent(Rect(100, 200));
+ space.setBounds(ui::Size(100, 200));
const ui::Transform identity;
for (int rotation = 0; rotation <= 3; rotation++) {
- space.orientation = ui::Rotation(rotation);
+ space.setOrientation(ui::Rotation(rotation));
EXPECT_EQ(space.getTransform(space), identity);
}
}
TEST(ProjectionSpaceTest, getTransformWhenTranslationIsNeeded) {
ProjectionSpace source;
- source.content = Rect(10, 10, 20, 20);
- source.bounds = Rect(100, 200);
+ source.setContent(Rect(10, 10, 20, 20));
+ source.setBounds(ui::Size(100, 200));
ProjectionSpace dest;
- dest.content = Rect(10, 20, 30, 20);
- dest.bounds = source.bounds;
+ dest.setContent(Rect(10, 20, 30, 20));
+ dest.setBounds(source.getBounds());
const auto transform = source.getTransform(dest);
- EXPECT_EQ(transform.transform(source.content), dest.content);
+ EXPECT_EQ(transform.transform(source.getContent()), dest.getContent());
}
TEST(ProjectionSpaceTest, getTransformWhenScaleIsNeeded) {
ProjectionSpace source;
- source.content = Rect(0, 0, 20, 20);
- source.bounds = Rect(100, 200);
+ source.setContent(Rect(0, 0, 20, 20));
+ source.setBounds(ui::Size(100, 200));
ProjectionSpace dest;
- dest.content = Rect(0, 0, 40, 30);
- dest.bounds = source.bounds;
+ dest.setContent(Rect(0, 0, 40, 30));
+ dest.setBounds(source.getBounds());
const auto transform = source.getTransform(dest);
- EXPECT_EQ(transform.transform(source.content), dest.content);
+ EXPECT_EQ(transform.transform(source.getContent()), dest.getContent());
}
TEST(ProjectionSpaceTest, getSideStripTest) {
@@ -99,7 +99,7 @@
void testTransform(const ProjectionSpace& source, const ProjectionSpace& dest) {
const auto transform = source.getTransform(dest);
- EXPECT_EQ(transform.transform(source.content), dest.content)
+ EXPECT_EQ(transform.transform(source.getContent()), dest.getContent())
<< "Source content doesn't map to dest content when projecting " << to_string(source)
<< " onto " << to_string(dest);
@@ -113,8 +113,8 @@
// | | | *
// +-----+ +-------*
// source(ROTATION_0) dest (ROTATION_90)
- const auto sourceStrip = getSideStrip(source.content, source.orientation);
- const auto destStrip = getSideStrip(dest.content, dest.orientation);
+ const auto sourceStrip = getSideStrip(source.getContent(), source.getOrientation());
+ const auto destStrip = getSideStrip(dest.getContent(), dest.getOrientation());
ASSERT_NE(sourceStrip, Rect::INVALID_RECT);
ASSERT_NE(destStrip, Rect::INVALID_RECT);
const auto mappedStrip = transform.transform(sourceStrip);
@@ -126,16 +126,16 @@
TEST(ProjectionSpaceTest, getTransformWithOrienations) {
ProjectionSpace source;
- source.bounds = Rect(12, 13, 678, 789);
- source.content = Rect(40, 50, 234, 343);
+ source.setBounds(ui::Size(666, 776));
+ source.setContent(Rect(40, 50, 234, 343));
ProjectionSpace dest;
- dest.bounds = Rect(17, 18, 879, 564);
- dest.content = Rect(43, 52, 432, 213);
+ dest.setBounds(ui::Size(862, 546));
+ dest.setContent(Rect(43, 52, 432, 213));
for (int sourceRot = 0; sourceRot <= 3; sourceRot++) {
- source.orientation = ui::Rotation(sourceRot);
+ source.setOrientation(ui::Rotation(sourceRot));
for (int destRot = 0; destRot <= 3; destRot++) {
- dest.orientation = ui::Rotation(destRot);
+ dest.setOrientation(ui::Rotation(destRot));
testTransform(source, dest);
}
}
diff --git a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp
index 818334d..ecb05f8 100644
--- a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp
@@ -123,7 +123,7 @@
// set up minimium params needed for rendering
mOutputState.dataspace = ui::Dataspace::SRGB;
mOutputState.framebufferSpace = ProjectionSpace(ui::Size(10, 20), Rect(10, 5));
- mOutputState.framebufferSpace.orientation = ui::ROTATION_90;
+ mOutputState.framebufferSpace.setOrientation(ui::ROTATION_90);
mOutputState.layerStackSpace = ProjectionSpace(ui::Size(20, 10), Rect(5, 10));
}
}
@@ -349,9 +349,9 @@
const std::vector<const renderengine::LayerSettings*>& layers,
const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
base::unique_fd &&) -> std::future<renderengine::RenderEngineResult> {
- EXPECT_EQ(mOutputState.framebufferSpace.content, displaySettings.physicalDisplay);
- EXPECT_EQ(mOutputState.layerStackSpace.content, displaySettings.clip);
- EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.orientation),
+ EXPECT_EQ(mOutputState.framebufferSpace.getContent(), displaySettings.physicalDisplay);
+ EXPECT_EQ(mOutputState.layerStackSpace.getContent(), displaySettings.clip);
+ EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.getOrientation()),
displaySettings.orientation);
EXPECT_EQ(0.5f, layers[0]->alpha);
EXPECT_EQ(0.75f, layers[1]->alpha);
@@ -401,9 +401,9 @@
const std::vector<const renderengine::LayerSettings*>& layers,
const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
base::unique_fd &&) -> std::future<renderengine::RenderEngineResult> {
- EXPECT_EQ(mOutputState.framebufferSpace.content, displaySettings.physicalDisplay);
- EXPECT_EQ(mOutputState.layerStackSpace.content, displaySettings.clip);
- EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.orientation),
+ EXPECT_EQ(mOutputState.framebufferSpace.getContent(), displaySettings.physicalDisplay);
+ EXPECT_EQ(mOutputState.layerStackSpace.getContent(), displaySettings.clip);
+ EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.getOrientation()),
displaySettings.orientation);
EXPECT_EQ(0.5f, layers[0]->alpha);
EXPECT_EQ(0.75f, layers[1]->alpha);
@@ -456,9 +456,9 @@
const std::vector<const renderengine::LayerSettings*>& layers,
const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
base::unique_fd &&) -> std::future<renderengine::RenderEngineResult> {
- EXPECT_EQ(mOutputState.framebufferSpace.content, displaySettings.physicalDisplay);
- EXPECT_EQ(mOutputState.layerStackSpace.content, displaySettings.clip);
- EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.orientation),
+ EXPECT_EQ(mOutputState.framebufferSpace.getContent(), displaySettings.physicalDisplay);
+ EXPECT_EQ(mOutputState.layerStackSpace.getContent(), displaySettings.clip);
+ EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.getOrientation()),
displaySettings.orientation);
EXPECT_EQ(0.5f, layers[0]->alpha);
EXPECT_EQ(0.75f, layers[1]->alpha);
diff --git a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp
index 0d5e362..9b0a75f 100644
--- a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp
+++ b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp
@@ -143,7 +143,7 @@
// set up minimium params needed for rendering
mOutputState.dataspace = ui::Dataspace::SRGB;
mOutputState.framebufferSpace = ProjectionSpace(ui::Size(10, 20), Rect(10, 5));
- mOutputState.framebufferSpace.orientation = ui::ROTATION_90;
+ mOutputState.framebufferSpace.setOrientation(ui::ROTATION_90);
}
}
@@ -503,7 +503,7 @@
initializeOverrideBuffer(layers);
EXPECT_NE(getNonBufferHash(layers),
mFlattener->flattenLayers(layers, getNonBufferHash(layers), mTime));
- mOutputState.framebufferSpace.orientation = ui::ROTATION_90;
+ mOutputState.framebufferSpace.setOrientation(ui::ROTATION_90);
mFlattener->renderCachedSets(mOutputState, std::nullopt);
EXPECT_NE(nullptr, overrideBuffer1);
@@ -516,7 +516,7 @@
initializeOverrideBuffer(layers);
EXPECT_NE(getNonBufferHash(layers),
mFlattener->flattenLayers(layers, getNonBufferHash(layers), mTime));
- mOutputState.framebufferSpace.orientation = ui::ROTATION_180;
+ mOutputState.framebufferSpace.setOrientation(ui::ROTATION_180);
mFlattener->renderCachedSets(mOutputState, std::nullopt);
EXPECT_NE(nullptr, overrideBuffer1);
@@ -544,7 +544,7 @@
initializeOverrideBuffer(layers);
EXPECT_NE(getNonBufferHash(layers),
mFlattener->flattenLayers(layers, getNonBufferHash(layers), mTime));
- mOutputState.framebufferSpace.orientation = ui::ROTATION_270;
+ mOutputState.framebufferSpace.setOrientation(ui::ROTATION_270);
mFlattener->renderCachedSets(mOutputState, std::nullopt);
EXPECT_NE(nullptr, overrideBuffer1);
diff --git a/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp b/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp
index 9fe30f8..3d24ecb 100644
--- a/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp
+++ b/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp
@@ -84,10 +84,10 @@
EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_0, mHardwareDisplaySize.width,
mHardwareDisplaySize.height),
compositionState.transform);
- EXPECT_EQ(ui::ROTATION_0, compositionState.displaySpace.orientation);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.content);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.orientedDisplaySpace.content);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.layerStackSpace.content);
+ EXPECT_EQ(ui::ROTATION_0, compositionState.displaySpace.getOrientation());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.getContent());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.orientedDisplaySpace.getContent());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.layerStackSpace.getContent());
EXPECT_EQ(false, compositionState.needsFiltering);
}
@@ -96,13 +96,14 @@
EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_90, mHardwareDisplaySize.width,
mHardwareDisplaySize.height),
compositionState.transform);
- EXPECT_EQ(ui::ROTATION_90, compositionState.displaySpace.orientation);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.content);
+ EXPECT_EQ(ui::ROTATION_90, compositionState.displaySpace.getOrientation());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.getContent());
// For 90, the orientedDisplaySpaceRect and layerStackSpaceRect have the hardware display
// size width and height swapped
EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)),
- compositionState.orientedDisplaySpace.content);
- EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)), compositionState.layerStackSpace.content);
+ compositionState.orientedDisplaySpace.getContent());
+ EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)),
+ compositionState.layerStackSpace.getContent());
EXPECT_EQ(false, compositionState.needsFiltering);
}
@@ -111,9 +112,9 @@
EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_180, mHardwareDisplaySize.width,
mHardwareDisplaySize.height),
compositionState.transform);
- EXPECT_EQ(ui::ROTATION_180, compositionState.displaySpace.orientation);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.orientedDisplaySpace.content);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.layerStackSpace.content);
+ EXPECT_EQ(ui::ROTATION_180, compositionState.displaySpace.getOrientation());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.orientedDisplaySpace.getContent());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.layerStackSpace.getContent());
EXPECT_EQ(false, compositionState.needsFiltering);
}
@@ -122,13 +123,14 @@
EXPECT_EQ(ui::Transform(TRANSFORM_FLAGS_ROT_270, mHardwareDisplaySize.width,
mHardwareDisplaySize.height),
compositionState.transform);
- EXPECT_EQ(ui::ROTATION_270, compositionState.displaySpace.orientation);
- EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.content);
+ EXPECT_EQ(ui::ROTATION_270, compositionState.displaySpace.getOrientation());
+ EXPECT_EQ(Rect(mHardwareDisplaySize), compositionState.displaySpace.getContent());
// For 270, the orientedDisplaySpaceRect and layerStackSpaceRect have the hardware display
// size width and height swapped
EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)),
- compositionState.orientedDisplaySpace.content);
- EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)), compositionState.layerStackSpace.content);
+ compositionState.orientedDisplaySpace.getContent());
+ EXPECT_EQ(Rect(swapWH(mHardwareDisplaySize)),
+ compositionState.layerStackSpace.getContent());
EXPECT_EQ(false, compositionState.needsFiltering);
}