Merge "SurfaceFlinger: Indicate whether we have captured secure layers." into qt-dev
diff --git a/libs/gui/include/gui/SurfaceControl.h b/libs/gui/include/gui/SurfaceControl.h
index 55efcbf..23bfc02 100644
--- a/libs/gui/include/gui/SurfaceControl.h
+++ b/libs/gui/include/gui/SurfaceControl.h
@@ -84,6 +84,9 @@
explicit SurfaceControl(const sp<SurfaceControl>& other);
+ SurfaceControl(const sp<SurfaceComposerClient>& client, const sp<IBinder>& handle,
+ const sp<IGraphicBufferProducer>& gbp, bool owned);
+
private:
// can't be copied
SurfaceControl& operator = (SurfaceControl& rhs);
@@ -92,12 +95,6 @@
friend class SurfaceComposerClient;
friend class Surface;
- SurfaceControl(
- const sp<SurfaceComposerClient>& client,
- const sp<IBinder>& handle,
- const sp<IGraphicBufferProducer>& gbp,
- bool owned);
-
~SurfaceControl();
sp<Surface> generateSurfaceLocked() const;
diff --git a/services/inputflinger/EventHub.cpp b/services/inputflinger/EventHub.cpp
index 0544ec1..ce56272 100644
--- a/services/inputflinger/EventHub.cpp
+++ b/services/inputflinger/EventHub.cpp
@@ -115,8 +115,15 @@
* The system property ro.input.video_enabled can be used to control whether
* EventHub scans and opens V4L devices. As V4L does not support multiple
* clients, EventHub effectively blocks access to these devices when it opens
- * them. This property enables other clients to read these devices for testing
- * and development.
+ * them.
+ *
+ * Setting this to "false" would prevent any video devices from being discovered and
+ * associated with input devices.
+ *
+ * This property can be used as follows:
+ * 1. To turn off features that are dependent on video device presence.
+ * 2. During testing and development, to allow other clients to read video devices
+ * directly from /dev.
*/
static bool isV4lScanningEnabled() {
return property_get_bool("ro.input.video_enabled", true /* default_value */);
diff --git a/services/surfaceflinger/AllowedDisplayConfigs.h b/services/surfaceflinger/AllowedDisplayConfigs.h
deleted file mode 100644
index 7ca62ea..0000000
--- a/services/surfaceflinger/AllowedDisplayConfigs.h
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- * 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;
-};
diff --git a/services/surfaceflinger/Client.cpp b/services/surfaceflinger/Client.cpp
index e54b460..508be13 100644
--- a/services/surfaceflinger/Client.cpp
+++ b/services/surfaceflinger/Client.cpp
@@ -76,18 +76,9 @@
uint32_t flags, const sp<IBinder>& parentHandle,
LayerMetadata metadata, sp<IBinder>* handle,
sp<IGraphicBufferProducer>* gbp) {
- sp<Layer> parent = nullptr;
- if (parentHandle != nullptr) {
- auto layerHandle = reinterpret_cast<Layer::Handle*>(parentHandle.get());
- parent = layerHandle->owner.promote();
- if (parent == nullptr) {
- return NAME_NOT_FOUND;
- }
- }
-
// We rely on createLayer to check permissions.
return mFlinger->createLayer(name, this, w, h, format, flags, std::move(metadata), handle, gbp,
- &parent);
+ parentHandle);
}
status_t Client::createWithSurfaceParent(const String8& name, uint32_t w, uint32_t h,
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 1142df8..d88702c 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -125,7 +125,6 @@
}
mFrameTracker.logAndResetStats(mName);
-
mFlinger->onLayerDestroyed();
}
diff --git a/services/surfaceflinger/RefreshRateOverlay.cpp b/services/surfaceflinger/RefreshRateOverlay.cpp
index e70bfe4..240c84e 100644
--- a/services/surfaceflinger/RefreshRateOverlay.cpp
+++ b/services/surfaceflinger/RefreshRateOverlay.cpp
@@ -31,9 +31,9 @@
const status_t ret =
mFlinger.createLayer(String8("RefreshRateOverlay"), mClient, 0, 0,
PIXEL_FORMAT_RGBA_8888, ISurfaceComposerClient::eFXSurfaceColor,
- LayerMetadata(), &mIBinder, &mGbp, &mLayer);
+ LayerMetadata(), &mIBinder, &mGbp, nullptr);
if (ret) {
- ALOGE("failed to color layer");
+ ALOGE("failed to create color layer");
return false;
}
diff --git a/services/surfaceflinger/Scheduler/RefreshRateConfigs.h b/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
index 1aa6ade..5874066 100644
--- a/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
+++ b/services/surfaceflinger/Scheduler/RefreshRateConfigs.h
@@ -51,13 +51,7 @@
// 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 @@
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:
std::map<RefreshRateType, std::shared_ptr<RefreshRate>> mRefreshRates;
};
diff --git a/services/surfaceflinger/Scheduler/RefreshRateStats.h b/services/surfaceflinger/Scheduler/RefreshRateStats.h
index ff63faf..7e7c630 100644
--- a/services/surfaceflinger/Scheduler/RefreshRateStats.h
+++ b/services/surfaceflinger/Scheduler/RefreshRateStats.h
@@ -41,12 +41,8 @@
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 @@
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 @@
// 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 @@
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 @@
}
// 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
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index e2a134b..8a45d69 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -558,14 +558,10 @@
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 @@
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 @@
return NO_ERROR;
}
-status_t SurfaceFlinger::getDisplayConfigsLocked(const sp<IBinder>& displayToken,
- Vector<DisplayInfo>* configs) {
+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 @@
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 @@
void SurfaceFlinger::setActiveConfigInternal() {
ATRACE_CALL();
- std::lock_guard<std::mutex> lock(mActiveConfigLock);
- mRefreshRateStats->setConfigMode(mUpcomingActiveConfig.configId);
+ const auto display = getDefaultDisplayDeviceLocked();
+ if (!display) {
+ return;
+ }
- const auto display = getDisplayDeviceLocked(mUpcomingActiveConfig.displayToken);
+ std::lock_guard<std::mutex> lock(mActiveConfigLock);
+ mRefreshRateStats.setConfigMode(mUpcomingActiveConfig.configId);
+
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 @@
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 @@
// 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 @@
*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 @@
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 @@
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 @@
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 @@
mCurrentState.displays.removeItemsAt(index);
}
mPhysicalDisplayTokens.erase(info->id);
- mRefreshRateConfigs.erase(info->id);
}
processDisplayChangesLocked();
@@ -3402,9 +3374,8 @@
renderEngine.drawLayers(clientCompositionDisplay, clientCompositionLayers,
buf->getNativeBuffer(), /*useFramebufferCache=*/true, std::move(fd),
readyFence);
- if (expensiveRenderingExpected && displayId) {
- mPowerAdvisor.setExpensiveRenderingExpected(*displayId, false);
- }
+ } else if (displayId) {
+ mPowerAdvisor.setExpensiveRenderingExpected(*displayId, false);
}
return true;
}
@@ -3418,12 +3389,20 @@
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbc,
const sp<Layer>& lbc,
- const sp<Layer>& parent,
+ const sp<IBinder>& parentHandle,
bool addToCurrentState)
{
// add this layer to the current state list
{
Mutex::Autolock _l(mStateLock);
+ sp<Layer> parent;
+ if (parentHandle != nullptr) {
+ parent = fromHandle(parentHandle);
+ if (parent == nullptr) {
+ return NAME_NOT_FOUND;
+ }
+ }
+
if (mNumLayers >= MAX_LAYERS) {
ALOGE("AddClientLayer failed, mNumLayers (%zu) >= MAX_LAYERS (%zu)", mNumLayers,
MAX_LAYERS);
@@ -4034,10 +4013,10 @@
return flags;
}
-status_t SurfaceFlinger::createLayer(const String8& name, const sp<Client>& client, uint32_t w,
- uint32_t h, PixelFormat format, uint32_t flags,
- LayerMetadata metadata, sp<IBinder>* handle,
- sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent) {
+status_t SurfaceFlinger::createLayer(
+ const String8& name, const sp<Client>& client, uint32_t w, uint32_t h, PixelFormat format,
+ uint32_t flags, LayerMetadata metadata, sp<IBinder>* handle,
+ sp<IGraphicBufferProducer>* gbp, const sp<IBinder>& parentHandle) {
if (int32_t(w|h) < 0) {
ALOGE("createLayer() failed, w or h is negative (w=%d, h=%d)",
int(w), int(h));
@@ -4102,12 +4081,14 @@
return result;
}
+ mLayersByLocalBinderToken.emplace((*handle)->localBinder(), layer);
+
if (primaryDisplayOnly) {
layer->setPrimaryDisplayOnly();
}
bool addToCurrentState = callingThreadHasUnscopedSurfaceFlingerAccess();
- result = addClientLayer(client, *handle, *gbp, layer, *parent,
+ result = addClientLayer(client, *handle, *gbp, layer, parentHandle,
addToCurrentState);
if (result != NO_ERROR) {
return result;
@@ -4225,6 +4206,16 @@
mCurrentState.layersSortedByZ.remove(layer);
}
markLayerPendingRemovalLocked(layer);
+
+ auto it = mLayersByLocalBinderToken.begin();
+ while (it != mLayersByLocalBinderToken.end()) {
+ if (it->second == layer) {
+ it = mLayersByLocalBinderToken.erase(it);
+ } else {
+ it++;
+ }
+ }
+
layer.clear();
}
@@ -4346,10 +4337,7 @@
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());
@@ -4877,7 +4865,7 @@
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) {
@@ -5495,34 +5483,50 @@
const bool mChildrenOnly;
};
- auto layerHandle = reinterpret_cast<Layer::Handle*>(layerHandleBinder.get());
- auto parent = layerHandle->owner.promote();
-
- if (parent == nullptr || parent->isRemovedFromCurrentState()) {
- ALOGE("captureLayers called with a removed parent");
- return NAME_NOT_FOUND;
- }
-
- const int uid = IPCThreadState::self()->getCallingUid();
- const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
- if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
- ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
- return PERMISSION_DENIED;
- }
-
+ int reqWidth = 0;
+ int reqHeight = 0;
+ sp<Layer> parent;
Rect crop(sourceCrop);
- if (sourceCrop.width() <= 0) {
- crop.left = 0;
- crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
- }
+ std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
- if (sourceCrop.height() <= 0) {
- crop.top = 0;
- crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
- }
+ {
+ Mutex::Autolock _l(mStateLock);
- int32_t reqWidth = crop.width() * frameScale;
- int32_t reqHeight = crop.height() * frameScale;
+ parent = fromHandle(layerHandleBinder);
+ if (parent == nullptr || parent->isRemovedFromCurrentState()) {
+ ALOGE("captureLayers called with an invalid or removed parent");
+ return NAME_NOT_FOUND;
+ }
+
+ const int uid = IPCThreadState::self()->getCallingUid();
+ const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
+ if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
+ ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
+ return PERMISSION_DENIED;
+ }
+
+ if (sourceCrop.width() <= 0) {
+ crop.left = 0;
+ crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
+ }
+
+ if (sourceCrop.height() <= 0) {
+ crop.top = 0;
+ crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
+ }
+ reqWidth = crop.width() * frameScale;
+ reqHeight = crop.height() * frameScale;
+
+ for (const auto& handle : excludeHandles) {
+ sp<Layer> excludeLayer = fromHandle(handle);
+ if (excludeLayer != nullptr) {
+ excludeLayers.emplace(excludeLayer);
+ } else {
+ ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
+ return NAME_NOT_FOUND;
+ }
+ }
+ } // mStateLock
// really small crop or frameScale
if (reqWidth <= 0) {
@@ -5532,18 +5536,6 @@
reqHeight = 1;
}
- std::unordered_set<sp<Layer>, ISurfaceComposer::SpHash<Layer>> excludeLayers;
- for (const auto& handle : excludeHandles) {
- BBinder* local = handle->localBinder();
- if (local != nullptr) {
- auto layerHandle = reinterpret_cast<Layer::Handle*>(local);
- excludeLayers.emplace(layerHandle->owner.promote());
- } else {
- ALOGW("Invalid layer handle passed as excludeLayer to captureLayers");
- return NAME_NOT_FOUND;
- }
- }
-
LayerRenderArea renderArea(this, parent, crop, reqWidth, reqHeight, reqDataspace, childrenOnly);
auto traverseLayers = [parent, childrenOnly,
&excludeLayers](const LayerVector::Visitor& visitor) {
@@ -5823,95 +5815,66 @@
}
}
-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");
+ if (!displayToken || allowedConfigs.empty()) {
return BAD_VALUE;
}
- if (!allowedConfigs.size()) {
- ALOGE("setAllowedDisplayConfigs: empty config set provided");
- 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;
}
@@ -5919,6 +5882,18 @@
mFlinger->setInputWindowsFinished();
}
+sp<Layer> SurfaceFlinger::fromHandle(const sp<IBinder>& handle) {
+ BBinder *b = handle->localBinder();
+ if (b == nullptr) {
+ return nullptr;
+ }
+ auto it = mLayersByLocalBinderToken.find(b);
+ if (it != mLayersByLocalBinderToken.end()) {
+ return it->second.promote();
+ }
+ return nullptr;
+}
+
} // namespace android
#if defined(__gl_h_)
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 7914afc..7dd7675 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -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;
@@ -313,6 +313,8 @@
return mTransactionCompletedThread;
}
+ sp<Layer> fromHandle(const sp<IBinder>& handle) REQUIRES(mStateLock);
+
private:
friend class BufferLayer;
friend class BufferQueueLayer;
@@ -408,12 +410,7 @@
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;
@@ -492,20 +489,10 @@
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;
}
};
@@ -520,14 +507,14 @@
// 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();
@@ -588,9 +575,10 @@
/* ------------------------------------------------------------------------
* Layer management
*/
- status_t createLayer(const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
- PixelFormat format, uint32_t flags, LayerMetadata metadata,
- sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, sp<Layer>* parent);
+ status_t createLayer(
+ const String8& name, const sp<Client>& client, uint32_t w, uint32_t h,
+ PixelFormat format, uint32_t flags, LayerMetadata metadata,
+ sp<IBinder>* handle, sp<IGraphicBufferProducer>* gbp, const sp<IBinder>& parentHandle);
status_t createBufferQueueLayer(const sp<Client>& client, const String8& name, uint32_t w,
uint32_t h, uint32_t flags, LayerMetadata metadata,
@@ -622,7 +610,7 @@
const sp<IBinder>& handle,
const sp<IGraphicBufferProducer>& gbc,
const sp<Layer>& lbc,
- const sp<Layer>& parent,
+ const sp<IBinder>& parentHandle,
bool addToCurrentState);
// Traverse through all the layers and compute and cache its bounds.
@@ -807,7 +795,7 @@
// 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
@@ -996,6 +984,9 @@
std::map<wp<IBinder>, sp<DisplayDevice>> mDisplays;
std::unordered_map<DisplayId, sp<IBinder>> mPhysicalDisplayTokens;
+ // protected by mStateLock
+ std::unordered_map<BBinder*, wp<Layer>> mLayersByLocalBinderToken;
+
// don't use a lock for these, we don't care
int mDebugRegion = 0;
bool mDebugDisableHWC = false;
@@ -1113,14 +1104,13 @@
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
diff --git a/services/surfaceflinger/tests/Android.bp b/services/surfaceflinger/tests/Android.bp
index f121a95..d3c87bf 100644
--- a/services/surfaceflinger/tests/Android.bp
+++ b/services/surfaceflinger/tests/Android.bp
@@ -19,6 +19,7 @@
srcs: [
"BufferGenerator.cpp",
"Credentials_test.cpp",
+ "InvalidHandles_test.cpp",
"Stress_test.cpp",
"SurfaceInterceptor_test.cpp",
"Transaction_test.cpp",
diff --git a/services/surfaceflinger/tests/InvalidHandles_test.cpp b/services/surfaceflinger/tests/InvalidHandles_test.cpp
new file mode 100644
index 0000000..42d1f5a
--- /dev/null
+++ b/services/surfaceflinger/tests/InvalidHandles_test.cpp
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 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.
+ */
+
+#include <binder/Binder.h>
+
+#include <gtest/gtest.h>
+
+#include <gui/ISurfaceComposer.h>
+#include <gui/SurfaceComposerClient.h>
+#include <private/gui/ComposerService.h>
+#include <ui/Rect.h>
+
+namespace android {
+namespace {
+
+class NotALayer : public BBinder {};
+
+/**
+ * For all of these tests we make a SurfaceControl with an invalid layer handle
+ * and verify we aren't able to trick SurfaceFlinger.
+ */
+class InvalidHandleTest : public ::testing::Test {
+protected:
+ sp<SurfaceComposerClient> mScc;
+ sp<SurfaceControl> mNotSc;
+ void SetUp() override {
+ mScc = new SurfaceComposerClient;
+ ASSERT_EQ(NO_ERROR, mScc->initCheck());
+ mNotSc = makeNotSurfaceControl();
+ }
+
+ sp<SurfaceControl> makeNotSurfaceControl() {
+ return new SurfaceControl(mScc, new NotALayer(), nullptr, true);
+ }
+};
+
+TEST_F(InvalidHandleTest, createSurfaceInvalidHandle) {
+ auto notSc = makeNotSurfaceControl();
+ ASSERT_EQ(nullptr,
+ mScc->createSurface(String8("lolcats"), 19, 47, PIXEL_FORMAT_RGBA_8888, 0,
+ notSc.get())
+ .get());
+}
+
+TEST_F(InvalidHandleTest, captureLayersInvalidHandle) {
+ sp<ISurfaceComposer> sf(ComposerService::getComposerService());
+ sp<GraphicBuffer> outBuffer;
+
+ ASSERT_EQ(NAME_NOT_FOUND,
+ sf->captureLayers(mNotSc->getHandle(), &outBuffer, Rect::EMPTY_RECT, 1.0f));
+}
+
+} // namespace
+} // namespace android
diff --git a/services/surfaceflinger/tests/SurfaceFlinger_test.filter b/services/surfaceflinger/tests/SurfaceFlinger_test.filter
index be862c9..a8d09ea 100644
--- a/services/surfaceflinger/tests/SurfaceFlinger_test.filter
+++ b/services/surfaceflinger/tests/SurfaceFlinger_test.filter
@@ -1,5 +1,5 @@
{
"presubmit": {
- "filter": "CredentialsTest.*:SurfaceFlingerStress.*:SurfaceInterceptorTest.*:LayerTransactionTest.*:LayerTypeTransactionTest.*:LayerUpdateTest.*:GeometryLatchingTest.*:CropLatchingTest.*:ChildLayerTest.*:ScreenCaptureTest.*:ScreenCaptureChildOnlyTest.*:DereferenceSurfaceControlTest.*:BoundlessLayerTest.*:MultiDisplayLayerBoundsTest.*"
+ "filter": "CredentialsTest.*:SurfaceFlingerStress.*:SurfaceInterceptorTest.*:LayerTransactionTest.*:LayerTypeTransactionTest.*:LayerUpdateTest.*:GeometryLatchingTest.*:CropLatchingTest.*:ChildLayerTest.*:ScreenCaptureTest.*:ScreenCaptureChildOnlyTest.*:DereferenceSurfaceControlTest.*:BoundlessLayerTest.*:MultiDisplayLayerBoundsTest.*:InvalidHandleTest.*"
}
}
diff --git a/services/surfaceflinger/tests/unittests/AllowedDisplayConfigsTest.cpp b/services/surfaceflinger/tests/unittests/AllowedDisplayConfigsTest.cpp
deleted file mode 100644
index 4274254..0000000
--- a/services/surfaceflinger/tests/unittests/AllowedDisplayConfigsTest.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * 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.
- */
-
-#undef LOG_TAG
-#define LOG_TAG "LibSurfaceFlingerUnittests"
-#define LOG_NDEBUG 0
-
-#include <memory>
-#include <vector>
-
-#include <gtest/gtest.h>
-
-#include <log/log.h>
-
-#include "AllowedDisplayConfigs.h"
-
-namespace android {
-namespace {
-
-class AllowedDisplayConfigsTest : public testing::Test {
-protected:
- AllowedDisplayConfigsTest();
- ~AllowedDisplayConfigsTest() override;
-
- void buildAllowedConfigs();
-
- const std::vector<int32_t> expectedConfigs = {0, 2, 7, 129};
- constexpr static int32_t notAllowedConfig = 5;
- std::unique_ptr<const AllowedDisplayConfigs> mAllowedConfigs;
-};
-
-AllowedDisplayConfigsTest::AllowedDisplayConfigsTest() {
- const ::testing::TestInfo* const test_info =
- ::testing::UnitTest::GetInstance()->current_test_info();
- ALOGD("**** Setting up for %s.%s\n", test_info->test_case_name(), test_info->name());
-}
-
-AllowedDisplayConfigsTest::~AllowedDisplayConfigsTest() {
- const ::testing::TestInfo* const test_info =
- ::testing::UnitTest::GetInstance()->current_test_info();
- ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
-}
-
-void AllowedDisplayConfigsTest::buildAllowedConfigs() {
- AllowedDisplayConfigs::Builder builder;
- for (int config : expectedConfigs) {
- builder.addConfig(config);
- }
- mAllowedConfigs = builder.build();
-}
-
-/* ------------------------------------------------------------------------
- * Test cases
- */
-
-TEST_F(AllowedDisplayConfigsTest, checkConfigs) {
- buildAllowedConfigs();
-
- // Check that all expected configs are allowed
- for (int config : expectedConfigs) {
- EXPECT_TRUE(mAllowedConfigs->isConfigAllowed(config));
- }
-
- // Check that all the allowed configs are expected
- std::vector<int32_t> allowedConfigVector;
- mAllowedConfigs->getAllowedConfigs(&allowedConfigVector);
- EXPECT_EQ(allowedConfigVector, expectedConfigs);
-
- // Check that notAllowedConfig is indeed not allowed
- EXPECT_TRUE(std::find(expectedConfigs.begin(), expectedConfigs.end(), notAllowedConfig) ==
- expectedConfigs.end());
- EXPECT_FALSE(mAllowedConfigs->isConfigAllowed(notAllowedConfig));
-}
-
-TEST_F(AllowedDisplayConfigsTest, getAllowedConfigsNullptr) {
- buildAllowedConfigs();
-
- // No other expectations rather than no crash
- mAllowedConfigs->getAllowedConfigs(nullptr);
-}
-
-} // namespace
-} // namespace android
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index d4eac88..85e9ce5 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -35,7 +35,6 @@
srcs: [
":libsurfaceflinger_sources",
"libsurfaceflinger_unittest_main.cpp",
- "AllowedDisplayConfigsTest.cpp",
"CompositionTest.cpp",
"DispSyncSourceTest.cpp",
"DisplayIdentificationTest.cpp",
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
index b218ad6..8b37c22 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateConfigsTest.cpp
@@ -49,6 +49,8 @@
ASSERT_EQ(left.name, right.name);
ASSERT_EQ(left.fps, right.fps);
}
+
+ RefreshRateConfigs mConfigs;
};
RefreshRateConfigsTest::RefreshRateConfigsTest() {
@@ -69,10 +71,10 @@
*/
TEST_F(RefreshRateConfigsTest, zeroDeviceConfigs_storesPowerSavingConfig) {
std::vector<std::shared_ptr<const HWC2::Display::Config>> displayConfigs;
- RefreshRateConfigs configs(displayConfigs);
+ mConfigs.populate(displayConfigs);
// We always store a configuration for screen off.
- const auto& rates = configs.getRefreshRates();
+ const auto& rates = mConfigs.getRefreshRates();
ASSERT_EQ(1, rates.size());
const auto& powerSavingRate = rates.find(RefreshRateType::POWER_SAVING);
ASSERT_NE(rates.end(), powerSavingRate);
@@ -82,13 +84,13 @@
RefreshRate expectedConfig = RefreshRate{SCREEN_OFF_CONFIG_ID, "ScreenOff", 0};
assertRatesEqual(expectedConfig, *powerSavingRate->second);
- ASSERT_TRUE(configs.getRefreshRate(RefreshRateType::POWER_SAVING));
- assertRatesEqual(expectedConfig, *configs.getRefreshRate(RefreshRateType::POWER_SAVING));
- ASSERT_FALSE(configs.getRefreshRate(RefreshRateType::PERFORMANCE));
- ASSERT_FALSE(configs.getRefreshRate(RefreshRateType::DEFAULT));
+ ASSERT_TRUE(mConfigs.getRefreshRate(RefreshRateType::POWER_SAVING));
+ assertRatesEqual(expectedConfig, *mConfigs.getRefreshRate(RefreshRateType::POWER_SAVING));
+ ASSERT_FALSE(mConfigs.getRefreshRate(RefreshRateType::PERFORMANCE));
+ ASSERT_FALSE(mConfigs.getRefreshRate(RefreshRateType::DEFAULT));
// Sanity check that getRefreshRate() does not modify the underlying configs.
- ASSERT_EQ(1, configs.getRefreshRates().size());
+ ASSERT_EQ(1, mConfigs.getRefreshRates().size());
}
TEST_F(RefreshRateConfigsTest, oneDeviceConfig_storesDefaultConfig) {
@@ -97,9 +99,9 @@
auto config60 = HWC2::Display::Config::Builder(*display, CONFIG_ID_60);
config60.setVsyncPeriod(VSYNC_60);
displayConfigs.push_back(config60.build());
- RefreshRateConfigs configs(displayConfigs);
+ mConfigs.populate(displayConfigs);
- const auto& rates = configs.getRefreshRates();
+ const auto& rates = mConfigs.getRefreshRates();
ASSERT_EQ(2, rates.size());
const auto& powerSavingRate = rates.find(RefreshRateType::POWER_SAVING);
const auto& defaultRate = rates.find(RefreshRateType::DEFAULT);
@@ -112,15 +114,15 @@
RefreshRate expectedDefaultConfig = RefreshRate{CONFIG_ID_60, "60fps", 60};
assertRatesEqual(expectedDefaultConfig, *defaultRate->second);
- ASSERT_TRUE(configs.getRefreshRate(RefreshRateType::POWER_SAVING));
+ ASSERT_TRUE(mConfigs.getRefreshRate(RefreshRateType::POWER_SAVING));
assertRatesEqual(expectedPowerSavingConfig,
- *configs.getRefreshRate(RefreshRateType::POWER_SAVING));
- ASSERT_TRUE(configs.getRefreshRate(RefreshRateType::DEFAULT));
- assertRatesEqual(expectedDefaultConfig, *configs.getRefreshRate(RefreshRateType::DEFAULT));
- ASSERT_FALSE(configs.getRefreshRate(RefreshRateType::PERFORMANCE));
+ *mConfigs.getRefreshRate(RefreshRateType::POWER_SAVING));
+ ASSERT_TRUE(mConfigs.getRefreshRate(RefreshRateType::DEFAULT));
+ assertRatesEqual(expectedDefaultConfig, *mConfigs.getRefreshRate(RefreshRateType::DEFAULT));
+ ASSERT_FALSE(mConfigs.getRefreshRate(RefreshRateType::PERFORMANCE));
// Sanity check that getRefreshRate() does not modify the underlying configs.
- ASSERT_EQ(2, configs.getRefreshRates().size());
+ ASSERT_EQ(2, mConfigs.getRefreshRates().size());
}
TEST_F(RefreshRateConfigsTest, twoDeviceConfigs_storesPerformanceConfig) {
@@ -132,9 +134,9 @@
auto config90 = HWC2::Display::Config::Builder(*display, CONFIG_ID_90);
config90.setVsyncPeriod(VSYNC_90);
displayConfigs.push_back(config90.build());
- RefreshRateConfigs configs(displayConfigs);
+ mConfigs.populate(displayConfigs);
- const auto& rates = configs.getRefreshRates();
+ const auto& rates = mConfigs.getRefreshRates();
ASSERT_EQ(3, rates.size());
const auto& powerSavingRate = rates.find(RefreshRateType::POWER_SAVING);
const auto& defaultRate = rates.find(RefreshRateType::DEFAULT);
@@ -150,14 +152,14 @@
RefreshRate expectedPerformanceConfig = RefreshRate{CONFIG_ID_90, "90fps", 90};
assertRatesEqual(expectedPerformanceConfig, *performanceRate->second);
- ASSERT_TRUE(configs.getRefreshRate(RefreshRateType::POWER_SAVING));
+ ASSERT_TRUE(mConfigs.getRefreshRate(RefreshRateType::POWER_SAVING));
assertRatesEqual(expectedPowerSavingConfig,
- *configs.getRefreshRate(RefreshRateType::POWER_SAVING));
- ASSERT_TRUE(configs.getRefreshRate(RefreshRateType::DEFAULT));
- assertRatesEqual(expectedDefaultConfig, *configs.getRefreshRate(RefreshRateType::DEFAULT));
- ASSERT_TRUE(configs.getRefreshRate(RefreshRateType::PERFORMANCE));
+ *mConfigs.getRefreshRate(RefreshRateType::POWER_SAVING));
+ ASSERT_TRUE(mConfigs.getRefreshRate(RefreshRateType::DEFAULT));
+ assertRatesEqual(expectedDefaultConfig, *mConfigs.getRefreshRate(RefreshRateType::DEFAULT));
+ ASSERT_TRUE(mConfigs.getRefreshRate(RefreshRateType::PERFORMANCE));
assertRatesEqual(expectedPerformanceConfig,
- *configs.getRefreshRate(RefreshRateType::PERFORMANCE));
+ *mConfigs.getRefreshRate(RefreshRateType::PERFORMANCE));
}
} // namespace
} // namespace scheduler
diff --git a/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp b/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp
index 10f5af8..411ec61 100644
--- a/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp
+++ b/services/surfaceflinger/tests/unittests/RefreshRateStatsTest.cpp
@@ -42,11 +42,9 @@
RefreshRateStatsTest();
~RefreshRateStatsTest();
- void init(std::vector<std::shared_ptr<const HWC2::Display::Config>> configs);
-
- std::unique_ptr<RefreshRateStats> mRefreshRateStats;
- std::shared_ptr<android::mock::TimeStats> mTimeStats;
- std::shared_ptr<RefreshRateConfigs> mRefreshRateConfigs;
+ mock::TimeStats mTimeStats;
+ RefreshRateConfigs mRefreshRateConfigs;
+ RefreshRateStats mRefreshRateStats{mRefreshRateConfigs, mTimeStats};
};
RefreshRateStatsTest::RefreshRateStatsTest() {
@@ -61,22 +59,16 @@
ALOGD("**** Tearing down after %s.%s\n", test_info->test_case_name(), test_info->name());
}
-void RefreshRateStatsTest::init(std::vector<std::shared_ptr<const HWC2::Display::Config>> configs) {
- mTimeStats = std::make_shared<android::mock::TimeStats>();
- mRefreshRateConfigs = std::make_shared<RefreshRateConfigs>(configs);
- mRefreshRateStats = std::make_unique<RefreshRateStats>(mRefreshRateConfigs, mTimeStats);
-}
-
namespace {
/* ------------------------------------------------------------------------
* Test cases
*/
TEST_F(RefreshRateStatsTest, canCreateAndDestroyTest) {
std::vector<std::shared_ptr<const HWC2::Display::Config>> configs;
- init(configs);
+ mRefreshRateConfigs.populate(configs);
// There is one default config, so the refresh rates should have one item.
- EXPECT_EQ(1, mRefreshRateStats->getTotalTimes().size());
+ EXPECT_EQ(1, mRefreshRateStats.getTotalTimes().size());
}
TEST_F(RefreshRateStatsTest, oneConfigTest) {
@@ -87,12 +79,12 @@
std::vector<std::shared_ptr<const HWC2::Display::Config>> configs;
configs.push_back(config.build());
- init(configs);
+ mRefreshRateConfigs.populate(configs);
- EXPECT_CALL(*mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
- EXPECT_CALL(*mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
+ EXPECT_CALL(mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
+ EXPECT_CALL(mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
- std::unordered_map<std::string, int64_t> times = mRefreshRateStats->getTotalTimes();
+ std::unordered_map<std::string, int64_t> times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(2, times.size());
EXPECT_NE(0u, times.count("ScreenOff"));
EXPECT_EQ(1u, times.count("90fps"));
@@ -105,29 +97,29 @@
// Screen is off by default.
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_LT(screenOff, times["ScreenOff"]);
EXPECT_EQ(0, times["90fps"]);
- mRefreshRateStats->setConfigMode(CONFIG_ID_90);
- mRefreshRateStats->setPowerMode(HWC_POWER_MODE_NORMAL);
- screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_90);
+ mRefreshRateStats.setPowerMode(HWC_POWER_MODE_NORMAL);
+ screenOff = mRefreshRateStats.getTotalTimes()["ScreenOff"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(screenOff, times["ScreenOff"]);
EXPECT_LT(ninety, times["90fps"]);
- mRefreshRateStats->setPowerMode(HWC_POWER_MODE_DOZE);
- ninety = mRefreshRateStats->getTotalTimes()["90fps"];
+ mRefreshRateStats.setPowerMode(HWC_POWER_MODE_DOZE);
+ ninety = mRefreshRateStats.getTotalTimes()["90fps"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_LT(screenOff, times["ScreenOff"]);
EXPECT_EQ(ninety, times["90fps"]);
- mRefreshRateStats->setConfigMode(CONFIG_ID_90);
- screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_90);
+ screenOff = mRefreshRateStats.getTotalTimes()["ScreenOff"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
// Because the power mode is not HWC_POWER_MODE_NORMAL, switching the config
// does not update refresh rates that come from the config.
EXPECT_LT(screenOff, times["ScreenOff"]);
@@ -146,13 +138,13 @@
config60.setVsyncPeriod(VSYNC_60);
configs.push_back(config60.build());
- init(configs);
+ mRefreshRateConfigs.populate(configs);
- EXPECT_CALL(*mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
- EXPECT_CALL(*mTimeStats, recordRefreshRate(60, _)).Times(AtLeast(1));
- EXPECT_CALL(*mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
+ EXPECT_CALL(mTimeStats, recordRefreshRate(0, _)).Times(AtLeast(1));
+ EXPECT_CALL(mTimeStats, recordRefreshRate(60, _)).Times(AtLeast(1));
+ EXPECT_CALL(mTimeStats, recordRefreshRate(90, _)).Times(AtLeast(1));
- std::unordered_map<std::string, int64_t> times = mRefreshRateStats->getTotalTimes();
+ std::unordered_map<std::string, int64_t> times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(3, times.size());
EXPECT_NE(0u, times.count("ScreenOff"));
EXPECT_EQ(1u, times.count("60fps"));
@@ -168,60 +160,60 @@
// Screen is off by default.
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_LT(screenOff, times["ScreenOff"]);
EXPECT_EQ(sixty, times["60fps"]);
EXPECT_EQ(ninety, times["90fps"]);
- mRefreshRateStats->setConfigMode(CONFIG_ID_90);
- mRefreshRateStats->setPowerMode(HWC_POWER_MODE_NORMAL);
- screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_90);
+ mRefreshRateStats.setPowerMode(HWC_POWER_MODE_NORMAL);
+ screenOff = mRefreshRateStats.getTotalTimes()["ScreenOff"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(screenOff, times["ScreenOff"]);
EXPECT_EQ(sixty, times["60fps"]);
EXPECT_LT(ninety, times["90fps"]);
// When power mode is normal, time for configs updates.
- mRefreshRateStats->setConfigMode(CONFIG_ID_60);
- ninety = mRefreshRateStats->getTotalTimes()["90fps"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_60);
+ ninety = mRefreshRateStats.getTotalTimes()["90fps"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(screenOff, times["ScreenOff"]);
EXPECT_EQ(ninety, times["90fps"]);
EXPECT_LT(sixty, times["60fps"]);
- mRefreshRateStats->setConfigMode(CONFIG_ID_90);
- sixty = mRefreshRateStats->getTotalTimes()["60fps"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_90);
+ sixty = mRefreshRateStats.getTotalTimes()["60fps"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(screenOff, times["ScreenOff"]);
EXPECT_LT(ninety, times["90fps"]);
EXPECT_EQ(sixty, times["60fps"]);
- mRefreshRateStats->setConfigMode(CONFIG_ID_60);
- ninety = mRefreshRateStats->getTotalTimes()["90fps"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_60);
+ ninety = mRefreshRateStats.getTotalTimes()["90fps"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_EQ(screenOff, times["ScreenOff"]);
EXPECT_EQ(ninety, times["90fps"]);
EXPECT_LT(sixty, times["60fps"]);
// Because the power mode is not HWC_POWER_MODE_NORMAL, switching the config
// does not update refresh rates that come from the config.
- mRefreshRateStats->setPowerMode(HWC_POWER_MODE_DOZE);
- mRefreshRateStats->setConfigMode(CONFIG_ID_90);
- sixty = mRefreshRateStats->getTotalTimes()["60fps"];
+ mRefreshRateStats.setPowerMode(HWC_POWER_MODE_DOZE);
+ mRefreshRateStats.setConfigMode(CONFIG_ID_90);
+ sixty = mRefreshRateStats.getTotalTimes()["60fps"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_LT(screenOff, times["ScreenOff"]);
EXPECT_EQ(ninety, times["90fps"]);
EXPECT_EQ(sixty, times["60fps"]);
- mRefreshRateStats->setConfigMode(CONFIG_ID_60);
- screenOff = mRefreshRateStats->getTotalTimes()["ScreenOff"];
+ mRefreshRateStats.setConfigMode(CONFIG_ID_60);
+ screenOff = mRefreshRateStats.getTotalTimes()["ScreenOff"];
std::this_thread::sleep_for(std::chrono::milliseconds(2));
- times = mRefreshRateStats->getTotalTimes();
+ times = mRefreshRateStats.getTotalTimes();
EXPECT_LT(screenOff, times["ScreenOff"]);
EXPECT_EQ(ninety, times["90fps"]);
EXPECT_EQ(sixty, times["60fps"]);