SurfaceFlinger: Rip out Input caching scheme. am: 6191fe5a44 (3dac45f3) · Commits · e / os / android_frameworks_native-old

services/surfaceflinger/BufferLayer.cpp

+0 −4

Original line number	Diff line number	Diff line
		@@ -497,10 +497,6 @@ bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
		}
		}

		if (recomputeVisibleRegions == true) {
		maybeDirtyInput();
		}

		return true;
		}

+0 −31

Original line number	Diff line number	Diff line
		@@ -220,9 +220,6 @@ void Layer::removeFromCurrentState() {
		}

		mFlinger->markLayerPendingRemovalLocked(this);
		if (hasInput()) {
		mFlinger->dirtyInput();
		}
		}

		void Layer::onRemovedFromCurrentState() {
		@@ -998,8 +995,6 @@ uint32_t Layer::doTransaction(uint32_t flags) {
		mPendingStatesSnapshot = mPendingStates;
		mCurrentState.callbackHandles = {};

		maybeDirtyInput();

		return flags;
		}

		@@ -2548,32 +2543,6 @@ Layer::FrameRateCompatibility Layer::FrameRate::convertCompatibility(int8_t comp
		}
		}

		bool Layer::maybeDirtyInput() {
		// No sense redirtying input.
		if (mFlinger->inputDirty()) return true;

		if (hasInput()) {
		mFlinger->dirtyInput();
		return true;
		}

		// If a child or relative dirties the input, no sense continuing to traverse
		// so we return early and halt the recursion. We traverse ourselves instead
		// of using traverse() so we can implement this early halt.
		for (const sp<Layer>& child : mDrawingChildren) {
		if (child->maybeDirtyInput()) {
		return true;
		}
		}
		for (const wp<Layer>& weakRelative : mDrawingState.zOrderRelatives) {
		sp<Layer> relative = weakRelative.promote();
		if (relative && relative->maybeDirtyInput()) {
		return true;
		}
		}
		return false;
		}

		// ---------------------------------------------------------------------------

		}; // namespace android

+0 −4

Original line number	Diff line number	Diff line
		@@ -1015,10 +1015,6 @@ protected:
		// Window types from WindowManager.LayoutParams
		const int mWindowType;

		// Called when mDrawingState has changed. If we or one of our children/relatives hasInput()
		// then we will dirty the setInputWindows cache.
		bool maybeDirtyInput();

		private:
		/**
		* Returns an unsorted vector of all layers that are part of this tree.

+0 −15

Original line number	Diff line number	Diff line
		@@ -2897,19 +2897,6 @@ void SurfaceFlinger::updateInputFlinger() {
		void SurfaceFlinger::updateInputWindowInfo() {
		std::vector<InputWindowInfo> inputHandles;

		// We use a simple caching algorithm here. mInputDirty begins as true,
		// after we call setInputWindows we set it to false, so
		// in the future we wont call it again.. We set input dirty to true again
		// when any layer that hasInput() has a transaction performed on it
		// or when any parent or relative parent of such a layer has a transaction
		// performed on it. Not all of these transactions will really result in
		// input changes but all input changes will spring from these transactions
		// so the cache is safe but not optimal. It seems like it might be annoyingly
		// costly to cache and comapre the actual InputWindowHandle vector though.
		if (!mInputDirty && !mInputWindowCommands.syncInputWindows) {
		return;
		}

		mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
		if (layer->hasInput()) {
		// When calculating the screen bounds we ignore the transparent region since it may
		@@ -2921,8 +2908,6 @@ void SurfaceFlinger::updateInputWindowInfo() {
		mInputFlinger->setInputWindows(inputHandles,
		mInputWindowCommands.syncInputWindows ? mSetInputWindowsListener
		: nullptr);

		mInputDirty = false;
		}

		void SurfaceFlinger::commitInputWindowCommands() {

+0 −5

Original line number	Diff line number	Diff line
		@@ -1255,11 +1255,6 @@ private:
		nsecs_t mMissedFrameJankStart = 0;
		int32_t mMissedFrameJankCount = 0;

		// See updateInputWindowInfo() for details
		std::atomic<bool> mInputDirty = true;
		void dirtyInput() { mInputDirty = true; }
		bool inputDirty() { return mInputDirty; }

		int mFrameRateFlexibilityTokenCount = 0;

		sp<IBinder> mDebugFrameRateFlexibilityToken;