SF: Remove per-display state in scheduler (cafa9a55) · Commits · e / os / platform_frameworks_native

services/surfaceflinger/AllowedDisplayConfigs.h

deleted100644 → 0

+0 −68

Original line number	Diff line number	Diff line
		/*
		* Copyright 2019 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#pragma once

		#include <log/log.h>
		#include <vector>

		/*
		* Used to represent the Display Configurations allowed to be set by SurfaceFlinger
		*/
		class AllowedDisplayConfigs {
		private:
		// Defining ConstructorTag as private to prevent instantiating this class from outside
		// while still allowing it to be constructed by std::make_unique
		struct ConstructorTag {};

		public:
		AllowedDisplayConfigs(ConstructorTag) {}

		class Builder {
		public:
		Builder()
		: mAllowedDisplayConfigs(std::make_unique<AllowedDisplayConfigs>(ConstructorTag{})) {}

		std::unique_ptr<const AllowedDisplayConfigs> build() {
		return std::move(mAllowedDisplayConfigs);
		}

		// add a config to the allowed config set
		Builder& addConfig(int32_t config) {
		mAllowedDisplayConfigs->addConfig(config);
		return *this;
		}

		private:
		std::unique_ptr<AllowedDisplayConfigs> mAllowedDisplayConfigs;
		};

		bool isConfigAllowed(int32_t config) const {
		return (std::find(mConfigs.begin(), mConfigs.end(), config) != mConfigs.end());
		}

		void getAllowedConfigs(std::vector<int32_t>* outConfigs) const {
		if (outConfigs) {
		*outConfigs = mConfigs;
		}
		}

		private:
		// add a config to the allowed config set
		void addConfig(int32_t config) { mConfigs.push_back(config); }

		std::vector<int32_t> mConfigs;
		};

services/surfaceflinger/Scheduler/RefreshRateConfigs.h

+5 −9

Original line number	Diff line number	Diff line
		@@ -51,13 +51,7 @@ public:

		// TODO(b/122916473): Get this information from configs prepared by vendors, instead of
		// baking them in.
		explicit RefreshRateConfigs(
		const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs) {
		init(configs);
		}
		~RefreshRateConfigs() = default;

		const std::map<RefreshRateType, std::shared_ptr<RefreshRate>>& getRefreshRates() {
		const std::map<RefreshRateType, std::shared_ptr<RefreshRate>>& getRefreshRates() const {
		return mRefreshRates;
		}
		std::shared_ptr<RefreshRate> getRefreshRate(RefreshRateType type) {
		@@ -68,8 +62,9 @@ public:
		return nullptr;
		}

		private:
		void init(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs) {
		void populate(const std::vector<std::shared_ptr<const HWC2::Display::Config>>& configs) {
		mRefreshRates.clear();

		// This is the rate that HWC encapsulates right now when the device is in DOZE mode.
		mRefreshRates.emplace(RefreshRateType::POWER_SAVING,
		std::make_shared<RefreshRate>(
		@@ -120,6 +115,7 @@ private:
		}
		}

		private:
		std::map<RefreshRateType, std::shared_ptr<RefreshRate>> mRefreshRates;
		};

services/surfaceflinger/Scheduler/RefreshRateStats.h

+11 −15

Original line number	Diff line number	Diff line
		@@ -41,12 +41,8 @@ class RefreshRateStats {
		static constexpr int64_t MS_PER_DAY = 24 * MS_PER_HOUR;

		public:
		explicit RefreshRateStats(const std::shared_ptr<RefreshRateConfigs>& refreshRateConfigs,
		const std::shared_ptr<TimeStats>& timeStats)
		: mRefreshRateConfigs(refreshRateConfigs),
		mTimeStats(timeStats),
		mPreviousRecordedTime(systemTime()) {}
		~RefreshRateStats() = default;
		RefreshRateStats(const RefreshRateConfigs& refreshRateConfigs, TimeStats& timeStats)
		: mRefreshRateConfigs(refreshRateConfigs), mTimeStats(timeStats) {}

		// Sets power mode. We only collect the information when the power mode is not
		// HWC_POWER_MODE_NORMAL. When power mode is HWC_POWER_MODE_NORMAL, we collect the stats based
		@@ -83,7 +79,7 @@ public:
		flushTime();

		std::unordered_map<std::string, int64_t> totalTime;
		for (auto [type, config] : mRefreshRateConfigs->getRefreshRates()) {
		for (const auto& [type, config] : mRefreshRateConfigs.getRefreshRates()) {
		int64_t totalTimeForConfig = 0;
		if (!config) {
		continue;
		@@ -98,11 +94,11 @@ public:

		// Traverses through the map of config modes and returns how long they've been running in easy
		// to read format.
		std::string doDump() {
		std::string doDump() const {
		std::ostringstream stream;
		stream << "+ Refresh rate: running time in seconds\n";
		for (auto stats : getTotalTimes()) {
		stream << stats.first.c_str() << ": " << getDateFormatFromMs(stats.second) << "\n";
		for (const auto& [name, time] : const_cast<RefreshRateStats*>(this)->getTotalTimes()) {
		stream << name << ": " << getDateFormatFromMs(time) << '\n';
		}
		return stream.str();
		}
		@@ -126,12 +122,12 @@ private:
		mPreviousRecordedTime = currentTime;

		mConfigModesTotalTime[mode] += timeElapsedMs;
		for (const auto& [type, config] : mRefreshRateConfigs->getRefreshRates()) {
		for (const auto& [type, config] : mRefreshRateConfigs.getRefreshRates()) {
		if (!config) {
		continue;
		}
		if (config->configId == mode) {
		mTimeStats->recordRefreshRate(config->fps, timeElapsed);
		mTimeStats.recordRefreshRate(config->fps, timeElapsed);
		}
		}
		}
		@@ -148,17 +144,17 @@ private:
		}

		// Keeps information about refresh rate configs that device has.
		std::shared_ptr<RefreshRateConfigs> mRefreshRateConfigs;
		const RefreshRateConfigs& mRefreshRateConfigs;

		// Aggregate refresh rate statistics for telemetry.
		std::shared_ptr<TimeStats> mTimeStats;
		TimeStats& mTimeStats;

		int64_t mCurrentConfigMode = SCREEN_OFF_CONFIG_ID;
		int32_t mCurrentPowerMode = HWC_POWER_MODE_OFF;

		std::unordered_map<int /* power mode /, int64_t / duration in ms */> mConfigModesTotalTime;

		nsecs_t mPreviousRecordedTime;
		nsecs_t mPreviousRecordedTime = systemTime();
		};

		} // namespace scheduler

services/surfaceflinger/SurfaceFlinger.cpp

+54 −114

Original line number	Diff line number	Diff line
		@@ -558,14 +558,10 @@ void SurfaceFlinger::bootFinished()
		mBootStage = BootStage::FINISHED;

		// set the refresh rate according to the policy
		const auto displayId = getInternalDisplayIdLocked();
		LOG_ALWAYS_FATAL_IF(!displayId);

		const auto& performanceRefreshRate =
		mRefreshRateConfigs[*displayId]->getRefreshRate(RefreshRateType::PERFORMANCE);
		mRefreshRateConfigs.getRefreshRate(RefreshRateType::PERFORMANCE);

		if (performanceRefreshRate &&
		isConfigAllowed(*displayId, performanceRefreshRate->configId)) {
		if (performanceRefreshRate && isDisplayConfigAllowed(performanceRefreshRate->configId)) {
		setRefreshRateTo(RefreshRateType::PERFORMANCE, Scheduler::ConfigEvent::None);
		} else {
		setRefreshRateTo(RefreshRateType::DEFAULT, Scheduler::ConfigEvent::None);
		@@ -706,12 +702,8 @@ void SurfaceFlinger::init() {
		setRefreshRateTo(type, event);
		});
		}
		mRefreshRateConfigs[*display->getId()] = std::make_shared<scheduler::RefreshRateConfigs>(
		getHwComposer().getConfigs(*display->getId()));
		mRefreshRateStats =
		std::make_unique<scheduler::RefreshRateStats>(mRefreshRateConfigs[*display->getId()],
		mTimeStats);
		mRefreshRateStats->setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));
		mRefreshRateConfigs.populate(getHwComposer().getConfigs(*display->getId()));
		mRefreshRateStats.setConfigMode(getHwComposer().getActiveConfigIndex(*display->getId()));

		ALOGV("Done initializing");
		}
		@@ -786,12 +778,14 @@ status_t SurfaceFlinger::getSupportedFrameTimestamps(
		return NO_ERROR;
		}

		status_t SurfaceFlinger::getDisplayConfigsLocked(const sp<IBinder>& displayToken,
		status_t SurfaceFlinger::getDisplayConfigs(const sp<IBinder>& displayToken,
		Vector<DisplayInfo>* configs) {
		if (!displayToken \|\| !configs) {
		return BAD_VALUE;
		}

		Mutex::Autolock lock(mStateLock);

		const auto displayId = getPhysicalDisplayIdLocked(displayToken);
		if (!displayId) {
		return NAME_NOT_FOUND;
		@@ -917,18 +911,6 @@ int SurfaceFlinger::getActiveConfig(const sp<IBinder>& displayToken) {
		void SurfaceFlinger::setDesiredActiveConfig(const ActiveConfigInfo& info) {
		ATRACE_CALL();

		// Lock is acquired by setRefreshRateTo.
		const auto display = getDisplayDeviceLocked(info.displayToken);
		if (!display) {
		ALOGE("Attempt to set active config %d for invalid display token %p", info.configId,
		info.displayToken.get());
		return;
		}
		if (display->isVirtual()) {
		ALOGW("Attempt to set active config %d for virtual display", info.configId);
		return;
		}

		// Don't check against the current mode yet. Worst case we set the desired
		// config twice. However event generation config might have changed so we need to update it
		// accordingly
		@@ -964,23 +946,28 @@ status_t SurfaceFlinger::setActiveConfig(const sp<IBinder>& displayToken, int mo
		void SurfaceFlinger::setActiveConfigInternal() {
		ATRACE_CALL();

		const auto display = getDefaultDisplayDeviceLocked();
		if (!display) {
		return;
		}

		std::lock_guard<std::mutex> lock(mActiveConfigLock);
		mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
		mRefreshRateStats.setConfigMode(mUpcomingActiveConfig.configId);

		const auto display = getDisplayDeviceLocked(mUpcomingActiveConfig.displayToken);
		display->setActiveConfig(mUpcomingActiveConfig.configId);

		mScheduler->resyncToHardwareVsync(true, getVsyncPeriod());
		const auto [early, gl, late] = mPhaseOffsets->getCurrentOffsets();
		mVsyncModulator.setPhaseOffsets(early, gl, late);
		ATRACE_INT("ActiveConfigMode", mUpcomingActiveConfig.configId);

		if (mUpcomingActiveConfig.event != Scheduler::ConfigEvent::None) {
		mScheduler->onConfigChanged(mAppConnectionHandle, display->getId()->value,
		mUpcomingActiveConfig.configId);
		}
		}

		bool SurfaceFlinger::performSetActiveConfig() NO_THREAD_SAFETY_ANALYSIS {
		bool SurfaceFlinger::performSetActiveConfig() {
		ATRACE_CALL();
		if (mCheckPendingFence) {
		if (mPreviousPresentFence != Fence::NO_FENCE &&
		@@ -1006,7 +993,7 @@ bool SurfaceFlinger::performSetActiveConfig() NO_THREAD_SAFETY_ANALYSIS {
		desiredActiveConfig = mDesiredActiveConfig;
		}

		const auto display = getDisplayDevice(desiredActiveConfig.displayToken);
		const auto display = getDefaultDisplayDeviceLocked();
		if (!display \|\| display->getActiveConfig() == desiredActiveConfig.configId) {
		// display is not valid or we are already in the requested mode
		// on both cases there is nothing left to do
		@@ -1021,7 +1008,7 @@ bool SurfaceFlinger::performSetActiveConfig() NO_THREAD_SAFETY_ANALYSIS {
		// Desired active config was set, it is different than the config currently in use, however
		// allowed configs might have change by the time we process the refresh.
		// Make sure the desired config is still allowed
		if (!isConfigAllowed(*display->getId(), desiredActiveConfig.configId)) {
		if (!isDisplayConfigAllowed(desiredActiveConfig.configId)) {
		std::lock_guard<std::mutex> lock(mActiveConfigLock);
		mDesiredActiveConfig.configId = display->getActiveConfig();
		return false;
		@@ -1422,29 +1409,19 @@ void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
		*compositorTiming = getBE().mCompositorTiming;
		}

		bool SurfaceFlinger::isConfigAllowed(const DisplayId& displayId, int32_t config) {
		std::lock_guard lock(mAllowedConfigsLock);

		// if allowed configs are not set yet for this display, every config is considered allowed
		if (mAllowedConfigs.find(displayId) == mAllowedConfigs.end()) {
		return true;
		}

		return mAllowedConfigs[displayId]->isConfigAllowed(config);
		bool SurfaceFlinger::isDisplayConfigAllowed(int32_t configId) {
		return mAllowedDisplayConfigs.empty() \|\| mAllowedDisplayConfigs.count(configId);
		}

		void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::ConfigEvent event) {
		if (mBootStage != BootStage::FINISHED) {
		const auto display = getDefaultDisplayDeviceLocked();
		if (!display \|\| mBootStage != BootStage::FINISHED) {
		return;
		}
		ATRACE_CALL();

		// Don't do any updating if the current fps is the same as the new one.
		const auto displayId = getInternalDisplayIdLocked();
		LOG_ALWAYS_FATAL_IF(!displayId);
		const auto displayToken = getInternalDisplayTokenLocked();

		const auto& refreshRateConfig = mRefreshRateConfigs[*displayId]->getRefreshRate(refreshRate);
		const auto& refreshRateConfig = mRefreshRateConfigs.getRefreshRate(refreshRate);
		if (!refreshRateConfig) {
		ALOGV("Skipping refresh rate change request for unsupported rate.");
		return;
		@@ -1452,19 +1429,18 @@ void SurfaceFlinger::setRefreshRateTo(RefreshRateType refreshRate, Scheduler::Co

		const int desiredConfigId = refreshRateConfig->configId;

		if (!isConfigAllowed(*displayId, desiredConfigId)) {
		if (!isDisplayConfigAllowed(desiredConfigId)) {
		ALOGV("Skipping config %d as it is not part of allowed configs", desiredConfigId);
		return;
		}

		mPhaseOffsets->setRefreshRateType(refreshRate);

		const auto display = getDisplayDeviceLocked(displayToken);
		if (desiredConfigId == display->getActiveConfig()) {
		return;
		}

		setDesiredActiveConfig({refreshRate, desiredConfigId, getInternalDisplayTokenLocked(), event});
		setDesiredActiveConfig({refreshRate, desiredConfigId, event});
		}

		void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hwc2_display_t hwcDisplayId,
		@@ -1604,7 +1580,7 @@ void SurfaceFlinger::updateVrFlinger() {
		setTransactionFlags(eDisplayTransactionNeeded);
		}

		void SurfaceFlinger::onMessageReceived(int32_t what) {
		void SurfaceFlinger::onMessageReceived(int32_t what) NO_THREAD_SAFETY_ANALYSIS {
		ATRACE_CALL();
		switch (what) {
		case MessageQueue::INVALIDATE: {
		@@ -2483,9 +2459,6 @@ void SurfaceFlinger::processDisplayHotplugEventsLocked() {
		state.displayName = info->name;
		mCurrentState.displays.add(mPhysicalDisplayTokens[info->id], state);
		mInterceptor->saveDisplayCreation(state);
		// TODO(b/123715322): Removes the per-display state that was added to the scheduler.
		mRefreshRateConfigs[info->id] = std::make_shared<scheduler::RefreshRateConfigs>(
		getHwComposer().getConfigs(info->id));
		}
		} else {
		ALOGV("Removing display %s", to_string(info->id).c_str());
		@@ -2497,7 +2470,6 @@ void SurfaceFlinger::processDisplayHotplugEventsLocked() {
		mCurrentState.displays.removeItemsAt(index);
		}
		mPhysicalDisplayTokens.erase(info->id);
		mRefreshRateConfigs.erase(info->id);
		}

		processDisplayChangesLocked();
		@@ -4345,10 +4317,7 @@ void SurfaceFlinger::setPowerModeInternal(const sp<DisplayDevice>& display, int

		if (display->isPrimary()) {
		mTimeStats->setPowerMode(mode);
		if (mRefreshRateStats) {
		// Update refresh rate stats.
		mRefreshRateStats->setPowerMode(mode);
		}
		mRefreshRateStats.setPowerMode(mode);
		}

		ALOGD("Finished setting power mode %d on display %s", mode, to_string(*displayId).c_str());
		@@ -4876,7 +4845,7 @@ void SurfaceFlinger::dumpAllLocked(const DumpArgs& args, std::string& result) co
		result.append("\nScheduler state:\n");
		result.append(mScheduler->doDump() + "\n");
		StringAppendF(&result, "+ Smart video mode: %s\n\n", mUseSmart90ForVideo ? "on" : "off");
		result.append(mRefreshRateStats->doDump() + "\n");
		result.append(mRefreshRateStats.doDump() + "\n");
		}

		const Vector<sp<Layer>>& SurfaceFlinger::getLayerSortedByZForHwcDisplay(DisplayId displayId) {
		@@ -5816,95 +5785,66 @@ void SurfaceFlinger::traverseLayersInDisplay(const sp<const DisplayDevice>& disp
		}
		}

		void SurfaceFlinger::setAllowedDisplayConfigsInternal(
		const android::sp<android::IBinder>& displayToken,
		std::unique_ptr<const AllowedDisplayConfigs>&& allowedConfigs) {
		const auto displayId = getPhysicalDisplayIdLocked(displayToken);
		if (!displayId) {
		ALOGE("setAllowedDisplayConfigsInternal: getPhysicalDisplayId failed");
		void SurfaceFlinger::setAllowedDisplayConfigsInternal(const sp<DisplayDevice>& display,
		const std::vector<int32_t>& allowedConfigs) {
		if (!display->isPrimary()) {
		return;
		}

		ALOGV("Updating allowed configs");
		{
		std::lock_guard lock(mAllowedConfigsLock);
		mAllowedConfigs[*displayId] = std::move(allowedConfigs);
		}
		mAllowedDisplayConfigs = DisplayConfigs(allowedConfigs.begin(), allowedConfigs.end());

		// Set the highest allowed config by iterating backwards on available refresh rates
		const auto& refreshRates = mRefreshRateConfigs[*displayId]->getRefreshRates();
		const auto& refreshRates = mRefreshRateConfigs.getRefreshRates();
		for (auto iter = refreshRates.crbegin(); iter != refreshRates.crend(); ++iter) {
		if (iter->second && isConfigAllowed(*displayId, iter->second->configId)) {
		if (iter->second && isDisplayConfigAllowed(iter->second->configId)) {
		ALOGV("switching to config %d", iter->second->configId);
		setDesiredActiveConfig({iter->first, iter->second->configId, displayToken,
		Scheduler::ConfigEvent::Changed});
		setDesiredActiveConfig(
		{iter->first, iter->second->configId, Scheduler::ConfigEvent::Changed});
		break;
		}
		}
		}

		status_t SurfaceFlinger::setAllowedDisplayConfigs(const android::sp<android::IBinder>& displayToken,
		status_t SurfaceFlinger::setAllowedDisplayConfigs(const sp<IBinder>& displayToken,
		const std::vector<int32_t>& allowedConfigs) {
		ATRACE_CALL();

		if (!displayToken) {
		ALOGE("setAllowedDisplayConfigs: displayToken is null");
		return BAD_VALUE;
		}

		if (!allowedConfigs.size()) {
		ALOGE("setAllowedDisplayConfigs: empty config set provided");
		if (!displayToken \|\| allowedConfigs.empty()) {
		return BAD_VALUE;
		}

		{
		ConditionalLock lock(mStateLock, std::this_thread::get_id() != mMainThreadId);
		const auto displayId = getPhysicalDisplayIdLocked(displayToken);
		if (!displayId) {
		ALOGE("setAllowedDisplayConfigs: display not found");
		return NAME_NOT_FOUND;
		}
		}

		auto allowedDisplayConfigsBuilder = AllowedDisplayConfigs::Builder();
		for (int config : allowedConfigs) {
		ALOGV("setAllowedDisplayConfigs: Adding config to the allowed configs = %d", config);
		allowedDisplayConfigsBuilder.addConfig(config);
		}
		auto allowedDisplayConfigs = allowedDisplayConfigsBuilder.build();
		postMessageSync(new LambdaMessage([&]() NO_THREAD_SAFETY_ANALYSIS {
		setAllowedDisplayConfigsInternal(displayToken, std::move(allowedDisplayConfigs));
		const auto display = getDisplayDeviceLocked(displayToken);
		if (!display) {
		ALOGE("Attempt to set allowed display configs for invalid display token %p",
		displayToken.get());
		} else if (display->isVirtual()) {
		ALOGW("Attempt to set allowed display configs for virtual display");
		} else {
		setAllowedDisplayConfigsInternal(display, allowedConfigs);
		}
		}));

		return NO_ERROR;
		}

		status_t SurfaceFlinger::getAllowedDisplayConfigs(const android::sp<android::IBinder>& displayToken,
		status_t SurfaceFlinger::getAllowedDisplayConfigs(const sp<IBinder>& displayToken,
		std::vector<int32_t>* outAllowedConfigs) {
		ATRACE_CALL();

		if (!displayToken) {
		ALOGE("getAllowedDisplayConfigs: displayToken is null");
		if (!displayToken \|\| !outAllowedConfigs) {
		return BAD_VALUE;
		}

		if (!outAllowedConfigs) {
		ALOGE("getAllowedDisplayConfigs: outAllowedConfigs is null");
		return BAD_VALUE;
		}
		Mutex::Autolock lock(mStateLock);

		ConditionalLock stateLock(mStateLock, std::this_thread::get_id() != mMainThreadId);
		const auto displayId = getPhysicalDisplayIdLocked(displayToken);
		if (!displayId) {
		ALOGE("getAllowedDisplayConfigs: display not found");
		if (displayToken != getInternalDisplayTokenLocked()) {
		ALOGE("%s is only supported for the internal display", __FUNCTION__);
		return NAME_NOT_FOUND;
		}

		std::lock_guard allowedConfigLock(mAllowedConfigsLock);
		auto allowedConfigIterator = mAllowedConfigs.find(displayId.value());
		if (allowedConfigIterator != mAllowedConfigs.end()) {
		allowedConfigIterator->second->getAllowedConfigs(outAllowedConfigs);
		}

		outAllowedConfigs->assign(mAllowedDisplayConfigs.begin(), mAllowedDisplayConfigs.end());
		return NO_ERROR;
		}

services/surfaceflinger/SurfaceFlinger.h

+13 −29

Original line number	Diff line number	Diff line
		@@ -46,7 +46,6 @@
		#include <utils/Trace.h>
		#include <utils/threads.h>

		#include "AllowedDisplayConfigs.h"
		#include "DisplayDevice.h"
		#include "DisplayHardware/HWC2.h"
		#include "DisplayHardware/PowerAdvisor.h"
		@@ -74,6 +73,7 @@
		#include <thread>
		#include <type_traits>
		#include <unordered_map>
		#include <unordered_set>
		#include <utility>

		using namespace android::surfaceflinger;
		@@ -407,12 +407,7 @@ private:
		float frameScale, bool childrenOnly) override;
		status_t getDisplayStats(const sp<IBinder>& displayToken, DisplayStatInfo* stats) override;
		status_t getDisplayConfigs(const sp<IBinder>& displayToken,
		Vector<DisplayInfo>* configs) override {
		Mutex::Autolock _l(mStateLock);
		return getDisplayConfigsLocked(displayToken, configs);
		}
		status_t getDisplayConfigsLocked(const sp<IBinder>& displayToken, Vector<DisplayInfo>* configs)
		REQUIRES(mStateLock);
		Vector<DisplayInfo>* configs) override;
		int getActiveConfig(const sp<IBinder>& displayToken) override;
		status_t getDisplayColorModes(const sp<IBinder>& displayToken,
		Vector<ui::ColorMode>* configs) override;
		@@ -491,20 +486,10 @@ private:
		struct ActiveConfigInfo {
		RefreshRateType type;
		int configId;
		sp<IBinder> displayToken;
		Scheduler::ConfigEvent event;

		bool operator!=(const ActiveConfigInfo& other) const {
		if (type != other.type) {
		return true;
		}
		if (configId != other.configId) {
		return true;
		}
		if (displayToken != other.displayToken) {
		return true;
		}
		return (event != other.event);
		return type != other.type \|\| configId != other.configId \|\| event != other.event;
		}
		};

		@@ -519,14 +504,14 @@ private:
		// desired config was set, HWC needs to update the panel on the next refresh, and when
		// we receive the fence back, we know that the process was complete. It returns whether
		// we need to wait for the next invalidate
		bool performSetActiveConfig();
		bool performSetActiveConfig() REQUIRES(mStateLock);
		// called on the main thread in response to setPowerMode()
		void setPowerModeInternal(const sp<DisplayDevice>& display, int mode) REQUIRES(mStateLock);

		// called on the main thread in response to setAllowedDisplayConfigs()
		void setAllowedDisplayConfigsInternal(
		const sp<IBinder>& displayToken,
		std::unique_ptr<const AllowedDisplayConfigs>&& allowedConfigs) REQUIRES(mStateLock);
		void setAllowedDisplayConfigsInternal(const sp<DisplayDevice>& display,
		const std::vector<int32_t>& allowedConfigs)
		REQUIRES(mStateLock);

		// Returns whether the transaction actually modified any state
		bool handleMessageTransaction();
		@@ -805,7 +790,7 @@ private:
		// the desired refresh rate.
		void setRefreshRateTo(RefreshRateType, Scheduler::ConfigEvent event) REQUIRES(mStateLock);

		bool isConfigAllowed(const DisplayId& displayId, int32_t config);
		bool isDisplayConfigAllowed(int32_t configId) REQUIRES(mStateLock);

		/*
		* Display identification
		@@ -1111,14 +1096,13 @@ private:
		std::unique_ptr<Scheduler> mScheduler;
		sp<Scheduler::ConnectionHandle> mAppConnectionHandle;
		sp<Scheduler::ConnectionHandle> mSfConnectionHandle;
		std::unique_ptr<scheduler::RefreshRateStats> mRefreshRateStats;

		std::unordered_map<DisplayId, std::shared_ptr<scheduler::RefreshRateConfigs>>
		mRefreshRateConfigs;
		scheduler::RefreshRateConfigs mRefreshRateConfigs;
		scheduler::RefreshRateStats mRefreshRateStats{mRefreshRateConfigs, *mTimeStats};

		std::mutex mAllowedConfigsLock;
		std::unordered_map<DisplayId, std::unique_ptr<const AllowedDisplayConfigs>> mAllowedConfigs
		GUARDED_BY(mAllowedConfigsLock);
		// All configs are allowed if the set is empty.
		using DisplayConfigs = std::unordered_set<int32_t>;
		DisplayConfigs mAllowedDisplayConfigs GUARDED_BY(mStateLock);

		std::mutex mActiveConfigLock;
		// This bit is set once we start setting the config. We read from this bit during the