Revert "SurfaceFlinger: protect state members in Layer"
State update transactions must be atomic. The fine-grained lock on each
Layer implied otherwise. Revert the fine grained lock as being
unhelpful.
Unfortunately there does not seem to be a way to use Clang thread
annotations to specify the desired locking behavior.
Note that the parent CL addresses the locking problem that led to the
bug.
This reverts commit 83729883eecd31a9907bc79bc21998a90f17105c.
Bug: 119481871
Test: SurfaceFlinger unit tests
Test: go/wm-smoke
Change-Id: I361741f8d10102aeb57f164c847c6063ff93dd14
diff --git a/services/surfaceflinger/BufferLayer.cpp b/services/surfaceflinger/BufferLayer.cpp
index 0a3be71..4e4d7dd 100644
--- a/services/surfaceflinger/BufferLayer.cpp
+++ b/services/surfaceflinger/BufferLayer.cpp
@@ -396,7 +396,6 @@
}
// Capture the old state of the layer for comparisons later
- Mutex::Autolock lock(mStateMutex);
const State& s(getDrawingState());
const bool oldOpacity = isOpaque(s);
sp<GraphicBuffer> oldBuffer = mActiveBuffer;
@@ -503,7 +502,7 @@
// FIXME: postedRegion should be dirty & bounds
// transform the dirty region to window-manager space
- return getTransformLocked().transform(Region(getBufferSize(s)));
+ return getTransform().transform(Region(getBufferSize(s)));
}
// transaction
@@ -551,7 +550,7 @@
// h/w composer set-up
bool BufferLayer::allTransactionsSignaled() {
- auto headFrameNumber = getHeadFrameNumberLocked();
+ auto headFrameNumber = getHeadFrameNumber();
bool matchingFramesFound = false;
bool allTransactionsApplied = true;
Mutex::Autolock lock(mLocalSyncPointMutex);
@@ -604,7 +603,6 @@
void BufferLayer::drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const {
ATRACE_CALL();
- Mutex::Autolock lock(mStateMutex);
const State& s(getDrawingState());
computeGeometry(renderArea, getBE().mMesh, useIdentityTransform);
@@ -623,9 +621,9 @@
* minimal value)? Or, we could make GL behave like HWC -- but this feel
* like more of a hack.
*/
- const Rect bounds{computeBoundsLocked()}; // Rounds from FloatRect
+ const Rect bounds{computeBounds()}; // Rounds from FloatRect
- ui::Transform t = getTransformLocked();
+ ui::Transform t = getTransform();
Rect win = bounds;
const int bufferWidth = getBufferSize(s).getWidth();
const int bufferHeight = getBufferSize(s).getHeight();
@@ -644,7 +642,7 @@
texCoords[2] = vec2(right, 1.0f - bottom);
texCoords[3] = vec2(right, 1.0f - top);
- const auto roundedCornerState = getRoundedCornerStateLocked();
+ const auto roundedCornerState = getRoundedCornerState();
const auto cropRect = roundedCornerState.cropRect;
setupRoundedCornersCropCoordinates(win, cropRect);
@@ -666,12 +664,7 @@
}
uint64_t BufferLayer::getHeadFrameNumber() const {
- Mutex::Autolock lock(mStateMutex);
- return getHeadFrameNumberLocked();
-}
-
-uint64_t BufferLayer::getHeadFrameNumberLocked() const {
- if (hasFrameUpdateLocked()) {
+ if (hasFrameUpdate()) {
return getFrameNumber();
} else {
return mCurrentFrameNumber;
@@ -698,7 +691,7 @@
std::swap(bufWidth, bufHeight);
}
- if (getTransformToDisplayInverseLocked()) {
+ if (getTransformToDisplayInverse()) {
uint32_t invTransform = DisplayDevice::getPrimaryDisplayOrientationTransform();
if (invTransform & ui::Transform::ROT_90) {
std::swap(bufWidth, bufHeight);
diff --git a/services/surfaceflinger/BufferLayer.h b/services/surfaceflinger/BufferLayer.h
index 98ae286..be16cf5 100644
--- a/services/surfaceflinger/BufferLayer.h
+++ b/services/surfaceflinger/BufferLayer.h
@@ -69,7 +69,7 @@
bool isOpaque(const Layer::State& s) const override;
// isVisible - true if this layer is visible, false otherwise
- bool isVisible() const override EXCLUDES(mStateMutex);
+ bool isVisible() const override;
// isProtected - true if the layer may contain protected content in the
// GRALLOC_USAGE_PROTECTED sense.
@@ -91,7 +91,7 @@
bool onPostComposition(const std::optional<DisplayId>& displayId,
const std::shared_ptr<FenceTime>& glDoneFence,
const std::shared_ptr<FenceTime>& presentFence,
- const CompositorTiming& compositorTiming) override EXCLUDES(mStateMutex);
+ const CompositorTiming& compositorTiming) override;
// latchBuffer - called each time the screen is redrawn and returns whether
// the visible regions need to be recomputed (this is a fairly heavy
@@ -101,13 +101,13 @@
// releaseFence will be populated with a native fence that fires when
// composition has completed.
Region latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
- const sp<Fence>& releaseFence) override EXCLUDES(mStateMutex);
+ const sp<Fence>& releaseFence) override;
bool isBufferLatched() const override { return mRefreshPending; }
void notifyAvailableFrames() override;
- bool hasReadyFrame() const override EXCLUDES(mStateMutex);
+ bool hasReadyFrame() const override;
// Returns the current scaling mode, unless mOverrideScalingMode
// is set, in which case, it returns mOverrideScalingMode
@@ -118,24 +118,19 @@
// Functions that must be implemented by derived classes
// -----------------------------------------------------------------------
private:
- virtual bool fenceHasSignaled() const EXCLUDES(mStateMutex) = 0;
+ virtual bool fenceHasSignaled() const = 0;
virtual nsecs_t getDesiredPresentTime() = 0;
- std::shared_ptr<FenceTime> getCurrentFenceTime() const EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- return getCurrentFenceTimeLocked();
- }
-
- virtual std::shared_ptr<FenceTime> getCurrentFenceTimeLocked() const REQUIRES(mStateMutex) = 0;
+ virtual std::shared_ptr<FenceTime> getCurrentFenceTime() const = 0;
virtual void getDrawingTransformMatrix(float *matrix) = 0;
- virtual uint32_t getDrawingTransform() const REQUIRES(mStateMutex) = 0;
- virtual ui::Dataspace getDrawingDataSpace() const REQUIRES(mStateMutex) = 0;
- virtual Rect getDrawingCrop() const REQUIRES(mStateMutex) = 0;
+ virtual uint32_t getDrawingTransform() const = 0;
+ virtual ui::Dataspace getDrawingDataSpace() const = 0;
+ virtual Rect getDrawingCrop() const = 0;
virtual uint32_t getDrawingScalingMode() const = 0;
- virtual Region getDrawingSurfaceDamage() const EXCLUDES(mStateMutex) = 0;
- virtual const HdrMetadata& getDrawingHdrMetadata() const EXCLUDES(mStateMutex) = 0;
- virtual int getDrawingApi() const EXCLUDES(mStateMutex) = 0;
+ virtual Region getDrawingSurfaceDamage() const = 0;
+ virtual const HdrMetadata& getDrawingHdrMetadata() const = 0;
+ virtual int getDrawingApi() const = 0;
virtual PixelFormat getPixelFormat() const = 0;
virtual uint64_t getFrameNumber() const = 0;
@@ -143,21 +138,20 @@
virtual bool getAutoRefresh() const = 0;
virtual bool getSidebandStreamChanged() const = 0;
- virtual std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions)
- EXCLUDES(mStateMutex) = 0;
+ virtual std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) = 0;
- virtual bool hasFrameUpdateLocked() const REQUIRES(mStateMutex) = 0;
+ virtual bool hasFrameUpdate() const = 0;
virtual void setFilteringEnabled(bool enabled) = 0;
- virtual status_t bindTextureImage() EXCLUDES(mStateMutex) = 0;
+ virtual status_t bindTextureImage() = 0;
virtual status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
- const sp<Fence>& flushFence) REQUIRES(mStateMutex) = 0;
+ const sp<Fence>& flushFence) = 0;
- virtual status_t updateActiveBuffer() REQUIRES(mStateMutex) = 0;
+ virtual status_t updateActiveBuffer() = 0;
virtual status_t updateFrameNumber(nsecs_t latchTime) = 0;
- virtual void setHwcLayerBuffer(DisplayId displayId) EXCLUDES(mStateMutex) = 0;
+ virtual void setHwcLayerBuffer(DisplayId displayId) = 0;
protected:
// Loads the corresponding system property once per process
@@ -166,15 +160,10 @@
// Check all of the local sync points to ensure that all transactions
// which need to have been applied prior to the frame which is about to
// be latched have signaled
- bool allTransactionsSignaled() REQUIRES(mStateMutex);
+ bool allTransactionsSignaled();
static bool getOpacityForFormat(uint32_t format);
- bool hasFrameUpdate() const EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- return hasFrameUpdateLocked();
- }
-
// from GLES
const uint32_t mTextureName;
@@ -183,12 +172,9 @@
bool needsFiltering(const RenderArea& renderArea) const;
// drawing
- void drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const
- EXCLUDES(mStateMutex);
+ void drawWithOpenGL(const RenderArea& renderArea, bool useIdentityTransform) const;
- uint64_t getHeadFrameNumber() const EXCLUDES(mStateMutex);
-
- uint64_t getHeadFrameNumberLocked() const REQUIRES(mStateMutex);
+ uint64_t getHeadFrameNumber() const;
uint32_t mCurrentScalingMode{NATIVE_WINDOW_SCALING_MODE_FREEZE};
@@ -200,7 +186,7 @@
bool mRefreshPending{false};
- Rect getBufferSize(const State& s) const override REQUIRES(mStateMutex);
+ Rect getBufferSize(const State& s) const override;
};
} // namespace android
diff --git a/services/surfaceflinger/BufferQueueLayer.cpp b/services/surfaceflinger/BufferQueueLayer.cpp
index 3341b98..5a61122 100644
--- a/services/surfaceflinger/BufferQueueLayer.cpp
+++ b/services/surfaceflinger/BufferQueueLayer.cpp
@@ -51,7 +51,7 @@
return history;
}
-bool BufferQueueLayer::getTransformToDisplayInverseLocked() const {
+bool BufferQueueLayer::getTransformToDisplayInverse() const {
return mConsumer->getTransformToDisplayInverse();
}
@@ -131,7 +131,7 @@
return mConsumer->getTimestamp();
}
-std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTimeLocked() const {
+std::shared_ptr<FenceTime> BufferQueueLayer::getCurrentFenceTime() const {
return mConsumer->getCurrentFenceTime();
}
@@ -192,7 +192,6 @@
std::optional<Region> BufferQueueLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
bool sidebandStreamChanged = true;
- Mutex::Autolock lock(mStateMutex);
if (mSidebandStreamChanged.compare_exchange_strong(sidebandStreamChanged, false)) {
// mSidebandStreamChanged was changed to false
// replicated in LayerBE until FE/BE is ready to be synchronized
@@ -201,15 +200,15 @@
setTransactionFlags(eTransactionNeeded);
mFlinger->setTransactionFlags(eTraversalNeeded);
}
-
recomputeVisibleRegions = true;
+
const State& s(getDrawingState());
- return getTransformLocked().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h)));
+ return getTransform().transform(Region(Rect(s.active_legacy.w, s.active_legacy.h)));
}
return {};
}
-bool BufferQueueLayer::hasFrameUpdateLocked() const {
+bool BufferQueueLayer::hasFrameUpdate() const {
return mQueuedFrames > 0;
}
@@ -229,18 +228,16 @@
// buffer mode.
bool queuedBuffer = false;
const int32_t layerID = getSequence();
- status_t updateResult;
- LayerRejecter r(mState.drawing, getCurrentState(), recomputeVisibleRegions,
+ LayerRejecter r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
getProducerStickyTransform() != 0, mName.string(), mOverrideScalingMode,
- getTransformToDisplayInverseLocked(), mFreezeGeometryUpdates);
+ getTransformToDisplayInverse(), mFreezeGeometryUpdates);
const nsecs_t expectedPresentTime = mFlinger->mUseScheduler
? mFlinger->mScheduler->mPrimaryDispSync->expectedPresentTime()
: mFlinger->mPrimaryDispSync->expectedPresentTime();
-
- updateResult = mConsumer->updateTexImage(&r, expectedPresentTime, &mAutoRefresh, &queuedBuffer,
- mLastFrameNumberReceived, releaseFence);
-
+ status_t updateResult =
+ mConsumer->updateTexImage(&r, expectedPresentTime, &mAutoRefresh, &queuedBuffer,
+ mLastFrameNumberReceived, releaseFence);
if (updateResult == BufferQueue::PRESENT_LATER) {
// Producer doesn't want buffer to be displayed yet. Signal a
// layer update so we check again at the next opportunity.
diff --git a/services/surfaceflinger/BufferQueueLayer.h b/services/surfaceflinger/BufferQueueLayer.h
index f9da044..ae0b705 100644
--- a/services/surfaceflinger/BufferQueueLayer.h
+++ b/services/surfaceflinger/BufferQueueLayer.h
@@ -44,7 +44,7 @@
std::vector<OccupancyTracker::Segment> getOccupancyHistory(bool forceFlush) override;
- bool getTransformToDisplayInverseLocked() const override REQUIRES(mStateMutex);
+ bool getTransformToDisplayInverse() const override;
// If a buffer was replaced this frame, release the former buffer
void releasePendingBuffer(nsecs_t dequeueReadyTime) override;
@@ -64,12 +64,12 @@
private:
nsecs_t getDesiredPresentTime() override;
- std::shared_ptr<FenceTime> getCurrentFenceTimeLocked() const override REQUIRES(mStateMutex);
+ std::shared_ptr<FenceTime> getCurrentFenceTime() const override;
void getDrawingTransformMatrix(float *matrix) override;
- uint32_t getDrawingTransform() const override REQUIRES(mStateMutex);
- ui::Dataspace getDrawingDataSpace() const override REQUIRES(mStateMutex);
- Rect getDrawingCrop() const override REQUIRES(mStateMutex);
+ uint32_t getDrawingTransform() const override;
+ ui::Dataspace getDrawingDataSpace() const override;
+ Rect getDrawingCrop() const override;
uint32_t getDrawingScalingMode() const override;
Region getDrawingSurfaceDamage() const override;
const HdrMetadata& getDrawingHdrMetadata() const override;
@@ -81,18 +81,17 @@
bool getAutoRefresh() const override;
bool getSidebandStreamChanged() const override;
- std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) override
- EXCLUDES(mStateMutex);
+ std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) override;
- bool hasFrameUpdateLocked() const override REQUIRES(mStateMutex);
+ bool hasFrameUpdate() const override;
void setFilteringEnabled(bool enabled) override;
status_t bindTextureImage() override;
status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
- const sp<Fence>& releaseFence) override REQUIRES(mStateMutex);
+ const sp<Fence>& releaseFence) override;
- status_t updateActiveBuffer() override REQUIRES(mStateMutex);
+ status_t updateActiveBuffer() override;
status_t updateFrameNumber(nsecs_t latchTime) override;
void setHwcLayerBuffer(DisplayId displayId) override;
diff --git a/services/surfaceflinger/BufferStateLayer.cpp b/services/surfaceflinger/BufferStateLayer.cpp
index 077be86..e0d9d23 100644
--- a/services/surfaceflinger/BufferStateLayer.cpp
+++ b/services/surfaceflinger/BufferStateLayer.cpp
@@ -72,31 +72,30 @@
}
bool BufferStateLayer::willPresentCurrentTransaction() const {
- Mutex::Autolock lock(mStateMutex);
// Returns true if the most recent Transaction applied to CurrentState will be presented.
return getSidebandStreamChanged() || getAutoRefresh() ||
- (mState.current.modified && mState.current.buffer != nullptr);
+ (mCurrentState.modified && mCurrentState.buffer != nullptr);
}
-bool BufferStateLayer::getTransformToDisplayInverseLocked() const {
- return mState.current.transformToDisplayInverse;
+bool BufferStateLayer::getTransformToDisplayInverse() const {
+ return mCurrentState.transformToDisplayInverse;
}
-void BufferStateLayer::pushPendingStateLocked() {
- if (!mState.current.modified) {
+void BufferStateLayer::pushPendingState() {
+ if (!mCurrentState.modified) {
return;
}
- mState.pending.push_back(mState.current);
- ATRACE_INT(mTransactionName.string(), mState.pending.size());
+ mPendingStates.push_back(mCurrentState);
+ ATRACE_INT(mTransactionName.string(), mPendingStates.size());
}
bool BufferStateLayer::applyPendingStates(Layer::State* stateToCommit) {
- const bool stateUpdateAvailable = !mState.pending.empty();
- while (!mState.pending.empty()) {
+ const bool stateUpdateAvailable = !mPendingStates.empty();
+ while (!mPendingStates.empty()) {
popPendingState(stateToCommit);
}
- mCurrentStateModified = stateUpdateAvailable && mState.current.modified;
- mState.current.modified = false;
+ mCurrentStateModified = stateUpdateAvailable && mCurrentState.modified;
+ mCurrentState.modified = false;
return stateUpdateAvailable;
}
@@ -106,31 +105,28 @@
}
bool BufferStateLayer::setTransform(uint32_t transform) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.transform == transform) return false;
- mState.current.sequence++;
- mState.current.transform = transform;
- mState.current.modified = true;
+ if (mCurrentState.transform == transform) return false;
+ mCurrentState.sequence++;
+ mCurrentState.transform = transform;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setTransformToDisplayInverse(bool transformToDisplayInverse) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.transformToDisplayInverse == transformToDisplayInverse) return false;
- mState.current.sequence++;
- mState.current.transformToDisplayInverse = transformToDisplayInverse;
- mState.current.modified = true;
+ if (mCurrentState.transformToDisplayInverse == transformToDisplayInverse) return false;
+ mCurrentState.sequence++;
+ mCurrentState.transformToDisplayInverse = transformToDisplayInverse;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setCrop(const Rect& crop) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.crop == crop) return false;
- mState.current.sequence++;
- mState.current.crop = crop;
- mState.current.modified = true;
+ if (mCurrentState.crop == crop) return false;
+ mCurrentState.sequence++;
+ mCurrentState.crop = crop;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
@@ -151,94 +147,86 @@
h = frame.bottom;
}
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.active.transform.tx() == x && mState.current.active.transform.ty() == y &&
- mState.current.active.w == w && mState.current.active.h == h) {
+ if (mCurrentState.active.transform.tx() == x && mCurrentState.active.transform.ty() == y &&
+ mCurrentState.active.w == w && mCurrentState.active.h == h) {
return false;
}
if (!frame.isValid()) {
x = y = w = h = 0;
}
- mState.current.active.transform.set(x, y);
- mState.current.active.w = w;
- mState.current.active.h = h;
+ mCurrentState.active.transform.set(x, y);
+ mCurrentState.active.w = w;
+ mCurrentState.active.h = h;
- mState.current.sequence++;
- mState.current.modified = true;
+ mCurrentState.sequence++;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setBuffer(const sp<GraphicBuffer>& buffer) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.buffer) {
+ if (mCurrentState.buffer) {
mReleasePreviousBuffer = true;
}
- mState.current.sequence++;
- mState.current.buffer = buffer;
- mState.current.modified = true;
+ mCurrentState.sequence++;
+ mCurrentState.buffer = buffer;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setAcquireFence(const sp<Fence>& fence) {
- Mutex::Autolock lock(mStateMutex);
// The acquire fences of BufferStateLayers have already signaled before they are set
mCallbackHandleAcquireTime = fence->getSignalTime();
- mState.current.acquireFence = fence;
- mState.current.modified = true;
+ mCurrentState.acquireFence = fence;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setDataspace(ui::Dataspace dataspace) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.dataspace == dataspace) return false;
- mState.current.sequence++;
- mState.current.dataspace = dataspace;
- mState.current.modified = true;
+ if (mCurrentState.dataspace == dataspace) return false;
+ mCurrentState.sequence++;
+ mCurrentState.dataspace = dataspace;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setHdrMetadata(const HdrMetadata& hdrMetadata) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.hdrMetadata == hdrMetadata) return false;
- mState.current.sequence++;
- mState.current.hdrMetadata = hdrMetadata;
- mState.current.modified = true;
+ if (mCurrentState.hdrMetadata == hdrMetadata) return false;
+ mCurrentState.sequence++;
+ mCurrentState.hdrMetadata = hdrMetadata;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setSurfaceDamageRegion(const Region& surfaceDamage) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.sequence++;
- mState.current.surfaceDamageRegion = surfaceDamage;
- mState.current.modified = true;
+ mCurrentState.sequence++;
+ mCurrentState.surfaceDamageRegion = surfaceDamage;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setApi(int32_t api) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.api == api) return false;
- mState.current.sequence++;
- mState.current.api = api;
- mState.current.modified = true;
+ if (mCurrentState.api == api) return false;
+ mCurrentState.sequence++;
+ mCurrentState.api = api;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool BufferStateLayer::setSidebandStream(const sp<NativeHandle>& sidebandStream) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.sidebandStream == sidebandStream) return false;
- mState.current.sequence++;
- mState.current.sidebandStream = sidebandStream;
- mState.current.modified = true;
+ if (mCurrentState.sidebandStream == sidebandStream) return false;
+ mCurrentState.sequence++;
+ mCurrentState.sidebandStream = sidebandStream;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
if (!mSidebandStreamChanged.exchange(true)) {
@@ -272,10 +260,7 @@
mFlinger->getTransactionCompletedThread().registerPendingLatchedCallbackHandle(handle);
// Store so latched time and release fence can be set
- {
- Mutex::Autolock lock(mStateMutex);
- mState.current.callbackHandles.push_back(handle);
- }
+ mCurrentState.callbackHandles.push_back(handle);
} else { // If this layer will NOT need to be relatched and presented this frame
// Notify the transaction completed thread this handle is done
@@ -290,9 +275,8 @@
}
bool BufferStateLayer::setTransparentRegionHint(const Region& transparent) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.transparentRegionHint = transparent;
- mState.current.modified = true;
+ mCurrentState.transparentRegionHint = transparent;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
@@ -328,7 +312,6 @@
return true;
}
- Mutex::Autolock lock(mStateMutex);
return getDrawingState().acquireFence->getStatus() == Fence::Status::Signaled;
}
@@ -337,7 +320,7 @@
return 0;
}
-std::shared_ptr<FenceTime> BufferStateLayer::getCurrentFenceTimeLocked() const {
+std::shared_ptr<FenceTime> BufferStateLayer::getCurrentFenceTime() const {
return std::make_shared<FenceTime>(getDrawingState().acquireFence);
}
@@ -384,17 +367,14 @@
}
Region BufferStateLayer::getDrawingSurfaceDamage() const {
- Mutex::Autolock lock(mStateMutex);
return getDrawingState().surfaceDamageRegion;
}
const HdrMetadata& BufferStateLayer::getDrawingHdrMetadata() const {
- Mutex::Autolock lock(mStateMutex);
return getDrawingState().hdrMetadata;
}
int BufferStateLayer::getDrawingApi() const {
- Mutex::Autolock lock(mStateMutex);
return getDrawingState().api;
}
@@ -419,7 +399,6 @@
}
std::optional<Region> BufferStateLayer::latchSidebandStream(bool& recomputeVisibleRegions) {
- Mutex::Autolock lock(mStateMutex);
if (mSidebandStreamChanged.exchange(false)) {
const State& s(getDrawingState());
// mSidebandStreamChanged was true
@@ -431,12 +410,12 @@
}
recomputeVisibleRegions = true;
- return getTransformLocked().transform(Region(Rect(s.active.w, s.active.h)));
+ return getTransform().transform(Region(Rect(s.active.w, s.active.h)));
}
return {};
}
-bool BufferStateLayer::hasFrameUpdateLocked() const {
+bool BufferStateLayer::hasFrameUpdate() const {
return mCurrentStateModified && getCurrentState().buffer != nullptr;
}
@@ -446,10 +425,6 @@
}
status_t BufferStateLayer::bindTextureImage() {
- Mutex::Autolock lock(mStateMutex);
- return bindTextureImageLocked();
-}
-status_t BufferStateLayer::bindTextureImageLocked() {
const State& s(getDrawingState());
auto& engine(mFlinger->getRenderEngine());
@@ -554,7 +529,7 @@
auto incomingStatus = releaseFence->getStatus();
if (incomingStatus == Fence::Status::Invalid) {
ALOGE("New fence has invalid state");
- mState.drawing.acquireFence = releaseFence;
+ mDrawingState.acquireFence = releaseFence;
mFlinger->mTimeStats->onDestroy(layerID);
return BAD_VALUE;
}
@@ -565,16 +540,16 @@
char fenceName[32] = {};
snprintf(fenceName, 32, "%.28s:%d", mName.string(), mFrameNumber);
sp<Fence> mergedFence =
- Fence::merge(fenceName, mState.drawing.acquireFence, releaseFence);
+ Fence::merge(fenceName, mDrawingState.acquireFence, releaseFence);
if (!mergedFence.get()) {
ALOGE("failed to merge release fences");
// synchronization is broken, the best we can do is hope fences
// signal in order so the new fence will act like a union
- mState.drawing.acquireFence = releaseFence;
+ mDrawingState.acquireFence = releaseFence;
mFlinger->mTimeStats->onDestroy(layerID);
return BAD_VALUE;
}
- mState.drawing.acquireFence = mergedFence;
+ mDrawingState.acquireFence = mergedFence;
} else if (incomingStatus == Fence::Status::Unsignaled) {
// If one fence has signaled and the other hasn't, the unsignaled
// fence will approximately correspond with the correct timestamp.
@@ -583,7 +558,7 @@
// by this point, they will have both signaled and only the timestamp
// will be slightly off; any dependencies after this point will
// already have been met.
- mState.drawing.acquireFence = releaseFence;
+ mDrawingState.acquireFence = releaseFence;
}
} else {
// Bind the new buffer to the GL texture.
@@ -592,7 +567,7 @@
// by glEGLImageTargetTexture2DOES, which this method calls. Newer
// devices will either call this in Layer::onDraw, or (if it's not
// a GL-composited layer) not at all.
- status_t err = bindTextureImageLocked();
+ status_t err = bindTextureImage();
if (err != NO_ERROR) {
mFlinger->mTimeStats->onDestroy(layerID);
return BAD_VALUE;
@@ -601,7 +576,7 @@
// TODO(marissaw): properly support mTimeStats
mFlinger->mTimeStats->setPostTime(layerID, getFrameNumber(), getName().c_str(), latchTime);
- mFlinger->mTimeStats->setAcquireFence(layerID, getFrameNumber(), getCurrentFenceTimeLocked());
+ mFlinger->mTimeStats->setAcquireFence(layerID, getFrameNumber(), getCurrentFenceTime());
mFlinger->mTimeStats->setLatchTime(layerID, getFrameNumber(), latchTime);
return NO_ERROR;
@@ -628,7 +603,6 @@
}
void BufferStateLayer::setHwcLayerBuffer(DisplayId displayId) {
- Mutex::Autolock lock(mStateMutex);
auto& hwcInfo = getBE().mHwcLayers[displayId];
auto& hwcLayer = hwcInfo.layer;
diff --git a/services/surfaceflinger/BufferStateLayer.h b/services/surfaceflinger/BufferStateLayer.h
index 655353c..3f891d3 100644
--- a/services/surfaceflinger/BufferStateLayer.h
+++ b/services/surfaceflinger/BufferStateLayer.h
@@ -41,14 +41,13 @@
bool shouldPresentNow(nsecs_t expectedPresentTime) const override;
- bool getTransformToDisplayInverseLocked() const override REQUIRES(mStateMutex);
+ bool getTransformToDisplayInverse() const override;
uint32_t doTransactionResize(uint32_t flags, Layer::State* /*stateToCommit*/) override {
return flags;
}
-
- void pushPendingStateLocked() override REQUIRES(mStateMutex);
- bool applyPendingStates(Layer::State* stateToCommit) override REQUIRES(mStateMutex);
+ void pushPendingState() override;
+ bool applyPendingStates(Layer::State* stateToCommit) override;
uint32_t getActiveWidth(const Layer::State& s) const override { return s.active.w; }
uint32_t getActiveHeight(const Layer::State& s) const override { return s.active.h; }
@@ -60,20 +59,18 @@
}
Rect getCrop(const Layer::State& s) const;
- bool setTransform(uint32_t transform) override EXCLUDES(mStateMutex);
- bool setTransformToDisplayInverse(bool transformToDisplayInverse) override
- EXCLUDES(mStateMutex);
- bool setCrop(const Rect& crop) override EXCLUDES(mStateMutex);
- bool setFrame(const Rect& frame) override EXCLUDES(mStateMutex);
- bool setBuffer(const sp<GraphicBuffer>& buffer) override EXCLUDES(mStateMutex);
- bool setAcquireFence(const sp<Fence>& fence) override EXCLUDES(mStateMutex);
- bool setDataspace(ui::Dataspace dataspace) override EXCLUDES(mStateMutex);
- bool setHdrMetadata(const HdrMetadata& hdrMetadata) override EXCLUDES(mStateMutex);
- bool setSurfaceDamageRegion(const Region& surfaceDamage) override EXCLUDES(mStateMutex);
- bool setApi(int32_t api) override EXCLUDES(mStateMutex);
- bool setSidebandStream(const sp<NativeHandle>& sidebandStream) override EXCLUDES(mStateMutex);
- bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) override
- EXCLUDES(mStateMutex);
+ bool setTransform(uint32_t transform) override;
+ bool setTransformToDisplayInverse(bool transformToDisplayInverse) override;
+ bool setCrop(const Rect& crop) override;
+ bool setFrame(const Rect& frame) override;
+ bool setBuffer(const sp<GraphicBuffer>& buffer) override;
+ bool setAcquireFence(const sp<Fence>& fence) override;
+ bool setDataspace(ui::Dataspace dataspace) override;
+ bool setHdrMetadata(const HdrMetadata& hdrMetadata) override;
+ bool setSurfaceDamageRegion(const Region& surfaceDamage) override;
+ bool setApi(int32_t api) override;
+ bool setSidebandStream(const sp<NativeHandle>& sidebandStream) override;
+ bool setTransactionCompletedListeners(const std::vector<sp<CallbackHandle>>& handles) override;
// Override to ignore legacy layer state properties that are not used by BufferStateLayer
bool setSize(uint32_t /*w*/, uint32_t /*h*/) override { return false; }
@@ -90,26 +87,26 @@
void deferTransactionUntil_legacy(const sp<Layer>& /*barrierLayer*/,
uint64_t /*frameNumber*/) override {}
- Rect getBufferSize(const State& s) const override REQUIRES(mStateMutex);
+ Rect getBufferSize(const State& s) const override;
// -----------------------------------------------------------------------
// -----------------------------------------------------------------------
// Interface implementation for BufferLayer
// -----------------------------------------------------------------------
- bool fenceHasSignaled() const override EXCLUDES(mStateMutex);
+ bool fenceHasSignaled() const override;
private:
nsecs_t getDesiredPresentTime() override;
- std::shared_ptr<FenceTime> getCurrentFenceTimeLocked() const override REQUIRES(mStateMutex);
+ std::shared_ptr<FenceTime> getCurrentFenceTime() const override;
void getDrawingTransformMatrix(float *matrix) override;
- uint32_t getDrawingTransform() const override REQUIRES(mStateMutex);
- ui::Dataspace getDrawingDataSpace() const override REQUIRES(mStateMutex);
- Rect getDrawingCrop() const override REQUIRES(mStateMutex);
+ uint32_t getDrawingTransform() const override;
+ ui::Dataspace getDrawingDataSpace() const override;
+ Rect getDrawingCrop() const override;
uint32_t getDrawingScalingMode() const override;
- Region getDrawingSurfaceDamage() const override EXCLUDES(mStateMutex);
- const HdrMetadata& getDrawingHdrMetadata() const override EXCLUDES(mStateMutex);
- int getDrawingApi() const override EXCLUDES(mStateMutex);
+ Region getDrawingSurfaceDamage() const override;
+ const HdrMetadata& getDrawingHdrMetadata() const override;
+ int getDrawingApi() const override;
PixelFormat getPixelFormat() const override;
uint64_t getFrameNumber() const override;
@@ -117,26 +114,24 @@
bool getAutoRefresh() const override;
bool getSidebandStreamChanged() const override;
- std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) override
- EXCLUDES(mStateMutex);
+ std::optional<Region> latchSidebandStream(bool& recomputeVisibleRegions) override;
- bool hasFrameUpdateLocked() const override REQUIRES(mStateMutex);
+ bool hasFrameUpdate() const override;
void setFilteringEnabled(bool enabled) override;
- status_t bindTextureImage() override EXCLUDES(mStateMutex);
+ status_t bindTextureImage() override;
status_t updateTexImage(bool& recomputeVisibleRegions, nsecs_t latchTime,
- const sp<Fence>& releaseFence) override REQUIRES(mStateMutex);
+ const sp<Fence>& releaseFence) override;
- status_t updateActiveBuffer() override REQUIRES(mStateMutex);
+ status_t updateActiveBuffer() override;
status_t updateFrameNumber(nsecs_t latchTime) override;
- void setHwcLayerBuffer(DisplayId displayId) override EXCLUDES(mStateMutex);
+ void setHwcLayerBuffer(DisplayId displayId) override;
private:
void onFirstRef() override;
bool willPresentCurrentTransaction() const;
- status_t bindTextureImageLocked() REQUIRES(mStateMutex);
static const std::array<float, 16> IDENTITY_MATRIX;
diff --git a/services/surfaceflinger/ColorLayer.cpp b/services/surfaceflinger/ColorLayer.cpp
index cb7642e..f27f6aa 100644
--- a/services/surfaceflinger/ColorLayer.cpp
+++ b/services/surfaceflinger/ColorLayer.cpp
@@ -40,16 +40,15 @@
void ColorLayer::onDraw(const RenderArea& renderArea, const Region& /* clip */,
bool useIdentityTransform) {
- Mutex::Autolock lock(mStateMutex);
half4 color = getColor();
if (color.a > 0) {
renderengine::Mesh mesh(renderengine::Mesh::TRIANGLE_FAN, 4, 2);
computeGeometry(renderArea, mesh, useIdentityTransform);
auto& engine(mFlinger->getRenderEngine());
- Rect win{computeBoundsLocked()};
+ Rect win{computeBounds()};
- const auto roundedCornerState = getRoundedCornerStateLocked();
+ const auto roundedCornerState = getRoundedCornerState();
const auto cropRect = roundedCornerState.cropRect;
setupRoundedCornersCropCoordinates(win, cropRect);
@@ -92,7 +91,6 @@
}
getBE().compositionInfo.hwc.dataspace = mCurrentDataSpace;
- Mutex::Autolock lock(mStateMutex);
half4 color = getColor();
error = hwcLayer->setColor({static_cast<uint8_t>(std::round(255.0f * color.r)),
static_cast<uint8_t>(std::round(255.0f * color.g)),
@@ -113,12 +111,12 @@
}
getBE().compositionInfo.hwc.transform = HWC2::Transform::None;
- error = hwcLayer->setColorTransform(getColorTransformLocked());
+ error = hwcLayer->setColorTransform(getColorTransform());
if (error != HWC2::Error::None) {
ALOGE("[%s] Failed to setColorTransform: %s (%d)", mName.string(),
to_string(error).c_str(), static_cast<int32_t>(error));
}
- getBE().compositionInfo.hwc.colorTransform = getColorTransformLocked();
+ getBE().compositionInfo.hwc.colorTransform = getColorTransform();
error = hwcLayer->setSurfaceDamage(surfaceDamageRegion);
if (error != HWC2::Error::None) {
diff --git a/services/surfaceflinger/ColorLayer.h b/services/surfaceflinger/ColorLayer.h
index 5850a2e..d1b1697 100644
--- a/services/surfaceflinger/ColorLayer.h
+++ b/services/surfaceflinger/ColorLayer.h
@@ -29,12 +29,12 @@
~ColorLayer() override;
virtual const char* getTypeId() const { return "ColorLayer"; }
- virtual void onDraw(const RenderArea& renderArea, const Region& clip, bool useIdentityTransform)
- EXCLUDES(mStateMutex);
- bool isVisible() const override EXCLUDES(mStateMutex);
+ virtual void onDraw(const RenderArea& renderArea, const Region& clip,
+ bool useIdentityTransform);
+ bool isVisible() const override;
void setPerFrameData(DisplayId displayId, const ui::Transform& transform, const Rect& viewport,
- int32_t supportedPerFrameMetadata) override EXCLUDES(mStateMutex);
+ int32_t supportedPerFrameMetadata) override;
bool onPreComposition(nsecs_t /*refreshStartTime*/) override { return false; }
diff --git a/services/surfaceflinger/ContainerLayer.h b/services/surfaceflinger/ContainerLayer.h
index 6c4f7c8..413844b 100644
--- a/services/surfaceflinger/ContainerLayer.h
+++ b/services/surfaceflinger/ContainerLayer.h
@@ -31,7 +31,7 @@
const char* getTypeId() const override { return "ContainerLayer"; }
void onDraw(const RenderArea& renderArea, const Region& clip,
bool useIdentityTransform) override;
- bool isVisible() const override EXCLUDES(mStateMutex);
+ bool isVisible() const override;
void setPerFrameData(DisplayId displayId, const ui::Transform& transform, const Rect& viewport,
int32_t supportedPerFrameMetadata) override;
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 2d3fd8e..b1827c1 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -83,35 +83,35 @@
mTransactionName = String8("TX - ") + mName;
- mState.current.active_legacy.w = args.w;
- mState.current.active_legacy.h = args.h;
- mState.current.flags = layerFlags;
- mState.current.active_legacy.transform.set(0, 0);
- mState.current.crop_legacy.makeInvalid();
- mState.current.requestedCrop_legacy = mState.current.crop_legacy;
- mState.current.z = 0;
- mState.current.color.a = 1.0f;
- mState.current.layerStack = 0;
- mState.current.sequence = 0;
- mState.current.requested_legacy = mState.current.active_legacy;
- mState.current.appId = 0;
- mState.current.type = 0;
- mState.current.active.w = UINT32_MAX;
- mState.current.active.h = UINT32_MAX;
- mState.current.active.transform.set(0, 0);
- mState.current.transform = 0;
- mState.current.transformToDisplayInverse = false;
- mState.current.crop.makeInvalid();
- mState.current.acquireFence = new Fence(-1);
- mState.current.dataspace = ui::Dataspace::UNKNOWN;
- mState.current.hdrMetadata.validTypes = 0;
- mState.current.surfaceDamageRegion.clear();
- mState.current.cornerRadius = 0.0f;
- mState.current.api = -1;
- mState.current.hasColorTransform = false;
+ mCurrentState.active_legacy.w = args.w;
+ mCurrentState.active_legacy.h = args.h;
+ mCurrentState.flags = layerFlags;
+ mCurrentState.active_legacy.transform.set(0, 0);
+ mCurrentState.crop_legacy.makeInvalid();
+ mCurrentState.requestedCrop_legacy = mCurrentState.crop_legacy;
+ mCurrentState.z = 0;
+ mCurrentState.color.a = 1.0f;
+ mCurrentState.layerStack = 0;
+ mCurrentState.sequence = 0;
+ mCurrentState.requested_legacy = mCurrentState.active_legacy;
+ mCurrentState.appId = 0;
+ mCurrentState.type = 0;
+ mCurrentState.active.w = UINT32_MAX;
+ mCurrentState.active.h = UINT32_MAX;
+ mCurrentState.active.transform.set(0, 0);
+ mCurrentState.transform = 0;
+ mCurrentState.transformToDisplayInverse = false;
+ mCurrentState.crop.makeInvalid();
+ mCurrentState.acquireFence = new Fence(-1);
+ mCurrentState.dataspace = ui::Dataspace::UNKNOWN;
+ mCurrentState.hdrMetadata.validTypes = 0;
+ mCurrentState.surfaceDamageRegion.clear();
+ mCurrentState.cornerRadius = 0.0f;
+ mCurrentState.api = -1;
+ mCurrentState.hasColorTransform = false;
// drawing state & current state are identical
- mState.drawing = mState.current;
+ mDrawingState = mCurrentState;
CompositorTiming compositorTiming;
args.flinger->getCompositorTiming(&compositorTiming);
@@ -148,17 +148,14 @@
void Layer::onRemovedFromCurrentState() {
mRemovedFromCurrentState = true;
- {
- Mutex::Autolock lock(mStateMutex);
- // the layer is removed from SF mState.current to mLayersPendingRemoval
- if (mState.current.zOrderRelativeOf != nullptr) {
- sp<Layer> strongRelative = mState.current.zOrderRelativeOf.promote();
- if (strongRelative != nullptr) {
- strongRelative->removeZOrderRelative(this);
- mFlinger->setTransactionFlags(eTraversalNeeded);
- }
- mState.current.zOrderRelativeOf = nullptr;
+ // the layer is removed from SF mCurrentState to mLayersPendingRemoval
+ if (mCurrentState.zOrderRelativeOf != nullptr) {
+ sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
+ if (strongRelative != nullptr) {
+ strongRelative->removeZOrderRelative(this);
+ mFlinger->setTransactionFlags(eTraversalNeeded);
}
+ mCurrentState.zOrderRelativeOf = nullptr;
}
// Since we are no longer reachable from CurrentState SurfaceFlinger
@@ -297,32 +294,21 @@
}
Rect Layer::computeScreenBounds(bool reduceTransparentRegion) const {
- Mutex::Autolock lock(mStateMutex);
const State& s(getDrawingState());
Region transparentRegion = reduceTransparentRegion ? getActiveTransparentRegion(s) : Region();
- FloatRect bounds = computeBoundsLocked(transparentRegion);
- ui::Transform t = getTransformLocked();
+ FloatRect bounds = computeBounds(transparentRegion);
+ ui::Transform t = getTransform();
// Transform to screen space.
bounds = t.transform(bounds);
return Rect{bounds};
}
FloatRect Layer::computeBounds() const {
- Mutex::Autolock lock(mStateMutex);
- return computeBoundsLocked();
-}
-
-FloatRect Layer::computeBoundsLocked() const {
const State& s(getDrawingState());
- return computeBoundsLocked(getActiveTransparentRegion(s));
+ return computeBounds(getActiveTransparentRegion(s));
}
FloatRect Layer::computeBounds(const Region& activeTransparentRegion) const {
- Mutex::Autolock lock(mStateMutex);
- return computeBoundsLocked(activeTransparentRegion);
-}
-
-FloatRect Layer::computeBoundsLocked(const Region& activeTransparentRegion) const {
const State& s(getDrawingState());
Rect bounds = getCroppedBufferSize(s);
FloatRect floatBounds = bounds.toFloatRect();
@@ -375,7 +361,6 @@
// child bounds as well.
ui::Transform t = s.active_legacy.transform;
croppedBounds = t.transform(croppedBounds);
- Mutex::Autolock lock(p->mStateMutex);
croppedBounds = p->cropChildBounds(croppedBounds);
croppedBounds = t.inverse().transform(croppedBounds);
}
@@ -403,8 +388,8 @@
// if there are no window scaling involved, this operation will map to full
// pixels in the buffer.
- FloatRect activeCropFloat = computeBoundsLocked();
- ui::Transform t = getTransformLocked();
+ FloatRect activeCropFloat = computeBounds();
+ ui::Transform t = getTransform();
// Transform to screen space.
activeCropFloat = t.transform(activeCropFloat);
activeCropFloat = activeCropFloat.intersect(display->getViewport().toFloatRect());
@@ -454,7 +439,7 @@
// which means using the inverse of the current transform set on the
// SurfaceFlingerConsumer.
uint32_t invTransform = mCurrentTransform;
- if (getTransformToDisplayInverseLocked()) {
+ if (getTransformToDisplayInverse()) {
/*
* the code below applies the primary display's inverse transform to the
* buffer
@@ -505,7 +490,6 @@
}
void Layer::setGeometry(const sp<const DisplayDevice>& display, uint32_t z) {
- Mutex::Autolock lock(mStateMutex);
const auto displayId = display->getId();
LOG_ALWAYS_FATAL_IF(!displayId);
RETURN_IF_NO_HWC_LAYER(*displayId);
@@ -514,7 +498,7 @@
// enable this layer
hwcInfo.forceClientComposition = false;
- if (isSecureLocked() && !display->isSecure()) {
+ if (isSecure() && !display->isSecure()) {
hwcInfo.forceClientComposition = true;
}
@@ -524,7 +508,7 @@
const State& s(getDrawingState());
const Rect bufferSize = getBufferSize(s);
auto blendMode = HWC2::BlendMode::None;
- if (!isOpaque(s) || getAlphaLocked() != 1.0f) {
+ if (!isOpaque(s) || getAlpha() != 1.0f) {
blendMode =
mPremultipliedAlpha ? HWC2::BlendMode::Premultiplied : HWC2::BlendMode::Coverage;
}
@@ -539,7 +523,7 @@
// apply the layer's transform, followed by the display's global transform
// here we're guaranteed that the layer's transform preserves rects
Region activeTransparentRegion(getActiveTransparentRegion(s));
- ui::Transform t = getTransformLocked();
+ ui::Transform t = getTransform();
Rect activeCrop = getCrop(s);
if (!activeCrop.isEmpty() && bufferSize.isValid()) {
activeCrop = t.transform(activeCrop);
@@ -567,7 +551,7 @@
// computeBounds returns a FloatRect to provide more accuracy during the
// transformation. We then round upon constructing 'frame'.
- Rect frame{t.transform(computeBoundsLocked(activeTransparentRegion))};
+ Rect frame{t.transform(computeBounds(activeTransparentRegion))};
if (!frame.intersect(display->getViewport(), &frame)) {
frame.clear();
}
@@ -595,7 +579,7 @@
}
getBE().compositionInfo.hwc.sourceCrop = sourceCrop;
- float alpha = static_cast<float>(getAlphaLocked());
+ float alpha = static_cast<float>(getAlpha());
error = hwcLayer->setPlaneAlpha(alpha);
ALOGE_IF(error != HWC2::Error::None,
"[%s] Failed to set plane alpha %.3f: "
@@ -612,7 +596,6 @@
int appId = s.appId;
sp<Layer> parent = mDrawingParent.promote();
if (parent.get()) {
- Mutex::Autolock lock(parent->mStateMutex);
auto& parentState = parent->getDrawingState();
if (parentState.type >= 0 || parentState.appId >= 0) {
type = parentState.type;
@@ -638,7 +621,7 @@
const ui::Transform bufferOrientation(mCurrentTransform);
ui::Transform transform(tr * t * bufferOrientation);
- if (getTransformToDisplayInverseLocked()) {
+ if (getTransformToDisplayInverse()) {
/*
* the code below applies the primary display's inverse transform to the
* buffer
@@ -688,7 +671,6 @@
}
void Layer::updateCursorPosition(const sp<const DisplayDevice>& display) {
- Mutex::Autolock lock(mStateMutex);
const auto displayId = display->getId();
LOG_ALWAYS_FATAL_IF(!displayId);
if (!hasHwcLayer(*displayId) || getCompositionType(displayId) != HWC2::Composition::Cursor) {
@@ -703,7 +685,7 @@
Rect win = getCroppedBufferSize(s);
// Subtract the transparent region and snap to the bounds
Rect bounds = reduce(win, getActiveTransparentRegion(s));
- Rect frame(getTransformLocked().transform(bounds));
+ Rect frame(getTransform().transform(bounds));
frame.intersect(display->getViewport(), &frame);
auto& displayTransform = display->getTransform();
auto position = displayTransform.transform(frame);
@@ -733,7 +715,6 @@
void Layer::clearWithOpenGL(const RenderArea& renderArea, float red, float green, float blue,
float alpha) const {
auto& engine(mFlinger->getRenderEngine());
- Mutex::Autolock lock(mStateMutex);
computeGeometry(renderArea, getBE().mMesh, false);
engine.setupFillWithColor(red, green, blue, alpha);
engine.drawMesh(getBE().mMesh);
@@ -818,14 +799,14 @@
renderengine::Mesh& mesh,
bool useIdentityTransform) const {
const ui::Transform renderAreaTransform(renderArea.getTransform());
- FloatRect win = computeBoundsLocked();
+ FloatRect win = computeBounds();
vec2 lt = vec2(win.left, win.top);
vec2 lb = vec2(win.left, win.bottom);
vec2 rb = vec2(win.right, win.bottom);
vec2 rt = vec2(win.right, win.top);
- ui::Transform layerTransform = getTransformLocked();
+ ui::Transform layerTransform = getTransform();
if (!useIdentityTransform) {
lt = layerTransform.transform(lt);
lb = layerTransform.transform(lb);
@@ -841,12 +822,7 @@
}
bool Layer::isSecure() const {
- Mutex::Autolock lock(mStateMutex);
- return isSecureLocked();
-}
-
-bool Layer::isSecureLocked() const {
- const State& s(mState.drawing);
+ const State& s(mDrawingState);
return (s.flags & layer_state_t::eLayerSecure);
}
@@ -874,13 +850,9 @@
// ----------------------------------------------------------------------------
// transaction
// ----------------------------------------------------------------------------
-void Layer::pushPendingState() {
- Mutex::Autolock lock(mStateMutex);
- pushPendingStateLocked();
-}
-void Layer::pushPendingStateLocked() {
- if (!mState.current.modified) {
+void Layer::pushPendingState() {
+ if (!mCurrentState.modified) {
return;
}
@@ -888,22 +860,22 @@
// point and send it to the remote layer.
// We don't allow installing sync points after we are removed from the current state
// as we won't be able to signal our end.
- if (mState.current.barrierLayer_legacy != nullptr && !isRemovedFromCurrentState()) {
- sp<Layer> barrierLayer = mState.current.barrierLayer_legacy.promote();
+ if (mCurrentState.barrierLayer_legacy != nullptr && !isRemovedFromCurrentState()) {
+ sp<Layer> barrierLayer = mCurrentState.barrierLayer_legacy.promote();
if (barrierLayer == nullptr) {
ALOGE("[%s] Unable to promote barrier Layer.", mName.string());
// If we can't promote the layer we are intended to wait on,
// then it is expired or otherwise invalid. Allow this transaction
// to be applied as per normal (no synchronization).
- mState.current.barrierLayer_legacy = nullptr;
+ mCurrentState.barrierLayer_legacy = nullptr;
} else {
- auto syncPoint = std::make_shared<SyncPoint>(mState.current.frameNumber_legacy);
+ auto syncPoint = std::make_shared<SyncPoint>(mCurrentState.frameNumber_legacy);
if (barrierLayer->addSyncPoint(syncPoint)) {
mRemoteSyncPoints.push_back(std::move(syncPoint));
} else {
// We already missed the frame we're supposed to synchronize
// on, so go ahead and apply the state update
- mState.current.barrierLayer_legacy = nullptr;
+ mCurrentState.barrierLayer_legacy = nullptr;
}
}
@@ -911,21 +883,21 @@
setTransactionFlags(eTransactionNeeded);
mFlinger->setTransactionFlags(eTraversalNeeded);
}
- mState.pending.push_back(mState.current);
- ATRACE_INT(mTransactionName.string(), mState.pending.size());
+ mPendingStates.push_back(mCurrentState);
+ ATRACE_INT(mTransactionName.string(), mPendingStates.size());
}
void Layer::popPendingState(State* stateToCommit) {
- *stateToCommit = mState.pending[0];
+ *stateToCommit = mPendingStates[0];
- mState.pending.removeAt(0);
- ATRACE_INT(mTransactionName.string(), mState.pending.size());
+ mPendingStates.removeAt(0);
+ ATRACE_INT(mTransactionName.string(), mPendingStates.size());
}
bool Layer::applyPendingStates(State* stateToCommit) {
bool stateUpdateAvailable = false;
- while (!mState.pending.empty()) {
- if (mState.pending[0].barrierLayer_legacy != nullptr) {
+ while (!mPendingStates.empty()) {
+ if (mPendingStates[0].barrierLayer_legacy != nullptr) {
if (mRemoteSyncPoints.empty()) {
// If we don't have a sync point for this, apply it anyway. It
// will be visually wrong, but it should keep us from getting
@@ -937,7 +909,7 @@
}
if (mRemoteSyncPoints.front()->getFrameNumber() !=
- mState.pending[0].frameNumber_legacy) {
+ mPendingStates[0].frameNumber_legacy) {
ALOGE("[%s] Unexpected sync point frame number found", mName.string());
// Signal our end of the sync point and then dispose of it
@@ -965,12 +937,12 @@
// If we still have pending updates, wake SurfaceFlinger back up and point
// it at this layer so we can process them
- if (!mState.pending.empty()) {
+ if (!mPendingStates.empty()) {
setTransactionFlags(eTransactionNeeded);
mFlinger->setTransactionFlags(eTraversalNeeded);
}
- mState.current.modified = false;
+ mCurrentState.modified = false;
return stateUpdateAvailable;
}
@@ -1067,8 +1039,7 @@
return 0;
}
- Mutex::Autolock lock(mStateMutex);
- pushPendingStateLocked();
+ pushPendingState();
State c = getCurrentState();
if (!applyPendingStates(&c)) {
return 0;
@@ -1100,60 +1071,49 @@
clearSyncPoints();
}
- if (mState.current.inputInfoChanged) {
+ if (mCurrentState.inputInfoChanged) {
flags |= eInputInfoChanged;
- mState.current.inputInfoChanged = false;
+ mCurrentState.inputInfoChanged = false;
}
// Commit the transaction
commitTransaction(c);
- mState.current.callbackHandles = {};
+ mCurrentState.callbackHandles = {};
return flags;
}
void Layer::commitTransaction(const State& stateToCommit) {
- mState.drawing = stateToCommit;
-}
-
-uint32_t Layer::getTransactionFlags() const {
- Mutex::Autolock lock(mStateMutex);
- return mState.transactionFlags;
+ mDrawingState = stateToCommit;
}
uint32_t Layer::getTransactionFlags(uint32_t flags) {
- Mutex::Autolock lock(mStateMutex);
- uint32_t and_flags = mState.transactionFlags & flags;
- mState.transactionFlags &= ~flags;
- return and_flags;
+ return mTransactionFlags.fetch_and(~flags) & flags;
}
uint32_t Layer::setTransactionFlags(uint32_t flags) {
- uint32_t old_flags = mState.transactionFlags;
- mState.transactionFlags |= flags;
- return old_flags;
+ return mTransactionFlags.fetch_or(flags);
}
bool Layer::setPosition(float x, float y, bool immediate) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.requested_legacy.transform.tx() == x &&
- mState.current.requested_legacy.transform.ty() == y)
+ if (mCurrentState.requested_legacy.transform.tx() == x &&
+ mCurrentState.requested_legacy.transform.ty() == y)
return false;
- mState.current.sequence++;
+ mCurrentState.sequence++;
// We update the requested and active position simultaneously because
// we want to apply the position portion of the transform matrix immediately,
// but still delay scaling when resizing a SCALING_MODE_FREEZE layer.
- mState.current.requested_legacy.transform.set(x, y);
+ mCurrentState.requested_legacy.transform.set(x, y);
if (immediate && !mFreezeGeometryUpdates) {
// Here we directly update the active state
// unlike other setters, because we store it within
// the transform, but use different latching rules.
// b/38182305
- mState.current.active_legacy.transform.set(x, y);
+ mCurrentState.active_legacy.transform.set(x, y);
}
mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate;
- mState.current.modified = true;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
@@ -1186,44 +1146,38 @@
}
bool Layer::setLayer(int32_t z) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.z == z && !usingRelativeZLocked(LayerVector::StateSet::Current))
- return false;
-
- mState.current.sequence++;
- mState.current.z = z;
- mState.current.modified = true;
+ if (mCurrentState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false;
+ mCurrentState.sequence++;
+ mCurrentState.z = z;
+ mCurrentState.modified = true;
// Discard all relative layering.
- if (mState.current.zOrderRelativeOf != nullptr) {
- sp<Layer> strongRelative = mState.current.zOrderRelativeOf.promote();
+ if (mCurrentState.zOrderRelativeOf != nullptr) {
+ sp<Layer> strongRelative = mCurrentState.zOrderRelativeOf.promote();
if (strongRelative != nullptr) {
strongRelative->removeZOrderRelative(this);
}
- mState.current.zOrderRelativeOf = nullptr;
+ mCurrentState.zOrderRelativeOf = nullptr;
}
setTransactionFlags(eTransactionNeeded);
return true;
}
void Layer::removeZOrderRelative(const wp<Layer>& relative) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.zOrderRelatives.remove(relative);
- mState.current.sequence++;
- mState.current.modified = true;
+ mCurrentState.zOrderRelatives.remove(relative);
+ mCurrentState.sequence++;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
}
void Layer::addZOrderRelative(const wp<Layer>& relative) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.zOrderRelatives.add(relative);
- mState.current.modified = true;
- mState.current.sequence++;
+ mCurrentState.zOrderRelatives.add(relative);
+ mCurrentState.modified = true;
+ mCurrentState.sequence++;
setTransactionFlags(eTransactionNeeded);
}
bool Layer::setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
- Mutex::Autolock lock(mStateMutex);
sp<Handle> handle = static_cast<Handle*>(relativeToHandle.get());
if (handle == nullptr) {
return false;
@@ -1233,20 +1187,20 @@
return false;
}
- if (mState.current.z == relativeZ && usingRelativeZLocked(LayerVector::StateSet::Current) &&
- mState.current.zOrderRelativeOf == relative) {
+ if (mCurrentState.z == relativeZ && usingRelativeZ(LayerVector::StateSet::Current) &&
+ mCurrentState.zOrderRelativeOf == relative) {
return false;
}
- mState.current.sequence++;
- mState.current.modified = true;
- mState.current.z = relativeZ;
+ mCurrentState.sequence++;
+ mCurrentState.modified = true;
+ mCurrentState.z = relativeZ;
- auto oldZOrderRelativeOf = mState.current.zOrderRelativeOf.promote();
+ auto oldZOrderRelativeOf = mCurrentState.zOrderRelativeOf.promote();
if (oldZOrderRelativeOf != nullptr) {
oldZOrderRelativeOf->removeZOrderRelative(this);
}
- mState.current.zOrderRelativeOf = relative;
+ mCurrentState.zOrderRelativeOf = relative;
relative->addZOrderRelative(this);
setTransactionFlags(eTransactionNeeded);
@@ -1255,51 +1209,47 @@
}
bool Layer::setSize(uint32_t w, uint32_t h) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.requested_legacy.w == w && mState.current.requested_legacy.h == h)
+ if (mCurrentState.requested_legacy.w == w && mCurrentState.requested_legacy.h == h)
return false;
- mState.current.requested_legacy.w = w;
- mState.current.requested_legacy.h = h;
- mState.current.modified = true;
+ mCurrentState.requested_legacy.w = w;
+ mCurrentState.requested_legacy.h = h;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
// record the new size, from this point on, when the client request
// a buffer, it'll get the new size.
- setDefaultBufferSize(mState.current.requested_legacy.w, mState.current.requested_legacy.h);
+ setDefaultBufferSize(mCurrentState.requested_legacy.w, mCurrentState.requested_legacy.h);
return true;
}
bool Layer::setAlpha(float alpha) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.color.a == alpha) return false;
- mState.current.sequence++;
- mState.current.color.a = alpha;
- mState.current.modified = true;
+ if (mCurrentState.color.a == alpha) return false;
+ mCurrentState.sequence++;
+ mCurrentState.color.a = alpha;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setColor(const half3& color) {
- Mutex::Autolock lock(mStateMutex);
- if (color.r == mState.current.color.r && color.g == mState.current.color.g &&
- color.b == mState.current.color.b)
+ if (color.r == mCurrentState.color.r && color.g == mCurrentState.color.g &&
+ color.b == mCurrentState.color.b)
return false;
- mState.current.sequence++;
- mState.current.color.r = color.r;
- mState.current.color.g = color.g;
- mState.current.color.b = color.b;
- mState.current.modified = true;
+ mCurrentState.sequence++;
+ mCurrentState.color.r = color.r;
+ mCurrentState.color.g = color.g;
+ mCurrentState.color.b = color.b;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setCornerRadius(float cornerRadius) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.cornerRadius == cornerRadius) return false;
+ if (mCurrentState.cornerRadius == cornerRadius) return false;
- mState.current.sequence++;
- mState.current.cornerRadius = cornerRadius;
- mState.current.modified = true;
+ mCurrentState.sequence++;
+ mCurrentState.cornerRadius = cornerRadius;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
@@ -1313,50 +1263,45 @@
ALOGW("Attempt to set rotation matrix without permission ACCESS_SURFACE_FLINGER ignored");
return false;
}
- Mutex::Autolock lock(mStateMutex);
- mState.current.sequence++;
- mState.current.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx,
- matrix.dsdy);
- mState.current.modified = true;
+ mCurrentState.sequence++;
+ mCurrentState.requested_legacy.transform.set(matrix.dsdx, matrix.dtdy, matrix.dtdx,
+ matrix.dsdy);
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setTransparentRegionHint(const Region& transparent) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.requestedTransparentRegion_legacy = transparent;
- mState.current.modified = true;
+ mCurrentState.requestedTransparentRegion_legacy = transparent;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setFlags(uint8_t flags, uint8_t mask) {
- Mutex::Autolock lock(mStateMutex);
- const uint32_t newFlags = (mState.current.flags & ~mask) | (flags & mask);
- if (mState.current.flags == newFlags) return false;
- mState.current.sequence++;
- mState.current.flags = newFlags;
- mState.current.modified = true;
+ const uint32_t newFlags = (mCurrentState.flags & ~mask) | (flags & mask);
+ if (mCurrentState.flags == newFlags) return false;
+ mCurrentState.sequence++;
+ mCurrentState.flags = newFlags;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setCrop_legacy(const Rect& crop, bool immediate) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.requestedCrop_legacy == crop) return false;
- mState.current.sequence++;
- mState.current.requestedCrop_legacy = crop;
+ if (mCurrentState.requestedCrop_legacy == crop) return false;
+ mCurrentState.sequence++;
+ mCurrentState.requestedCrop_legacy = crop;
if (immediate && !mFreezeGeometryUpdates) {
- mState.current.crop_legacy = crop;
+ mCurrentState.crop_legacy = crop;
}
mFreezeGeometryUpdates = mFreezeGeometryUpdates || !immediate;
- mState.current.modified = true;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
bool Layer::setOverrideScalingMode(int32_t scalingMode) {
- Mutex::Autolock lock(mStateMutex);
if (scalingMode == mOverrideScalingMode) return false;
mOverrideScalingMode = scalingMode;
setTransactionFlags(eTransactionNeeded);
@@ -1364,29 +1309,22 @@
}
void Layer::setInfo(int32_t type, int32_t appId) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.appId = appId;
- mState.current.type = type;
- mState.current.modified = true;
+ mCurrentState.appId = appId;
+ mCurrentState.type = type;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
}
bool Layer::setLayerStack(uint32_t layerStack) {
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.layerStack == layerStack) return false;
- mState.current.sequence++;
- mState.current.layerStack = layerStack;
- mState.current.modified = true;
+ if (mCurrentState.layerStack == layerStack) return false;
+ mCurrentState.sequence++;
+ mCurrentState.layerStack = layerStack;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
uint32_t Layer::getLayerStack() const {
- Mutex::Autolock lock(mStateMutex);
- return getLayerStackLocked();
-}
-
-uint32_t Layer::getLayerStackLocked() const {
auto p = mDrawingParent.promote();
if (p == nullptr) {
return getDrawingState().layerStack;
@@ -1395,16 +1333,15 @@
}
void Layer::deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.barrierLayer_legacy = barrierLayer;
- mState.current.frameNumber_legacy = frameNumber;
+ mCurrentState.barrierLayer_legacy = barrierLayer;
+ mCurrentState.frameNumber_legacy = frameNumber;
// We don't set eTransactionNeeded, because just receiving a deferral
// request without any other state updates shouldn't actually induce a delay
- mState.current.modified = true;
- pushPendingStateLocked();
- mState.current.barrierLayer_legacy = nullptr;
- mState.current.frameNumber_legacy = 0;
- mState.current.modified = false;
+ mCurrentState.modified = true;
+ pushPendingState();
+ mCurrentState.barrierLayer_legacy = nullptr;
+ mCurrentState.frameNumber_legacy = 0;
+ mCurrentState.modified = false;
}
void Layer::deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle, uint64_t frameNumber) {
@@ -1417,8 +1354,7 @@
// ----------------------------------------------------------------------------
bool Layer::isHiddenByPolicy() const {
- Mutex::Autolock lock(mStateMutex);
- const State& s(mState.drawing);
+ const State& s(mDrawingState);
const auto& parent = mDrawingParent.promote();
if (parent != nullptr && parent->isHiddenByPolicy()) {
return true;
@@ -1463,7 +1399,6 @@
// TODO(marissaw): add new layer state info to layer debugging
LayerDebugInfo Layer::getLayerDebugInfo() const {
- Mutex::Autolock lock(mStateMutex);
LayerDebugInfo info;
const State& ds = getDrawingState();
info.mName = getName();
@@ -1473,7 +1408,7 @@
info.mTransparentRegion = ds.activeTransparentRegion_legacy;
info.mVisibleRegion = visibleRegion;
info.mSurfaceDamageRegion = surfaceDamageRegion;
- info.mLayerStack = getLayerStackLocked();
+ info.mLayerStack = getLayerStack();
info.mX = ds.active_legacy.transform.tx();
info.mY = ds.active_legacy.transform.ty();
info.mZ = ds.z;
@@ -1509,13 +1444,6 @@
return info;
}
-std::tuple<uint32_t, int32_t> Layer::getLayerStackAndZ(StateSet stateSet) {
- Mutex::Autolock lock(mStateMutex);
- const State& state = (stateSet == StateSet::Current) ? mState.current : mState.drawing;
-
- return {state.layerStack, state.z};
-}
-
void Layer::miniDumpHeader(std::string& result) {
result.append("-------------------------------");
result.append("-------------------------------");
@@ -1532,7 +1460,6 @@
}
void Layer::miniDump(std::string& result, DisplayId displayId) const {
- Mutex::Autolock lock(mStateMutex);
if (!hasHwcLayer(displayId)) {
return;
}
@@ -1661,7 +1588,6 @@
}
if (attachChildren()) {
- Mutex::Autolock lock(mStateMutex);
setTransactionFlags(eTransactionNeeded);
}
for (const sp<Layer>& child : mCurrentChildren) {
@@ -1700,7 +1626,6 @@
addToCurrentState();
}
- Mutex::Autolock lock(mStateMutex);
if (mLayerDetached) {
mLayerDetached = false;
setTransactionFlags(eTransactionNeeded);
@@ -1744,24 +1669,18 @@
bool Layer::setColorTransform(const mat4& matrix) {
static const mat4 identityMatrix = mat4();
- Mutex::Autolock lock(mStateMutex);
- if (mState.current.colorTransform == matrix) {
+ if (mCurrentState.colorTransform == matrix) {
return false;
}
- ++mState.current.sequence;
- mState.current.colorTransform = matrix;
- mState.current.hasColorTransform = matrix != identityMatrix;
- mState.current.modified = true;
+ ++mCurrentState.sequence;
+ mCurrentState.colorTransform = matrix;
+ mCurrentState.hasColorTransform = matrix != identityMatrix;
+ mCurrentState.modified = true;
setTransactionFlags(eTransactionNeeded);
return true;
}
mat4 Layer::getColorTransform() const {
- Mutex::Autolock lock(mStateMutex);
- return getColorTransformLocked();
-}
-
-mat4 Layer::getColorTransformLocked() const {
mat4 colorTransform = mat4(getDrawingState().colorTransform);
if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
colorTransform = parent->getColorTransform() * colorTransform;
@@ -1770,7 +1689,6 @@
}
bool Layer::hasColorTransform() const {
- Mutex::Autolock lock(mStateMutex);
bool hasColorTransform = getDrawingState().hasColorTransform;
if (sp<Layer> parent = mDrawingParent.promote(); parent != nullptr) {
hasColorTransform = hasColorTransform || parent->hasColorTransform();
@@ -1801,18 +1719,12 @@
}
int32_t Layer::getZ() const {
- Mutex::Autolock lock(mStateMutex);
- return mState.drawing.z;
+ return mDrawingState.z;
}
bool Layer::usingRelativeZ(LayerVector::StateSet stateSet) {
- Mutex::Autolock lock(mStateMutex);
- return usingRelativeZLocked(stateSet);
-}
-
-bool Layer::usingRelativeZLocked(LayerVector::StateSet stateSet) {
const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
- const State& state = useDrawing ? mState.drawing : mState.current;
+ const State& state = useDrawing ? mDrawingState : mCurrentState;
return state.zOrderRelativeOf != nullptr;
}
@@ -1822,7 +1734,7 @@
"makeTraversalList received invalid stateSet");
const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
- const State& state = useDrawing ? mState.drawing : mState.current;
+ const State& state = useDrawing ? mDrawingState : mCurrentState;
if (state.zOrderRelatives.size() == 0) {
*outSkipRelativeZUsers = true;
@@ -1838,7 +1750,7 @@
}
for (const sp<Layer>& child : children) {
- const State& childState = useDrawing ? child->mState.drawing : child->mState.current;
+ const State& childState = useDrawing ? child->mDrawingState : child->mCurrentState;
if (childState.zOrderRelativeOf != nullptr) {
continue;
}
@@ -1877,6 +1789,7 @@
visitor(this);
for (; i < list.size(); i++) {
const auto& relative = list[i];
+
if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
continue;
}
@@ -1924,7 +1837,7 @@
"makeTraversalList received invalid stateSet");
const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
- const State& state = useDrawing ? mState.drawing : mState.current;
+ const State& state = useDrawing ? mDrawingState : mCurrentState;
LayerVector traverse(stateSet);
for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
@@ -1937,7 +1850,7 @@
}
for (const sp<Layer>& child : children) {
- const State& childState = useDrawing ? child->mState.drawing : child->mState.current;
+ const State& childState = useDrawing ? child->mDrawingState : child->mCurrentState;
// If a layer has a relativeOf layer, only ignore if the layer it's relative to is a
// descendent of the top most parent of the tree. If it's not a descendent, then just add
// the child here since it won't be added later as a relative.
@@ -1994,16 +1907,10 @@
}
ui::Transform Layer::getTransform() const {
- Mutex::Autolock lock(mStateMutex);
- return getTransformLocked();
-}
-
-ui::Transform Layer::getTransformLocked() const {
ui::Transform t;
const auto& p = mDrawingParent.promote();
if (p != nullptr) {
- Mutex::Autolock lock(p->mStateMutex);
- t = p->getTransformLocked();
+ t = p->getTransform();
// If the parent is not using NATIVE_WINDOW_SCALING_MODE_FREEZE (e.g.
// it isFixedSize) then there may be additional scaling not accounted
@@ -2031,27 +1938,18 @@
}
half Layer::getAlpha() const {
- Mutex::Autolock lock(mStateMutex);
- return getAlphaLocked();
-}
-
-half Layer::getAlphaLocked() const {
const auto& p = mDrawingParent.promote();
+
half parentAlpha = (p != nullptr) ? p->getAlpha() : 1.0_hf;
return parentAlpha * getDrawingState().color.a;
}
half4 Layer::getColor() const {
const half4 color(getDrawingState().color);
- return half4(color.r, color.g, color.b, getAlphaLocked());
+ return half4(color.r, color.g, color.b, getAlpha());
}
Layer::RoundedCornerState Layer::getRoundedCornerState() const {
- Mutex::Autolock lock(mStateMutex);
- return getRoundedCornerStateLocked();
-}
-
-Layer::RoundedCornerState Layer::getRoundedCornerStateLocked() const {
const auto& p = mDrawingParent.promote();
if (p != nullptr) {
RoundedCornerState parentState = p->getRoundedCornerState();
@@ -2068,7 +1966,7 @@
}
}
const float radius = getDrawingState().cornerRadius;
- return radius > 0 ? RoundedCornerState(computeBoundsLocked(), radius) : RoundedCornerState();
+ return radius > 0 ? RoundedCornerState(computeBounds(), radius) : RoundedCornerState();
}
void Layer::commitChildList() {
@@ -2081,21 +1979,19 @@
}
void Layer::setInputInfo(const InputWindowInfo& info) {
- Mutex::Autolock lock(mStateMutex);
- mState.current.inputInfo = info;
- mState.current.modified = true;
- mState.current.inputInfoChanged = true;
+ mCurrentState.inputInfo = info;
+ mCurrentState.modified = true;
+ mCurrentState.inputInfoChanged = true;
setTransactionFlags(eTransactionNeeded);
}
void Layer::writeToProto(LayerProto* layerInfo, LayerVector::StateSet stateSet) {
- Mutex::Autolock lock(mStateMutex);
const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
- const State& state = useDrawing ? mState.drawing : mState.current;
+ const State& state = useDrawing ? mDrawingState : mCurrentState;
ui::Transform requestedTransform = state.active_legacy.transform;
- ui::Transform transform = getTransformLocked();
+ ui::Transform transform = getTransform();
layerInfo->set_id(sequence);
layerInfo->set_name(getName().c_str());
@@ -2117,7 +2013,7 @@
LayerProtoHelper::writeToProto(visibleRegion, layerInfo->mutable_visible_region());
LayerProtoHelper::writeToProto(surfaceDamageRegion, layerInfo->mutable_damage_region());
- layerInfo->set_layer_stack(getLayerStackLocked());
+ layerInfo->set_layer_stack(getLayerStack());
layerInfo->set_z(state.z);
PositionProto* position = layerInfo->mutable_position();
@@ -2133,7 +2029,7 @@
size->set_h(state.active_legacy.h);
LayerProtoHelper::writeToProto(state.crop_legacy, layerInfo->mutable_crop());
- layerInfo->set_corner_radius(getRoundedCornerStateLocked().radius);
+ layerInfo->set_corner_radius(getRoundedCornerState().radius);
layerInfo->set_is_opaque(isOpaque(state));
layerInfo->set_invalidate(contentDirty);
@@ -2174,7 +2070,7 @@
layerInfo->set_curr_frame(mCurrentFrameNumber);
layerInfo->set_effective_scaling_mode(getEffectiveScalingMode());
- for (const auto& pendingState : mState.pending) {
+ for (const auto& pendingState : mPendingStates) {
auto barrierLayer = pendingState.barrierLayer_legacy.promote();
if (barrierLayer != nullptr) {
BarrierLayerProto* barrierLayerProto = layerInfo->add_barrier_layer();
@@ -2218,25 +2114,19 @@
}
InputWindowInfo Layer::fillInputInfo(const Rect& screenBounds) {
- InputWindowInfo info;
- ui::Transform t;
- Rect layerBounds;
- {
- Mutex::Autolock lock(mStateMutex);
- info = mState.drawing.inputInfo;
- t = getTransformLocked();
- const float xScale = t.sx();
- const float yScale = t.sy();
- if (xScale != 1.0f || yScale != 1.0f) {
- info.windowXScale *= 1.0f / xScale;
- info.windowYScale *= 1.0f / yScale;
- info.touchableRegion.scaleSelf(xScale, yScale);
- }
+ InputWindowInfo info = mDrawingState.inputInfo;
- // Transform layer size to screen space and inset it by surface insets.
- layerBounds = getCroppedBufferSize(getDrawingState());
+ ui::Transform t = getTransform();
+ const float xScale = t.sx();
+ const float yScale = t.sy();
+ if (xScale != 1.0f || yScale != 1.0f) {
+ info.windowXScale *= 1.0f / xScale;
+ info.windowYScale *= 1.0f / yScale;
+ info.touchableRegion.scaleSelf(xScale, yScale);
}
+ // Transform layer size to screen space and inset it by surface insets.
+ Rect layerBounds = getCroppedBufferSize(getDrawingState());
layerBounds = t.transform(layerBounds);
layerBounds.inset(info.surfaceInset, info.surfaceInset, info.surfaceInset, info.surfaceInset);
@@ -2259,8 +2149,7 @@
}
bool Layer::hasInput() const {
- Mutex::Autolock lock(mStateMutex);
- return mState.drawing.inputInfo.token != nullptr;
+ return mDrawingState.inputInfo.token != nullptr;
}
// ---------------------------------------------------------------------------
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index fb75e4c..2e75088 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -55,7 +55,6 @@
#include "RenderArea.h"
using namespace android::surfaceflinger;
-using StateSet = android::LayerVector::StateSet;
namespace android {
@@ -240,7 +239,7 @@
// also the rendered size of the layer prior to any transformations. Parent
// or local matrix transformations will not affect the size of the buffer,
// but may affect it's on-screen size or clipping.
- virtual bool setSize(uint32_t w, uint32_t h) EXCLUDES(mStateMutex);
+ virtual bool setSize(uint32_t w, uint32_t h);
// Set a 2x2 transformation matrix on the layer. This transform
// will be applied after parent transforms, but before any final
// producer specified transform.
@@ -255,76 +254,58 @@
// setPosition operates in parent buffer space (pre parent-transform) or display
// space for top-level layers.
- virtual bool setPosition(float x, float y, bool immediate) EXCLUDES(mStateMutex);
+ virtual bool setPosition(float x, float y, bool immediate);
// Buffer space
- virtual bool setCrop_legacy(const Rect& crop, bool immediate) EXCLUDES(mStateMutex);
+ virtual bool setCrop_legacy(const Rect& crop, bool immediate);
// TODO(b/38182121): Could we eliminate the various latching modes by
// using the layer hierarchy?
// -----------------------------------------------------------------------
- virtual bool setLayer(int32_t z) EXCLUDES(mStateMutex);
- virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ)
- EXCLUDES(mStateMutex);
+ virtual bool setLayer(int32_t z);
+ virtual bool setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ);
- virtual bool setAlpha(float alpha) EXCLUDES(mStateMutex);
- virtual bool setColor(const half3& color) EXCLUDES(mStateMutex);
+ virtual bool setAlpha(float alpha);
+ virtual bool setColor(const half3& color);
// Set rounded corner radius for this layer and its children.
//
// We only support 1 radius per layer in the hierarchy, where parent layers have precedence.
// The shape of the rounded corner rectangle is specified by the crop rectangle of the layer
// from which we inferred the rounded corner radius.
- virtual bool setCornerRadius(float cornerRadius) EXCLUDES(mStateMutex);
- virtual bool setTransparentRegionHint(const Region& transparent) EXCLUDES(mStateMutex);
- virtual bool setFlags(uint8_t flags, uint8_t mask) EXCLUDES(mStateMutex);
- virtual bool setLayerStack(uint32_t layerStack) EXCLUDES(mStateMutex);
- virtual uint32_t getLayerStack() const EXCLUDES(mStateMutex);
+ virtual bool setCornerRadius(float cornerRadius);
+ virtual bool setTransparentRegionHint(const Region& transparent);
+ virtual bool setFlags(uint8_t flags, uint8_t mask);
+ virtual bool setLayerStack(uint32_t layerStack);
+ virtual uint32_t getLayerStack() const;
virtual void deferTransactionUntil_legacy(const sp<IBinder>& barrierHandle,
uint64_t frameNumber);
- virtual void deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber)
- EXCLUDES(mStateMutex);
- virtual bool setOverrideScalingMode(int32_t overrideScalingMode) EXCLUDES(mStateMutex);
- virtual void setInfo(int32_t type, int32_t appId) EXCLUDES(mStateMutex);
- virtual bool reparentChildren(const sp<IBinder>& layer) EXCLUDES(mStateMutex);
+ virtual void deferTransactionUntil_legacy(const sp<Layer>& barrierLayer, uint64_t frameNumber);
+ virtual bool setOverrideScalingMode(int32_t overrideScalingMode);
+ virtual void setInfo(int32_t type, int32_t appId);
+ virtual bool reparentChildren(const sp<IBinder>& layer);
virtual void setChildrenDrawingParent(const sp<Layer>& layer);
- virtual bool reparent(const sp<IBinder>& newParentHandle) EXCLUDES(mStateMutex);
+ virtual bool reparent(const sp<IBinder>& newParentHandle);
virtual bool detachChildren();
bool attachChildren();
bool isLayerDetached() const { return mLayerDetached; }
- virtual bool setColorTransform(const mat4& matrix) EXCLUDES(mStateMutex);
- mat4 getColorTransform() const EXCLUDES(mStateMutex);
- virtual mat4 getColorTransformLocked() const REQUIRES(mStateMutex);
- virtual bool hasColorTransform() const EXCLUDES(mStateMutex);
- ;
+ virtual bool setColorTransform(const mat4& matrix);
+ virtual mat4 getColorTransform() const;
+ virtual bool hasColorTransform() const;
// Used only to set BufferStateLayer state
- virtual bool setTransform(uint32_t /*transform*/) EXCLUDES(mStateMutex) { return false; };
- virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/)
- EXCLUDES(mStateMutex) {
- return false;
- };
- virtual bool setCrop(const Rect& /*crop*/) EXCLUDES(mStateMutex) { return false; };
- virtual bool setFrame(const Rect& /*frame*/) EXCLUDES(mStateMutex) { return false; };
- virtual bool setBuffer(const sp<GraphicBuffer>& /*buffer*/) EXCLUDES(mStateMutex) {
- return false;
- };
- virtual bool setAcquireFence(const sp<Fence>& /*fence*/) EXCLUDES(mStateMutex) {
- return false;
- };
- virtual bool setDataspace(ui::Dataspace /*dataspace*/) EXCLUDES(mStateMutex) { return false; };
- virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) EXCLUDES(mStateMutex) {
- return false;
- };
- virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) EXCLUDES(mStateMutex) {
- return false;
- };
- virtual bool setApi(int32_t /*api*/) EXCLUDES(mStateMutex) { return false; };
- virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/)
- EXCLUDES(mStateMutex) {
- return false;
- };
+ virtual bool setTransform(uint32_t /*transform*/) { return false; };
+ virtual bool setTransformToDisplayInverse(bool /*transformToDisplayInverse*/) { return false; };
+ virtual bool setCrop(const Rect& /*crop*/) { return false; };
+ virtual bool setFrame(const Rect& /*frame*/) { return false; };
+ virtual bool setBuffer(const sp<GraphicBuffer>& /*buffer*/) { return false; };
+ virtual bool setAcquireFence(const sp<Fence>& /*fence*/) { return false; };
+ virtual bool setDataspace(ui::Dataspace /*dataspace*/) { return false; };
+ virtual bool setHdrMetadata(const HdrMetadata& /*hdrMetadata*/) { return false; };
+ virtual bool setSurfaceDamageRegion(const Region& /*surfaceDamage*/) { return false; };
+ virtual bool setApi(int32_t /*api*/) { return false; };
+ virtual bool setSidebandStream(const sp<NativeHandle>& /*sidebandStream*/) { return false; };
virtual bool setTransactionCompletedListeners(
- const std::vector<sp<CallbackHandle>>& /*handles*/) EXCLUDES(mStateMutex) {
+ const std::vector<sp<CallbackHandle>>& /*handles*/) {
return false;
};
@@ -343,21 +324,18 @@
virtual void useSurfaceDamage() {}
virtual void useEmptyDamage() {}
- uint32_t getTransactionFlags() const EXCLUDES(mStateMutex);
- uint32_t getTransactionFlags(uint32_t flags) EXCLUDES(mStateMutex);
- uint32_t setTransactionFlags(uint32_t flags) REQUIRES(mStateMutex);
+ uint32_t getTransactionFlags() const { return mTransactionFlags; }
+ uint32_t getTransactionFlags(uint32_t flags);
+ uint32_t setTransactionFlags(uint32_t flags);
- bool belongsToDisplay(uint32_t layerStack, bool isPrimaryDisplay) const EXCLUDES(mStateMutex) {
+ bool belongsToDisplay(uint32_t layerStack, bool isPrimaryDisplay) const {
return getLayerStack() == layerStack && (!mPrimaryDisplayOnly || isPrimaryDisplay);
}
void computeGeometry(const RenderArea& renderArea, renderengine::Mesh& mesh,
- bool useIdentityTransform) const REQUIRES(mStateMutex);
- FloatRect computeBounds(const Region& activeTransparentRegion) const EXCLUDES(mStateMutex);
- FloatRect computeBoundsLocked(const Region& activeTransparentRegion) const
- REQUIRES(mStateMutex);
- FloatRect computeBounds() const EXCLUDES(mStateMutex);
- FloatRect computeBoundsLocked() const REQUIRES(mStateMutex);
+ bool useIdentityTransform) const;
+ FloatRect computeBounds(const Region& activeTransparentRegion) const;
+ FloatRect computeBounds() const;
int32_t getSequence() const { return sequence; }
@@ -374,21 +352,16 @@
*/
virtual bool isOpaque(const Layer::State&) const { return false; }
- virtual bool isDrawingOpaque() const EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- return isOpaque(mState.drawing);
- }
-
/*
* isSecure - true if this surface is secure, that is if it prevents
* screenshots or VNC servers.
*/
- bool isSecure() const EXCLUDES(mStateMutex);
+ bool isSecure() const;
/*
* isVisible - true if this layer is visible, false otherwise
*/
- virtual bool isVisible() const EXCLUDES(mStateMutex) = 0;
+ virtual bool isVisible() const = 0;
/*
* isHiddenByPolicy - true if this layer has been forced invisible.
@@ -396,7 +369,7 @@
* For example if this layer has no active buffer, it may not be hidden by
* policy, but it still can not be visible.
*/
- bool isHiddenByPolicy() const EXCLUDES(mStateMutex);
+ bool isHiddenByPolicy() const;
/*
* isProtected - true if the layer may contain protected content in the
@@ -417,8 +390,7 @@
bool isRemovedFromCurrentState() const;
void writeToProto(LayerProto* layerInfo,
- LayerVector::StateSet stateSet = LayerVector::StateSet::Drawing)
- EXCLUDES(mStateMutex);
+ LayerVector::StateSet stateSet = LayerVector::StateSet::Drawing);
void writeToProto(LayerProto* layerInfo, DisplayId displayId);
@@ -431,32 +403,25 @@
virtual Region getActiveTransparentRegion(const Layer::State& s) const {
return s.activeTransparentRegion_legacy;
}
-
- virtual Region getDrawingActiveTransparentRegion() const EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- return getActiveTransparentRegion(mState.drawing);
- }
-
virtual Rect getCrop(const Layer::State& s) const { return s.crop_legacy; }
protected:
/*
* onDraw - draws the surface.
*/
- virtual void onDraw(const RenderArea& renderArea, const Region& clip, bool useIdentityTransform)
- EXCLUDES(mStateMutex) = 0;
+ virtual void onDraw(const RenderArea& renderArea, const Region& clip,
+ bool useIdentityTransform) = 0;
public:
virtual void setDefaultBufferSize(uint32_t /*w*/, uint32_t /*h*/) {}
virtual bool isHdrY410() const { return false; }
- void setGeometry(const sp<const DisplayDevice>& display, uint32_t z) EXCLUDES(mStateMutex);
+ void setGeometry(const sp<const DisplayDevice>& display, uint32_t z);
void forceClientComposition(DisplayId displayId);
bool getForceClientComposition(DisplayId displayId);
virtual void setPerFrameData(DisplayId displayId, const ui::Transform& transform,
- const Rect& viewport, int32_t supportedPerFrameMetadata)
- EXCLUDES(mStateMutex) = 0;
+ const Rect& viewport, int32_t supportedPerFrameMetadata) = 0;
// callIntoHwc exists so we can update our local state and call
// acceptDisplayChanges without unnecessarily updating the device's state
@@ -464,7 +429,7 @@
HWC2::Composition getCompositionType(const std::optional<DisplayId>& displayId) const;
void setClearClientTarget(DisplayId displayId, bool clear);
bool getClearClientTarget(DisplayId displayId) const;
- void updateCursorPosition(const sp<const DisplayDevice>& display) EXCLUDES(mStateMutex);
+ void updateCursorPosition(const sp<const DisplayDevice>& display);
/*
* called after page-flip
@@ -487,8 +452,7 @@
virtual bool onPostComposition(const std::optional<DisplayId>& /*displayId*/,
const std::shared_ptr<FenceTime>& /*glDoneFence*/,
const std::shared_ptr<FenceTime>& /*presentFence*/,
- const CompositorTiming& /*compositorTiming*/)
- EXCLUDES(mStateMutex) {
+ const CompositorTiming& /*compositorTiming*/) {
return false;
}
@@ -500,14 +464,14 @@
* draw - performs some global clipping optimizations
* and calls onDraw().
*/
- void draw(const RenderArea& renderArea, const Region& clip) EXCLUDES(mStateMutex);
- void draw(const RenderArea& renderArea, bool useIdentityTransform) EXCLUDES(mStateMutex);
+ void draw(const RenderArea& renderArea, const Region& clip);
+ void draw(const RenderArea& renderArea, bool useIdentityTransform);
/*
* doTransaction - process the transaction. This is a good place to figure
* out which attributes of the surface have changed.
*/
- uint32_t doTransaction(uint32_t transactionFlags) EXCLUDES(mStateMutex);
+ uint32_t doTransaction(uint32_t transactionFlags);
/*
* setVisibleRegion - called to set the new visible region. This gives
@@ -540,17 +504,17 @@
* to figure out if the content or size of a surface has changed.
*/
virtual Region latchBuffer(bool& /*recomputeVisibleRegions*/, nsecs_t /*latchTime*/,
- const sp<Fence>& /*releaseFence*/) EXCLUDES(mStateMutex) {
+ const sp<Fence>& /*releaseFence*/) {
return {};
}
virtual bool isBufferLatched() const { return false; }
/*
- * called with SurfaceFlinger mStateLock a binder thread when the layer is
+ * called with the state lock from a binder thread when the layer is
* removed from the current list to the pending removal list
*/
- void onRemovedFromCurrentState() EXCLUDES(mStateMutex);
+ void onRemovedFromCurrentState();
/*
* Called when the layer is added back to the current state list.
@@ -570,7 +534,7 @@
/*
* Returns if a frame is ready
*/
- virtual bool hasReadyFrame() const EXCLUDES(mStateMutex) { return false; }
+ virtual bool hasReadyFrame() const { return false; }
virtual int32_t getQueuedFrameCount() const { return 0; }
@@ -599,32 +563,17 @@
}
// -----------------------------------------------------------------------
- void clearWithOpenGL(const RenderArea& renderArea) const EXCLUDES(mStateMutex);
+ void clearWithOpenGL(const RenderArea& renderArea) const;
- inline const State& getDrawingState() const REQUIRES(mStateMutex) { return mState.drawing; }
+ inline const State& getDrawingState() const { return mDrawingState; }
+ inline const State& getCurrentState() const { return mCurrentState; }
+ inline State& getCurrentState() { return mCurrentState; }
- inline const State& getCurrentState() const REQUIRES(mStateMutex) { return mState.current; }
-
- inline State& getCurrentState() REQUIRES(mStateMutex) { return mState.current; }
-
- std::tuple<uint32_t, int32_t> getLayerStackAndZ(StateSet stateSet) EXCLUDES(mStateMutex);
- wp<Layer> getZOrderRelativeOf(StateSet stateSet) EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- const State& state = (stateSet == StateSet::Current) ? mState.current : mState.drawing;
-
- return state.zOrderRelativeOf;
- }
-
- uint8_t getCurrentFlags() EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- return mState.current.flags;
- }
-
- LayerDebugInfo getLayerDebugInfo() const EXCLUDES(mStateMutex);
+ LayerDebugInfo getLayerDebugInfo() const;
/* always call base class first */
static void miniDumpHeader(std::string& result);
- void miniDump(std::string& result, DisplayId displayId) const EXCLUDES(mStateMutex);
+ void miniDump(std::string& result, DisplayId displayId) const;
void dumpFrameStats(std::string& result) const;
void dumpFrameEvents(std::string& result);
void clearFrameStats();
@@ -639,29 +588,22 @@
void addAndGetFrameTimestamps(const NewFrameEventsEntry* newEntry,
FrameEventHistoryDelta* outDelta);
- bool getTransformToDisplayInverse() const EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- return getTransformToDisplayInverseLocked();
- }
+ virtual bool getTransformToDisplayInverse() const { return false; }
- virtual bool getTransformToDisplayInverseLocked() const REQUIRES(mStateMutex) { return false; }
-
- ui::Transform getTransform() const EXCLUDES(mStateMutex);
- ui::Transform getTransformLocked() const REQUIRES(mStateMutex);
+ ui::Transform getTransform() const;
// Returns the Alpha of the Surface, accounting for the Alpha
// of parent Surfaces in the hierarchy (alpha's will be multiplied
// down the hierarchy).
- half getAlpha() const EXCLUDES(mStateMutex);
- half4 getColor() const REQUIRES(mStateMutex);
+ half getAlpha() const;
+ half4 getColor() const;
// Returns how rounded corners should be drawn for this layer.
// This will traverse the hierarchy until it reaches its root, finding topmost rounded
// corner definition and converting it into current layer's coordinates.
// As of now, only 1 corner radius per display list is supported. Subsequent ones will be
// ignored.
- RoundedCornerState getRoundedCornerState() const EXCLUDES(mStateMutex);
- RoundedCornerState getRoundedCornerStateLocked() const REQUIRES(mStateMutex);
+ RoundedCornerState getRoundedCornerState() const;
void traverseInReverseZOrder(LayerVector::StateSet stateSet,
const LayerVector::Visitor& visitor);
@@ -681,7 +623,7 @@
ssize_t removeChild(const sp<Layer>& layer);
sp<Layer> getParent() const { return mCurrentParent.promote(); }
bool hasParent() const { return getParent() != nullptr; }
- Rect computeScreenBounds(bool reduceTransparentRegion = true) const EXCLUDES(mStateMutex);
+ Rect computeScreenBounds(bool reduceTransparentRegion = true) const;
bool setChildLayer(const sp<Layer>& childLayer, int32_t z);
bool setChildRelativeLayer(const sp<Layer>& childLayer,
const sp<IBinder>& relativeToHandle, int32_t relativeZ);
@@ -689,23 +631,14 @@
// Copy the current list of children to the drawing state. Called by
// SurfaceFlinger to complete a transaction.
void commitChildList();
- int32_t getZ() const EXCLUDES(mStateMutex);
- void pushPendingState() EXCLUDES(mStateMutex);
- virtual void pushPendingStateLocked() REQUIRES(mStateMutex);
+ int32_t getZ() const;
+ virtual void pushPendingState();
/**
* Returns active buffer size in the correct orientation. Buffer size is determined by undoing
* any buffer transformations. If the layer has no buffer then return INVALID_RECT.
*/
- virtual Rect getBufferSize(const Layer::State&) const REQUIRES(mStateMutex) {
- return Rect::INVALID_RECT;
- }
-
- virtual Rect getBufferSize(StateSet stateSet) const EXCLUDES(mStateMutex) {
- Mutex::Autolock lock(mStateMutex);
- const State& state = (stateSet == StateSet::Current) ? mState.current : mState.drawing;
- return getBufferSize(state);
- }
+ virtual Rect getBufferSize(const Layer::State&) const { return Rect::INVALID_RECT; }
protected:
// constant
@@ -734,17 +667,16 @@
// For unit tests
friend class TestableSurfaceFlinger;
- void commitTransaction(const State& stateToCommit) REQUIRES(mStateMutex);
+ void commitTransaction(const State& stateToCommit);
uint32_t getEffectiveUsage(uint32_t usage) const;
- virtual FloatRect computeCrop(const sp<const DisplayDevice>& display) const
- REQUIRES(mStateMutex);
+ virtual FloatRect computeCrop(const sp<const DisplayDevice>& display) const;
// Compute the initial crop as specified by parent layers and the
// SurfaceControl for this layer. Does not include buffer crop from the
// IGraphicBufferProducer client, as that should not affect child clipping.
// Returns in screen space.
- Rect computeInitialCrop(const sp<const DisplayDevice>& display) const REQUIRES(mStateMutex);
+ Rect computeInitialCrop(const sp<const DisplayDevice>& display) const;
/**
* Setup rounded corners coordinates of this layer, taking into account the layer bounds and
* crop coordinates, transforming them into layer space.
@@ -752,13 +684,13 @@
void setupRoundedCornersCropCoordinates(Rect win, const FloatRect& roundedCornersCrop) const;
// drawing
- void clearWithOpenGL(const RenderArea& renderArea, float r, float g, float b, float alpha) const
- EXCLUDES(mStateMutex);
+ void clearWithOpenGL(const RenderArea& renderArea, float r, float g, float b,
+ float alpha) const;
void setParent(const sp<Layer>& layer);
LayerVector makeTraversalList(LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers);
- void addZOrderRelative(const wp<Layer>& relative) EXCLUDES(mStateMutex);
- void removeZOrderRelative(const wp<Layer>& relative) EXCLUDES(mStateMutex);
+ void addZOrderRelative(const wp<Layer>& relative);
+ void removeZOrderRelative(const wp<Layer>& relative);
class SyncPoint {
public:
@@ -794,10 +726,9 @@
// Returns false if the relevant frame has already been latched
bool addSyncPoint(const std::shared_ptr<SyncPoint>& point);
- void popPendingState(State* stateToCommit) REQUIRES(mStateMutex);
- virtual bool applyPendingStates(State* stateToCommit) REQUIRES(mStateMutex);
- virtual uint32_t doTransactionResize(uint32_t flags, Layer::State* stateToCommit)
- REQUIRES(mStateMutex);
+ void popPendingState(State* stateToCommit);
+ virtual bool applyPendingStates(State* stateToCommit);
+ virtual uint32_t doTransactionResize(uint32_t flags, Layer::State* stateToCommit);
void clearSyncPoints();
@@ -830,15 +761,14 @@
bool getPremultipledAlpha() const;
bool mPendingHWCDestroy{false};
- void setInputInfo(const InputWindowInfo& info) EXCLUDES(mStateMutex);
+ void setInputInfo(const InputWindowInfo& info);
- InputWindowInfo fillInputInfo(const Rect& screenBounds) EXCLUDES(mStateMutex);
- bool hasInput() const EXCLUDES(mStateMutex);
+ InputWindowInfo fillInputInfo(const Rect& screenBounds);
+ bool hasInput() const;
protected:
// -----------------------------------------------------------------------
- bool usingRelativeZ(LayerVector::StateSet stateSet) EXCLUDES(mStateMutex);
- bool usingRelativeZLocked(LayerVector::StateSet stateSet) REQUIRES(mStateMutex);
+ bool usingRelativeZ(LayerVector::StateSet stateSet);
bool mPremultipliedAlpha{true};
String8 mName;
@@ -846,14 +776,14 @@
bool mPrimaryDisplayOnly = false;
+ // these are protected by an external lock
+ State mCurrentState;
+ State mDrawingState;
+ std::atomic<uint32_t> mTransactionFlags{0};
+
// Accessed from main thread and binder threads
- mutable Mutex mStateMutex;
- struct {
- State current;
- State drawing;
- uint32_t transactionFlags{0};
- Vector<State> pending;
- } mState GUARDED_BY(mStateMutex);
+ Mutex mPendingStateMutex;
+ Vector<State> mPendingStates;
// Timestamp history for UIAutomation. Thread safe.
FrameTracker mFrameTracker;
@@ -926,7 +856,7 @@
* The cropped bounds must be transformed back from parent layer space to child layer space by
* applying the inverse of the child's transformation.
*/
- FloatRect cropChildBounds(const FloatRect& childBounds) const REQUIRES(mStateMutex);
+ FloatRect cropChildBounds(const FloatRect& childBounds) const;
/**
* Returns the cropped buffer size or the layer crop if the layer has no buffer. Return
@@ -934,12 +864,7 @@
* A layer with an invalid buffer size and no crop is considered to be boundless. The layer
* bounds are constrained by its parent bounds.
*/
- Rect getCroppedBufferSize(const Layer::State& s) const REQUIRES(mStateMutex);
-
- // locked version of public methods
- bool isSecureLocked() const REQUIRES(mStateMutex);
- virtual uint32_t getLayerStackLocked() const REQUIRES(mStateMutex);
- half getAlphaLocked() const REQUIRES(mStateMutex);
+ Rect getCroppedBufferSize(const Layer::State& s) const;
};
} // namespace android
diff --git a/services/surfaceflinger/LayerVector.cpp b/services/surfaceflinger/LayerVector.cpp
index a7db23e..8494524 100644
--- a/services/surfaceflinger/LayerVector.cpp
+++ b/services/surfaceflinger/LayerVector.cpp
@@ -38,12 +38,18 @@
const auto& l = *reinterpret_cast<const sp<Layer>*>(lhs);
const auto& r = *reinterpret_cast<const sp<Layer>*>(rhs);
- const auto& [ls, lz] = l->getLayerStackAndZ(mStateSet);
- const auto& [rs, rz] = r->getLayerStackAndZ(mStateSet);
+ const auto& lState =
+ (mStateSet == StateSet::Current) ? l->getCurrentState() : l->getDrawingState();
+ const auto& rState =
+ (mStateSet == StateSet::Current) ? r->getCurrentState() : r->getDrawingState();
+ uint32_t ls = lState.layerStack;
+ uint32_t rs = rState.layerStack;
if (ls != rs)
return (ls > rs) ? 1 : -1;
+ int32_t lz = lState.z;
+ int32_t rz = rState.z;
if (lz != rz)
return (lz > rz) ? 1 : -1;
@@ -56,8 +62,9 @@
void LayerVector::traverseInZOrder(StateSet stateSet, const Visitor& visitor) const {
for (size_t i = 0; i < size(); i++) {
const auto& layer = (*this)[i];
- auto zOrderRelativeOf = layer->getZOrderRelativeOf(stateSet);
- if (zOrderRelativeOf != nullptr) {
+ auto& state = (stateSet == StateSet::Current) ? layer->getCurrentState()
+ : layer->getDrawingState();
+ if (state.zOrderRelativeOf != nullptr) {
continue;
}
layer->traverseInZOrder(stateSet, visitor);
@@ -67,8 +74,9 @@
void LayerVector::traverseInReverseZOrder(StateSet stateSet, const Visitor& visitor) const {
for (auto i = static_cast<int64_t>(size()) - 1; i >= 0; i--) {
const auto& layer = (*this)[i];
- auto zOrderRelativeOf = layer->getZOrderRelativeOf(stateSet);
- if (zOrderRelativeOf != nullptr) {
+ auto& state = (stateSet == StateSet::Current) ? layer->getCurrentState()
+ : layer->getDrawingState();
+ if (state.zOrderRelativeOf != nullptr) {
continue;
}
layer->traverseInReverseZOrder(stateSet, visitor);
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 1b31674..fd25abf 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -2836,6 +2836,9 @@
outDirtyRegion.clear();
mDrawingState.traverseInReverseZOrder([&](Layer* layer) {
+ // start with the whole surface at its current location
+ const Layer::State& s(layer->getDrawingState());
+
// only consider the layers on the given layer stack
if (!layer->belongsToDisplay(display->getLayerStack(), display->isPrimary())) {
return;
@@ -2873,7 +2876,7 @@
// handle hidden surfaces by setting the visible region to empty
if (CC_LIKELY(layer->isVisible())) {
- const bool translucent = !layer->isDrawingOpaque();
+ const bool translucent = !layer->isOpaque(s);
Rect bounds(layer->computeScreenBounds());
visibleRegion.set(bounds);
@@ -2883,8 +2886,7 @@
if (translucent) {
if (tr.preserveRects()) {
// transform the transparent region
- transparentRegion =
- tr.transform(layer->getDrawingActiveTransparentRegion());
+ transparentRegion = tr.transform(layer->getActiveTransparentRegion(s));
} else {
// transformation too complex, can't do the
// transparent region optimization.
@@ -3183,8 +3185,9 @@
case HWC2::Composition::Sideband:
case HWC2::Composition::SolidColor: {
LOG_ALWAYS_FATAL_IF(!displayId);
+ const Layer::State& state(layer->getDrawingState());
if (layer->getClearClientTarget(*displayId) && !firstLayer &&
- layer->isDrawingOpaque() && (layer->getAlpha() == 1.0f) &&
+ layer->isOpaque(state) && (layer->getAlpha() == 1.0f) &&
layer->getRoundedCornerState().radius == 0.0f && hasClientComposition) {
// never clear the very first layer since we're
// guaranteed the FB is already cleared
@@ -5268,12 +5271,15 @@
mFlinger(flinger),
mChildrenOnly(childrenOnly) {}
const ui::Transform& getTransform() const override { return mTransform; }
- Rect getBounds() const override { return mLayer->getBufferSize(StateSet::Drawing); }
+ Rect getBounds() const override {
+ const Layer::State& layerState(mLayer->getDrawingState());
+ return mLayer->getBufferSize(layerState);
+ }
int getHeight() const override {
- return mLayer->getBufferSize(StateSet::Drawing).getHeight();
+ return mLayer->getBufferSize(mLayer->getDrawingState()).getHeight();
}
int getWidth() const override {
- return mLayer->getBufferSize(StateSet::Drawing).getWidth();
+ return mLayer->getBufferSize(mLayer->getDrawingState()).getWidth();
}
bool isSecure() const override { return false; }
bool needsFiltering() const override { return mNeedsFiltering; }
@@ -5340,7 +5346,7 @@
const int uid = IPCThreadState::self()->getCallingUid();
const bool forSystem = uid == AID_GRAPHICS || uid == AID_SYSTEM;
- if (!forSystem && parent->getCurrentFlags() & layer_state_t::eLayerSecure) {
+ if (!forSystem && parent->getCurrentState().flags & layer_state_t::eLayerSecure) {
ALOGW("Attempting to capture secure layer: PERMISSION_DENIED");
return PERMISSION_DENIED;
}
@@ -5348,12 +5354,12 @@
Rect crop(sourceCrop);
if (sourceCrop.width() <= 0) {
crop.left = 0;
- crop.right = parent->getBufferSize(StateSet::Current).getWidth();
+ crop.right = parent->getBufferSize(parent->getCurrentState()).getWidth();
}
if (sourceCrop.height() <= 0) {
crop.top = 0;
- crop.bottom = parent->getBufferSize(StateSet::Current).getHeight();
+ crop.bottom = parent->getBufferSize(parent->getCurrentState()).getHeight();
}
int32_t reqWidth = crop.width() * frameScale;
diff --git a/services/surfaceflinger/SurfaceInterceptor.cpp b/services/surfaceflinger/SurfaceInterceptor.cpp
index a6dcb7e..7bfe033 100644
--- a/services/surfaceflinger/SurfaceInterceptor.cpp
+++ b/services/surfaceflinger/SurfaceInterceptor.cpp
@@ -101,23 +101,22 @@
transaction->set_animation(layerFlags & BnSurfaceComposer::eAnimation);
const int32_t layerId(getLayerId(layer));
- Mutex::Autolock lock(layer->mStateMutex);
- addPositionLocked(transaction, layerId, layer->mState.current.active_legacy.transform.tx(),
- layer->mState.current.active_legacy.transform.ty());
- addDepthLocked(transaction, layerId, layer->mState.current.z);
- addAlphaLocked(transaction, layerId, layer->mState.current.color.a);
+ addPositionLocked(transaction, layerId, layer->mCurrentState.active_legacy.transform.tx(),
+ layer->mCurrentState.active_legacy.transform.ty());
+ addDepthLocked(transaction, layerId, layer->mCurrentState.z);
+ addAlphaLocked(transaction, layerId, layer->mCurrentState.color.a);
addTransparentRegionLocked(transaction, layerId,
- layer->mState.current.activeTransparentRegion_legacy);
- addLayerStackLocked(transaction, layerId, layer->mState.current.layerStack);
- addCropLocked(transaction, layerId, layer->mState.current.crop_legacy);
- addCornerRadiusLocked(transaction, layerId, layer->mState.current.cornerRadius);
- if (layer->mState.current.barrierLayer_legacy != nullptr) {
+ layer->mCurrentState.activeTransparentRegion_legacy);
+ addLayerStackLocked(transaction, layerId, layer->mCurrentState.layerStack);
+ addCropLocked(transaction, layerId, layer->mCurrentState.crop_legacy);
+ addCornerRadiusLocked(transaction, layerId, layer->mCurrentState.cornerRadius);
+ if (layer->mCurrentState.barrierLayer_legacy != nullptr) {
addDeferTransactionLocked(transaction, layerId,
- layer->mState.current.barrierLayer_legacy.promote(),
- layer->mState.current.frameNumber_legacy);
+ layer->mCurrentState.barrierLayer_legacy.promote(),
+ layer->mCurrentState.frameNumber_legacy);
}
addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode());
- addFlagsLocked(transaction, layerId, layer->mState.current.flags);
+ addFlagsLocked(transaction, layerId, layer->mCurrentState.flags);
}
void SurfaceInterceptor::addInitialDisplayStateLocked(Increment* increment,
@@ -427,9 +426,8 @@
SurfaceCreation* creation(increment->mutable_surface_creation());
creation->set_id(getLayerId(layer));
creation->set_name(getLayerName(layer));
- Mutex::Autolock lock(layer->mStateMutex);
- creation->set_w(layer->mState.current.active_legacy.w);
- creation->set_h(layer->mState.current.active_legacy.h);
+ creation->set_w(layer->mCurrentState.active_legacy.w);
+ creation->set_h(layer->mCurrentState.active_legacy.h);
}
void SurfaceInterceptor::addSurfaceDeletionLocked(Increment* increment,
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 4da08b8..8d58627 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -178,12 +178,11 @@
using HotplugEvent = SurfaceFlinger::HotplugEvent;
- auto& mutableLayerCurrentState(sp<Layer> layer) { return layer->mState.current; }
- auto& mutableLayerDrawingState(sp<Layer> layer) { return layer->mState.drawing; }
+ auto& mutableLayerCurrentState(sp<Layer> layer) { return layer->mCurrentState; }
+ auto& mutableLayerDrawingState(sp<Layer> layer) { return layer->mDrawingState; }
void setLayerSidebandStream(sp<Layer> layer, sp<NativeHandle> sidebandStream) {
- Mutex::Autolock lock(layer->mStateMutex);
- layer->mState.drawing.sidebandStream = sidebandStream;
+ layer->mDrawingState.sidebandStream = sidebandStream;
layer->getBE().compositionInfo.hwc.sidebandStream = sidebandStream;
}