Remove legacy layer mirroring (620fefda) · Commits · e / os / android_frameworks_native

services/surfaceflinger/Layer.cpp

+0 −210

Original line number	Diff line number	Diff line
		@@ -231,10 +231,6 @@ Layer::~Layer() {
		LOG_ALWAYS_FATAL_IF(std::this_thread::get_id() != mFlinger->mMainThreadId,
		"Layer destructor called off the main thread.");

		// The original layer and the clone layer share the same texture and buffer. Therefore, only
		// one of the layers, in this case the original layer, needs to handle the deletion. The
		// original layer and the clone should be removed at the same time so there shouldn't be any
		// issue with the clone layer trying to use the texture.
		if (mBufferInfo.mBuffer != nullptr) {
		callReleaseBufferCallback(mDrawingState.releaseBufferListener,
		mBufferInfo.mBuffer->getBuffer(), mBufferInfo.mFrameNumber,
		@@ -250,10 +246,6 @@ Layer::~Layer() {
		if (mDrawingState.sidebandStream != nullptr) {
		mFlinger->mTunnelModeEnabledReporter->decrementTunnelModeCount();
		}
		if (mHadClonedChild) {
		auto& roots = mFlinger->mLayerMirrorRoots;
		roots.erase(std::remove(roots.begin(), roots.end(), this), roots.end());
		}
		if (hasTrustedPresentationListener()) {
		mFlinger->mNumTrustedPresentationListeners--;
		updateTrustedPresentationState(nullptr, nullptr, -1 /* time_in_ms /, true / leaveState*/);
		@@ -1872,16 +1864,6 @@ WindowInfo Layer::fillInputInfo(const InputDisplayArgs& displayArgs) {
		info.inputConfig \|= WindowInfo::InputConfig::TRUSTED_OVERLAY;
		}

		// If the layer is a clone, we need to crop the input region to cloned root to prevent
		// touches from going outside the cloned area.
		if (isClone()) {
		info.inputConfig \|= WindowInfo::InputConfig::CLONE;
		if (const sp<Layer> clonedRoot = getClonedRoot()) {
		const Rect rect = displayTransform.transform(Rect{clonedRoot->mScreenBounds});
		info.touchableRegion = info.touchableRegion.intersect(rect);
		}
		}

		Rect bufferSize = getBufferSize(getDrawingState());
		info.contentSize = Size(bufferSize.width(), bufferSize.height());

		@@ -1909,16 +1891,6 @@ Rect Layer::getInputBoundsInDisplaySpace(const FloatRect& inputBounds,
		return Rect{layerToDisplay.transform(croppedInputBounds)};
		}

		sp<Layer> Layer::getClonedRoot() {
		if (mClonedChild != nullptr) {
		return sp<Layer>::fromExisting(this);
		}
		if (mDrawingParent == nullptr \|\| mDrawingParent.promote() == nullptr) {
		return nullptr;
		}
		return mDrawingParent.promote()->getClonedRoot();
		}

		bool Layer::hasInputInfo() const {
		return mDrawingState.inputInfo.token != nullptr \|\|
		mDrawingState.inputInfo.inputConfig.test(WindowInfo::InputConfig::NO_INPUT_CHANNEL);
		@@ -1958,166 +1930,6 @@ Region Layer::getVisibleRegion(const DisplayDevice* display) const {
		return outputLayer ? outputLayer->getState().visibleRegion : Region();
		}

		void Layer::updateCloneBufferInfo() {
		if (!isClone() \|\| !isClonedFromAlive()) {
		return;
		}

		sp<Layer> clonedFrom = getClonedFrom();
		mBufferInfo = clonedFrom->mBufferInfo;
		mSidebandStream = clonedFrom->mSidebandStream;
		surfaceDamageRegion = clonedFrom->surfaceDamageRegion;
		mCurrentFrameNumber = clonedFrom->mCurrentFrameNumber.load();
		mPreviousFrameNumber = clonedFrom->mPreviousFrameNumber;

		// After buffer info is updated, the drawingState from the real layer needs to be copied into
		// the cloned. This is because some properties of drawingState can change when latchBuffer is
		// called. However, copying the drawingState would also overwrite the cloned layer's relatives
		// and touchableRegionCrop. Therefore, temporarily store the relatives so they can be set in
		// the cloned drawingState again.
		wp<Layer> tmpZOrderRelativeOf = mDrawingState.zOrderRelativeOf;
		SortedVector<wp<Layer>> tmpZOrderRelatives = mDrawingState.zOrderRelatives;
		wp<Layer> tmpTouchableRegionCrop = mDrawingState.touchableRegionCrop;
		WindowInfo tmpInputInfo = mDrawingState.inputInfo;

		cloneDrawingState(clonedFrom.get());

		mDrawingState.touchableRegionCrop = tmpTouchableRegionCrop;
		mDrawingState.zOrderRelativeOf = tmpZOrderRelativeOf;
		mDrawingState.zOrderRelatives = tmpZOrderRelatives;
		mDrawingState.inputInfo = tmpInputInfo;
		}

		bool Layer::updateMirrorInfo(const std::deque<Layer*>& cloneRootsPendingUpdates) {
		if (mClonedChild == nullptr \|\| !mClonedChild->isClonedFromAlive()) {
		// If mClonedChild is null, there is nothing to mirror. If isClonedFromAlive returns false,
		// it means that there is a clone, but the layer it was cloned from has been destroyed. In
		// that case, we want to delete the reference to the clone since we want it to get
		// destroyed. The root, this layer, will still be around since the client can continue
		// to hold a reference, but no cloned layers will be displayed.
		mClonedChild = nullptr;
		return true;
		}

		std::map<sp<Layer>, sp<Layer>> clonedLayersMap;
		// If the real layer exists and is in current state, add the clone as a child of the root.
		// There's no need to remove from drawingState when the layer is offscreen since currentState is
		// copied to drawingState for the root layer. So the clonedChild is always removed from
		// drawingState and then needs to be added back each traversal.
		mClonedChild->updateClonedDrawingState(clonedLayersMap);
		mClonedChild->updateClonedChildren(sp<Layer>::fromExisting(this), clonedLayersMap);
		mClonedChild->updateClonedRelatives(clonedLayersMap);

		for (Layer* root : cloneRootsPendingUpdates) {
		if (clonedLayersMap.find(sp<Layer>::fromExisting(root)) != clonedLayersMap.end()) {
		return false;
		}
		}
		return true;
		}

		void Layer::updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
		// If the layer the clone was cloned from is alive, copy the content of the drawingState
		// to the clone. If the real layer is no longer alive, continue traversing the children
		// since we may be able to pull out other children that are still alive.
		if (isClonedFromAlive()) {
		sp<Layer> clonedFrom = getClonedFrom();
		cloneDrawingState(clonedFrom.get());
		clonedLayersMap.emplace(clonedFrom, sp<Layer>::fromExisting(this));
		}

		// The clone layer may have children in drawingState since they may have been created and
		// added from a previous request to updateMirorInfo. This is to ensure we don't recreate clones
		// that already exist, since we can just re-use them.
		// The drawingChildren will not get overwritten by the currentChildren since the clones are
		// not updated in the regular traversal. They are skipped since the root will lose the
		// reference to them when it copies its currentChildren to drawing.
		for (sp<Layer>& child : mDrawingChildren) {
		child->updateClonedDrawingState(clonedLayersMap);
		}
		}

		void Layer::updateClonedChildren(const sp<Layer>& mirrorRoot,
		std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
		mDrawingChildren.clear();

		if (!isClonedFromAlive()) {
		return;
		}

		sp<Layer> clonedFrom = getClonedFrom();
		for (sp<Layer>& child : clonedFrom->mDrawingChildren) {
		if (child == mirrorRoot) {
		// This is to avoid cyclical mirroring.
		continue;
		}
		sp<Layer> clonedChild = clonedLayersMap[child];
		if (clonedChild == nullptr) {
		clonedChild = child->createClone();
		clonedLayersMap[child] = clonedChild;
		}
		addChildToDrawing(clonedChild);
		clonedChild->updateClonedChildren(mirrorRoot, clonedLayersMap);
		}
		}

		void Layer::updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
		auto cropLayer = mDrawingState.touchableRegionCrop.promote();
		if (cropLayer != nullptr) {
		if (clonedLayersMap.count(cropLayer) == 0) {
		// Real layer had a crop layer but it's not in the cloned hierarchy. Just set to
		// self as crop layer to avoid going outside bounds.
		mDrawingState.touchableRegionCrop = wp<Layer>::fromExisting(this);
		} else {
		const sp<Layer>& clonedCropLayer = clonedLayersMap.at(cropLayer);
		mDrawingState.touchableRegionCrop = clonedCropLayer;
		}
		}
		// Cloned layers shouldn't handle watch outside since their z order is not determined by
		// WM or the client.
		mDrawingState.inputInfo.setInputConfig(WindowInfo::InputConfig::WATCH_OUTSIDE_TOUCH, false);
		}

		void Layer::updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap) {
		mDrawingState.zOrderRelativeOf = wp<Layer>();
		mDrawingState.zOrderRelatives.clear();

		if (!isClonedFromAlive()) {
		return;
		}

		const sp<Layer>& clonedFrom = getClonedFrom();
		for (wp<Layer>& relativeWeak : clonedFrom->mDrawingState.zOrderRelatives) {
		const sp<Layer>& relative = relativeWeak.promote();
		if (clonedLayersMap.count(relative) > 0) {
		auto& clonedRelative = clonedLayersMap.at(relative);
		mDrawingState.zOrderRelatives.add(clonedRelative);
		}
		}

		// Check if the relativeLayer for the real layer is part of the cloned hierarchy.
		// It's possible that the layer it's relative to is outside the requested cloned hierarchy.
		// In that case, we treat the layer as if the relativeOf has been removed. This way, it will
		// still traverse the children, but the layer with the missing relativeOf will not be shown
		// on screen.
		const sp<Layer>& relativeOf = clonedFrom->mDrawingState.zOrderRelativeOf.promote();
		if (clonedLayersMap.count(relativeOf) > 0) {
		const sp<Layer>& clonedRelativeOf = clonedLayersMap.at(relativeOf);
		mDrawingState.zOrderRelativeOf = clonedRelativeOf;
		}

		updateClonedInputInfo(clonedLayersMap);

		for (sp<Layer>& child : mDrawingChildren) {
		child->updateClonedRelatives(clonedLayersMap);
		}
		}

		void Layer::addChildToDrawing(const sp<Layer>& layer) {
		mDrawingChildren.add(layer);
		layer->mDrawingParent = sp<Layer>::fromExisting(this);
		}

		bool Layer::isInternalDisplayOverlay() const {
		const State& s(mDrawingState);
		if (s.flags & layer_state_t::eLayerSkipScreenshot) {
		@@ -2128,12 +1940,6 @@ bool Layer::isInternalDisplayOverlay() const {
		return parent && parent->isInternalDisplayOverlay();
		}

		void Layer::setClonedChild(const sp<Layer>& clonedChild) {
		mClonedChild = clonedChild;
		mHadClonedChild = true;
		mFlinger->mLayerMirrorRoots.push_back(this);
		}

		bool Layer::setDropInputMode(gui::DropInputMode mode) {
		if (mDrawingState.dropInputMode == mode) {
		return false;
		@@ -2142,15 +1948,6 @@ bool Layer::setDropInputMode(gui::DropInputMode mode) {
		return true;
		}

		void Layer::cloneDrawingState(const Layer* from) {
		mDrawingState = from->mDrawingState;
		// Skip callback info since they are not applicable for cloned layers.
		mDrawingState.releaseBufferListener = nullptr;
		// TODO (b/238781169) currently broken for mirror layers because we do not
		// track release fences for mirror layers composed on other displays
		mDrawingState.callbackHandles = {};
		}

		void Layer::callReleaseBufferCallback(const sp<ITransactionCompletedListener>& listener,
		const sp<GraphicBuffer>& buffer, uint64_t framenumber,
		const sp<Fence>& releaseFence) {
		@@ -2997,13 +2794,6 @@ Rect Layer::computeBufferCrop(const State& s) {
		}
		}

		sp<Layer> Layer::createClone() {
		surfaceflinger::LayerCreationArgs args(mFlinger.get(), nullptr, mName + " (Mirror)", 0,
		LayerMetadata());
		sp<Layer> layer = mFlinger->getFactory().createBufferStateLayer(args);
		return layer;
		}

		void Layer::decrementPendingBufferCount() {
		int32_t pendingBuffers = --mPendingBufferTransactions;
		tracePendingBufferCount(pendingBuffers);

services/surfaceflinger/Layer.h

+0 −38

Original line number	Diff line number	Diff line
		@@ -250,8 +250,6 @@ public:
		// true if this layer is visible, false otherwise
		virtual bool isVisible() const;

		virtual sp<Layer> createClone();

		// Set a 2x2 transformation matrix on the layer. This transform
		// will be applied after parent transforms, but before any final
		// producer specified transform.
		@@ -423,7 +421,6 @@ public:

		// from graphics API
		static ui::Dataspace translateDataspace(ui::Dataspace dataspace);
		void updateCloneBufferInfo();
		uint64_t mPreviousFrameNumber = 0;

		void onCompositionPresented(const DisplayDevice*,
		@@ -652,8 +649,6 @@ public:

		gui::WindowInfo::Type getWindowType() const { return mWindowType; }

		bool updateMirrorInfo(const std::deque<Layer*>& cloneRootsPendingUpdates);

		/*
		* doTransaction - process the transaction. This is a good place to figure
		* out which attributes of the surface have changed.
		@@ -754,15 +749,6 @@ public:

		int32_t getOwnerAppId() { return mOwnerAppId; }

		// This layer is not a clone, but it's the parent to the cloned hierarchy. The
		// variable mClonedChild represents the top layer that will be cloned so this
		// layer will be the parent of mClonedChild.
		// The layers in the cloned hierarchy will match the lifetime of the real layers. That is
		// if the real layer is destroyed, then the clone layer will also be destroyed.
		sp<Layer> mClonedChild;
		bool mHadClonedChild = false;
		void setClonedChild(const sp<Layer>& mClonedChild);

		mutable bool contentDirty{false};
		Region surfaceDamageRegion;

		@@ -807,10 +793,6 @@ public:
		// CompositionEngine to create a single path for composing layers.
		void updateSnapshot(bool updateGeometry);
		void updateChildrenSnapshots(bool updateGeometry);
		sp<Layer> getClonedFrom() const {
		return mClonedFrom != nullptr ? mClonedFrom.promote() : nullptr;
		}
		bool isClone() { return mClonedFrom != nullptr; }

		bool willPresentCurrentTransaction() const;

		@@ -876,16 +858,6 @@ protected:
		void preparePerFrameEffectsCompositionState();
		void gatherBufferInfo();

		bool isClonedFromAlive() { return getClonedFrom() != nullptr; }

		void cloneDrawingState(const Layer* from);
		void updateClonedDrawingState(std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
		void updateClonedChildren(const sp<Layer>& mirrorRoot,
		std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
		void updateClonedRelatives(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);
		void addChildToDrawing(const sp<Layer>&);
		void updateClonedInputInfo(const std::map<sp<Layer>, sp<Layer>>& clonedLayersMap);

		void prepareBasicGeometryCompositionState();
		void prepareGeometryCompositionState();
		void prepareCursorCompositionState();
		@@ -1024,10 +996,6 @@ private:
		gui::DropInputMode getDropInputMode() const;
		void handleDropInputMode(gui::WindowInfo& info) const;

		// Find the root of the cloned hierarchy, this means the first non cloned parent.
		// This will return null if first non cloned parent is not found.
		sp<Layer> getClonedRoot();

		// Finds the top most layer in the hierarchy. This will find the root Layer where the parent is
		// null.
		sp<Layer> getRootLayer();
		@@ -1102,12 +1070,6 @@ private:

		bool mGetHandleCalled = false;

		// The current layer is a clone of mClonedFrom. This means that this layer will update it's
		// properties based on mClonedFrom. When mClonedFrom latches a new buffer for BufferLayers,
		// this layer will update it's buffer. When mClonedFrom updates it's drawing state, children,
		// and relatives, this layer will update as well.
		wp<Layer> mClonedFrom;

		// The inherited shadow radius after taking into account the layer hierarchy. This is the
		// final shadow radius for this layer. If a shadow is specified for a layer, then effective
		// shadow radius is the set shadow radius, otherwise its the parent's shadow radius.

services/surfaceflinger/SurfaceFlinger.cpp

+2 −25

Original line number	Diff line number	Diff line
		@@ -2845,9 +2845,7 @@ CompositeResultsPerDisplay SurfaceFlinger::composite(
		for (auto [layer, layerFE] : layers) {
		CompositionResult compositionResult{layerFE->stealCompositionResult()};
		for (auto& [releaseFence, layerStack] : compositionResult.releaseFences) {
		Layer* clonedFrom = layer->getClonedFrom().get();
		auto owningLayer = clonedFrom ? clonedFrom : layer;
		owningLayer->onLayerDisplayed(std::move(releaseFence), layerStack);
		layer->onLayerDisplayed(std::move(releaseFence), layerStack);
		}
		if (compositionResult.lastClientCompositionFence) {
		layer->setWasClientComposed(compositionResult.lastClientCompositionFence);
		@@ -4335,23 +4333,6 @@ void SurfaceFlinger::doCommitTransactions() {
		SFTRACE_CALL();
		mDrawingState = mCurrentState;
		mCurrentState.colorMatrixChanged = false;

		if (mLayerMirrorRoots.size() > 0) {
		std::deque<Layer*> pendingUpdates;
		pendingUpdates.insert(pendingUpdates.end(), mLayerMirrorRoots.begin(),
		mLayerMirrorRoots.end());
		std::vector<Layer*> needsUpdating;
		for (Layer* cloneRoot : mLayerMirrorRoots) {
		pendingUpdates.pop_front();
		if (cloneRoot->updateMirrorInfo(pendingUpdates)) {
		} else {
		needsUpdating.push_back(cloneRoot);
		}
		}
		for (Layer* cloneRoot : needsUpdating) {
		cloneRoot->updateMirrorInfo({});
		}
		}
		}

		void SurfaceFlinger::invalidateLayerStack(const ui::LayerFilter& layerFilter, const Region& dirty) {
		@@ -5120,8 +5101,6 @@ status_t SurfaceFlinger::mirrorLayer(const LayerCreationArgs& args,
		if (result != NO_ERROR) {
		return result;
		}

		mirrorLayer->setClonedChild(mirrorFrom->createClone());
		}

		outResult.layerId = mirrorLayer->sequence;
		@@ -7178,9 +7157,7 @@ void SurfaceFlinger::captureLayers(const LayerCaptureArgs& args,
		void SurfaceFlinger::attachReleaseFenceFutureToLayer(Layer* layer, LayerFE* layerFE,
		ui::LayerStack layerStack) {
		ftl::Future<FenceResult> futureFence = layerFE->createReleaseFenceFuture();
		Layer* clonedFrom = layer->getClonedFrom().get();
		auto owningLayer = clonedFrom ? clonedFrom : layer;
		owningLayer->prepareReleaseCallbacks(std::move(futureFence), layerStack);
		layer->prepareReleaseCallbacks(std::move(futureFence), layerStack);
		}

		// Loop over all visible layers to see whether there's any protected layer. A protected layer is

services/surfaceflinger/SurfaceFlinger.h

+0 −2

Original line number	Diff line number	Diff line
		@@ -297,8 +297,6 @@ public:
		// the client can no longer modify this layer directly.
		void onHandleDestroyed(BBinder* handle, sp<Layer>& layer, uint32_t layerId);

		std::vector<Layer*> mLayerMirrorRoots;

		TransactionCallbackInvoker& getTransactionCallbackInvoker() {
		return mTransactionCallbackInvoker;
		}