Remove legacy transform hint (0ae2eb89) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Layer.cpp

+0 −15

Original line number	Diff line number	Diff line
		@@ -1350,14 +1350,6 @@ uint32_t Layer::getEffectiveUsage(uint32_t usage) const {
		return usage;
		}

		void Layer::updateTransformHint(ui::Transform::RotationFlags transformHint) {
		if (mFlinger->mDebugDisableTransformHint \|\| transformHint & ui::Transform::ROT_INVALID) {
		transformHint = ui::Transform::ROT_0;
		}

		setTransformHintLegacy(transformHint);
		}

		// ----------------------------------------------------------------------------
		// debugging
		// ----------------------------------------------------------------------------
		@@ -4001,13 +3993,6 @@ sp<GraphicBuffer> Layer::getBuffer() const {
		return mBufferInfo.mBuffer ? mBufferInfo.mBuffer->getBuffer() : nullptr;
		}

		void Layer::setTransformHintLegacy(ui::Transform::RotationFlags displayTransformHint) {
		mTransformHintLegacy = getFixedTransformHint();
		if (mTransformHintLegacy == ui::Transform::ROT_INVALID) {
		mTransformHintLegacy = displayTransformHint;
		}
		}

		const std::shared_ptr<renderengine::ExternalTexture>& Layer::getExternalTexture() const {
		return mBufferInfo.mBuffer;
		}

services/surfaceflinger/Layer.h

+0 −6

Original line number	Diff line number	Diff line
		@@ -687,10 +687,6 @@ public:
		*/
		void addToCurrentState();

		/*
		* Sets display transform hint on BufferLayerConsumer.
		*/
		void updateTransformHint(ui::Transform::RotationFlags);
		inline const State& getDrawingState() const { return mDrawingState; }
		inline State& getDrawingState() { return mDrawingState; }

		@@ -1212,13 +1208,11 @@ private:

		bool findInHierarchy(const sp<Layer>&);

		void setTransformHintLegacy(ui::Transform::RotationFlags);
		void releasePreviousBuffer();
		void resetDrawingStateBufferInfo();

		// Transform hint provided to the producer. This must be accessed holding
		// the mStateLock.
		ui::Transform::RotationFlags mTransformHintLegacy = ui::Transform::ROT_0;
		std::optional<ui::Transform::RotationFlags> mTransformHint = std::nullopt;

		ReleaseCallbackId mPreviousReleaseCallbackId = ReleaseCallbackId::INVALID_ID;

services/surfaceflinger/SurfaceFlinger.cpp

+0 −60

Original line number	Diff line number	Diff line
		@@ -3932,51 +3932,6 @@ void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
		mUpdateInputInfo = true;
		}

		// Update transform hint.
		if (transactionFlags & (eTransformHintUpdateNeeded \| eDisplayTransactionNeeded)) {
		// Layers and/or displays have changed, so update the transform hint for each layer.
		//
		// NOTE: we do this here, rather than when presenting the display so that
		// the hint is set before we acquire a buffer from the surface texture.
		//
		// NOTE: layer transactions have taken place already, so we use their
		// drawing state. However, SurfaceFlinger's own transaction has not
		// happened yet, so we must use the current state layer list
		// (soon to become the drawing state list).
		//
		sp<const DisplayDevice> hintDisplay;
		ui::LayerStack layerStack;

		mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
		// NOTE: we rely on the fact that layers are sorted by
		// layerStack first (so we don't have to traverse the list
		// of displays for every layer).
		if (const auto filter = layer->getOutputFilter(); layerStack != filter.layerStack) {
		layerStack = filter.layerStack;
		hintDisplay = nullptr;

		// Find the display that includes the layer.
		for (const auto& [token, display] : mDisplays) {
		if (!display->getCompositionDisplay()->includesLayer(filter)) {
		continue;
		}

		// Pick the primary display if another display mirrors the layer.
		if (hintDisplay) {
		hintDisplay = nullptr;
		break;
		}

		hintDisplay = display;
		}
		}

		if (hintDisplay) {
		layer->updateTransformHint(hintDisplay->getTransformHint());
		}
		});
		}

		if (mLayersAdded) {
		mLayersAdded = false;
		// Layers have been added.
		@@ -4493,7 +4448,6 @@ status_t SurfaceFlinger::addClientLayer(LayerCreationArgs& args, const sp<IBinde
		return NO_MEMORY;
		}

		layer->updateTransformHint(mActiveDisplayTransformHint);
		if (outTransformHint) {
		*outTransformHint = mActiveDisplayTransformHint;
		}
		@@ -8143,20 +8097,6 @@ void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, Vs
		} else {
		parent->addChild(layer);
		}

		ui::LayerStack layerStack = layer->getLayerStack(LayerVector::StateSet::Current);
		sp<const DisplayDevice> hintDisplay;
		// Find the display that includes the layer.
		for (const auto& [token, display] : mDisplays) {
		if (display->getLayerStack() == layerStack) {
		hintDisplay = display;
		break;
		}
		}

		if (hintDisplay) {
		layer->updateTransformHint(hintDisplay->getTransformHint());
		}
		}

		void SurfaceFlinger::sample() {