Snap for 7571196 from 149cebdeeba6a1a74819a99fec42b6d15d1dd745 to sc-v2-release (441e1db2) · Commits · e / os / android_frameworks_native-old

libs/input/Android.bp

+13 −2

Original line number	Diff line number	Diff line
		@@ -68,12 +68,10 @@ cc_library {

		static_libs: [
		"libui-types",
		"libgui_window_info_static",
		],

		export_static_lib_headers: [
		"libui-types",
		"libgui_window_info_static",
		],

		target: {
		@@ -96,6 +94,14 @@ cc_library {
		"libui",
		],

		static_libs: [
		"libgui_window_info_static",
		],

		export_static_lib_headers: [
		"libgui_window_info_static",
		],

		sanitize: {
		misc_undefined: ["integer"],
		},
		@@ -117,10 +123,15 @@ cc_library {
		],
		static_libs: [
		"libhostgraphics",
		"libgui_window_info_static",
		],
		shared_libs: [
		"libbinder",
		],

		export_static_lib_headers: [
		"libgui_window_info_static",
		],
		},
		},

services/surfaceflinger/CompositionEngine/src/planner/CachedSet.cpp

+1 −1

Original line number	Diff line number	Diff line
		@@ -175,7 +175,7 @@ void CachedSet::render(renderengine::RenderEngine& renderEngine, TexturePool& te
		LayerFE::ClientCompositionTargetSettings targetSettings{
		.clip = Region(viewport),
		.needsFiltering = false,
		.isSecure = true,
		.isSecure = outputState.isSecure,
		.supportsProtectedContent = false,
		.clearRegion = clearRegion,
		.viewport = viewport,

services/surfaceflinger/CompositionEngine/tests/planner/CachedSetTest.cpp

+69 −3

Original line number	Diff line number	Diff line
		@@ -51,6 +51,15 @@ MATCHER_P(ClientCompositionTargetSettingsBlurSettingsEq, expectedBlurSetting, ""

		return expectedBlurSetting == arg.blurSetting;
		}

		MATCHER_P(ClientCompositionTargetSettingsSecureEq, expectedSecureSetting, "") {
		*result_listener << "ClientCompositionTargetSettings' SecureSettings aren't equal \n";
		*result_listener << "expected " << expectedSecureSetting << "\n";
		*result_listener << "actual " << arg.isSecure << "\n";

		return expectedSecureSetting == arg.isSecure;
		}

		static const ui::Size kOutputSize = ui::Size(1, 1);

		class CachedSetTest : public testing::Test {
		@@ -315,7 +324,7 @@ TEST_F(CachedSetTest, updateAge_BufferUpdate) {
		EXPECT_EQ(0u, cachedSet.getAge());
		}

		TEST_F(CachedSetTest, render) {
		TEST_F(CachedSetTest, renderUnsecureOutput) {
		// Skip the 0th layer to ensure that the bounding box of the layers is offset from (0, 0)
		CachedSet::Layer& layer1 = *mTestLayers[1]->cachedSetLayer.get();
		sp<mock::LayerFE> layerFE1 = mTestLayers[1]->layerFE;
		@@ -348,9 +357,66 @@ TEST_F(CachedSetTest, render) {
		return NO_ERROR;
		};

		EXPECT_CALL(*layerFE1, prepareClientCompositionList(_)).WillOnce(Return(clientCompList1));
		EXPECT_CALL(*layerFE2, prepareClientCompositionList(_)).WillOnce(Return(clientCompList2));
		EXPECT_CALL(*layerFE1,
		prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false)))
		.WillOnce(Return(clientCompList1));
		EXPECT_CALL(*layerFE2,
		prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(false)))
		.WillOnce(Return(clientCompList2));
		EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _, _)).WillOnce(Invoke(drawLayers));
		mOutputState.isSecure = false;
		cachedSet.render(mRenderEngine, mTexturePool, mOutputState);
		expectReadyBuffer(cachedSet);

		EXPECT_EQ(mOutputState.framebufferSpace, cachedSet.getOutputSpace());
		EXPECT_EQ(Rect(kOutputSize.width, kOutputSize.height), cachedSet.getTextureBounds());

		// Now check that appending a new cached set properly cleans up RenderEngine resources.
		CachedSet::Layer& layer3 = *mTestLayers[2]->cachedSetLayer.get();
		cachedSet.append(CachedSet(layer3));
		}

		TEST_F(CachedSetTest, renderSecureOutput) {
		// Skip the 0th layer to ensure that the bounding box of the layers is offset from (0, 0)
		CachedSet::Layer& layer1 = *mTestLayers[1]->cachedSetLayer.get();
		sp<mock::LayerFE> layerFE1 = mTestLayers[1]->layerFE;
		CachedSet::Layer& layer2 = *mTestLayers[2]->cachedSetLayer.get();
		sp<mock::LayerFE> layerFE2 = mTestLayers[2]->layerFE;

		CachedSet cachedSet(layer1);
		cachedSet.append(CachedSet(layer2));

		std::vector<compositionengine::LayerFE::LayerSettings> clientCompList1;
		clientCompList1.push_back({});
		clientCompList1[0].alpha = 0.5f;

		std::vector<compositionengine::LayerFE::LayerSettings> clientCompList2;
		clientCompList2.push_back({});
		clientCompList2[0].alpha = 0.75f;

		const auto drawLayers = [&](const renderengine::DisplaySettings& displaySettings,
		const std::vector<const renderengine::LayerSettings*>& layers,
		const std::shared_ptr<renderengine::ExternalTexture>&, const bool,
		base::unique_fd&&, base::unique_fd*) -> size_t {
		EXPECT_EQ(mOutputState.framebufferSpace.content, displaySettings.physicalDisplay);
		EXPECT_EQ(mOutputState.layerStackSpace.content, displaySettings.clip);
		EXPECT_EQ(ui::Transform::toRotationFlags(mOutputState.framebufferSpace.orientation),
		displaySettings.orientation);
		EXPECT_EQ(0.5f, layers[0]->alpha);
		EXPECT_EQ(0.75f, layers[1]->alpha);
		EXPECT_EQ(ui::Dataspace::SRGB, displaySettings.outputDataspace);

		return NO_ERROR;
		};

		EXPECT_CALL(*layerFE1,
		prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true)))
		.WillOnce(Return(clientCompList1));
		EXPECT_CALL(*layerFE2,
		prepareClientCompositionList(ClientCompositionTargetSettingsSecureEq(true)))
		.WillOnce(Return(clientCompList2));
		EXPECT_CALL(mRenderEngine, drawLayers(_, _, _, _, _, _)).WillOnce(Invoke(drawLayers));
		mOutputState.isSecure = true;
		cachedSet.render(mRenderEngine, mTexturePool, mOutputState);
		expectReadyBuffer(cachedSet);

services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp

+5 −2

Original line number	Diff line number	Diff line
		@@ -84,10 +84,13 @@ ScheduleResult VSyncDispatchTimerQueueEntry::schedule(VSyncDispatch::ScheduleTim
		VSyncTracker& tracker, nsecs_t now) {
		auto nextVsyncTime = tracker.nextAnticipatedVSyncTimeFrom(
		std::max(timing.earliestVsync, now + timing.workDuration + timing.readyDuration));
		auto nextWakeupTime = nextVsyncTime - timing.workDuration - timing.readyDuration;

		bool const wouldSkipAVsyncTarget =
		mArmedInfo && (nextVsyncTime > (mArmedInfo->mActualVsyncTime + mMinVsyncDistance));
		if (wouldSkipAVsyncTarget) {
		bool const wouldSkipAWakeup =
		mArmedInfo && ((nextWakeupTime > (mArmedInfo->mActualWakeupTime + mMinVsyncDistance)));
		if (wouldSkipAVsyncTarget && wouldSkipAWakeup) {
		return getExpectedCallbackTime(nextVsyncTime, timing);
		}

		@@ -97,9 +100,9 @@ ScheduleResult VSyncDispatchTimerQueueEntry::schedule(VSyncDispatch::ScheduleTim
		if (alreadyDispatchedForVsync) {
		nextVsyncTime =
		tracker.nextAnticipatedVSyncTimeFrom(*mLastDispatchTime + mMinVsyncDistance);
		nextWakeupTime = nextVsyncTime - timing.workDuration - timing.readyDuration;
		}

		auto const nextWakeupTime = nextVsyncTime - timing.workDuration - timing.readyDuration;
		auto const nextReadyTime = nextVsyncTime - timing.readyDuration;
		mScheduleTiming = timing;
		mArmedInfo = {nextWakeupTime, nextVsyncTime, nextReadyTime};

services/surfaceflinger/SurfaceFlinger.cpp

+15 −13

Original line number	Diff line number	Diff line
		@@ -3124,9 +3124,11 @@ void SurfaceFlinger::triggerOnFrameRateOverridesChanged() {

		void SurfaceFlinger::initScheduler(const sp<DisplayDevice>& display) {
		if (mScheduler) {
		// In practice it's not allowed to hotplug in/out the primary display once it's been
		// connected during startup, but some tests do it, so just warn and return.
		ALOGW("Can't re-init scheduler");
		// If the scheduler is already initialized, this means that we received
		// a hotplug(connected) on the primary display. In that case we should
		// update the scheduler with the most recent display information.
		ALOGW("Scheduler already initialized, updating instead");
		mScheduler->setRefreshRateConfigs(display->holdRefreshRateConfigs());
		return;
		}
		const auto currRefreshRate = display->getActiveMode()->getFps();
		@@ -3357,7 +3359,7 @@ void SurfaceFlinger::invalidateHwcGeometry() {
		status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBinder>& handle,
		const sp<IGraphicBufferProducer>& gbc, const sp<Layer>& lbc,
		const sp<IBinder>& parentHandle,
		const sp<Layer>& parentLayer, bool addToCurrentState,
		const sp<Layer>& parentLayer, bool addToRoot,
		uint32_t* outTransformHint) {
		if (mNumLayers >= ISurfaceComposer::MAX_LAYERS) {
		ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers.load(),
		@@ -3369,7 +3371,7 @@ status_t SurfaceFlinger::addClientLayer(const sp<Client>& client, const sp<IBind
		if (gbc != nullptr) {
		initialProducer = IInterface::asBinder(gbc);
		}
		setLayerCreatedState(handle, lbc, parentHandle, parentLayer, initialProducer);
		setLayerCreatedState(handle, lbc, parentHandle, parentLayer, initialProducer, addToRoot);

		// Create a transaction includes the initial parent and producer.
		Vector<ComposerState> states;
		@@ -3899,7 +3901,7 @@ uint32_t SurfaceFlinger::setClientStateLocked(
		sp<Layer> layer = nullptr;
		if (s.surface) {
		if (what & layer_state_t::eLayerCreated) {
		layer = handleLayerCreatedLocked(s.surface, privileged);
		layer = handleLayerCreatedLocked(s.surface);
		if (layer) {
		// put the created layer into mLayersByLocalBinderToken.
		mLayersByLocalBinderToken.emplace(s.surface->localBinder(), layer);
		@@ -4309,9 +4311,9 @@ status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& clie
		return result;
		}

		bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
		result = addClientLayer(client, handle, gbp, layer, parentHandle, parentLayer,
		addToCurrentState, outTransformHint);
		bool addToRoot = callingThreadHasUnscopedSurfaceFlingerAccess();
		result = addClientLayer(client, handle, gbp, layer, parentHandle, parentLayer, addToRoot,
		outTransformHint);
		if (result != NO_ERROR) {
		return result;
		}
		@@ -6854,10 +6856,10 @@ void SurfaceFlinger::TransactionState::traverseStatesWithBuffers(

		void SurfaceFlinger::setLayerCreatedState(const sp<IBinder>& handle, const wp<Layer>& layer,
		const wp<IBinder>& parent, const wp<Layer> parentLayer,
		const wp<IBinder>& producer) {
		const wp<IBinder>& producer, bool addToRoot) {
		Mutex::Autolock lock(mCreatedLayersLock);
		mCreatedLayers[handle->localBinder()] =
		std::make_unique<LayerCreatedState>(layer, parent, parentLayer, producer);
		std::make_unique<LayerCreatedState>(layer, parent, parentLayer, producer, addToRoot);
		}

		auto SurfaceFlinger::getLayerCreatedState(const sp<IBinder>& handle) {
		@@ -6882,7 +6884,7 @@ auto SurfaceFlinger::getLayerCreatedState(const sp<IBinder>& handle) {
		return state;
		}

		sp<Layer> SurfaceFlinger::handleLayerCreatedLocked(const sp<IBinder>& handle, bool privileged) {
		sp<Layer> SurfaceFlinger::handleLayerCreatedLocked(const sp<IBinder>& handle) {
		const auto& state = getLayerCreatedState(handle);
		if (!state) {
		return nullptr;
		@@ -6895,7 +6897,7 @@ sp<Layer> SurfaceFlinger::handleLayerCreatedLocked(const sp<IBinder>& handle, bo
		}

		sp<Layer> parent;
		bool allowAddRoot = privileged;
		bool allowAddRoot = state->addToRoot;
		if (state->initialParent != nullptr) {
		parent = fromHandleLocked(state->initialParent.promote()).promote();
		if (parent == nullptr) {