Remove legacy layer hierarchy (a12c5c7f) · Commits · e / os / android_frameworks_native

services/surfaceflinger/FrontEnd/Update.h

+1 −16

Original line number	Diff line number	Diff line
		@@ -22,28 +22,13 @@
		#include "RequestedLayerState.h"
		#include "TransactionState.h"

		namespace android {
		struct LayerCreatedState {
		LayerCreatedState(const wp<Layer>& layer, const wp<Layer>& parent, bool addToRoot)
		: layer(layer), initialParent(parent), addToRoot(addToRoot) {}
		wp<Layer> layer;
		// Indicates the initial parent of the created layer, only used for creating layer in
		// SurfaceFlinger. If nullptr, it may add the created layer into the current root layers.
		wp<Layer> initialParent;
		// Indicates whether the layer getting created should be added at root if there's no parent
		// and has permission ACCESS_SURFACE_FLINGER. If set to false and no parent, the layer will
		// be added offscreen.
		bool addToRoot;
		};
		} // namespace android

		namespace android::surfaceflinger::frontend {

		// Atomic set of changes affecting layer state. These changes are queued in binder threads and
		// applied every vsync.
		struct Update {
		std::vector<TransactionState> transactions;
		std::vector<LayerCreatedState> layerCreatedStates;
		std::vector<sp<Layer>> legacyLayers;
		std::vector<std::unique_ptr<frontend::RequestedLayerState>> newLayers;
		std::vector<LayerCreationArgs> layerCreationArgs;
		std::vector<std::pair<uint32_t, std::string /* debugName */>> destroyedHandles;

services/surfaceflinger/Layer.cpp

+0 −375

Original line number	Diff line number	Diff line
		@@ -282,48 +282,6 @@ void Layer::removeRelativeZ(const std::vector<Layer*>& layersInTree) {
		}
		}

		void Layer::removeFromCurrentState() {
		if (!mRemovedFromDrawingState) {
		mRemovedFromDrawingState = true;
		mFlinger->mScheduler->deregisterLayer(this);
		}
		updateTrustedPresentationState(nullptr, nullptr, -1 /* time_in_ms /, true / leaveState*/);

		mFlinger->markLayerPendingRemovalLocked(sp<Layer>::fromExisting(this));
		}

		sp<Layer> Layer::getRootLayer() {
		sp<Layer> parent = getParent();
		if (parent == nullptr) {
		return sp<Layer>::fromExisting(this);
		}
		return parent->getRootLayer();
		}

		void Layer::onRemovedFromCurrentState() {
		// Use the root layer since we want to maintain the hierarchy for the entire subtree.
		auto layersInTree = getRootLayer()->getLayersInTree(LayerVector::StateSet::Current);
		std::sort(layersInTree.begin(), layersInTree.end());

		REQUIRE_MUTEX(mFlinger->mStateLock);
		traverse(LayerVector::StateSet::Current,
		[&](Layer* layer) REQUIRES(layer->mFlinger->mStateLock) {
		layer->removeFromCurrentState();
		layer->removeRelativeZ(layersInTree);
		});
		}

		void Layer::addToCurrentState() {
		if (mRemovedFromDrawingState) {
		mRemovedFromDrawingState = false;
		mFlinger->mScheduler->registerLayer(this, FrameRateCompatibility::Default);
		}

		for (const auto& child : mCurrentChildren) {
		child->addToCurrentState();
		}
		}

		// ---------------------------------------------------------------------------
		// set-up
		// ---------------------------------------------------------------------------
		@@ -592,7 +550,6 @@ void Layer::prepareBasicGeometryCompositionState() {
		snapshot->alpha = alpha;
		snapshot->backgroundBlurRadius = getBackgroundBlurRadius();
		snapshot->blurRegions = getBlurRegions();
		snapshot->stretchEffect = getStretchEffect();
		}

		void Layer::prepareGeometryCompositionState() {
		@@ -826,33 +783,6 @@ void Layer::setTransactionFlags(uint32_t mask) {
		mTransactionFlags \|= mask;
		}

		bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) {
		ssize_t idx = mCurrentChildren.indexOf(childLayer);
		if (idx < 0) {
		return false;
		}
		if (childLayer->setLayer(z)) {
		mCurrentChildren.removeAt(idx);
		mCurrentChildren.add(childLayer);
		return true;
		}
		return false;
		}

		bool Layer::setChildRelativeLayer(const sp<Layer>& childLayer,
		const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
		ssize_t idx = mCurrentChildren.indexOf(childLayer);
		if (idx < 0) {
		return false;
		}
		if (childLayer->setRelativeLayer(relativeToHandle, relativeZ)) {
		mCurrentChildren.removeAt(idx);
		mCurrentChildren.add(childLayer);
		return true;
		}
		return false;
		}

		bool Layer::setLayer(int32_t z) {
		if (mDrawingState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false;
		mDrawingState.sequence++;
		@@ -959,46 +889,6 @@ bool Layer::setAlpha(float alpha) {
		return true;
		}

		bool Layer::setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace) {
		if (!mDrawingState.bgColorLayer && alpha == 0) {
		return false;
		}
		mDrawingState.sequence++;
		mDrawingState.modified = true;
		setTransactionFlags(eTransactionNeeded);

		if (!mDrawingState.bgColorLayer && alpha != 0) {
		// create background color layer if one does not yet exist
		uint32_t flags = ISurfaceComposerClient::eFXSurfaceEffect;
		std::string name = mName + "BackgroundColorLayer";
		mDrawingState.bgColorLayer = mFlinger->getFactory().createEffectLayer(
		surfaceflinger::LayerCreationArgs(mFlinger.get(), nullptr, std::move(name), flags,
		LayerMetadata()));

		// add to child list
		addChild(mDrawingState.bgColorLayer);
		mFlinger->mLayersAdded = true;
		// set up SF to handle added color layer
		if (isRemovedFromCurrentState()) {
		MUTEX_ALIAS(mFlinger->mStateLock, mDrawingState.bgColorLayer->mFlinger->mStateLock);
		mDrawingState.bgColorLayer->onRemovedFromCurrentState();
		}
		mFlinger->setTransactionFlags(eTransactionNeeded);
		} else if (mDrawingState.bgColorLayer && alpha == 0) {
		MUTEX_ALIAS(mFlinger->mStateLock, mDrawingState.bgColorLayer->mFlinger->mStateLock);
		mDrawingState.bgColorLayer->reparent(nullptr);
		mDrawingState.bgColorLayer = nullptr;
		return true;
		}

		mDrawingState.bgColorLayer->setColor(color);
		mDrawingState.bgColorLayer->setLayer(std::numeric_limits<int32_t>::min());
		mDrawingState.bgColorLayer->setAlpha(alpha);
		mDrawingState.bgColorLayer->setDataspace(dataspace);

		return true;
		}

		bool Layer::setCornerRadius(float cornerRadius) {
		if (mDrawingState.cornerRadius == cornerRadius) return false;

		@@ -1149,22 +1039,6 @@ bool Layer::setStretchEffect(const StretchEffect& effect) {
		return true;
		}

		StretchEffect Layer::getStretchEffect() const {
		if (mDrawingState.stretchEffect.hasEffect()) {
		return mDrawingState.stretchEffect;
		}

		sp<Layer> parent = getParent();
		if (parent != nullptr) {
		auto effect = parent->getStretchEffect();
		if (effect.hasEffect()) {
		// TODO(b/179047472): Map it? Or do we make the effect be in global space?
		return effect;
		}
		}
		return StretchEffect{};
		}

		void Layer::setFrameTimelineVsyncForBufferTransaction(const FrameTimelineInfo& info,
		nsecs_t postTime, gui::GameMode gameMode) {
		mDrawingState.postTime = postTime;
		@@ -1439,32 +1313,6 @@ void Layer::onDisconnect() {
		mFlinger->mFrameTracer->onDestroy(layerId);
		}

		size_t Layer::getDescendantCount() const {
		size_t count = 0;
		for (const sp<Layer>& child : mDrawingChildren) {
		count += 1 + child->getChildrenCount();
		}
		return count;
		}

		void Layer::addChild(const sp<Layer>& layer) {
		mFlinger->mSomeChildrenChanged = true;
		setTransactionFlags(eTransactionNeeded);

		mCurrentChildren.add(layer);
		layer->setParent(sp<Layer>::fromExisting(this));
		}

		ssize_t Layer::removeChild(const sp<Layer>& layer) {
		mFlinger->mSomeChildrenChanged = true;
		setTransactionFlags(eTransactionNeeded);

		layer->setParent(nullptr);
		const auto removeResult = mCurrentChildren.remove(layer);

		return removeResult;
		}

		void Layer::setChildrenDrawingParent(const sp<Layer>& newParent) {
		for (const sp<Layer>& child : mDrawingChildren) {
		child->mDrawingParent = newParent;
		@@ -1475,39 +1323,6 @@ void Layer::setChildrenDrawingParent(const sp<Layer>& newParent) {
		}
		}

		bool Layer::reparent(const sp<IBinder>& newParentHandle) {
		sp<Layer> newParent;
		if (newParentHandle != nullptr) {
		newParent = LayerHandle::getLayer(newParentHandle);
		if (newParent == nullptr) {
		ALOGE("Unable to promote Layer handle");
		return false;
		}
		if (newParent == this) {
		ALOGE("Invalid attempt to reparent Layer (%s) to itself", getName().c_str());
		return false;
		}
		}

		sp<Layer> parent = getParent();
		if (parent != nullptr) {
		parent->removeChild(sp<Layer>::fromExisting(this));
		}

		if (newParentHandle != nullptr) {
		newParent->addChild(sp<Layer>::fromExisting(this));
		if (!newParent->isRemovedFromCurrentState()) {
		addToCurrentState();
		} else {
		onRemovedFromCurrentState();
		}
		} else {
		onRemovedFromCurrentState();
		}

		return true;
		}

		bool Layer::setColorTransform(const mat4& matrix) {
		static const mat4 identityMatrix = mat4();

		@@ -1590,167 +1405,6 @@ __attribute__((no_sanitize("unsigned-integer-overflow"))) LayerVector Layer::mak
		return traverse;
		}

		/**
		* Negatively signed relatives are before 'this' in Z-order.
		*/
		void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) {
		// In the case we have other layers who are using a relative Z to us, makeTraversalList will
		// produce a new list for traversing, including our relatives, and not including our children
		// who are relatives of another surface. In the case that there are no relative Z,
		// makeTraversalList returns our children directly to avoid significant overhead.
		// However in this case we need to take the responsibility for filtering children which
		// are relatives of another surface here.
		bool skipRelativeZUsers = false;
		const LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);

		size_t i = 0;
		for (; i < list.size(); i++) {
		const auto& relative = list[i];
		if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
		continue;
		}

		if (relative->getZ(stateSet) >= 0) {
		break;
		}
		relative->traverseInZOrder(stateSet, visitor);
		}

		visitor(this);
		for (; i < list.size(); i++) {
		const auto& relative = list[i];

		if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
		continue;
		}
		relative->traverseInZOrder(stateSet, visitor);
		}
		}

		/**
		* Positively signed relatives are before 'this' in reverse Z-order.
		*/
		void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet,
		const LayerVector::Visitor& visitor) {
		// See traverseInZOrder for documentation.
		bool skipRelativeZUsers = false;
		LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);

		int32_t i = 0;
		for (i = int32_t(list.size()) - 1; i >= 0; i--) {
		const auto& relative = list[i];

		if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
		continue;
		}

		if (relative->getZ(stateSet) < 0) {
		break;
		}
		relative->traverseInReverseZOrder(stateSet, visitor);
		}
		visitor(this);
		for (; i >= 0; i--) {
		const auto& relative = list[i];

		if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
		continue;
		}

		relative->traverseInReverseZOrder(stateSet, visitor);
		}
		}

		void Layer::traverse(LayerVector::StateSet state, const LayerVector::Visitor& visitor) {
		visitor(this);
		const LayerVector& children =
		state == LayerVector::StateSet::Drawing ? mDrawingChildren : mCurrentChildren;
		for (const sp<Layer>& child : children) {
		child->traverse(state, visitor);
		}
		}

		void Layer::traverseChildren(const LayerVector::Visitor& visitor) {
		for (const sp<Layer>& child : mDrawingChildren) {
		visitor(child.get());
		}
		}

		LayerVector Layer::makeChildrenTraversalList(LayerVector::StateSet stateSet,
		const std::vector<Layer*>& layersInTree) {
		LOG_ALWAYS_FATAL_IF(stateSet == LayerVector::StateSet::Invalid,
		"makeTraversalList received invalid stateSet");
		const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
		const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
		const State& state = useDrawing ? mDrawingState : mDrawingState;

		LayerVector traverse(stateSet);
		for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
		sp<Layer> strongRelative = weakRelative.promote();
		// Only add relative layers that are also descendents of the top most parent of the tree.
		// If a relative layer is not a descendent, then it should be ignored.
		if (std::binary_search(layersInTree.begin(), layersInTree.end(), strongRelative.get())) {
		traverse.add(strongRelative);
		}
		}

		for (const sp<Layer>& child : children) {
		const State& childState = useDrawing ? child->mDrawingState : child->mDrawingState;
		// If a layer has a relativeOf layer, only ignore if the layer it's relative to is a
		// descendent of the top most parent of the tree. If it's not a descendent, then just add
		// the child here since it won't be added later as a relative.
		if (std::binary_search(layersInTree.begin(), layersInTree.end(),
		childState.zOrderRelativeOf.promote().get())) {
		continue;
		}
		traverse.add(child);
		}

		return traverse;
		}

		void Layer::traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
		LayerVector::StateSet stateSet,
		const LayerVector::Visitor& visitor) {
		const LayerVector list = makeChildrenTraversalList(stateSet, layersInTree);

		size_t i = 0;
		for (; i < list.size(); i++) {
		const auto& relative = list[i];
		if (relative->getZ(stateSet) >= 0) {
		break;
		}
		relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
		}

		visitor(this);
		for (; i < list.size(); i++) {
		const auto& relative = list[i];
		relative->traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
		}
		}

		std::vector<Layer*> Layer::getLayersInTree(LayerVector::StateSet stateSet) {
		const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
		const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;

		std::vector<Layer*> layersInTree = {this};
		for (size_t i = 0; i < children.size(); i++) {
		const auto& child = children[i];
		std::vector<Layer*> childLayers = child->getLayersInTree(stateSet);
		layersInTree.insert(layersInTree.end(), childLayers.cbegin(), childLayers.cend());
		}

		return layersInTree;
		}

		void Layer::traverseChildrenInZOrder(LayerVector::StateSet stateSet,
		const LayerVector::Visitor& visitor) {
		std::vector<Layer*> layersInTree = getLayersInTree(stateSet);
		std::sort(layersInTree.begin(), layersInTree.end());
		traverseChildrenInZOrderInner(layersInTree, stateSet, visitor);
		}

		ui::Transform Layer::getTransform() const {
		return mEffectiveTransform;
		}
		@@ -1861,27 +1515,6 @@ bool Layer::findInHierarchy(const sp<Layer>& l) {
		return false;
		}

		void Layer::commitChildList() {
		for (size_t i = 0; i < mCurrentChildren.size(); i++) {
		const auto& child = mCurrentChildren[i];
		child->commitChildList();
		}
		mDrawingChildren = mCurrentChildren;
		mDrawingParent = mCurrentParent;
		if (CC_UNLIKELY(usingRelativeZ(LayerVector::StateSet::Drawing))) {
		auto zOrderRelativeOf = mDrawingState.zOrderRelativeOf.promote();
		if (zOrderRelativeOf == nullptr) return;
		if (findInHierarchy(zOrderRelativeOf)) {
		ALOGE("Detected Z ordering loop between %s and %s", mName.c_str(),
		zOrderRelativeOf->mName.c_str());
		ALOGE("Severing rel Z loop, potentially dangerous");
		mDrawingState.isRelativeOf = false;
		zOrderRelativeOf->removeZOrderRelative(wp<Layer>::fromExisting(this));
		}
		}
		}


		void Layer::setInputInfo(const WindowInfo& info) {
		mDrawingState.inputInfo = info;
		mDrawingState.touchableRegionCrop =
		@@ -2048,10 +1681,6 @@ void Layer::writeToProtoCommonState(perfetto::protos::LayerProto* layerInfo,
		[&]() { return layerInfo->mutable_destination_frame(); });
		}

		bool Layer::isRemovedFromCurrentState() const {
		return mRemovedFromDrawingState;
		}

		// Applies the given transform to the region, while protecting against overflows caused by any
		// offsets. If applying the offset in the transform to any of the Rects in the region would result
		// in an overflow, they are not added to the output Region.
		@@ -2375,10 +2004,6 @@ bool Layer::updateMirrorInfo(const std::deque<Layer*>& cloneRootsPendingUpdates)
		// 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.
		if (!mClonedChild->getClonedFrom()->isRemovedFromCurrentState()) {
		addChildToDrawing(mClonedChild);
		}

		mClonedChild->updateClonedDrawingState(clonedLayersMap);
		mClonedChild->updateClonedChildren(sp<Layer>::fromExisting(this), clonedLayersMap);
		mClonedChild->updateClonedRelatives(clonedLayersMap);

services/surfaceflinger/Layer.h

+0 −83

Original line number	Diff line number	Diff line
		@@ -297,7 +297,6 @@ public:

		virtual bool setMetadata(const LayerMetadata& data);
		virtual void setChildrenDrawingParent(const sp<Layer>&);
		virtual bool reparent(const sp<IBinder>& newParentHandle) REQUIRES(mFlinger->mStateLock);
		virtual bool setColorTransform(const mat4& matrix);
		virtual mat4 getColorTransform() const;
		virtual bool hasColorTransform() const;
		@@ -326,8 +325,6 @@ public:
		gui::GameMode gameMode);
		bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& /handles/,
		bool willPresent);
		virtual bool setBackgroundColor(const half3& color, float alpha, ui::Dataspace dataspace)
		REQUIRES(mFlinger->mStateLock);
		virtual bool setColorSpaceAgnostic(const bool agnostic);
		virtual bool setDimmingEnabled(const bool dimmingEnabled);
		virtual bool setFixedTransformHint(ui::Transform::RotationFlags fixedTransformHint);
		@@ -638,8 +635,6 @@ public:
		return {getLayerStack(), isInternalDisplayOverlay()};
		}

		bool isRemovedFromCurrentState() const;

		perfetto::protos::LayerProto* writeToProto(perfetto::protos::LayersProto& layersProto,
		uint32_t traceFlags);
		void writeCompositionStateToProto(perfetto::protos::LayerProto* layerProto,
		@@ -671,22 +666,6 @@ public:
		*/
		void removeRelativeZ(const std::vector<Layer*>& layersInTree);

		/*
		* Remove from current state and mark for removal.
		*/
		void removeFromCurrentState() REQUIRES(mFlinger->mStateLock);

		/*
		* called with the state lock from a binder thread when the layer is
		* removed from the current list to the pending removal list
		*/
		void onRemovedFromCurrentState() REQUIRES(mFlinger->mStateLock);

		/*
		* Called when the layer is added back to the current state list.
		*/
		void addToCurrentState();

		inline const State& getDrawingState() const { return mDrawingState; }
		inline State& getDrawingState() { return mDrawingState; }

		@@ -715,57 +694,9 @@ public:
		// is ready to acquire a buffer.
		ui::Transform::RotationFlags getFixedTransformHint() const;

		/**
		* Traverse this layer and it's hierarchy of children directly. Unlike traverseInZOrder
		* which will not emit children who have relativeZOrder to another layer, this method
		* just directly emits all children. It also emits them in no particular order.
		* So this method is not suitable for graphical operations, as it doesn't represent
		* the scene state, but it's also more efficient than traverseInZOrder and so useful for
		* book-keeping.
		*/
		void traverse(LayerVector::StateSet, const LayerVector::Visitor&);
		void traverseInReverseZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
		void traverseInZOrder(LayerVector::StateSet, const LayerVector::Visitor&);
		void traverseChildren(const LayerVector::Visitor&);

		/**
		* Traverse only children in z order, ignoring relative layers that are not children of the
		* parent.
		*/
		void traverseChildrenInZOrder(LayerVector::StateSet, const LayerVector::Visitor&);

		size_t getDescendantCount() const;
		size_t getChildrenCount() const { return mDrawingChildren.size(); }
		bool isHandleAlive() const { return mHandleAlive; }
		bool onHandleDestroyed() { return mHandleAlive = false; }

		// ONLY CALL THIS FROM THE LAYER DTOR!
		// See b/141111965. We need to add current children to offscreen layers in
		// the layer dtor so as not to dangle layers. Since the layer has not
		// committed its transaction when the layer is destroyed, we must add
		// current children. This is safe in the dtor as we will no longer update
		// the current state, but should not be called anywhere else!
		LayerVector& getCurrentChildren() { return mCurrentChildren; }

		void addChild(const sp<Layer>&);
		// Returns index if removed, or negative value otherwise
		// for symmetry with Vector::remove
		ssize_t removeChild(const sp<Layer>& layer);
		sp<Layer> getParent() const { return mCurrentParent.promote(); }

		// Should be called with the surfaceflinger statelock held
		bool isAtRoot() const { return mIsAtRoot; }
		void setIsAtRoot(bool isAtRoot) { mIsAtRoot = isAtRoot; }

		bool hasParent() const { return getParent() != nullptr; }
		Rect getScreenBounds(bool reduceTransparentRegion = true) const;
		bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
		bool setChildRelativeLayer(const sp<Layer>& childLayer,
		const sp<IBinder>& relativeToHandle, int32_t relativeZ);

		// Copy the current list of children to the drawing state. Called by
		// SurfaceFlinger to complete a transaction.
		void commitChildList();
		int32_t getZ(LayerVector::StateSet) const;

		/**
		@@ -855,7 +786,6 @@ public:
		}

		bool setStretchEffect(const StretchEffect& effect);
		StretchEffect getStretchEffect() const;

		bool setBufferCrop(const Rect& /* bufferCrop */);
		bool setDestinationFrame(const Rect& /* destinationFrame */);
		@@ -1086,19 +1016,6 @@ private:
		const DisplayDevice&) const;
		aidl::android::hardware::graphics::composer3::Composition getCompositionType(
		const compositionengine::OutputLayer*) const;
		/**
		* Returns an unsorted vector of all layers that are part of this tree.
		* That includes the current layer and all its descendants.
		*/
		std::vector<Layer*> getLayersInTree(LayerVector::StateSet);
		/**
		* Traverses layers that are part of this tree in the correct z order.
		* layersInTree must be sorted before calling this method.
		*/
		void traverseChildrenInZOrderInner(const std::vector<Layer*>& layersInTree,
		LayerVector::StateSet, const LayerVector::Visitor&);
		LayerVector makeChildrenTraversalList(LayerVector::StateSet,
		const std::vector<Layer*>& layersInTree);

		bool propagateFrameRateForLayerTree(FrameRate parentFrameRate, bool overrideChildren,
		bool* transactionNeeded);

services/surfaceflinger/LayerVector.cpp

+0 −29

Original line number	Diff line number	Diff line
		@@ -61,35 +61,6 @@ int LayerVector::do_compare(const void* lhs, const void* rhs) const
		return (l->sequence > r->sequence) ? 1 : -1;
		}

		void LayerVector::traverseInZOrder(StateSet stateSet, const Visitor& visitor) const {
		for (size_t i = 0; i < size(); i++) {
		const auto& layer = (*this)[i];
		auto& state = layer->getDrawingState();
		if (state.isRelativeOf) {
		continue;
		}
		layer->traverseInZOrder(stateSet, visitor);
		}
		}

		void LayerVector::traverseInReverseZOrder(StateSet stateSet, const Visitor& visitor) const {
		for (auto i = static_cast<int64_t>(size()) - 1; i >= 0; i--) {
		const auto& layer = (*this)[i];
		auto& state = layer->getDrawingState();
		if (state.isRelativeOf) {
		continue;
		}
		layer->traverseInReverseZOrder(stateSet, visitor);
		}
		}

		void LayerVector::traverse(const Visitor& visitor) const {
		for (auto i = static_cast<int64_t>(size()) - 1; i >= 0; i--) {
		const auto& layer = (*this)[i];
		layer->traverse(mStateSet, visitor);
		}
		}

		} // namespace android

		// TODO(b/129481165): remove the #pragma below and fix conversion issues

services/surfaceflinger/LayerVector.h

+1 −4

Original line number	Diff line number	Diff line
		@@ -46,11 +46,8 @@ public:

		// Sorts layer by layer-stack, Z order, and finally creation order (sequence).
		int do_compare(const void* lhs, const void* rhs) const override;

		using Visitor = std::function<void(Layer*)>;
		void traverseInReverseZOrder(StateSet stateSet, const Visitor& visitor) const;
		void traverseInZOrder(StateSet stateSet, const Visitor& visitor) const;
		void traverse(const Visitor& visitor) const;

		private:
		const StateSet mStateSet;
		};