Merge "CE: Move knowledge of the OutputLayers out of Output" (2a6de281) · Commits · e / os / android_frameworks_native

services/surfaceflinger/CompositionEngine/include/compositionengine/Output.h

+79 −17

Original line number	Diff line number	Diff line
		@@ -17,9 +17,12 @@
		#pragma once

		#include <cstdint>
		#include <iterator>
		#include <optional>
		#include <string>
		#include <type_traits>
		#include <unordered_map>
		#include <utility>

		#include <compositionengine/LayerFE.h>
		#include <renderengine/LayerSettings.h>
		@@ -55,10 +58,67 @@ struct OutputCompositionState;
		*/
		class Output {
		public:
		using OutputLayers = std::vector<std::unique_ptr<compositionengine::OutputLayer>>;
		using ReleasedLayers = std::vector<wp<LayerFE>>;
		using UniqueFELayerStateMap = std::unordered_map<LayerFE, LayerFECompositionState>;

		// A helper class for enumerating the output layers using a C++11 ranged-based for loop
		template <typename T>
		class OutputLayersEnumerator {
		public:
		// TODO(lpique): Consider turning this into a C++20 view when possible.
		template <bool IsConstIter>
		class IteratorImpl {
		public:
		// Required definitions to be considered an iterator
		using iterator_category = std::forward_iterator_tag;
		using value_type = decltype(std::declval<T>().getOutputLayerOrderedByZByIndex(0));
		using difference_type = std::ptrdiff_t;
		using pointer = std::conditional_t<IsConstIter, const value_type, value_type>;
		using reference = std::conditional_t<IsConstIter, const value_type&, value_type&>;

		IteratorImpl() = default;
		IteratorImpl(const T* output, size_t index) : mOutput(output), mIndex(index) {}

		value_type operator*() const {
		return mOutput->getOutputLayerOrderedByZByIndex(mIndex);
		}
		value_type operator->() const {
		return mOutput->getOutputLayerOrderedByZByIndex(mIndex);
		}

		bool operator==(const IteratorImpl& other) const {
		return mOutput == other.mOutput && mIndex == other.mIndex;
		}
		bool operator!=(const IteratorImpl& other) const { return !operator==(other); }

		IteratorImpl& operator++() {
		++mIndex;
		return *this;
		}
		IteratorImpl operator++(int) {
		auto prev = *this;
		++mIndex;
		return prev;
		}

		private:
		const T* mOutput{nullptr};
		size_t mIndex{0};
		};

		using iterator = IteratorImpl<false>;
		using const_iterator = IteratorImpl<true>;

		explicit OutputLayersEnumerator(const T& output) : mOutput(output) {}
		auto begin() const { return iterator(&mOutput, 0); }
		auto end() const { return iterator(&mOutput, mOutput.getOutputLayerCount()); }
		auto cbegin() const { return const_iterator(&mOutput, 0); }
		auto cend() const { return const_iterator(&mOutput, mOutput.getOutputLayerCount()); }

		private:
		const T& mOutput;
		};

		struct FrameFences {
		sp<Fence> presentFence{Fence::NO_FENCE};
		sp<Fence> clientTargetAcquireFence{Fence::NO_FENCE};
		@@ -152,28 +212,32 @@ public:
		virtual bool belongsInOutput(std::optional<uint32_t> layerStackId, bool internalOnly) const = 0;

		// Determines if a layer belongs to the output.
		virtual bool belongsInOutput(const compositionengine::Layer*) const = 0;
		virtual bool belongsInOutput(const Layer*) const = 0;

		// Returns a pointer to the output layer corresponding to the given layer on
		// this output, or nullptr if the layer does not have one
		virtual OutputLayer* getOutputLayerForLayer(Layer*) const = 0;

		// Creates an OutputLayer instance for this output
		virtual std::unique_ptr<OutputLayer> createOutputLayer(const std::shared_ptr<Layer>&,
		const sp<LayerFE>&) const = 0;
		// Immediately clears all layers from the output.
		virtual void clearOutputLayers() = 0;

		// For tests use only. Creates and appends an OutputLayer into the output.
		virtual OutputLayer* injectOutputLayerForTest(const std::shared_ptr<Layer>&,
		const sp<LayerFE>&) = 0;

		// Sets the new ordered set of output layers for this output
		virtual void setOutputLayersOrderedByZ(OutputLayers&&) = 0;
		// Gets the count of output layers managed by this output
		virtual size_t getOutputLayerCount() const = 0;

		// Gets the ordered set of output layers for this output
		virtual const OutputLayers& getOutputLayersOrderedByZ() const = 0;
		// Gets an output layer in Z order given its index
		virtual OutputLayer* getOutputLayerOrderedByZByIndex(size_t) const = 0;

		// A helper function for enumerating all the output layers in Z order using
		// a C++11 range-based for loop.
		auto getOutputLayersOrderedByZ() const { return OutputLayersEnumerator(*this); }

		// Sets the new set of layers being released this frame
		virtual void setReleasedLayers(ReleasedLayers&&) = 0;

		// Takes (moves) the set of layers being released this frame.
		virtual ReleasedLayers takeReleasedLayers() = 0;

		// Prepare the output, updating the OutputLayers used in the output
		virtual void prepare(const CompositionRefreshArgs&, LayerFESet&) = 0;

		@@ -187,12 +251,10 @@ protected:
		virtual void setDisplayColorProfile(std::unique_ptr<DisplayColorProfile>) = 0;
		virtual void setRenderSurface(std::unique_ptr<RenderSurface>) = 0;

		virtual void rebuildLayerStacks(const compositionengine::CompositionRefreshArgs&,
		LayerFESet&) = 0;
		virtual void rebuildLayerStacks(const CompositionRefreshArgs&, LayerFESet&) = 0;
		virtual void collectVisibleLayers(const CompositionRefreshArgs&, CoverageState&) = 0;
		virtual std::unique_ptr<OutputLayer> getOutputLayerIfVisible(
		std::shared_ptr<compositionengine::Layer>, CoverageState&) = 0;
		virtual void setReleasedLayers(const compositionengine::CompositionRefreshArgs&) = 0;
		virtual void ensureOutputLayerIfVisible(std::shared_ptr<Layer>, CoverageState&) = 0;
		virtual void setReleasedLayers(const CompositionRefreshArgs&) = 0;

		virtual void updateAndWriteCompositionState(const CompositionRefreshArgs&) = 0;
		virtual void setColorTransform(const CompositionRefreshArgs&) = 0;

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Display.h

+4 −2

Original line number	Diff line number	Diff line
		@@ -41,8 +41,6 @@ public:

		// compositionengine::Output overrides
		void dump(std::string&) const override;
		std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(
		const std::shared_ptr<compositionengine::Layer>&, const sp<LayerFE>&) const override;
		using compositionengine::impl::Output::setReleasedLayers;
		void setReleasedLayers(const CompositionRefreshArgs&) override;
		void setColorTransform(const CompositionRefreshArgs&) override;
		@@ -72,6 +70,10 @@ public:
		virtual void applyDisplayRequests(const DisplayRequests&);
		virtual void applyLayerRequestsToLayers(const LayerRequests&);

		// Internal
		std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(
		const std::shared_ptr<compositionengine::Layer>&, const sp<LayerFE>&) const;

		private:
		const bool mIsVirtual;
		std::optional<DisplayId> mId;

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Output.h

+71 −13

Original line number	Diff line number	Diff line
		@@ -60,13 +60,8 @@ public:

		compositionengine::OutputLayer* getOutputLayerForLayer(
		compositionengine::Layer*) const override;
		std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(
		const std::shared_ptr<Layer>&, const sp<LayerFE>&) const override;
		void setOutputLayersOrderedByZ(OutputLayers&&) override;
		const OutputLayers& getOutputLayersOrderedByZ() const override;

		void setReleasedLayers(ReleasedLayers&&) override;
		ReleasedLayers takeReleasedLayers() override;

		void prepare(const CompositionRefreshArgs&, LayerFESet&) override;
		void present(const CompositionRefreshArgs&) override;
		@@ -74,8 +69,7 @@ public:
		void rebuildLayerStacks(const CompositionRefreshArgs&, LayerFESet&) override;
		void collectVisibleLayers(const CompositionRefreshArgs&,
		compositionengine::Output::CoverageState&) override;
		std::unique_ptr<compositionengine::OutputLayer> getOutputLayerIfVisible(
		std::shared_ptr<compositionengine::Layer>,
		void ensureOutputLayerIfVisible(std::shared_ptr<compositionengine::Layer>,
		compositionengine::Output::CoverageState&) override;
		void setReleasedLayers(const compositionengine::CompositionRefreshArgs&) override;

		@@ -95,9 +89,9 @@ public:
		void setRenderSurfaceForTest(std::unique_ptr<compositionengine::RenderSurface>);

		protected:
		virtual const CompositionEngine& getCompositionEngine() const = 0;
		std::unique_ptr<compositionengine::OutputLayer> takeOutputLayerForLayer(
		compositionengine::Layer*);
		std::unique_ptr<compositionengine::OutputLayer> createOutputLayer(
		const std::shared_ptr<compositionengine::Layer>&, const sp<LayerFE>&) const;
		std::optional<size_t> findCurrentOutputLayerForLayer(compositionengine::Layer*) const;
		void chooseCompositionStrategy() override;
		bool getSkipColorTransform() const override;
		compositionengine::Output::FrameFences presentAndGetFrameFences() override;
		@@ -109,7 +103,14 @@ protected:
		void dumpBase(std::string&) const;

		// Implemented by the final implementation for the final state it uses.
		virtual void dumpState(std::string&) const = 0;
		virtual compositionengine::OutputLayer* ensureOutputLayer(
		std::optional<size_t>, const std::shared_ptr<compositionengine::Layer>&,
		const sp<LayerFE>&) = 0;
		virtual compositionengine::OutputLayer* injectOutputLayerForTest(
		const std::shared_ptr<compositionengine::Layer>&, const sp<LayerFE>&) = 0;
		virtual void finalizePendingOutputLayers() = 0;
		virtual const compositionengine::CompositionEngine& getCompositionEngine() const = 0;
		virtual void dumpState(std::string& out) const = 0;

		private:
		void dirtyEntireOutput();
		@@ -122,7 +123,6 @@ private:
		std::unique_ptr<compositionengine::DisplayColorProfile> mDisplayColorProfile;
		std::unique_ptr<compositionengine::RenderSurface> mRenderSurface;

		OutputLayers mOutputLayersOrderedByZ;
		ReleasedLayers mReleasedLayers;
		};

		@@ -141,6 +141,8 @@ std::shared_ptr<BaseOutput> createOutputTemplated(const CompositionEngine& compo

		using OutputCompositionState = std::remove_const_t<
		std::remove_reference_t<decltype(std::declval<BaseOutput>().getState())>>;
		using OutputLayer = std::remove_pointer_t<decltype(
		std::declval<BaseOutput>().getOutputLayerOrderedByZByIndex(0))>;

		#pragma clang diagnostic pop

		@@ -151,16 +153,72 @@ std::shared_ptr<BaseOutput> createOutputTemplated(const CompositionEngine& compo
		private:
		// compositionengine::Output overrides
		const OutputCompositionState& getState() const override { return mState; }

		OutputCompositionState& editState() override { return mState; }

		size_t getOutputLayerCount() const override {
		return mCurrentOutputLayersOrderedByZ.size();
		}

		OutputLayer* getOutputLayerOrderedByZByIndex(size_t index) const override {
		if (index >= mCurrentOutputLayersOrderedByZ.size()) {
		return nullptr;
		}
		return mCurrentOutputLayersOrderedByZ[index].get();
		}

		// compositionengine::impl::Output overrides
		const CompositionEngine& getCompositionEngine() const override {
		return mCompositionEngine;
		};

		OutputLayer* ensureOutputLayer(std::optional<size_t> prevIndex,
		const std::shared_ptr<compositionengine::Layer>& layer,
		const sp<LayerFE>& layerFE) {
		auto outputLayer = (prevIndex && *prevIndex <= mCurrentOutputLayersOrderedByZ.size())
		? std::move(mCurrentOutputLayersOrderedByZ[*prevIndex])
		: BaseOutput::createOutputLayer(layer, layerFE);
		auto result = outputLayer.get();
		mPendingOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
		return result;
		}

		void finalizePendingOutputLayers() override {
		// The pending layers are added in reverse order. Reverse them to
		// get the back-to-front ordered list of layers.
		std::reverse(mPendingOutputLayersOrderedByZ.begin(),
		mPendingOutputLayersOrderedByZ.end());

		mCurrentOutputLayersOrderedByZ = std::move(mPendingOutputLayersOrderedByZ);
		}

		void dumpState(std::string& out) const override { mState.dump(out); }

		OutputLayer* injectOutputLayerForTest(
		const std::shared_ptr<compositionengine::Layer>& layer,
		const sp<LayerFE>& layerFE) override {
		auto outputLayer = BaseOutput::createOutputLayer(layer, layerFE);
		auto result = outputLayer.get();
		mCurrentOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
		return result;
		}

		// Note: This is declared as a private virtual non-override so it can be
		// an override implementation in the unit tests, but otherwise is not an
		// accessible override for the normal implementation.
		virtual void injectOutputLayerForTest(std::unique_ptr<OutputLayer> outputLayer) {
		mCurrentOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
		}

		void clearOutputLayers() override {
		mCurrentOutputLayersOrderedByZ.clear();
		mPendingOutputLayersOrderedByZ.clear();
		}

		const CompositionEngine& mCompositionEngine;
		OutputCompositionState mState;
		std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ;
		std::vector<std::unique_ptr<OutputLayer>> mPendingOutputLayersOrderedByZ;
		};

		return std::make_shared<Output>(compositionEngine, std::forward<Args>(args)...);

services/surfaceflinger/CompositionEngine/include/compositionengine/mock/Output.h

+9 −16

Original line number	Diff line number	Diff line
		@@ -64,20 +64,14 @@ public:

		MOCK_CONST_METHOD1(getOutputLayerForLayer,
		compositionengine::OutputLayer(compositionengine::Layer));
		MOCK_CONST_METHOD2(createOutputLayer,
		std::unique_ptr<compositionengine::OutputLayer>(
		const std::shared_ptr<compositionengine::Layer>&,
		MOCK_METHOD0(clearOutputLayers, void());
		MOCK_METHOD2(injectOutputLayerForTest,
		compositionengine::OutputLayer*(const std::shared_ptr<compositionengine::Layer>&,
		const sp<compositionengine::LayerFE>&));
		MOCK_METHOD2(getOrCreateOutputLayer,
		std::unique_ptr<compositionengine::OutputLayer>(
		std::shared_ptr<compositionengine::Layer>,
		sp<compositionengine::LayerFE>));

		MOCK_METHOD1(setOutputLayersOrderedByZ, void(OutputLayers&&));
		MOCK_CONST_METHOD0(getOutputLayersOrderedByZ, OutputLayers&());
		MOCK_CONST_METHOD0(getOutputLayerCount, size_t());
		MOCK_CONST_METHOD1(getOutputLayerOrderedByZByIndex, OutputLayer*(size_t));

		MOCK_METHOD1(setReleasedLayers, void(ReleasedLayers&&));
		MOCK_METHOD0(takeReleasedLayers, ReleasedLayers());

		MOCK_METHOD2(prepare, void(const compositionengine::CompositionRefreshArgs&, LayerFESet&));
		MOCK_METHOD1(present, void(const compositionengine::CompositionRefreshArgs&));
		@@ -87,9 +81,8 @@ public:
		MOCK_METHOD2(collectVisibleLayers,
		void(const compositionengine::CompositionRefreshArgs&,
		compositionengine::Output::CoverageState&));
		MOCK_METHOD2(getOutputLayerIfVisible,
		std::unique_ptr<compositionengine::OutputLayer>(
		std::shared_ptr<compositionengine::Layer>,
		MOCK_METHOD2(ensureOutputLayerIfVisible,
		void(std::shared_ptr<compositionengine::Layer>,
		compositionengine::Output::CoverageState&));
		MOCK_METHOD1(setReleasedLayers, void(const compositionengine::CompositionRefreshArgs&));

services/surfaceflinger/CompositionEngine/src/CompositionEngine.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -101,7 +101,7 @@ void CompositionEngine::updateCursorAsync(CompositionRefreshArgs& args) {
		uniqueVisibleLayers;

		for (const auto& output : args.outputs) {
		for (auto& layer : output->getOutputLayersOrderedByZ()) {
		for (auto* layer : output->getOutputLayersOrderedByZ()) {
		if (layer->isHardwareCursor()) {
		// Latch the cursor composition state from each front-end layer.
		layer->getLayerFE().latchCursorCompositionState(layer->getLayer().editFEState());