diff options
12 files changed, 242 insertions, 215 deletions
diff --git a/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h b/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h index 58bb41adbb..a63145a7fd 100644 --- a/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h +++ b/services/surfaceflinger/CompositionEngine/include/compositionengine/ProjectionSpace.h @@ -28,51 +28,36 @@ namespace compositionengine { // 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 @@ struct ProjectionSpace { // 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 @@ struct ProjectionSpace { } 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 @@ struct ProjectionSpace { 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 6b9ea87df5..02fa49f3c0 100644 --- a/services/surfaceflinger/CompositionEngine/src/Display.cpp +++ b/services/surfaceflinger/CompositionEngine/src/Display.cpp @@ -53,7 +53,7 @@ void Display::setConfiguration(const compositionengine::DisplayCreationArgs& arg 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 1747294159..535458e8f4 100644 --- a/services/surfaceflinger/CompositionEngine/src/Output.cpp +++ b/services/surfaceflinger/CompositionEngine/src/Output.cpp @@ -156,38 +156,40 @@ void Output::setProjection(ui::Rotation orientation, const Rect& layerStackSpace 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 @@ void Output::setDisplaySize(const ui::Size& size) { 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 @@ compositionengine::RenderSurface* Output::getRenderSurface() const { 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 @@ void Output::setRenderSurfaceForTest(std::unique_ptr<compositionengine::RenderSu 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 @@ void Output::rebuildLayerStacks(const compositionengine::CompositionRefreshArgs& // 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 @@ void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE, // 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 @@ void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE, 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 @@ std::optional<base::unique_fd> Output::composeSurfaces( 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 @@ std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests( 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 @@ std::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests( 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::renderCachedSets(const CompositionRefreshArgs& refreshArgs) { 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 56e9d27f14..ecfd9018d3 100644 --- a/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp +++ b/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp @@ -79,7 +79,7 @@ Rect OutputLayer::calculateInitialCrop() const { 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 @@ FloatRect OutputLayer::calculateOutputSourceCrop() const { * 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 OutputLayer::calculateOutputDisplayFrame() const { 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 @@ Rect OutputLayer::calculateOutputDisplayFrame() const { 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 @@ void OutputLayer::writeCursorPositionToHWC() const { 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 5bbd58ee09..e6b716e8f2 100644 --- a/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp +++ b/services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp @@ -159,13 +159,13 @@ void CachedSet::updateAge(std::chrono::steady_clock::time_point now) { 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 @@ void CachedSet::render(renderengine::RenderEngine& renderEngine, TexturePool& te 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 f2978f904d..ed235b8b57 100644 --- a/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/DisplayTest.cpp @@ -876,7 +876,7 @@ TEST_F(DisplayFinishFrameTest, doesNotSkipCompositionIfNotDirtyOnHwcDisplay) { 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 @@ TEST_F(DisplayFinishFrameTest, skipsCompositionIfNotDirty) { 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 @@ TEST_F(DisplayFinishFrameTest, performsCompositionIfDirty) { 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 c8c6012ef9..53b71b7d94 100644 --- a/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/OutputLayerTest.cpp @@ -158,7 +158,7 @@ struct OutputLayerSourceCropTest : public OutputLayerTest { 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 @@ TEST_F(OutputLayerSourceCropTest, calculateOutputSourceCropWorksWithATransformed 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, geomContentCropAffectsCrop) { } 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 @@ struct OutputLayerDisplayFrameTest : public OutputLayerTest { 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, geomLayerBoundsAffectsFrame) { } 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 @@ TEST_F(OutputLayerTest, calculateOutputRelativeBufferTransformTestsNeeded) { 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 @@ TEST_F(OutputLayerTest, 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 @@ TEST_F(OutputLayerTest, displayInstallOrientationBufferTransformSetTo90) { // 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 @@ struct OutputLayerWriteCursorPositionToHWCTest : public OutputLayerTest { 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 a904c7df4d..244a20a761 100644 --- a/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/OutputTest.cpp @@ -143,7 +143,8 @@ struct OutputTest : public testing::Test { 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, setLayerCachingEnabled_disablesCachingAndResetsOverrideInfo) 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 @@ TEST_F(OutputTest, setProjectionWorks) { 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, setProjectionWorks) { 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 @@ TEST_F(OutputTest, setProjectionWithSmallFramebufferWorks) { 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, setProjectionWithSmallFramebufferWorks) { */ 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 @@ TEST_F(OutputTest, setDisplaySpaceSizeUpdatesOutputStateAndDirtiesEntireOutput) 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 @@ TEST_F(OutputTest, setRenderSurfaceResetsBounds) { 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, setRenderSurfaceResetsBounds) { 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 @@ struct OutputRebuildLayerStacksTest : public testing::Test { 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 @@ struct OutputEnsureOutputLayerIfVisibleTest : public testing::Test { 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, takesEarlyOutIfLayerHasEmptyVisible } 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 @@ TEST_F(OutputEnsureOutputLayerIfVisibleTest, 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 @@ TEST_F(OutputEnsureOutputLayerIfVisibleTest, 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 @@ struct OutputComposeSurfacesTest : public testing::Test { 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 : public testing::Test { 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 @@ TEST_F(GenerateClientCompositionRequestsTest, handlesLandscapeModeSplitScreenReq 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 704f5a8c07..19b3928434 100644 --- a/services/surfaceflinger/CompositionEngine/tests/ProjectionSpaceTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/ProjectionSpaceTest.cpp @@ -53,40 +53,40 @@ Rect getSideStrip(const Rect& rect, ui::Rotation rotation) { 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 @@ TEST(ProjectionSpaceTest, getSideStripTest) { 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 @@ void testTransform(const ProjectionSpace& source, const ProjectionSpace& dest) { // | | | * // +-----+ +-------* // 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 @@ void testTransform(const ProjectionSpace& source, const ProjectionSpace& dest) { 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 818334d9c7..ecb05f8e5f 100644 --- a/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp @@ -123,7 +123,7 @@ void CachedSetTest::SetUp() { // 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 @@ TEST_F(CachedSetTest, renderUnsecureOutput) { 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 @@ TEST_F(CachedSetTest, renderSecureOutput) { 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 @@ TEST_F(CachedSetTest, rendersWithOffsetFramebufferContent) { 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 0d5e362169..9b0a75fd47 100644 --- a/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp +++ b/services/surfaceflinger/CompositionEngine/tests/planner/FlattenerTest.cpp @@ -143,7 +143,7 @@ void FlattenerTest::SetUp() { // 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 @@ TEST_F(FlattenerTest, flattenLayers_BufferUpdateForMiddleLayer) { 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 @@ TEST_F(FlattenerTest, flattenLayers_BufferUpdateForMiddleLayer) { 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 @@ TEST_F(FlattenerTest, flattenLayers_BufferUpdateForMiddleLayer) { 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 9fe30f8f72..3d24ecbf71 100644 --- a/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp +++ b/services/surfaceflinger/tests/unittests/DisplayDevice_SetProjectionTest.cpp @@ -84,10 +84,10 @@ public: 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 @@ public: 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 @@ public: 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 @@ public: 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); } |