diff options
19 files changed, 1066 insertions, 1410 deletions
diff --git a/cmds/flatland/GLHelper.cpp b/cmds/flatland/GLHelper.cpp index dfc3e581fd..d5b3372f96 100644 --- a/cmds/flatland/GLHelper.cpp +++ b/cmds/flatland/GLHelper.cpp @@ -269,24 +269,10 @@ bool GLHelper::createWindowSurface(uint32_t w, uint32_t h, return false; } - SurfaceComposerClient::openGlobalTransaction(); - err = sc->setLayer(0x7FFFFFFF); - if (err != NO_ERROR) { - fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err); - return false; - } - err = sc->setMatrix(scale, 0.0f, 0.0f, scale); - if (err != NO_ERROR) { - fprintf(stderr, "SurfaceComposer::setMatrix error: %#x\n", err); - return false; - } - - err = sc->show(); - if (err != NO_ERROR) { - fprintf(stderr, "SurfaceComposer::show error: %#x\n", err); - return false; - } - SurfaceComposerClient::closeGlobalTransaction(); + SurfaceComposerClient::Transaction{}.setLayer(sc, 0x7FFFFFFF) + .setMatrix(sc, scale, 0.0f, 0.0f, scale) + .show(sc) + .apply(); sp<ANativeWindow> anw = sc->getSurface(); EGLSurface s = eglCreateWindowSurface(mDisplay, mConfig, anw.get(), NULL); diff --git a/cmds/surfacereplayer/replayer/Replayer.cpp b/cmds/surfacereplayer/replayer/Replayer.cpp index 2b5389b8dc..4140f40888 100644 --- a/cmds/surfacereplayer/replayer/Replayer.cpp +++ b/cmds/surfacereplayer/replayer/Replayer.cpp @@ -24,9 +24,9 @@ #include <gui/BufferQueue.h> #include <gui/ISurfaceComposer.h> +#include <gui/LayerState.h> #include <gui/Surface.h> #include <private/gui/ComposerService.h> -#include <private/gui/LayerState.h> #include <ui/DisplayInfo.h> #include <utils/Log.h> @@ -338,27 +338,29 @@ status_t Replayer::dispatchEvent(int index) { status_t Replayer::doTransaction(const Transaction& t, const std::shared_ptr<Event>& event) { ALOGV("Started Transaction"); - SurfaceComposerClient::openGlobalTransaction(); + SurfaceComposerClient::Transaction liveTransaction; status_t status = NO_ERROR; - status = doSurfaceTransaction(t.surface_change()); - doDisplayTransaction(t.display_change()); + status = doSurfaceTransaction(liveTransaction, t.surface_change()); + doDisplayTransaction(liveTransaction, t.display_change()); if (t.animation()) { - SurfaceComposerClient::setAnimationTransaction(); + liveTransaction.setAnimationTransaction(); } event->readyToExecute(); - SurfaceComposerClient::closeGlobalTransaction(t.synchronous()); + liveTransaction.apply(t.synchronous()); ALOGV("Ended Transaction"); return status; } -status_t Replayer::doSurfaceTransaction(const SurfaceChanges& surfaceChanges) { +status_t Replayer::doSurfaceTransaction( + SurfaceComposerClient::Transaction& transaction, + const SurfaceChanges& surfaceChanges) { status_t status = NO_ERROR; for (const SurfaceChange& change : surfaceChanges) { @@ -369,62 +371,66 @@ status_t Replayer::doSurfaceTransaction(const SurfaceChanges& surfaceChanges) { switch (change.SurfaceChange_case()) { case SurfaceChange::SurfaceChangeCase::kPosition: - status = setPosition(change.id(), change.position()); + setPosition(transaction, change.id(), change.position()); break; case SurfaceChange::SurfaceChangeCase::kSize: - status = setSize(change.id(), change.size()); + setSize(transaction, change.id(), change.size()); break; case SurfaceChange::SurfaceChangeCase::kAlpha: - status = setAlpha(change.id(), change.alpha()); + setAlpha(transaction, change.id(), change.alpha()); break; case SurfaceChange::SurfaceChangeCase::kLayer: - status = setLayer(change.id(), change.layer()); + setLayer(transaction, change.id(), change.layer()); break; case SurfaceChange::SurfaceChangeCase::kCrop: - status = setCrop(change.id(), change.crop()); + setCrop(transaction, change.id(), change.crop()); break; case SurfaceChange::SurfaceChangeCase::kMatrix: - status = setMatrix(change.id(), change.matrix()); + setMatrix(transaction, change.id(), change.matrix()); break; case SurfaceChange::SurfaceChangeCase::kFinalCrop: - status = setFinalCrop(change.id(), change.final_crop()); + setFinalCrop(transaction, change.id(), change.final_crop()); break; case SurfaceChange::SurfaceChangeCase::kOverrideScalingMode: - status = setOverrideScalingMode(change.id(), change.override_scaling_mode()); + setOverrideScalingMode(transaction, change.id(), + change.override_scaling_mode()); break; case SurfaceChange::SurfaceChangeCase::kTransparentRegionHint: - status = setTransparentRegionHint(change.id(), change.transparent_region_hint()); + setTransparentRegionHint(transaction, change.id(), + change.transparent_region_hint()); break; case SurfaceChange::SurfaceChangeCase::kLayerStack: - status = setLayerStack(change.id(), change.layer_stack()); + setLayerStack(transaction, change.id(), change.layer_stack()); break; case SurfaceChange::SurfaceChangeCase::kHiddenFlag: - status = setHiddenFlag(change.id(), change.hidden_flag()); + setHiddenFlag(transaction, change.id(), change.hidden_flag()); break; case SurfaceChange::SurfaceChangeCase::kOpaqueFlag: - status = setOpaqueFlag(change.id(), change.opaque_flag()); + setOpaqueFlag(transaction, change.id(), change.opaque_flag()); break; case SurfaceChange::SurfaceChangeCase::kSecureFlag: - status = setSecureFlag(change.id(), change.secure_flag()); + setSecureFlag(transaction, change.id(), change.secure_flag()); break; case SurfaceChange::SurfaceChangeCase::kDeferredTransaction: waitUntilDeferredTransactionLayerExists(change.deferred_transaction(), lock); - status = setDeferredTransaction(change.id(), change.deferred_transaction()); + setDeferredTransaction(transaction, change.id(), + change.deferred_transaction()); break; default: - status = NO_ERROR; + status = 1; break; } if (status != NO_ERROR) { - ALOGE("SET TRANSACTION FAILED"); + ALOGE("Unknown Transaction Code"); return status; } } return status; } -void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { +void Replayer::doDisplayTransaction(SurfaceComposerClient::Transaction& t, + const DisplayChanges& displayChanges) { for (const DisplayChange& change : displayChanges) { ALOGV("Doing display transaction"); std::unique_lock<std::mutex> lock(mDisplayLock); @@ -434,16 +440,16 @@ void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { switch (change.DisplayChange_case()) { case DisplayChange::DisplayChangeCase::kSurface: - setDisplaySurface(change.id(), change.surface()); + setDisplaySurface(t, change.id(), change.surface()); break; case DisplayChange::DisplayChangeCase::kLayerStack: - setDisplayLayerStack(change.id(), change.layer_stack()); + setDisplayLayerStack(t, change.id(), change.layer_stack()); break; case DisplayChange::DisplayChangeCase::kSize: - setDisplaySize(change.id(), change.size()); + setDisplaySize(t, change.id(), change.size()); break; case DisplayChange::DisplayChangeCase::kProjection: - setDisplayProjection(change.id(), change.projection()); + setDisplayProjection(t, change.id(), change.projection()); break; default: break; @@ -451,57 +457,66 @@ void Replayer::doDisplayTransaction(const DisplayChanges& displayChanges) { } } -status_t Replayer::setPosition(layer_id id, const PositionChange& pc) { +void Replayer::setPosition(SurfaceComposerClient::Transaction& t, + layer_id id, const PositionChange& pc) { ALOGV("Layer %d: Setting Position -- x=%f, y=%f", id, pc.x(), pc.y()); - return mLayers[id]->setPosition(pc.x(), pc.y()); + t.setPosition(mLayers[id], pc.x(), pc.y()); } -status_t Replayer::setSize(layer_id id, const SizeChange& sc) { +void Replayer::setSize(SurfaceComposerClient::Transaction& t, + layer_id id, const SizeChange& sc) { ALOGV("Layer %d: Setting Size -- w=%u, h=%u", id, sc.w(), sc.h()); - return mLayers[id]->setSize(sc.w(), sc.h()); + t.setSize(mLayers[id], sc.w(), sc.h()); } -status_t Replayer::setLayer(layer_id id, const LayerChange& lc) { +void Replayer::setLayer(SurfaceComposerClient::Transaction& t, + layer_id id, const LayerChange& lc) { ALOGV("Layer %d: Setting Layer -- layer=%d", id, lc.layer()); - return mLayers[id]->setLayer(lc.layer()); + t.setLayer(mLayers[id], lc.layer()); } -status_t Replayer::setAlpha(layer_id id, const AlphaChange& ac) { +void Replayer::setAlpha(SurfaceComposerClient::Transaction& t, + layer_id id, const AlphaChange& ac) { ALOGV("Layer %d: Setting Alpha -- alpha=%f", id, ac.alpha()); - return mLayers[id]->setAlpha(ac.alpha()); + t.setAlpha(mLayers[id], ac.alpha()); } -status_t Replayer::setCrop(layer_id id, const CropChange& cc) { +void Replayer::setCrop(SurfaceComposerClient::Transaction& t, + layer_id id, const CropChange& cc) { ALOGV("Layer %d: Setting Crop -- left=%d, top=%d, right=%d, bottom=%d", id, cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(), cc.rectangle().bottom()); Rect r = Rect(cc.rectangle().left(), cc.rectangle().top(), cc.rectangle().right(), cc.rectangle().bottom()); - return mLayers[id]->setCrop(r); + t.setCrop(mLayers[id], r); } -status_t Replayer::setFinalCrop(layer_id id, const FinalCropChange& fcc) { +void Replayer::setFinalCrop(SurfaceComposerClient::Transaction& t, + layer_id id, const FinalCropChange& fcc) { ALOGV("Layer %d: Setting Final Crop -- left=%d, top=%d, right=%d, bottom=%d", id, fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(), fcc.rectangle().bottom()); Rect r = Rect(fcc.rectangle().left(), fcc.rectangle().top(), fcc.rectangle().right(), fcc.rectangle().bottom()); - return mLayers[id]->setFinalCrop(r); + t.setFinalCrop(mLayers[id], r); } -status_t Replayer::setMatrix(layer_id id, const MatrixChange& mc) { +void Replayer::setMatrix(SurfaceComposerClient::Transaction& t, + layer_id id, const MatrixChange& mc) { ALOGV("Layer %d: Setting Matrix -- dsdx=%f, dtdx=%f, dsdy=%f, dtdy=%f", id, mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy()); - return mLayers[id]->setMatrix(mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy()); + t.setMatrix(mLayers[id], mc.dsdx(), mc.dtdx(), mc.dsdy(), mc.dtdy()); } -status_t Replayer::setOverrideScalingMode(layer_id id, const OverrideScalingModeChange& osmc) { +void Replayer::setOverrideScalingMode(SurfaceComposerClient::Transaction& t, + layer_id id, const OverrideScalingModeChange& osmc) { ALOGV("Layer %d: Setting Override Scaling Mode -- mode=%d", id, osmc.override_scaling_mode()); - return mLayers[id]->setOverrideScalingMode(osmc.override_scaling_mode()); + t.setOverrideScalingMode(mLayers[id], osmc.override_scaling_mode()); } -status_t Replayer::setTransparentRegionHint(layer_id id, const TransparentRegionHintChange& trhc) { +void Replayer::setTransparentRegionHint(SurfaceComposerClient::Transaction& t, + layer_id id, const TransparentRegionHintChange& trhc) { ALOGV("Setting Transparent Region Hint"); Region re = Region(); @@ -510,71 +525,80 @@ status_t Replayer::setTransparentRegionHint(layer_id id, const TransparentRegion re.merge(rect); } - return mLayers[id]->setTransparentRegionHint(re); + t.setTransparentRegionHint(mLayers[id], re); } -status_t Replayer::setLayerStack(layer_id id, const LayerStackChange& lsc) { +void Replayer::setLayerStack(SurfaceComposerClient::Transaction& t, + layer_id id, const LayerStackChange& lsc) { ALOGV("Layer %d: Setting LayerStack -- layer_stack=%d", id, lsc.layer_stack()); - return mLayers[id]->setLayerStack(lsc.layer_stack()); + t.setLayerStack(mLayers[id], lsc.layer_stack()); } -status_t Replayer::setHiddenFlag(layer_id id, const HiddenFlagChange& hfc) { +void Replayer::setHiddenFlag(SurfaceComposerClient::Transaction& t, + layer_id id, const HiddenFlagChange& hfc) { ALOGV("Layer %d: Setting Hidden Flag -- hidden_flag=%d", id, hfc.hidden_flag()); layer_id flag = hfc.hidden_flag() ? layer_state_t::eLayerHidden : 0; - return mLayers[id]->setFlags(flag, layer_state_t::eLayerHidden); + t.setFlags(mLayers[id], flag, layer_state_t::eLayerHidden); } -status_t Replayer::setOpaqueFlag(layer_id id, const OpaqueFlagChange& ofc) { +void Replayer::setOpaqueFlag(SurfaceComposerClient::Transaction& t, + layer_id id, const OpaqueFlagChange& ofc) { ALOGV("Layer %d: Setting Opaque Flag -- opaque_flag=%d", id, ofc.opaque_flag()); layer_id flag = ofc.opaque_flag() ? layer_state_t::eLayerOpaque : 0; - return mLayers[id]->setFlags(flag, layer_state_t::eLayerOpaque); + t.setFlags(mLayers[id], flag, layer_state_t::eLayerOpaque); } -status_t Replayer::setSecureFlag(layer_id id, const SecureFlagChange& sfc) { +void Replayer::setSecureFlag(SurfaceComposerClient::Transaction& t, + layer_id id, const SecureFlagChange& sfc) { ALOGV("Layer %d: Setting Secure Flag -- secure_flag=%d", id, sfc.secure_flag()); layer_id flag = sfc.secure_flag() ? layer_state_t::eLayerSecure : 0; - return mLayers[id]->setFlags(flag, layer_state_t::eLayerSecure); + t.setFlags(mLayers[id], flag, layer_state_t::eLayerSecure); } -status_t Replayer::setDeferredTransaction(layer_id id, const DeferredTransactionChange& dtc) { +void Replayer::setDeferredTransaction(SurfaceComposerClient::Transaction& t, + layer_id id, const DeferredTransactionChange& dtc) { ALOGV("Layer %d: Setting Deferred Transaction -- layer_id=%d, " "frame_number=%llu", id, dtc.layer_id(), dtc.frame_number()); if (mLayers.count(dtc.layer_id()) == 0 || mLayers[dtc.layer_id()] == nullptr) { ALOGE("Layer %d not found in Deferred Transaction", dtc.layer_id()); - return BAD_VALUE; + return; } auto handle = mLayers[dtc.layer_id()]->getHandle(); - return mLayers[id]->deferTransactionUntil(handle, dtc.frame_number()); + t.deferTransactionUntil(mLayers[id], handle, dtc.frame_number()); } -void Replayer::setDisplaySurface(display_id id, const DispSurfaceChange& /*dsc*/) { +void Replayer::setDisplaySurface(SurfaceComposerClient::Transaction& t, + display_id id, const DispSurfaceChange& /*dsc*/) { sp<IGraphicBufferProducer> outProducer; sp<IGraphicBufferConsumer> outConsumer; BufferQueue::createBufferQueue(&outProducer, &outConsumer); - SurfaceComposerClient::setDisplaySurface(mDisplays[id], outProducer); + t.setDisplaySurface(mDisplays[id], outProducer); } -void Replayer::setDisplayLayerStack(display_id id, const LayerStackChange& lsc) { - SurfaceComposerClient::setDisplayLayerStack(mDisplays[id], lsc.layer_stack()); +void Replayer::setDisplayLayerStack(SurfaceComposerClient::Transaction& t, + display_id id, const LayerStackChange& lsc) { + t.setDisplayLayerStack(mDisplays[id], lsc.layer_stack()); } -void Replayer::setDisplaySize(display_id id, const SizeChange& sc) { - SurfaceComposerClient::setDisplaySize(mDisplays[id], sc.w(), sc.h()); +void Replayer::setDisplaySize(SurfaceComposerClient::Transaction& t, + display_id id, const SizeChange& sc) { + t.setDisplaySize(mDisplays[id], sc.w(), sc.h()); } -void Replayer::setDisplayProjection(display_id id, const ProjectionChange& pc) { +void Replayer::setDisplayProjection(SurfaceComposerClient::Transaction& t, + display_id id, const ProjectionChange& pc) { Rect viewport = Rect(pc.viewport().left(), pc.viewport().top(), pc.viewport().right(), pc.viewport().bottom()); Rect frame = Rect(pc.frame().left(), pc.frame().top(), pc.frame().right(), pc.frame().bottom()); - SurfaceComposerClient::setDisplayProjection(mDisplays[id], pc.orientation(), viewport, frame); + t.setDisplayProjection(mDisplays[id], pc.orientation(), viewport, frame); } status_t Replayer::createSurfaceControl( diff --git a/cmds/surfacereplayer/replayer/Replayer.h b/cmds/surfacereplayer/replayer/Replayer.h index f36c9fd4a4..295403eace 100644 --- a/cmds/surfacereplayer/replayer/Replayer.h +++ b/cmds/surfacereplayer/replayer/Replayer.h @@ -77,28 +77,48 @@ class Replayer { void deleteDisplay(const DisplayDeletion& delete_, const std::shared_ptr<Event>& event); void updatePowerMode(const PowerModeUpdate& update, const std::shared_ptr<Event>& event); - status_t doSurfaceTransaction(const SurfaceChanges& surfaceChange); - void doDisplayTransaction(const DisplayChanges& displayChange); - - status_t setPosition(layer_id id, const PositionChange& pc); - status_t setSize(layer_id id, const SizeChange& sc); - status_t setAlpha(layer_id id, const AlphaChange& ac); - status_t setLayer(layer_id id, const LayerChange& lc); - status_t setCrop(layer_id id, const CropChange& cc); - status_t setFinalCrop(layer_id id, const FinalCropChange& fcc); - status_t setMatrix(layer_id id, const MatrixChange& mc); - status_t setOverrideScalingMode(layer_id id, const OverrideScalingModeChange& osmc); - status_t setTransparentRegionHint(layer_id id, const TransparentRegionHintChange& trgc); - status_t setLayerStack(layer_id id, const LayerStackChange& lsc); - status_t setHiddenFlag(layer_id id, const HiddenFlagChange& hfc); - status_t setOpaqueFlag(layer_id id, const OpaqueFlagChange& ofc); - status_t setSecureFlag(layer_id id, const SecureFlagChange& sfc); - status_t setDeferredTransaction(layer_id id, const DeferredTransactionChange& dtc); - - void setDisplaySurface(display_id id, const DispSurfaceChange& dsc); - void setDisplayLayerStack(display_id id, const LayerStackChange& lsc); - void setDisplaySize(display_id id, const SizeChange& sc); - void setDisplayProjection(display_id id, const ProjectionChange& pc); + status_t doSurfaceTransaction(SurfaceComposerClient::Transaction& transaction, + const SurfaceChanges& surfaceChange); + void doDisplayTransaction(SurfaceComposerClient::Transaction& transaction, + const DisplayChanges& displayChange); + + void setPosition(SurfaceComposerClient::Transaction& t, + layer_id id, const PositionChange& pc); + void setSize(SurfaceComposerClient::Transaction& t, + layer_id id, const SizeChange& sc); + void setAlpha(SurfaceComposerClient::Transaction& t, + layer_id id, const AlphaChange& ac); + void setLayer(SurfaceComposerClient::Transaction& t, + layer_id id, const LayerChange& lc); + void setCrop(SurfaceComposerClient::Transaction& t, + layer_id id, const CropChange& cc); + void setFinalCrop(SurfaceComposerClient::Transaction& t, + layer_id id, const FinalCropChange& fcc); + void setMatrix(SurfaceComposerClient::Transaction& t, + layer_id id, const MatrixChange& mc); + void setOverrideScalingMode(SurfaceComposerClient::Transaction& t, + layer_id id, const OverrideScalingModeChange& osmc); + void setTransparentRegionHint(SurfaceComposerClient::Transaction& t, + layer_id id, const TransparentRegionHintChange& trgc); + void setLayerStack(SurfaceComposerClient::Transaction& t, + layer_id id, const LayerStackChange& lsc); + void setHiddenFlag(SurfaceComposerClient::Transaction& t, + layer_id id, const HiddenFlagChange& hfc); + void setOpaqueFlag(SurfaceComposerClient::Transaction& t, + layer_id id, const OpaqueFlagChange& ofc); + void setSecureFlag(SurfaceComposerClient::Transaction& t, + layer_id id, const SecureFlagChange& sfc); + void setDeferredTransaction(SurfaceComposerClient::Transaction& t, + layer_id id, const DeferredTransactionChange& dtc); + + void setDisplaySurface(SurfaceComposerClient::Transaction& t, + display_id id, const DispSurfaceChange& dsc); + void setDisplayLayerStack(SurfaceComposerClient::Transaction& t, + display_id id, const LayerStackChange& lsc); + void setDisplaySize(SurfaceComposerClient::Transaction& t, + display_id id, const SizeChange& sc); + void setDisplayProjection(SurfaceComposerClient::Transaction& t, + display_id id, const ProjectionChange& pc); void doDeleteSurfaceControls(); void waitUntilTimestamp(int64_t timestamp); diff --git a/libs/gui/ISurfaceComposer.cpp b/libs/gui/ISurfaceComposer.cpp index 8e7f814313..96771257c1 100644 --- a/libs/gui/ISurfaceComposer.cpp +++ b/libs/gui/ISurfaceComposer.cpp @@ -29,8 +29,7 @@ #include <gui/ISurfaceComposer.h> #include <gui/ISurfaceComposerClient.h> #include <gui/LayerDebugInfo.h> - -#include <private/gui/LayerState.h> +#include <gui/LayerState.h> #include <system/graphics.h> diff --git a/libs/gui/LayerState.cpp b/libs/gui/LayerState.cpp index fcee73f445..bfc6f28704 100644 --- a/libs/gui/LayerState.cpp +++ b/libs/gui/LayerState.cpp @@ -18,7 +18,7 @@ #include <binder/Parcel.h> #include <gui/ISurfaceComposerClient.h> #include <gui/IGraphicBufferProducer.h> -#include <private/gui/LayerState.h> +#include <gui/LayerState.h> namespace android { diff --git a/libs/gui/SurfaceComposerClient.cpp b/libs/gui/SurfaceComposerClient.cpp index c5a4389ae8..40e319e28a 100644 --- a/libs/gui/SurfaceComposerClient.cpp +++ b/libs/gui/SurfaceComposerClient.cpp @@ -21,7 +21,6 @@ #include <utils/Errors.h> #include <utils/Log.h> -#include <utils/Singleton.h> #include <utils/SortedVector.h> #include <utils/String8.h> #include <utils/threads.h> @@ -37,11 +36,11 @@ #include <gui/IGraphicBufferProducer.h> #include <gui/ISurfaceComposer.h> #include <gui/ISurfaceComposerClient.h> +#include <gui/LayerState.h> #include <gui/Surface.h> #include <gui/SurfaceComposerClient.h> #include <private/gui/ComposerService.h> -#include <private/gui/LayerState.h> namespace android { // --------------------------------------------------------------------------- @@ -97,208 +96,71 @@ void ComposerService::composerServiceDied() // --------------------------------------------------------------------------- -static inline -int compare_type(const ComposerState& lhs, const ComposerState& rhs) { - if (lhs.client < rhs.client) return -1; - if (lhs.client > rhs.client) return 1; - if (lhs.state.surface < rhs.state.surface) return -1; - if (lhs.state.surface > rhs.state.surface) return 1; - return 0; +SurfaceComposerClient::Transaction::Transaction(const Transaction& other) : + mForceSynchronous(other.mForceSynchronous), + mTransactionNestCount(other.mTransactionNestCount), + mAnimation(other.mAnimation) { + mDisplayStates = other.mDisplayStates; + mComposerStates = other.mComposerStates; } -static inline -int compare_type(const DisplayState& lhs, const DisplayState& rhs) { - return compare_type(lhs.token, rhs.token); -} - -class Composer : public Singleton<Composer> -{ - friend class Singleton<Composer>; - - mutable Mutex mLock; - SortedVector<ComposerState> mComposerStates; - SortedVector<DisplayState > mDisplayStates; - uint32_t mForceSynchronous; - uint32_t mTransactionNestCount; - bool mAnimation; - - Composer() : Singleton<Composer>(), - mForceSynchronous(0), mTransactionNestCount(0), - mAnimation(false) - { } - - void openGlobalTransactionImpl(); - void closeGlobalTransactionImpl(bool synchronous); - void setAnimationTransactionImpl(); - status_t enableVSyncInjectionsImpl(bool enable); - status_t injectVSyncImpl(nsecs_t when); - - layer_state_t* getLayerStateLocked( - const sp<SurfaceComposerClient>& client, const sp<IBinder>& id); - - DisplayState& getDisplayStateLocked(const sp<IBinder>& token); - -public: - sp<IBinder> createDisplay(const String8& displayName, bool secure); - void destroyDisplay(const sp<IBinder>& display); - sp<IBinder> getBuiltInDisplay(int32_t id); - - status_t setPosition(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - float x, float y); - status_t setSize(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - uint32_t w, uint32_t h); - status_t setLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - int32_t z); - status_t setRelativeLayer(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - const sp<IBinder>& relativeTo, int32_t z); - status_t setFlags(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - uint32_t flags, uint32_t mask); - status_t setTransparentRegionHint( - const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - const Region& transparentRegion); - status_t setAlpha(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - float alpha); - status_t setColor(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - const half3& color); - status_t setMatrix(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - float dsdx, float dtdx, float dtdy, float dsdy); - status_t setOrientation(int orientation); - status_t setCrop(const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, - const Rect& crop); - status_t setFinalCrop(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const Rect& crop); - status_t setLayerStack(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, uint32_t layerStack); - status_t deferTransactionUntil(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const sp<IBinder>& handle, - uint64_t frameNumber); - status_t deferTransactionUntil(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const sp<Surface>& barrierSurface, - uint64_t frameNumber); - status_t reparentChildren(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, - const sp<IBinder>& newParentHandle); - status_t reparent(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const sp<IBinder>& newParentHandle); - status_t detachChildren(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id); - status_t setOverrideScalingMode(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, int32_t overrideScalingMode); - status_t setGeometryAppliesWithResize(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id); - - status_t setDisplaySurface(const sp<IBinder>& token, - sp<IGraphicBufferProducer> bufferProducer); - void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack); - void setDisplayProjection(const sp<IBinder>& token, - uint32_t orientation, - const Rect& layerStackRect, - const Rect& displayRect); - void setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height); - - static void setAnimationTransaction() { - Composer::getInstance().setAnimationTransactionImpl(); +status_t SurfaceComposerClient::Transaction::apply(bool synchronous) { + if (mStatus != NO_ERROR) { + return mStatus; } - static void openGlobalTransaction() { - Composer::getInstance().openGlobalTransactionImpl(); - } + sp<ISurfaceComposer> sf(ComposerService::getComposerService()); - static void closeGlobalTransaction(bool synchronous) { - Composer::getInstance().closeGlobalTransactionImpl(synchronous); - } + Vector<ComposerState> composerStates; + Vector<DisplayState> displayStates; + uint32_t flags = 0; - static status_t enableVSyncInjections(bool enable) { - return Composer::getInstance().enableVSyncInjectionsImpl(enable); - } + mForceSynchronous |= synchronous; - static status_t injectVSync(nsecs_t when) { - return Composer::getInstance().injectVSyncImpl(when); + composerStates = mComposerStates; + mComposerStates.clear(); + + displayStates = mDisplayStates; + mDisplayStates.clear(); + + if (mForceSynchronous) { + flags |= ISurfaceComposer::eSynchronous; + } + if (mAnimation) { + flags |= ISurfaceComposer::eAnimation; } -}; -ANDROID_SINGLETON_STATIC_INSTANCE(Composer); + mForceSynchronous = false; + mAnimation = false; + + sf->setTransactionState(composerStates, displayStates, flags); + mStatus = NO_ERROR; + return NO_ERROR; +} // --------------------------------------------------------------------------- -sp<IBinder> Composer::createDisplay(const String8& displayName, bool secure) { +sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName, bool secure) { return ComposerService::getComposerService()->createDisplay(displayName, secure); } -void Composer::destroyDisplay(const sp<IBinder>& display) { +void SurfaceComposerClient::destroyDisplay(const sp<IBinder>& display) { return ComposerService::getComposerService()->destroyDisplay(display); } -sp<IBinder> Composer::getBuiltInDisplay(int32_t id) { +sp<IBinder> SurfaceComposerClient::getBuiltInDisplay(int32_t id) { return ComposerService::getComposerService()->getBuiltInDisplay(id); } -void Composer::openGlobalTransactionImpl() { - { // scope for the lock - Mutex::Autolock _l(mLock); - mTransactionNestCount += 1; - } -} - -void Composer::closeGlobalTransactionImpl(bool synchronous) { - sp<ISurfaceComposer> sm(ComposerService::getComposerService()); - - Vector<ComposerState> transaction; - Vector<DisplayState> displayTransaction; - uint32_t flags = 0; - - { // scope for the lock - Mutex::Autolock _l(mLock); - mForceSynchronous |= synchronous; - if (!mTransactionNestCount) { - ALOGW("At least one call to closeGlobalTransaction() was not matched by a prior " - "call to openGlobalTransaction()."); - } else if (--mTransactionNestCount) { - return; - } - - transaction = mComposerStates; - mComposerStates.clear(); - - displayTransaction = mDisplayStates; - mDisplayStates.clear(); - - if (mForceSynchronous) { - flags |= ISurfaceComposer::eSynchronous; - } - if (mAnimation) { - flags |= ISurfaceComposer::eAnimation; - } - - mForceSynchronous = false; - mAnimation = false; - } - - sm->setTransactionState(transaction, displayTransaction, flags); -} - -status_t Composer::enableVSyncInjectionsImpl(bool enable) { - sp<ISurfaceComposer> sm(ComposerService::getComposerService()); - return sm->enableVSyncInjections(enable); -} - -status_t Composer::injectVSyncImpl(nsecs_t when) { - sp<ISurfaceComposer> sm(ComposerService::getComposerService()); - return sm->injectVSync(when); -} - -void Composer::setAnimationTransactionImpl() { - Mutex::Autolock _l(mLock); +void SurfaceComposerClient::Transaction::setAnimationTransaction() { mAnimation = true; } -layer_state_t* Composer::getLayerStateLocked( - const sp<SurfaceComposerClient>& client, const sp<IBinder>& id) { - +layer_state_t* SurfaceComposerClient::Transaction::getLayerStateLocked(const sp<SurfaceControl>& sc) { ComposerState s; - s.client = client->mClient; - s.state.surface = id; + s.client = sc->getClient()->mClient; + s.state.surface = sc->getHandle(); ssize_t index = mComposerStates.indexOf(s); if (index < 0) { @@ -310,24 +172,36 @@ layer_state_t* Composer::getLayerStateLocked( return &(out[index].state); } -status_t Composer::setPosition(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, float x, float y) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setPosition( + const sp<SurfaceControl>& sc, float x, float y) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::ePositionChanged; s->x = x; s->y = y; - return NO_ERROR; + return *this; } -status_t Composer::setSize(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, uint32_t w, uint32_t h) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::show( + const sp<SurfaceControl>& sc) { + return setFlags(sc, 0, layer_state_t::eLayerHidden); +} + +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::hide( + const sp<SurfaceControl>& sc) { + return setFlags(sc, layer_state_t::eLayerHidden, layer_state_t::eLayerHidden); +} + +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setSize( + const sp<SurfaceControl>& sc, uint32_t w, uint32_t h) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eSizeChanged; s->w = w; s->h = h; @@ -335,41 +209,41 @@ status_t Composer::setSize(const sp<SurfaceComposerClient>& client, // Resizing a surface makes the transaction synchronous. mForceSynchronous = true; - return NO_ERROR; + return *this; } -status_t Composer::setLayer(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, int32_t z) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setLayer( + const sp<SurfaceControl>& sc, int32_t z) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eLayerChanged; s->z = z; - return NO_ERROR; + return *this; } -status_t Composer::setRelativeLayer(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const sp<IBinder>& relativeTo, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setRelativeLayer(const sp<SurfaceControl>& sc, const sp<IBinder>& relativeTo, int32_t z) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; } s->what |= layer_state_t::eRelativeLayerChanged; s->relativeLayerHandle = relativeTo; s->z = z; - return NO_ERROR; + return *this; } -status_t Composer::setFlags(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, uint32_t flags, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFlags( + const sp<SurfaceControl>& sc, uint32_t flags, uint32_t mask) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } if ((mask & layer_state_t::eLayerOpaque) || (mask & layer_state_t::eLayerHidden) || (mask & layer_state_t::eLayerSecure)) { @@ -378,61 +252,54 @@ status_t Composer::setFlags(const sp<SurfaceComposerClient>& client, s->flags &= ~mask; s->flags |= (flags & mask); s->mask |= mask; - return NO_ERROR; + return *this; } -status_t Composer::setTransparentRegionHint( - const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setTransparentRegionHint( + const sp<SurfaceControl>& sc, const Region& transparentRegion) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eTransparentRegionChanged; s->transparentRegion = transparentRegion; - return NO_ERROR; + return *this; } -status_t Composer::setAlpha(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, float alpha) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setAlpha( + const sp<SurfaceControl>& sc, float alpha) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eAlphaChanged; s->alpha = alpha; - return NO_ERROR; + return *this; } -status_t Composer::setColor(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const half3& color) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; - s->what |= layer_state_t::eColorChanged; - s->color = color; - return NO_ERROR; -} - -status_t Composer::setLayerStack(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, uint32_t layerStack) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setLayerStack( + const sp<SurfaceControl>& sc, uint32_t layerStack) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eLayerStackChanged; s->layerStack = layerStack; - return NO_ERROR; + return *this; } -status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, float dsdx, float dtdx, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setMatrix( + const sp<SurfaceControl>& sc, float dsdx, float dtdx, float dtdy, float dsdy) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eMatrixChanged; layer_state_t::matrix22_t matrix; matrix.dsdx = dsdx; @@ -440,106 +307,115 @@ status_t Composer::setMatrix(const sp<SurfaceComposerClient>& client, matrix.dsdy = dsdy; matrix.dtdy = dtdy; s->matrix = matrix; - return NO_ERROR; + return *this; } -status_t Composer::setCrop(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const Rect& crop) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); - if (!s) - return BAD_INDEX; +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setCrop( + const sp<SurfaceControl>& sc, const Rect& crop) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } s->what |= layer_state_t::eCropChanged; s->crop = crop; - return NO_ERROR; + return *this; } -status_t Composer::setFinalCrop(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, const Rect& crop) { - Mutex::Autolock _l(mLock); - layer_state_t* s = getLayerStateLocked(client, id); +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setFinalCrop(const sp<SurfaceControl>& sc, const Rect& crop) { + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } s->what |= layer_state_t::eFinalCropChanged; s->finalCrop = crop; - return NO_ERROR; + return *this; } -status_t Composer::deferTransactionUntil( - const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::deferTransactionUntil( + const sp<SurfaceControl>& sc, const sp<IBinder>& handle, uint64_t frameNumber) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } s->what |= layer_state_t::eDeferTransaction; s->barrierHandle = handle; s->frameNumber = frameNumber; - return NO_ERROR; + return *this; } -status_t Composer::deferTransactionUntil( - const sp<SurfaceComposerClient>& client, const sp<IBinder>& id, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::deferTransactionUntil( + const sp<SurfaceControl>& sc, const sp<Surface>& barrierSurface, uint64_t frameNumber) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } s->what |= layer_state_t::eDeferTransaction; s->barrierGbp = barrierSurface->getIGraphicBufferProducer(); s->frameNumber = frameNumber; - return NO_ERROR; + return *this; } -status_t Composer::reparentChildren( - const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::reparentChildren( + const sp<SurfaceControl>& sc, const sp<IBinder>& newParentHandle) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } s->what |= layer_state_t::eReparentChildren; s->reparentHandle = newParentHandle; - return NO_ERROR; + return *this; } -status_t Composer::reparent(const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::reparent( + const sp<SurfaceControl>& sc, const sp<IBinder>& newParentHandle) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } s->what |= layer_state_t::eReparent; s->parentHandleForChild = newParentHandle; - return NO_ERROR; + return *this; +} + +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setColor( + const sp<SurfaceControl>& sc, + const half3& color) { + layer_state_t* s = getLayerStateLocked(sc); + if (!s) { + mStatus = BAD_INDEX; + return *this; + } + s->what |= layer_state_t::eColorChanged; + s->color = color; + return *this; } -status_t Composer::detachChildren( - const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::detachChildren( + const sp<SurfaceControl>& sc) { + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; } s->what |= layer_state_t::eDetachChildren; - return NO_ERROR; + return *this; } -status_t Composer::setOverrideScalingMode( - const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id, int32_t overrideScalingMode) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setOverrideScalingMode( + const sp<SurfaceControl>& sc, int32_t overrideScalingMode) { + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } switch (overrideScalingMode) { @@ -552,29 +428,29 @@ status_t Composer::setOverrideScalingMode( default: ALOGE("unknown scaling mode: %d", overrideScalingMode); - return BAD_VALUE; + mStatus = BAD_VALUE; + return *this; } s->what |= layer_state_t::eOverrideScalingModeChanged; s->overrideScalingMode = overrideScalingMode; - return NO_ERROR; + return *this; } -status_t Composer::setGeometryAppliesWithResize( - const sp<SurfaceComposerClient>& client, - const sp<IBinder>& id) { - Mutex::Autolock lock(mLock); - layer_state_t* s = getLayerStateLocked(client, id); +SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setGeometryAppliesWithResize( + const sp<SurfaceControl>& sc) { + layer_state_t* s = getLayerStateLocked(sc); if (!s) { - return BAD_INDEX; + mStatus = BAD_INDEX; + return *this; } s->what |= layer_state_t::eGeometryAppliesWithResize; - return NO_ERROR; + return *this; } // --------------------------------------------------------------------------- -DisplayState& Composer::getDisplayStateLocked(const sp<IBinder>& token) { +DisplayState& SurfaceComposerClient::Transaction::getDisplayStateLocked(const sp<IBinder>& token) { DisplayState s; s.token = token; ssize_t index = mDisplayStates.indexOf(s); @@ -586,8 +462,8 @@ DisplayState& Composer::getDisplayStateLocked(const sp<IBinder>& token) { return mDisplayStates.editItemAt(static_cast<size_t>(index)); } -status_t Composer::setDisplaySurface(const sp<IBinder>& token, - sp<IGraphicBufferProducer> bufferProducer) { +status_t SurfaceComposerClient::Transaction::setDisplaySurface(const sp<IBinder>& token, + const sp<IGraphicBufferProducer>& bufferProducer) { if (bufferProducer.get() != nullptr) { // Make sure that composition can never be stalled by a virtual display // consumer that isn't processing buffers fast enough. @@ -599,26 +475,23 @@ status_t Composer::setDisplaySurface(const sp<IBinder>& token, return err; } } - Mutex::Autolock _l(mLock); DisplayState& s(getDisplayStateLocked(token)); s.surface = bufferProducer; s.what |= DisplayState::eSurfaceChanged; return NO_ERROR; } -void Composer::setDisplayLayerStack(const sp<IBinder>& token, +void SurfaceComposerClient::Transaction::setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack) { - Mutex::Autolock _l(mLock); DisplayState& s(getDisplayStateLocked(token)); s.layerStack = layerStack; s.what |= DisplayState::eLayerStackChanged; } -void Composer::setDisplayProjection(const sp<IBinder>& token, +void SurfaceComposerClient::Transaction::setDisplayProjection(const sp<IBinder>& token, uint32_t orientation, const Rect& layerStackRect, const Rect& displayRect) { - Mutex::Autolock _l(mLock); DisplayState& s(getDisplayStateLocked(token)); s.orientation = orientation; s.viewport = layerStackRect; @@ -627,8 +500,7 @@ void Composer::setDisplayProjection(const sp<IBinder>& token, mForceSynchronous = true; // TODO: do we actually still need this? } -void Composer::setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height) { - Mutex::Autolock _l(mLock); +void SurfaceComposerClient::Transaction::setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height) { DisplayState& s(getDisplayStateLocked(token)); s.width = width; s.height = height; @@ -638,22 +510,22 @@ void Composer::setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t // --------------------------------------------------------------------------- SurfaceComposerClient::SurfaceComposerClient() - : mStatus(NO_INIT), mComposer(Composer::getInstance()) + : mStatus(NO_INIT) { } SurfaceComposerClient::SurfaceComposerClient(const sp<IGraphicBufferProducer>& root) - : mStatus(NO_INIT), mComposer(Composer::getInstance()), mParent(root) + : mStatus(NO_INIT), mParent(root) { } void SurfaceComposerClient::onFirstRef() { - sp<ISurfaceComposer> sm(ComposerService::getComposerService()); - if (sm != 0) { + sp<ISurfaceComposer> sf(ComposerService::getComposerService()); + if (sf != 0) { auto rootProducer = mParent.promote(); sp<ISurfaceComposerClient> conn; - conn = (rootProducer != nullptr) ? sm->createScopedConnection(rootProducer) : - sm->createConnection(); + conn = (rootProducer != nullptr) ? sf->createScopedConnection(rootProducer) : + sf->createConnection(); if (conn != 0) { mClient = conn; mStatus = NO_ERROR; @@ -676,8 +548,8 @@ sp<IBinder> SurfaceComposerClient::connection() const { status_t SurfaceComposerClient::linkToComposerDeath( const sp<IBinder::DeathRecipient>& recipient, void* cookie, uint32_t flags) { - sp<ISurfaceComposer> sm(ComposerService::getComposerService()); - return IInterface::asBinder(sm)->linkToDeath(recipient, cookie, flags); + sp<ISurfaceComposer> sf(ComposerService::getComposerService()); + return IInterface::asBinder(sf)->linkToDeath(recipient, cookie, flags); } void SurfaceComposerClient::dispose() { @@ -720,19 +592,6 @@ sp<SurfaceControl> SurfaceComposerClient::createSurface( return sur; } -sp<IBinder> SurfaceComposerClient::createDisplay(const String8& displayName, - bool secure) { - return Composer::getInstance().createDisplay(displayName, secure); -} - -void SurfaceComposerClient::destroyDisplay(const sp<IBinder>& display) { - Composer::getInstance().destroyDisplay(display); -} - -sp<IBinder> SurfaceComposerClient::getBuiltInDisplay(int32_t id) { - return Composer::getInstance().getBuiltInDisplay(id); -} - status_t SurfaceComposerClient::destroySurface(const sp<IBinder>& sid) { if (mStatus != NO_ERROR) return mStatus; @@ -755,161 +614,18 @@ status_t SurfaceComposerClient::getLayerFrameStats(const sp<IBinder>& token, return mClient->getLayerFrameStats(token, outStats); } -inline Composer& SurfaceComposerClient::getComposer() { - return mComposer; -} - // ---------------------------------------------------------------------------- -void SurfaceComposerClient::openGlobalTransaction() { - Composer::openGlobalTransaction(); -} - -void SurfaceComposerClient::closeGlobalTransaction(bool synchronous) { - Composer::closeGlobalTransaction(synchronous); -} - -void SurfaceComposerClient::setAnimationTransaction() { - Composer::setAnimationTransaction(); -} - status_t SurfaceComposerClient::enableVSyncInjections(bool enable) { - return Composer::enableVSyncInjections(enable); + sp<ISurfaceComposer> sf(ComposerService::getComposerService()); + return sf->enableVSyncInjections(enable); } status_t SurfaceComposerClient::injectVSync(nsecs_t when) { - return Composer::injectVSync(when); -} - -// ---------------------------------------------------------------------------- - -status_t SurfaceComposerClient::setCrop(const sp<IBinder>& id, const Rect& crop) { - return getComposer().setCrop(this, id, crop); -} - -status_t SurfaceComposerClient::setFinalCrop(const sp<IBinder>& id, - const Rect& crop) { - return getComposer().setFinalCrop(this, id, crop); -} - -status_t SurfaceComposerClient::setPosition(const sp<IBinder>& id, float x, float y) { - return getComposer().setPosition(this, id, x, y); + sp<ISurfaceComposer> sf(ComposerService::getComposerService()); + return sf->injectVSync(when); } -status_t SurfaceComposerClient::setSize(const sp<IBinder>& id, uint32_t w, uint32_t h) { - return getComposer().setSize(this, id, w, h); -} - -status_t SurfaceComposerClient::setLayer(const sp<IBinder>& id, int32_t z) { - return getComposer().setLayer(this, id, z); -} - -status_t SurfaceComposerClient::setRelativeLayer(const sp<IBinder>& id, - const sp<IBinder>& relativeTo, int32_t z) { - return getComposer().setRelativeLayer(this, id, relativeTo, z); -} - -status_t SurfaceComposerClient::hide(const sp<IBinder>& id) { - return getComposer().setFlags(this, id, - layer_state_t::eLayerHidden, - layer_state_t::eLayerHidden); -} - -status_t SurfaceComposerClient::show(const sp<IBinder>& id) { - return getComposer().setFlags(this, id, - 0, - layer_state_t::eLayerHidden); -} - -status_t SurfaceComposerClient::setFlags(const sp<IBinder>& id, uint32_t flags, - uint32_t mask) { - return getComposer().setFlags(this, id, flags, mask); -} - -status_t SurfaceComposerClient::setTransparentRegionHint(const sp<IBinder>& id, - const Region& transparentRegion) { - return getComposer().setTransparentRegionHint(this, id, transparentRegion); -} - -status_t SurfaceComposerClient::setAlpha(const sp<IBinder>& id, float alpha) { - return getComposer().setAlpha(this, id, alpha); -} - -status_t SurfaceComposerClient::setColor(const sp<IBinder>& id, const half3& color) { - return getComposer().setColor(this, id, color); -} - -status_t SurfaceComposerClient::setLayerStack(const sp<IBinder>& id, uint32_t layerStack) { - return getComposer().setLayerStack(this, id, layerStack); -} - -status_t SurfaceComposerClient::setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, - float dtdy, float dsdy) { - return getComposer().setMatrix(this, id, dsdx, dtdx, dtdy, dsdy); -} - -status_t SurfaceComposerClient::deferTransactionUntil(const sp<IBinder>& id, - const sp<IBinder>& handle, uint64_t frameNumber) { - return getComposer().deferTransactionUntil(this, id, handle, frameNumber); -} - -status_t SurfaceComposerClient::deferTransactionUntil(const sp<IBinder>& id, - const sp<Surface>& barrierSurface, uint64_t frameNumber) { - return getComposer().deferTransactionUntil(this, id, barrierSurface, frameNumber); -} - -status_t SurfaceComposerClient::reparentChildren(const sp<IBinder>& id, - const sp<IBinder>& newParentHandle) { - return getComposer().reparentChildren(this, id, newParentHandle); -} - -status_t SurfaceComposerClient::reparent(const sp<IBinder>& id, - const sp<IBinder>& newParentHandle) { - return getComposer().reparent(this, id, newParentHandle); -} - -status_t SurfaceComposerClient::detachChildren(const sp<IBinder>& id) { - return getComposer().detachChildren(this, id); -} - -status_t SurfaceComposerClient::setOverrideScalingMode( - const sp<IBinder>& id, int32_t overrideScalingMode) { - return getComposer().setOverrideScalingMode( - this, id, overrideScalingMode); -} - -status_t SurfaceComposerClient::setGeometryAppliesWithResize( - const sp<IBinder>& id) { - return getComposer().setGeometryAppliesWithResize(this, id); -} - -// ---------------------------------------------------------------------------- - -status_t SurfaceComposerClient::setDisplaySurface(const sp<IBinder>& token, - sp<IGraphicBufferProducer> bufferProducer) { - return Composer::getInstance().setDisplaySurface(token, bufferProducer); -} - -void SurfaceComposerClient::setDisplayLayerStack(const sp<IBinder>& token, - uint32_t layerStack) { - Composer::getInstance().setDisplayLayerStack(token, layerStack); -} - -void SurfaceComposerClient::setDisplayProjection(const sp<IBinder>& token, - uint32_t orientation, - const Rect& layerStackRect, - const Rect& displayRect) { - Composer::getInstance().setDisplayProjection(token, orientation, - layerStackRect, displayRect); -} - -void SurfaceComposerClient::setDisplaySize(const sp<IBinder>& token, - uint32_t width, uint32_t height) { - Composer::getInstance().setDisplaySize(token, width, height); -} - -// ---------------------------------------------------------------------------- - status_t SurfaceComposerClient::getDisplayConfigs( const sp<IBinder>& display, Vector<DisplayInfo>* configs) { diff --git a/libs/gui/SurfaceControl.cpp b/libs/gui/SurfaceControl.cpp index 9e1d7b6647..f6a2b8fed6 100644 --- a/libs/gui/SurfaceControl.cpp +++ b/libs/gui/SurfaceControl.cpp @@ -97,123 +97,6 @@ bool SurfaceControl::isSameSurface( return lhs->mHandle == rhs->mHandle; } -status_t SurfaceControl::setLayerStack(uint32_t layerStack) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setLayerStack(mHandle, layerStack); -} - -status_t SurfaceControl::setLayer(int32_t layer) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setLayer(mHandle, layer); -} - -status_t SurfaceControl::setRelativeLayer(const sp<IBinder>& relativeTo, int32_t layer) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setRelativeLayer(mHandle, relativeTo, layer); -} - -status_t SurfaceControl::setPosition(float x, float y) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setPosition(mHandle, x, y); -} -status_t SurfaceControl::setGeometryAppliesWithResize() { - status_t err = validate(); - if (err < 0) return err; - return mClient->setGeometryAppliesWithResize(mHandle); -} -status_t SurfaceControl::setSize(uint32_t w, uint32_t h) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setSize(mHandle, w, h); -} -status_t SurfaceControl::hide() { - status_t err = validate(); - if (err < 0) return err; - return mClient->hide(mHandle); -} -status_t SurfaceControl::show() { - status_t err = validate(); - if (err < 0) return err; - return mClient->show(mHandle); -} -status_t SurfaceControl::setFlags(uint32_t flags, uint32_t mask) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setFlags(mHandle, flags, mask); -} -status_t SurfaceControl::setTransparentRegionHint(const Region& transparent) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setTransparentRegionHint(mHandle, transparent); -} -status_t SurfaceControl::setAlpha(float alpha) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setAlpha(mHandle, alpha); -} -status_t SurfaceControl::setColor(const half3& color) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setColor(mHandle, color); -} -status_t SurfaceControl::setMatrix(float dsdx, float dtdx, float dtdy, float dsdy) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setMatrix(mHandle, dsdx, dtdx, dtdy, dsdy); -} -status_t SurfaceControl::setCrop(const Rect& crop) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setCrop(mHandle, crop); -} -status_t SurfaceControl::setFinalCrop(const Rect& crop) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setFinalCrop(mHandle, crop); -} - -status_t SurfaceControl::deferTransactionUntil(const sp<IBinder>& handle, - uint64_t frameNumber) { - status_t err = validate(); - if (err < 0) return err; - return mClient->deferTransactionUntil(mHandle, handle, frameNumber); -} - -status_t SurfaceControl::deferTransactionUntil(const sp<Surface>& handle, - uint64_t frameNumber) { - status_t err = validate(); - if (err < 0) return err; - return mClient->deferTransactionUntil(mHandle, handle, frameNumber); -} - -status_t SurfaceControl::reparentChildren(const sp<IBinder>& newParentHandle) { - status_t err = validate(); - if (err < 0) return err; - return mClient->reparentChildren(mHandle, newParentHandle); -} - -status_t SurfaceControl::reparent(const sp<IBinder>& newParentHandle) { - status_t err = validate(); - if (err < 0) return err; - return mClient->reparent(mHandle, newParentHandle); -} - -status_t SurfaceControl::detachChildren() { - status_t err = validate(); - if (err < 0) return err; - return mClient->detachChildren(mHandle); -} - -status_t SurfaceControl::setOverrideScalingMode(int32_t overrideScalingMode) { - status_t err = validate(); - if (err < 0) return err; - return mClient->setOverrideScalingMode(mHandle, overrideScalingMode); -} - status_t SurfaceControl::clearLayerFrameStats() const { status_t err = validate(); if (err < 0) return err; @@ -278,5 +161,10 @@ sp<IBinder> SurfaceControl::getHandle() const return mHandle; } +sp<SurfaceComposerClient> SurfaceControl::getClient() const +{ + return mClient; +} + // ---------------------------------------------------------------------------- }; // namespace android diff --git a/libs/gui/include/private/gui/LayerState.h b/libs/gui/include/gui/LayerState.h index bd42634730..ae6965a0fc 100644 --- a/libs/gui/include/private/gui/LayerState.h +++ b/libs/gui/include/gui/LayerState.h @@ -157,6 +157,20 @@ struct DisplayState { status_t read(const Parcel& input); }; +static inline +int compare_type(const ComposerState& lhs, const ComposerState& rhs) { + if (lhs.client < rhs.client) return -1; + if (lhs.client > rhs.client) return 1; + if (lhs.state.surface < rhs.state.surface) return -1; + if (lhs.state.surface > rhs.state.surface) return 1; + return 0; +} + +static inline +int compare_type(const DisplayState& lhs, const DisplayState& rhs) { + return compare_type(lhs.token, rhs.token); +} + }; // namespace android #endif // ANDROID_SF_LAYER_STATE_H diff --git a/libs/gui/include/gui/SurfaceComposerClient.h b/libs/gui/include/gui/SurfaceComposerClient.h index 17181430c7..00d593638d 100644 --- a/libs/gui/include/gui/SurfaceComposerClient.h +++ b/libs/gui/include/gui/SurfaceComposerClient.h @@ -33,13 +33,13 @@ #include <gui/CpuConsumer.h> #include <gui/SurfaceControl.h> #include <math/vec3.h> +#include <gui/LayerState.h> namespace android { // --------------------------------------------------------------------------- struct DisplayInfo; -class Composer; class HdrCapabilities; class ISurfaceComposerClient; class IGraphicBufferProducer; @@ -122,93 +122,158 @@ public: //! Possible values for id are eDisplayIdMain and eDisplayIdHdmi. static sp<IBinder> getBuiltInDisplay(int32_t id); - // ------------------------------------------------------------------------ - // Composer parameters - // All composer parameters must be changed within a transaction - // several surfaces can be updated in one transaction, all changes are - // committed at once when the transaction is closed. - // closeGlobalTransaction() requires an IPC with the server. - - //! Open a composer transaction on all active SurfaceComposerClients. - static void openGlobalTransaction(); - - //! Close a composer transaction on all active SurfaceComposerClients. - static void closeGlobalTransaction(bool synchronous = false); - static status_t enableVSyncInjections(bool enable); static status_t injectVSync(nsecs_t when); - //! Flag the currently open transaction as an animation transaction. - static void setAnimationTransaction(); - - status_t hide(const sp<IBinder>& id); - status_t show(const sp<IBinder>& id); - status_t setFlags(const sp<IBinder>& id, uint32_t flags, uint32_t mask); - status_t setTransparentRegionHint(const sp<IBinder>& id, const Region& transparent); - status_t setLayer(const sp<IBinder>& id, int32_t layer); - status_t setRelativeLayer(const sp<IBinder>& id, - const sp<IBinder>& relativeTo, int32_t layer); - status_t setAlpha(const sp<IBinder>& id, float alpha=1.0f); - status_t setColor(const sp<IBinder>& id, const half3& color); - status_t setMatrix(const sp<IBinder>& id, float dsdx, float dtdx, float dtdy, float dsdy); - status_t setPosition(const sp<IBinder>& id, float x, float y); - status_t setSize(const sp<IBinder>& id, uint32_t w, uint32_t h); - status_t setCrop(const sp<IBinder>& id, const Rect& crop); - status_t setFinalCrop(const sp<IBinder>& id, const Rect& crop); - status_t setLayerStack(const sp<IBinder>& id, uint32_t layerStack); - status_t deferTransactionUntil(const sp<IBinder>& id, - const sp<IBinder>& handle, uint64_t frameNumber); - status_t deferTransactionUntil(const sp<IBinder>& id, - const sp<Surface>& handle, uint64_t frameNumber); - status_t reparentChildren(const sp<IBinder>& id, - const sp<IBinder>& newParentHandle); - status_t reparent(const sp<IBinder>& id, const sp<IBinder>& newParentHandle); - status_t detachChildren(const sp<IBinder>& id); - status_t setOverrideScalingMode(const sp<IBinder>& id, - int32_t overrideScalingMode); - status_t setGeometryAppliesWithResize(const sp<IBinder>& id); + class Transaction { + SortedVector<ComposerState> mComposerStates; + SortedVector<DisplayState > mDisplayStates; + uint32_t mForceSynchronous = 0; + uint32_t mTransactionNestCount = 0; + bool mAnimation = false; + + int mStatus = NO_ERROR; + + layer_state_t* getLayerStateLocked(const sp<SurfaceControl>& sc); + DisplayState& getDisplayStateLocked(const sp<IBinder>& token); + + public: + Transaction() = default; + virtual ~Transaction() = default; + Transaction(Transaction const& other); + + status_t apply(bool synchronous = false); + + Transaction& show(const sp<SurfaceControl>& sc); + Transaction& hide(const sp<SurfaceControl>& sc); + Transaction& setPosition(const sp<SurfaceControl>& sc, + float x, float y); + Transaction& setSize(const sp<SurfaceControl>& sc, + uint32_t w, uint32_t h); + Transaction& setLayer(const sp<SurfaceControl>& sc, + int32_t z); + + // Sets a Z order relative to the Surface specified by "relativeTo" but + // without becoming a full child of the relative. Z-ordering works exactly + // as if it were a child however. + // + // As a nod to sanity, only non-child surfaces may have a relative Z-order. + // + // This overrides any previous call and is overriden by any future calls + // to setLayer. + // + // If the relative is removed, the Surface will have no layer and be + // invisible, until the next time set(Relative)Layer is called. + Transaction& setRelativeLayer(const sp<SurfaceControl>& sc, + const sp<IBinder>& relativeTo, int32_t z); + Transaction& setFlags(const sp<SurfaceControl>& sc, + uint32_t flags, uint32_t mask); + Transaction& setTransparentRegionHint(const sp<SurfaceControl>& sc, + const Region& transparentRegion); + Transaction& setAlpha(const sp<SurfaceControl>& sc, + float alpha); + Transaction& setMatrix(const sp<SurfaceControl>& sc, + float dsdx, float dtdx, float dtdy, float dsdy); + Transaction& setOrientation(const sp<SurfaceControl>& sc, + const Rect& crop); + Transaction& setCrop(const sp<SurfaceControl>& sc, const Rect& crop); + Transaction& setFinalCrop(const sp<SurfaceControl>& sc, const Rect& crop); + Transaction& setLayerStack(const sp<SurfaceControl>& sc, uint32_t layerStack); + // Defers applying any changes made in this transaction until the Layer + // identified by handle reaches the given frameNumber. If the Layer identified + // by handle is removed, then we will apply this transaction regardless of + // what frame number has been reached. + Transaction& deferTransactionUntil(const sp<SurfaceControl>& sc, + const sp<IBinder>& handle, + uint64_t frameNumber); + // A variant of deferTransactionUntil which identifies the Layer we wait for by + // Surface instead of Handle. Useful for clients which may not have the + // SurfaceControl for some of their Surfaces. Otherwise behaves identically. + Transaction& deferTransactionUntil(const sp<SurfaceControl>& sc, + const sp<Surface>& barrierSurface, + uint64_t frameNumber); + // Reparents all children of this layer to the new parent handle. + Transaction& reparentChildren(const sp<SurfaceControl>& sc, + const sp<IBinder>& newParentHandle); + + /// Reparents the current layer to the new parent handle. The new parent must not be null. + // This can be used instead of reparentChildren if the caller wants to + // only re-parent a specific child. + Transaction& reparent(const sp<SurfaceControl>& sc, + const sp<IBinder>& newParentHandle); + + Transaction& setColor(const sp<SurfaceControl>& sc, const half3& color); + + // Detaches all child surfaces (and their children recursively) + // from their SurfaceControl. + // The child SurfaceControls will not throw exceptions or return errors, + // but transactions will have no effect. + // The child surfaces will continue to follow their parent surfaces, + // and remain eligible for rendering, but their relative state will be + // frozen. We use this in the WindowManager, in app shutdown/relaunch + // scenarios, where the app would otherwise clean up its child Surfaces. + // Sometimes the WindowManager needs to extend their lifetime slightly + // in order to perform an exit animation or prevent flicker. + Transaction& detachChildren(const sp<SurfaceControl>& sc); + // Set an override scaling mode as documented in <system/window.h> + // the override scaling mode will take precedence over any client + // specified scaling mode. -1 will clear the override scaling mode. + Transaction& setOverrideScalingMode(const sp<SurfaceControl>& sc, + int32_t overrideScalingMode); + + // If the size changes in this transaction, all geometry updates specified + // in this transaction will not complete until a buffer of the new size + // arrives. As some elements normally apply immediately, this enables + // freezing the total geometry of a surface until a resize is completed. + Transaction& setGeometryAppliesWithResize(const sp<SurfaceControl>& sc); + + status_t setDisplaySurface(const sp<IBinder>& token, + const sp<IGraphicBufferProducer>& bufferProducer); + + void setDisplayLayerStack(const sp<IBinder>& token, uint32_t layerStack); + + /* setDisplayProjection() defines the projection of layer stacks + * to a given display. + * + * - orientation defines the display's orientation. + * - layerStackRect defines which area of the window manager coordinate + * space will be used. + * - displayRect defines where on the display will layerStackRect be + * mapped to. displayRect is specified post-orientation, that is + * it uses the orientation seen by the end-user. + */ + void setDisplayProjection(const sp<IBinder>& token, + uint32_t orientation, + const Rect& layerStackRect, + const Rect& displayRect); + void setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height); + void setAnimationTransaction(); + }; status_t destroySurface(const sp<IBinder>& id); status_t clearLayerFrameStats(const sp<IBinder>& token) const; status_t getLayerFrameStats(const sp<IBinder>& token, FrameStats* outStats) const; - static status_t clearAnimationFrameStats(); static status_t getAnimationFrameStats(FrameStats* outStats); static status_t getHdrCapabilities(const sp<IBinder>& display, HdrCapabilities* outCapabilities); - static status_t setDisplaySurface(const sp<IBinder>& token, - sp<IGraphicBufferProducer> bufferProducer); - static void setDisplayLayerStack(const sp<IBinder>& token, - uint32_t layerStack); - static void setDisplaySize(const sp<IBinder>& token, uint32_t width, uint32_t height); - - /* setDisplayProjection() defines the projection of layer stacks - * to a given display. - * - * - orientation defines the display's orientation. - * - layerStackRect defines which area of the window manager coordinate - * space will be used. - * - displayRect defines where on the display will layerStackRect be - * mapped to. displayRect is specified post-orientation, that is - * it uses the orientation seen by the end-user. - */ static void setDisplayProjection(const sp<IBinder>& token, uint32_t orientation, const Rect& layerStackRect, const Rect& displayRect); + inline sp<ISurfaceComposerClient> getClient() { return mClient; } + private: virtual void onFirstRef(); - Composer& getComposer(); mutable Mutex mLock; status_t mStatus; sp<ISurfaceComposerClient> mClient; - Composer& mComposer; wp<IGraphicBufferProducer> mParent; }; diff --git a/libs/gui/include/gui/SurfaceControl.h b/libs/gui/include/gui/SurfaceControl.h index e98e26a391..384815dad8 100644 --- a/libs/gui/include/gui/SurfaceControl.h +++ b/libs/gui/include/gui/SurfaceControl.h @@ -61,93 +61,6 @@ public: // disconnect any api that's connected void disconnect(); - status_t setLayerStack(uint32_t layerStack); - status_t setLayer(int32_t layer); - - // Sets a Z order relative to the Surface specified by "relativeTo" but - // without becoming a full child of the relative. Z-ordering works exactly - // as if it were a child however. - // - // As a nod to sanity, only non-child surfaces may have a relative Z-order. - // - // This overrides any previous and is overriden by any future calls - // to setLayer. - // - // If the relative dissapears, the Surface will have no layer and be - // invisible, until the next time set(Relative)Layer is called. - // - // TODO: This is probably a hack. Currently it exists only to work around - // some framework usage of the hidden APPLICATION_MEDIA_OVERLAY window type - // which allows inserting a window between a SurfaceView and it's main application - // window. However, since we are using child windows for the SurfaceView, but not using - // child windows elsewhere in O, the WindowManager can't set the layer appropriately. - // This is only used by the "TvInputService" and following the port of ViewRootImpl - // to child surfaces, we can then port this and remove this method. - status_t setRelativeLayer(const sp<IBinder>& relativeTo, int32_t layer); - status_t setPosition(float x, float y); - status_t setSize(uint32_t w, uint32_t h); - status_t hide(); - status_t show(); - status_t setFlags(uint32_t flags, uint32_t mask); - status_t setTransparentRegionHint(const Region& transparent); - status_t setAlpha(float alpha=1.0f); - status_t setColor(const half3& color); - - // Experimentarily it appears that the matrix transforms the - // on-screen rectangle and it's contents before the position is - // applied. - // - // TODO: Test with other combinations to find approximate transformation rules. - // - // For example: - // Layer sized (W,H) set to position (x,y) with matrix M=[-1, 0, 0, 1] (Horizontal flip) gives - // [((0, 0), (W, H)) x M] + (x,y) = ((-W, 0), (0, H)) + (x,y) = ((-W + x, y), (x, H+y)) - status_t setMatrix(float dsdx, float dtdx, float dtdy, float dsdy); - status_t setCrop(const Rect& crop); - status_t setFinalCrop(const Rect& crop); - - // If the size changes in this transaction, all geometry updates specified - // in this transaction will not complete until a buffer of the new size - // arrives. As some elements normally apply immediately, this enables - // freezing the total geometry of a surface until a resize is completed. - status_t setGeometryAppliesWithResize(); - - // Defers applying any changes made in this transaction until the Layer - // identified by handle reaches the given frameNumber. If the Layer identified - // by handle is removed, then we will apply this transaction regardless of - // what frame number has been reached. - status_t deferTransactionUntil(const sp<IBinder>& handle, uint64_t frameNumber); - - // A variant of deferTransactionUntil which identifies the Layer we wait for by - // Surface instead of Handle. Useful for clients which may not have the - // SurfaceControl for some of their Surfaces. Otherwise behaves identically. - status_t deferTransactionUntil(const sp<Surface>& barrier, uint64_t frameNumber); - - // Reparents all children of this layer to the new parent handle. - status_t reparentChildren(const sp<IBinder>& newParentHandle); - - // Reparents the current layer to the new parent handle. The new parent must not be null. - // This can be used instead of reparentChildren if the caller wants to - // only re-parent a specific child. - status_t reparent(const sp<IBinder>& newParentHandle); - - // Detaches all child surfaces (and their children recursively) - // from their SurfaceControl. - // The child SurfaceControl's will not throw exceptions or return errors, - // but transactions will have no effect. - // The child surfaces will continue to follow their parent surfaces, - // and remain eligible for rendering, but their relative state will be - // frozen. We use this in the WindowManager, in app shutdown/relaunch - // scenarios, where the app would otherwise clean up its child Surfaces. - // Sometimes the WindowManager needs to extend their lifetime slightly - // in order to perform an exit animation or prevent flicker. - status_t detachChildren(); - - // Set an override scaling mode as documented in <system/window.h> - // the override scaling mode will take precedence over any client - // specified scaling mode. -1 will clear the override scaling mode. - status_t setOverrideScalingMode(int32_t overrideScalingMode); - static status_t writeSurfaceToParcel( const sp<SurfaceControl>& control, Parcel* parcel); @@ -158,6 +71,8 @@ public: status_t clearLayerFrameStats() const; status_t getLayerFrameStats(FrameStats* outStats) const; + sp<SurfaceComposerClient> getClient() const; + private: // can't be copied SurfaceControl& operator = (SurfaceControl& rhs); diff --git a/libs/gui/tests/GLTest.cpp b/libs/gui/tests/GLTest.cpp index 1739d9c7ca..a91552f7fe 100644 --- a/libs/gui/tests/GLTest.cpp +++ b/libs/gui/tests/GLTest.cpp @@ -22,6 +22,8 @@ namespace android { +using Transaction = SurfaceComposerClient::Transaction; + static int abs(int value) { return value > 0 ? value : -value; } @@ -68,10 +70,10 @@ void GLTest::SetUp() { ASSERT_TRUE(mSurfaceControl != NULL); ASSERT_TRUE(mSurfaceControl->isValid()); - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7FFFFFFF)); - ASSERT_EQ(NO_ERROR, mSurfaceControl->show()); - SurfaceComposerClient::closeGlobalTransaction(); + Transaction t; + ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7FFFFFFF) + .show(mSurfaceControl) + .apply()); sp<ANativeWindow> window = mSurfaceControl->getSurface(); mEglSurface = createWindowSurface(mEglDisplay, mGlConfig, window); diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp index 45e95a593b..bfcd75f26c 100644 --- a/libs/gui/tests/Surface_test.cpp +++ b/libs/gui/tests/Surface_test.cpp @@ -42,6 +42,8 @@ using namespace std::chrono_literals; using namespace android::hardware::configstore; using namespace android::hardware::configstore::V1_0; +using Transaction = SurfaceComposerClient::Transaction; + static bool hasWideColorDisplay = getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false); @@ -69,10 +71,10 @@ protected: ASSERT_TRUE(mSurfaceControl != NULL); ASSERT_TRUE(mSurfaceControl->isValid()); - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff)); - ASSERT_EQ(NO_ERROR, mSurfaceControl->show()); - SurfaceComposerClient::closeGlobalTransaction(); + Transaction t; + ASSERT_EQ(NO_ERROR, t.setLayer(mSurfaceControl, 0x7fffffff) + .show(mSurfaceControl) + .apply()); mSurface = mSurfaceControl->getSurface(); ASSERT_TRUE(mSurface != NULL); diff --git a/opengl/tests/lib/WindowSurface.cpp b/opengl/tests/lib/WindowSurface.cpp index 142894524d..2b76279801 100644 --- a/opengl/tests/lib/WindowSurface.cpp +++ b/opengl/tests/lib/WindowSurface.cpp @@ -62,19 +62,10 @@ WindowSurface::WindowSurface() { return; } - SurfaceComposerClient::openGlobalTransaction(); - err = sc->setLayer(0x7FFFFFFF); // always on top - if (err != NO_ERROR) { - fprintf(stderr, "SurfaceComposer::setLayer error: %#x\n", err); - return; - } - - err = sc->show(); - if (err != NO_ERROR) { - fprintf(stderr, "SurfaceComposer::show error: %#x\n", err); - return; - } - SurfaceComposerClient::closeGlobalTransaction(); + SurfaceComposerClient::Transaction{} + .setLayer(sc, 0x7FFFFFFF) + .show(sc) + .apply(); mSurfaceControl = sc; } diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h index 921492b210..47924ae877 100644 --- a/services/surfaceflinger/Layer.h +++ b/services/surfaceflinger/Layer.h @@ -33,8 +33,7 @@ #include <ui/Region.h> #include <gui/ISurfaceComposerClient.h> - -#include <private/gui/LayerState.h> +#include <gui/LayerState.h> #include <list> diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h index e87d35f912..32e4067ece 100644 --- a/services/surfaceflinger/SurfaceFlinger.h +++ b/services/surfaceflinger/SurfaceFlinger.h @@ -43,14 +43,14 @@ #include <gui/FrameTimestamps.h> #include <gui/ISurfaceComposer.h> #include <gui/ISurfaceComposerClient.h> +#include <gui/LayerState.h> + #include <gui/OccupancyTracker.h> #include <hardware/hwcomposer_defs.h> #include <system/graphics.h> -#include <private/gui/LayerState.h> - #include "Barrier.h" #include "DisplayDevice.h" #include "DispSync.h" diff --git a/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp b/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp index 0cc763c740..ed806b87f5 100644 --- a/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp +++ b/services/surfaceflinger/tests/SurfaceInterceptor_test.cpp @@ -22,10 +22,11 @@ #include <android/native_window.h> #include <gui/ISurfaceComposer.h> +#include <gui/LayerState.h> #include <gui/Surface.h> #include <gui/SurfaceComposerClient.h> + #include <private/gui/ComposerService.h> -#include <private/gui/LayerState.h> #include <ui/DisplayInfo.h> #include <fstream> @@ -34,6 +35,8 @@ namespace android { +using Transaction = SurfaceComposerClient::Transaction; + constexpr int32_t SCALING_UPDATE = 1; constexpr uint32_t BUFFER_UPDATES = 18; constexpr uint32_t LAYER_UPDATE = INT_MAX - 2; @@ -149,11 +152,11 @@ protected: ASSERT_TRUE(mBGSurfaceControl->isValid()); mBGLayerId = getSurfaceId("BG Interceptor Test Surface"); - SurfaceComposerClient::openGlobalTransaction(); - mComposerClient->setDisplayLayerStack(display, 0); - ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT_MAX-3)); - ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show()); - SurfaceComposerClient::closeGlobalTransaction(true); + Transaction t; + t.setDisplayLayerStack(display, 0); + ASSERT_EQ(NO_ERROR, t.setLayer(mBGSurfaceControl, INT_MAX-3) + .show(mBGSurfaceControl) + .apply()); } virtual void TearDown() { @@ -169,13 +172,14 @@ protected: int32_t mTargetId; public: - void captureTest(void (SurfaceInterceptorTest::* action)(void), + void captureTest(void (SurfaceInterceptorTest::* action)(Transaction&), bool (SurfaceInterceptorTest::* verification)(Trace *)); - void captureTest(void (SurfaceInterceptorTest::* action)(void), + void captureTest(void (SurfaceInterceptorTest::* action)(Transaction&), SurfaceChange::SurfaceChangeCase changeCase); - void captureTest(void (SurfaceInterceptorTest::* action)(void), + void captureTest(void (SurfaceInterceptorTest::* action)(Transaction&), Increment::IncrementCase incrementCase); - void runInTransaction(void (SurfaceInterceptorTest::* action)(void), bool intercepted = false); + void runInTransaction(void (SurfaceInterceptorTest::* action)(Transaction&), + bool intercepted = false); // Verification of changes to a surface bool positionUpdateFound(const SurfaceChange& change, bool foundPosition); @@ -206,28 +210,29 @@ public: bool bufferUpdatesFound(Trace* trace); // Perform each of the possible changes to a surface - void positionUpdate(); - void sizeUpdate(); - void alphaUpdate(); - void layerUpdate(); - void cropUpdate(); - void finalCropUpdate(); - void matrixUpdate(); - void overrideScalingModeUpdate(); - void transparentRegionHintUpdate(); - void layerStackUpdate(); - void hiddenFlagUpdate(); - void opaqueFlagUpdate(); - void secureFlagUpdate(); - void deferredTransactionUpdate(); - void runAllUpdates(); - void surfaceCreation(); + void positionUpdate(Transaction&); + void sizeUpdate(Transaction&); + void alphaUpdate(Transaction&); + void layerUpdate(Transaction&); + void cropUpdate(Transaction&); + void finalCropUpdate(Transaction&); + void matrixUpdate(Transaction&); + void overrideScalingModeUpdate(Transaction&); + void transparentRegionHintUpdate(Transaction&); + void layerStackUpdate(Transaction&); + void hiddenFlagUpdate(Transaction&); + void opaqueFlagUpdate(Transaction&); + void secureFlagUpdate(Transaction&); + void deferredTransactionUpdate(Transaction&); + void surfaceCreation(Transaction&); + void displayCreation(Transaction&); + void displayDeletion(Transaction&); + void nBufferUpdates(); - void displayCreation(); - void displayDeletion(); + void runAllUpdates(); }; -void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void), +void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(Transaction&), bool (SurfaceInterceptorTest::* verification)(Trace *)) { runInTransaction(action, true); @@ -236,7 +241,7 @@ void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action) ASSERT_TRUE((this->*verification)(&capturedTrace)); } -void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void), +void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(Transaction&), Increment::IncrementCase incrementCase) { runInTransaction(action, true); @@ -245,7 +250,7 @@ void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action) ASSERT_TRUE(singleIncrementFound(&capturedTrace, incrementCase)); } -void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(void), +void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action)(Transaction&), SurfaceChange::SurfaceChangeCase changeCase) { runInTransaction(action, true); @@ -254,83 +259,84 @@ void SurfaceInterceptorTest::captureTest(void (SurfaceInterceptorTest::* action) ASSERT_TRUE(surfaceUpdateFound(&capturedTrace, changeCase)); } -void SurfaceInterceptorTest::runInTransaction(void (SurfaceInterceptorTest::* action)(void), +void SurfaceInterceptorTest::runInTransaction(void (SurfaceInterceptorTest::* action)(Transaction&), bool intercepted) { if (intercepted) { enableInterceptor(); } - SurfaceComposerClient::openGlobalTransaction(); - (this->*action)(); - SurfaceComposerClient::closeGlobalTransaction(true); + Transaction t; + (this->*action)(t); + t.apply(true); + if (intercepted) { disableInterceptor(); } } -void SurfaceInterceptorTest::positionUpdate() { - mBGSurfaceControl->setPosition(POSITION_UPDATE, POSITION_UPDATE); +void SurfaceInterceptorTest::positionUpdate(Transaction& t) { + t.setPosition(mBGSurfaceControl, POSITION_UPDATE, POSITION_UPDATE); } -void SurfaceInterceptorTest::sizeUpdate() { - mBGSurfaceControl->setSize(SIZE_UPDATE, SIZE_UPDATE); +void SurfaceInterceptorTest::sizeUpdate(Transaction& t) { + t.setSize(mBGSurfaceControl, SIZE_UPDATE, SIZE_UPDATE); } -void SurfaceInterceptorTest::alphaUpdate() { - mBGSurfaceControl->setAlpha(ALPHA_UPDATE); +void SurfaceInterceptorTest::alphaUpdate(Transaction& t) { + t.setAlpha(mBGSurfaceControl, ALPHA_UPDATE); } -void SurfaceInterceptorTest::layerUpdate() { - mBGSurfaceControl->setLayer(LAYER_UPDATE); +void SurfaceInterceptorTest::layerUpdate(Transaction& t) { + t.setLayer(mBGSurfaceControl, LAYER_UPDATE); } -void SurfaceInterceptorTest::cropUpdate() { - mBGSurfaceControl->setCrop(CROP_UPDATE); +void SurfaceInterceptorTest::cropUpdate(Transaction& t) { + t.setCrop(mBGSurfaceControl, CROP_UPDATE); } -void SurfaceInterceptorTest::finalCropUpdate() { - mBGSurfaceControl->setFinalCrop(CROP_UPDATE); +void SurfaceInterceptorTest::finalCropUpdate(Transaction& t) { + t.setFinalCrop(mBGSurfaceControl, CROP_UPDATE); } -void SurfaceInterceptorTest::matrixUpdate() { - mBGSurfaceControl->setMatrix(M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2, M_SQRT1_2); +void SurfaceInterceptorTest::matrixUpdate(Transaction& t) { + t.setMatrix(mBGSurfaceControl, M_SQRT1_2, M_SQRT1_2, -M_SQRT1_2, M_SQRT1_2); } -void SurfaceInterceptorTest::overrideScalingModeUpdate() { - mBGSurfaceControl->setOverrideScalingMode(SCALING_UPDATE); +void SurfaceInterceptorTest::overrideScalingModeUpdate(Transaction& t) { + t.setOverrideScalingMode(mBGSurfaceControl, SCALING_UPDATE); } -void SurfaceInterceptorTest::transparentRegionHintUpdate() { +void SurfaceInterceptorTest::transparentRegionHintUpdate(Transaction& t) { Region region(CROP_UPDATE); - mBGSurfaceControl->setTransparentRegionHint(region); + t.setTransparentRegionHint(mBGSurfaceControl, region); } -void SurfaceInterceptorTest::layerStackUpdate() { - mBGSurfaceControl->setLayerStack(STACK_UPDATE); +void SurfaceInterceptorTest::layerStackUpdate(Transaction& t) { + t.setLayerStack(mBGSurfaceControl, STACK_UPDATE); } -void SurfaceInterceptorTest::hiddenFlagUpdate() { - mBGSurfaceControl->setFlags(layer_state_t::eLayerHidden, layer_state_t::eLayerHidden); +void SurfaceInterceptorTest::hiddenFlagUpdate(Transaction& t) { + t.setFlags(mBGSurfaceControl, layer_state_t::eLayerHidden, layer_state_t::eLayerHidden); } -void SurfaceInterceptorTest::opaqueFlagUpdate() { - mBGSurfaceControl->setFlags(layer_state_t::eLayerOpaque, layer_state_t::eLayerOpaque); +void SurfaceInterceptorTest::opaqueFlagUpdate(Transaction& t) { + t.setFlags(mBGSurfaceControl, layer_state_t::eLayerOpaque, layer_state_t::eLayerOpaque); } -void SurfaceInterceptorTest::secureFlagUpdate() { - mBGSurfaceControl->setFlags(layer_state_t::eLayerSecure, layer_state_t::eLayerSecure); +void SurfaceInterceptorTest::secureFlagUpdate(Transaction& t) { + t.setFlags(mBGSurfaceControl, layer_state_t::eLayerSecure, layer_state_t::eLayerSecure); } -void SurfaceInterceptorTest::deferredTransactionUpdate() { - mBGSurfaceControl->deferTransactionUntil(mBGSurfaceControl->getHandle(), DEFERRED_UPDATE); +void SurfaceInterceptorTest::deferredTransactionUpdate(Transaction& t) { + t.deferTransactionUntil(mBGSurfaceControl, mBGSurfaceControl->getHandle(), DEFERRED_UPDATE); } -void SurfaceInterceptorTest::displayCreation() { +void SurfaceInterceptorTest::displayCreation(Transaction&) { sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, true); SurfaceComposerClient::destroyDisplay(testDisplay); } -void SurfaceInterceptorTest::displayDeletion() { +void SurfaceInterceptorTest::displayDeletion(Transaction&) { sp<IBinder> testDisplay = SurfaceComposerClient::createDisplay(DISPLAY_NAME, false); mTargetId = getDisplayId(DISPLAY_NAME.string()); SurfaceComposerClient::destroyDisplay(testDisplay); @@ -353,7 +359,7 @@ void SurfaceInterceptorTest::runAllUpdates() { runInTransaction(&SurfaceInterceptorTest::deferredTransactionUpdate); } -void SurfaceInterceptorTest::surfaceCreation() { +void SurfaceInterceptorTest::surfaceCreation(Transaction&) { mComposerClient->createSurface(String8(LAYER_NAME), SIZE_UPDATE, SIZE_UPDATE, PIXEL_FORMAT_RGBA_8888, 0); } @@ -825,8 +831,10 @@ TEST_F(SurfaceInterceptorTest, InterceptDisplayDeletionWorks) { } TEST_F(SurfaceInterceptorTest, InterceptBufferUpdateWorks) { - captureTest(&SurfaceInterceptorTest::nBufferUpdates, - &SurfaceInterceptorTest::bufferUpdatesFound); + nBufferUpdates(); + Trace capturedTrace; + ASSERT_EQ(NO_ERROR, readProtoFile(&capturedTrace)); + ASSERT_TRUE(bufferUpdatesFound(&capturedTrace)); } // If the interceptor is enabled while buffer updates are being pushed, the interceptor should diff --git a/services/surfaceflinger/tests/Transaction_test.cpp b/services/surfaceflinger/tests/Transaction_test.cpp index d285785c83..f61a978487 100644 --- a/services/surfaceflinger/tests/Transaction_test.cpp +++ b/services/surfaceflinger/tests/Transaction_test.cpp @@ -19,10 +19,11 @@ #include <android/native_window.h> #include <gui/ISurfaceComposer.h> +#include <gui/LayerState.h> + #include <gui/Surface.h> #include <gui/SurfaceComposerClient.h> #include <private/gui/ComposerService.h> -#include <private/gui/LayerState.h> #include <utils/String8.h> #include <ui/DisplayInfo.h> @@ -30,8 +31,12 @@ #include <math.h> #include <math/vec3.h> +#include <functional> + namespace android { +using Transaction = SurfaceComposerClient::Transaction; + // Fill an RGBA_8888 formatted surface with a single color. static void fillSurfaceRGBA8(const sp<SurfaceControl>& sc, uint8_t r, uint8_t g, uint8_t b, bool unlock=true) { @@ -66,8 +71,8 @@ public: sp<ISurfaceComposer> sf(ComposerService::getComposerService()); sp<IBinder> display(sf->getBuiltInDisplay( ISurfaceComposer::eDisplayIdMain)); - SurfaceComposerClient::openGlobalTransaction(); - SurfaceComposerClient::closeGlobalTransaction(true); + SurfaceComposerClient::Transaction().apply(true); + ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(), 0, 0, 0, INT_MAX, false)); *sc = new ScreenCapture(cpuConsumer); @@ -149,23 +154,21 @@ protected: fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31); - SurfaceComposerClient::openGlobalTransaction(); - - mComposerClient->setDisplayLayerStack(display, 0); - - ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT32_MAX-2)); - ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show()); + asTransaction([&](Transaction& t) { + t.setDisplayLayerStack(display, 0); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT32_MAX-1)); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(64, 64)); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->show()); + t.setLayer(mBGSurfaceControl, INT32_MAX-2) + .show(mBGSurfaceControl); - ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setLayer(INT32_MAX-1)); - ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->setPosition(displayWidth-2, - displayHeight-2)); - ASSERT_EQ(NO_ERROR, mSyncSurfaceControl->show()); + t.setLayer(mFGSurfaceControl, INT32_MAX-1) + .setPosition(mFGSurfaceControl, 64, 64) + .show(mFGSurfaceControl); - SurfaceComposerClient::closeGlobalTransaction(true); + t.setLayer(mSyncSurfaceControl, INT32_MAX-1) + .setPosition(mSyncSurfaceControl, displayWidth-2, + displayHeight-2) + .show(mSyncSurfaceControl); + }); } virtual void TearDown() { @@ -186,6 +189,12 @@ protected: fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31); } + void asTransaction(const std::function<void(Transaction&)>& exec) { + Transaction t; + exec(t); + t.apply(true); + } + sp<SurfaceComposerClient> mComposerClient; sp<SurfaceControl> mBGSurfaceControl; sp<SurfaceControl> mFGSurfaceControl; @@ -205,9 +214,10 @@ TEST_F(LayerUpdateTest, LayerMoveWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(128, 128)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setPosition(mFGSurfaceControl, 128, 128); + }); + { // This should reflect the new position, but not the new color. SCOPED_TRACE("after move, before redraw"); @@ -240,9 +250,9 @@ TEST_F(LayerUpdateTest, LayerResizeWorks) { } ALOGD("resizing"); - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setSize(128, 128)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + }); ALOGD("resized"); { // This should not reflect the new size or color because SurfaceFlinger @@ -278,10 +288,10 @@ TEST_F(LayerUpdateTest, LayerCropWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - Rect cropRect(16, 16, 32, 32); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setCrop(cropRect)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + Rect cropRect(16, 16, 32, 32); + t.setCrop(mFGSurfaceControl, cropRect); + }); { // This should crop the foreground surface. SCOPED_TRACE("after crop"); @@ -303,10 +313,10 @@ TEST_F(LayerUpdateTest, LayerFinalCropWorks) { sc->expectFGColor(75, 75); sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - Rect cropRect(16, 16, 32, 32); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setFinalCrop(cropRect)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + Rect cropRect(16, 16, 32, 32); + t.setFinalCrop(mFGSurfaceControl, cropRect); + }); { // This should crop the foreground surface. SCOPED_TRACE("after crop"); @@ -329,9 +339,10 @@ TEST_F(LayerUpdateTest, LayerSetLayerWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT_MAX - 3)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setLayer(mFGSurfaceControl, INT_MAX - 3); + }); + { // This should hide the foreground surface beneath the background. SCOPED_TRACE("after setLayer"); @@ -352,9 +363,10 @@ TEST_F(LayerUpdateTest, LayerShowHideWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->hide()); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.hide(mFGSurfaceControl); + }); + { // This should hide the foreground surface. SCOPED_TRACE("after hide, before show"); @@ -364,9 +376,10 @@ TEST_F(LayerUpdateTest, LayerShowHideWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->show()); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mFGSurfaceControl); + }); + { // This should show the foreground surface. SCOPED_TRACE("after show"); @@ -387,9 +400,10 @@ TEST_F(LayerUpdateTest, LayerSetAlphaWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.75f)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setAlpha(mFGSurfaceControl, 0.75f); + }); + { // This should set foreground to be 75% opaque. SCOPED_TRACE("after setAlpha"); @@ -410,9 +424,9 @@ TEST_F(LayerUpdateTest, LayerSetLayerStackWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayerStack(1)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setLayerStack(mFGSurfaceControl, 1); + }); { // This should hide the foreground surface since it goes to a different // layer stack. @@ -434,10 +448,10 @@ TEST_F(LayerUpdateTest, LayerSetFlagsWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setFlags( - layer_state_t::eLayerHidden, layer_state_t::eLayerHidden)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setFlags(mFGSurfaceControl, + layer_state_t::eLayerHidden, layer_state_t::eLayerHidden); + }); { // This should hide the foreground surface SCOPED_TRACE("after setFlags"); @@ -459,10 +473,11 @@ TEST_F(LayerUpdateTest, LayerSetMatrixWorks) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setMatrix(M_SQRT1_2, M_SQRT1_2, - -M_SQRT1_2, M_SQRT1_2)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setMatrix(mFGSurfaceControl, + M_SQRT1_2, M_SQRT1_2, + -M_SQRT1_2, M_SQRT1_2); + }); { SCOPED_TRACE("after setMatrix"); ScreenCapture::captureScreen(&sc); @@ -498,12 +513,12 @@ protected: waitForPostedBuffers(); } void restoreInitialState() { - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(64, 64); - mFGSurfaceControl->setPosition(64, 64); - mFGSurfaceControl->setCrop(Rect(0, 0, 64, 64)); - mFGSurfaceControl->setFinalCrop(Rect(0, 0, -1, -1)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 64, 64); + t.setPosition(mFGSurfaceControl, 64, 64); + t.setCrop(mFGSurfaceControl, Rect(0, 0, 64, 64)); + t.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1)); + }); EXPECT_INITIAL_STATE("After restoring initial state"); } @@ -515,10 +530,10 @@ TEST_F(GeometryLatchingTest, SurfacePositionLatching) { // By default position can be updated even while // a resize is pending. - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(32, 32); - mFGSurfaceControl->setPosition(100, 100); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 32, 32); + t.setPosition(mFGSurfaceControl, 100, 100); + }); { SCOPED_TRACE("After moving surface"); @@ -532,11 +547,11 @@ TEST_F(GeometryLatchingTest, SurfacePositionLatching) { // Now we repeat with setGeometryAppliesWithResize // and verify the position DOESN'T latch. - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setSize(32, 32); - mFGSurfaceControl->setPosition(100, 100); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setGeometryAppliesWithResize(mFGSurfaceControl); + t.setSize(mFGSurfaceControl, 32, 32); + t.setPosition(mFGSurfaceControl, 100, 100); + }); { SCOPED_TRACE("While resize is pending"); @@ -581,20 +596,20 @@ protected: TEST_F(CropLatchingTest, CropLatching) { EXPECT_INITIAL_STATE("before anything"); // Normally the crop applies immediately even while a resize is pending. - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setCrop(Rect(0, 0, 63, 63)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63)); + }); EXPECT_CROPPED_STATE("after setting crop (without geometryAppliesWithResize)"); restoreInitialState(); - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setCrop(Rect(0, 0, 63, 63)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setGeometryAppliesWithResize(mFGSurfaceControl); + t.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63)); + }); EXPECT_INITIAL_STATE("after setting crop (with geometryAppliesWithResize)"); @@ -606,20 +621,20 @@ TEST_F(CropLatchingTest, CropLatching) { TEST_F(CropLatchingTest, FinalCropLatching) { EXPECT_INITIAL_STATE("before anything"); // Normally the crop applies immediately even while a resize is pending. - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); + }); EXPECT_CROPPED_STATE("after setting crop (without geometryAppliesWithResize)"); restoreInitialState(); - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setGeometryAppliesWithResize(mFGSurfaceControl); + t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); + }); EXPECT_INITIAL_STATE("after setting crop (with geometryAppliesWithResize)"); @@ -633,10 +648,10 @@ TEST_F(CropLatchingTest, FinalCropLatching) { TEST_F(CropLatchingTest, FinalCropLatchingBufferOldSize) { EXPECT_INITIAL_STATE("before anything"); // Normally the crop applies immediately even while a resize is pending. - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); + }); EXPECT_CROPPED_STATE("after setting crop (without geometryAppliesWithResize)"); @@ -646,11 +661,11 @@ TEST_F(CropLatchingTest, FinalCropLatchingBufferOldSize) { // initiating the resize. lockAndFillFGBuffer(); - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setGeometryAppliesWithResize(mFGSurfaceControl); + t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); + }); EXPECT_INITIAL_STATE("after setting crop (with geometryAppliesWithResize)"); @@ -670,17 +685,17 @@ TEST_F(CropLatchingTest, FinalCropLatchingRegressionForb37531386) { // In this scenario, we attempt to set the final crop a second time while the resize // is still pending, and ensure we are successful. Success meaning the second crop // is the one which eventually latches and not the first. - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 128); + t.setGeometryAppliesWithResize(mFGSurfaceControl); + t.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); + }); EXPECT_INITIAL_STATE("after setting crops with geometryAppliesWithResize"); - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setFinalCrop(Rect(0, 0, -1, -1)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1)); + }); EXPECT_INITIAL_STATE("after setting another crop"); @@ -700,17 +715,17 @@ TEST_F(LayerUpdateTest, DeferredTransactionTest) { } // set up two deferred transactions on different frames - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.75)); - mFGSurfaceControl->deferTransactionUntil(mSyncSurfaceControl->getHandle(), - mSyncSurfaceControl->getSurface()->getNextFrameNumber()); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setAlpha(mFGSurfaceControl, 0.75); + t.deferTransactionUntil(mFGSurfaceControl, mSyncSurfaceControl->getHandle(), + mSyncSurfaceControl->getSurface()->getNextFrameNumber()); + }); - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(128,128)); - mFGSurfaceControl->deferTransactionUntil(mSyncSurfaceControl->getHandle(), - mSyncSurfaceControl->getSurface()->getNextFrameNumber() + 1); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setPosition(mFGSurfaceControl, 128,128); + t.deferTransactionUntil(mFGSurfaceControl, mSyncSurfaceControl->getHandle(), + mSyncSurfaceControl->getSurface()->getNextFrameNumber() + 1); + }); { SCOPED_TRACE("before any trigger"); @@ -731,9 +746,9 @@ TEST_F(LayerUpdateTest, DeferredTransactionTest) { } // should show up immediately since it's not deferred - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(1.0)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setAlpha(mFGSurfaceControl, 1.0); + }); // trigger the second deferred transaction fillSurfaceRGBA8(mSyncSurfaceControl, 31, 31, 31); @@ -762,12 +777,11 @@ TEST_F(LayerUpdateTest, LayerSetRelativeLayerWorks) { waitForPostedBuffers(); // Now we stack the surface above the foreground surface and make sure it is visible. - SurfaceComposerClient::openGlobalTransaction(); - relativeSurfaceControl->setPosition(64, 64); - relativeSurfaceControl->show(); - relativeSurfaceControl->setRelativeLayer(mFGSurfaceControl->getHandle(), 1); - SurfaceComposerClient::closeGlobalTransaction(true); - + asTransaction([&](Transaction& t) { + t.setPosition(relativeSurfaceControl, 64, 64); + t.show(relativeSurfaceControl); + t.setRelativeLayer(relativeSurfaceControl, mFGSurfaceControl->getHandle(), 1); + }); { SCOPED_TRACE("after adding relative surface"); @@ -777,9 +791,9 @@ TEST_F(LayerUpdateTest, LayerSetRelativeLayerWorks) { } // A call to setLayer will override a call to setRelativeLayer - SurfaceComposerClient::openGlobalTransaction(); - relativeSurfaceControl->setLayer(0); - SurfaceComposerClient::closeGlobalTransaction(); + asTransaction([&](Transaction& t) { + t.setLayer(relativeSurfaceControl, 0); + }); { SCOPED_TRACE("after set layer"); @@ -801,11 +815,10 @@ TEST_F(LayerUpdateTest, LayerWithNoBuffersResizesImmediately) { PIXEL_FORMAT_RGBA_8888, 0, childNoBuffer.get()); fillSurfaceRGBA8(childBuffer, 200, 200, 200); - SurfaceComposerClient::openGlobalTransaction(); - childNoBuffer->show(); - childBuffer->show(); - SurfaceComposerClient::closeGlobalTransaction(); - + SurfaceComposerClient::Transaction{} + .show(childNoBuffer) + .show(childBuffer) + .apply(true); { ScreenCapture::captureScreen(&sc); @@ -813,9 +826,9 @@ TEST_F(LayerUpdateTest, LayerWithNoBuffersResizesImmediately) { sc->expectFGColor(74, 74); } - SurfaceComposerClient::openGlobalTransaction(); - childNoBuffer->setSize(20, 20); - SurfaceComposerClient::closeGlobalTransaction(true); + SurfaceComposerClient::Transaction{} + .setSize(childNoBuffer, 20, 20) + .apply(true); { ScreenCapture::captureScreen(&sc); @@ -850,11 +863,11 @@ protected: }; TEST_F(ChildLayerTest, ChildLayerPositioning) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 10, 10); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -866,9 +879,9 @@ TEST_F(ChildLayerTest, ChildLayerPositioning) { mCapture->expectFGColor(84, 84); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(0, 0)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setPosition(mFGSurfaceControl, 0, 0); + }); { ScreenCapture::captureScreen(&mCapture); @@ -882,12 +895,12 @@ TEST_F(ChildLayerTest, ChildLayerPositioning) { } TEST_F(ChildLayerTest, ChildLayerCropping) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - mFGSurfaceControl->setCrop(Rect(0, 0, 5, 5)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 0, 0); + t.setPosition(mFGSurfaceControl, 0, 0); + t.setCrop(mFGSurfaceControl, Rect(0, 0, 5, 5)); + }); { ScreenCapture::captureScreen(&mCapture); @@ -898,12 +911,12 @@ TEST_F(ChildLayerTest, ChildLayerCropping) { } TEST_F(ChildLayerTest, ChildLayerFinalCropping) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - mFGSurfaceControl->setFinalCrop(Rect(0, 0, 5, 5)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 0, 0); + t.setPosition(mFGSurfaceControl, 0, 0); + t.setFinalCrop(mFGSurfaceControl, Rect(0, 0, 5, 5)); + }); { ScreenCapture::captureScreen(&mCapture); @@ -914,11 +927,11 @@ TEST_F(ChildLayerTest, ChildLayerFinalCropping) { } TEST_F(ChildLayerTest, ChildLayerConstraints) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mFGSurfaceControl->setPosition(0, 0); - mChild->setPosition(63, 63); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mFGSurfaceControl, 0, 0); + t.setPosition(mChild, 63, 63); + }); { ScreenCapture::captureScreen(&mCapture); @@ -932,9 +945,9 @@ TEST_F(ChildLayerTest, ChildLayerConstraints) { } TEST_F(ChildLayerTest, ChildLayerScaling) { - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setPosition(0, 0); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setPosition(mFGSurfaceControl, 0, 0); + }); // Find the boundary between the parent and child { @@ -943,9 +956,9 @@ TEST_F(ChildLayerTest, ChildLayerScaling) { mCapture->expectFGColor(10, 10); } - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setMatrix(2.0, 0, 0, 2.0); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setMatrix(mFGSurfaceControl, 2.0, 0, 0, 2.0); + }); // The boundary should be twice as far from the origin now. // The pixels from the last test should all be child now @@ -964,11 +977,11 @@ TEST_F(ChildLayerTest, ChildLayerAlpha) { fillSurfaceRGBA8(mChild, 0, 254, 0); waitForPostedBuffers(); - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 0, 0); + t.setPosition(mFGSurfaceControl, 0, 0); + }); { ScreenCapture::captureScreen(&mCapture); @@ -976,9 +989,9 @@ TEST_F(ChildLayerTest, ChildLayerAlpha) { mCapture->checkPixel(0, 0, 0, 254, 0); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mChild->setAlpha(0.5)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setAlpha(mChild, 0.5); + }); { ScreenCapture::captureScreen(&mCapture); @@ -986,9 +999,9 @@ TEST_F(ChildLayerTest, ChildLayerAlpha) { mCapture->checkPixel(0, 0, 127, 127, 0); } - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.5)); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setAlpha(mFGSurfaceControl, 0.5); + }); { ScreenCapture::captureScreen(&mCapture); @@ -998,11 +1011,11 @@ TEST_F(ChildLayerTest, ChildLayerAlpha) { } TEST_F(ChildLayerTest, ReparentChildren) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 10, 10); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1013,7 +1026,11 @@ TEST_F(ChildLayerTest, ReparentChildren) { // And 10 more pixels we should be back to the foreground surface mCapture->expectFGColor(84, 84); } - mFGSurfaceControl->reparentChildren(mBGSurfaceControl->getHandle()); + + asTransaction([&](Transaction& t) { + t.reparentChildren(mFGSurfaceControl, mBGSurfaceControl->getHandle()); + }); + { ScreenCapture::captureScreen(&mCapture); mCapture->expectFGColor(64, 64); @@ -1027,11 +1044,11 @@ TEST_F(ChildLayerTest, ReparentChildren) { } TEST_F(ChildLayerTest, DetachChildrenSameClient) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 10, 10); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1043,13 +1060,13 @@ TEST_F(ChildLayerTest, DetachChildrenSameClient) { mCapture->expectFGColor(84, 84); } - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->detachChildren(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.detachChildren(mFGSurfaceControl); + }); - SurfaceComposerClient::openGlobalTransaction(); - mChild->hide(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.hide(mChild); + }); // Since the child has the same client as the parent, it will not get // detached and will be hidden. @@ -1072,12 +1089,12 @@ TEST_F(ChildLayerTest, DetachChildrenDifferentClient) { fillSurfaceRGBA8(mChildNewClient, 200, 200, 200); - SurfaceComposerClient::openGlobalTransaction(); - mChild->hide(); - mChildNewClient->show(); - mChildNewClient->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.hide(mChild); + t.show(mChildNewClient); + t.setPosition(mChildNewClient, 10, 10); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1089,13 +1106,13 @@ TEST_F(ChildLayerTest, DetachChildrenDifferentClient) { mCapture->expectFGColor(84, 84); } - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->detachChildren(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.detachChildren(mFGSurfaceControl); + }); - SurfaceComposerClient::openGlobalTransaction(); - mChildNewClient->hide(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.hide(mChildNewClient); + }); // Nothing should have changed. { @@ -1107,11 +1124,11 @@ TEST_F(ChildLayerTest, DetachChildrenDifferentClient) { } TEST_F(ChildLayerTest, ChildrenInheritNonTransformScalingFromParent) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 0, 0); + t.setPosition(mFGSurfaceControl, 0, 0); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1121,11 +1138,11 @@ TEST_F(ChildLayerTest, ChildrenInheritNonTransformScalingFromParent) { mCapture->expectFGColor(10, 10); } - SurfaceComposerClient::openGlobalTransaction(); - mFGSurfaceControl->setOverrideScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); - // We cause scaling by 2. - mFGSurfaceControl->setSize(128, 128); - SurfaceComposerClient::closeGlobalTransaction(); + asTransaction([&](Transaction& t) { + t.setOverrideScalingMode(mFGSurfaceControl, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); + // We cause scaling by 2. + t.setSize(mFGSurfaceControl, 128, 128); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1140,11 +1157,11 @@ TEST_F(ChildLayerTest, ChildrenInheritNonTransformScalingFromParent) { // Regression test for b/37673612 TEST_F(ChildLayerTest, ChildrenWithParentBufferTransform) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 0, 0); + t.setPosition(mFGSurfaceControl, 0, 0); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1153,11 +1170,11 @@ TEST_F(ChildLayerTest, ChildrenWithParentBufferTransform) { // But it's only 10x10. mCapture->expectFGColor(10, 10); } - - // We set things up as in b/37673612 so that there is a mismatch between the buffer size and // the WM specified state size. - mFGSurfaceControl->setSize(128, 64); + asTransaction([&](Transaction& t) { + t.setSize(mFGSurfaceControl, 128, 64); + }); sp<Surface> s = mFGSurfaceControl->getSurface(); auto anw = static_cast<ANativeWindow*>(s.get()); native_window_set_buffers_transform(anw, NATIVE_WINDOW_TRANSFORM_ROT_90); @@ -1184,11 +1201,11 @@ TEST_F(ChildLayerTest, Bug36858924) { mFGSurfaceControl.get()); // Show the child layer in a deferred transaction - SurfaceComposerClient::openGlobalTransaction(); - mChild->deferTransactionUntil(mFGSurfaceControl->getHandle(), - mFGSurfaceControl->getSurface()->getNextFrameNumber()); - mChild->show(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.deferTransactionUntil(mChild, mFGSurfaceControl->getHandle(), + mFGSurfaceControl->getSurface()->getNextFrameNumber()); + t.show(mChild); + }); // Render the foreground surface a few times // @@ -1206,11 +1223,11 @@ TEST_F(ChildLayerTest, Bug36858924) { } TEST_F(ChildLayerTest, Reparent) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 10, 10); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1221,7 +1238,11 @@ TEST_F(ChildLayerTest, Reparent) { // And 10 more pixels we should be back to the foreground surface mCapture->expectFGColor(84, 84); } - mChild->reparent(mBGSurfaceControl->getHandle()); + + asTransaction([&](Transaction& t) { + t.reparent(mChild, mBGSurfaceControl->getHandle()); + }); + { ScreenCapture::captureScreen(&mCapture); mCapture->expectFGColor(64, 64); @@ -1235,11 +1256,11 @@ TEST_F(ChildLayerTest, Reparent) { } TEST_F(ChildLayerTest, ReparentToNoParent) { - SurfaceComposerClient::openGlobalTransaction(); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mChild); + t.setPosition(mChild, 10, 10); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1250,7 +1271,9 @@ TEST_F(ChildLayerTest, ReparentToNoParent) { // And 10 more pixels we should be back to the foreground surface mCapture->expectFGColor(84, 84); } - mChild->reparent(nullptr); + asTransaction([&](Transaction& t) { + t.reparent(mChild, nullptr); + }); { ScreenCapture::captureScreen(&mCapture); // Nothing should have changed. @@ -1267,13 +1290,13 @@ TEST_F(ChildLayerTest, ReparentFromNoParent) { ASSERT_TRUE(newSurface->isValid()); fillSurfaceRGBA8(newSurface, 63, 195, 63); - SurfaceComposerClient::openGlobalTransaction(); - mChild->hide(); - newSurface->show(); - newSurface->setPosition(10, 10); - newSurface->setLayer(INT32_MAX-2); - mFGSurfaceControl->setPosition(64, 64); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.hide(mChild); + t.show(newSurface); + t.setPosition(newSurface, 10, 10); + t.setLayer(newSurface, INT32_MAX-2); + t.setPosition(mFGSurfaceControl, 64, 64); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1283,9 +1306,9 @@ TEST_F(ChildLayerTest, ReparentFromNoParent) { mCapture->checkPixel(10, 10, 63, 195, 63); } - SurfaceComposerClient::openGlobalTransaction(); - newSurface->reparent(mFGSurfaceControl->getHandle()); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.reparent(newSurface, mFGSurfaceControl->getHandle()); + }); { ScreenCapture::captureScreen(&mCapture); @@ -1325,12 +1348,12 @@ class LayerColorTest : public LayerUpdateTest { ASSERT_TRUE(mLayerColorControl != NULL); ASSERT_TRUE(mLayerColorControl->isValid()); - SurfaceComposerClient::openGlobalTransaction(); - ASSERT_EQ(NO_ERROR, mLayerColorControl->setLayer(INT32_MAX-1)); - ASSERT_EQ(NO_ERROR, mLayerColorControl->setPosition(140, 140)); - ASSERT_EQ(NO_ERROR, mLayerColorControl->hide()); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->hide()); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.setLayer(mLayerColorControl, INT32_MAX-1); + t.setPosition(mLayerColorControl, 140, 140); + t.hide(mLayerColorControl); + t.hide(mFGSurfaceControl); + }); } void TearDown() override { @@ -1350,15 +1373,16 @@ TEST_F(LayerColorTest, ColorLayerNoAlpha) { sc->expectBGColor(145, 145); } + asTransaction([&](Transaction& t) { + half3 color(43.0f/255.0f, 207.0f/255.0f, 131.0f/255.0f); + t.setColor(mLayerColorControl, color); + t.show(mLayerColorControl); + }); - SurfaceComposerClient::openGlobalTransaction(); - half3 color(43.0f/255.0f, 207.0f/255.0f, 131.0f/255.0f); - mLayerColorControl->setColor(color); - mLayerColorControl->show(); - SurfaceComposerClient::closeGlobalTransaction(true); { // There should now be a color SCOPED_TRACE("after setColor"); + ScreenCapture::captureScreen(&sc); sc->checkPixel(145, 145, 43, 207, 131); } @@ -1372,12 +1396,13 @@ TEST_F(LayerColorTest, ColorLayerWithAlpha) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - half3 color(43.0f/255.0f, 207.0f/255.0f, 131.0f/255.0f); - mLayerColorControl->setColor(color); - mLayerColorControl->setAlpha(.75f); - mLayerColorControl->show(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + half3 color(43.0f/255.0f, 207.0f/255.0f, 131.0f/255.0f); + t.setColor(mLayerColorControl, color); + t.setAlpha(mLayerColorControl, .75f); + t.show(mLayerColorControl); + }); + { // There should now be a color with .75 alpha SCOPED_TRACE("after setColor"); @@ -1394,9 +1419,10 @@ TEST_F(LayerColorTest, ColorLayerWithNoColor) { sc->expectBGColor(145, 145); } - SurfaceComposerClient::openGlobalTransaction(); - mLayerColorControl->show(); - SurfaceComposerClient::closeGlobalTransaction(true); + asTransaction([&](Transaction& t) { + t.show(mLayerColorControl); + }); + { // There should now be set to 0,0,0 (black) as default. SCOPED_TRACE("after setColor"); diff --git a/services/surfaceflinger/tests/fakehwc/FakeComposerUtils.h b/services/surfaceflinger/tests/fakehwc/FakeComposerUtils.h index 74dc0e51bb..1258a970c7 100644 --- a/services/surfaceflinger/tests/fakehwc/FakeComposerUtils.h +++ b/services/surfaceflinger/tests/fakehwc/FakeComposerUtils.h @@ -87,7 +87,7 @@ public: /* * All surface state changes are supposed to happen inside a global - * transaction. GlobalTransactionScope object at the beginning of + * transaction. TransactionScope object at the beginning of * scope automates the process. The resulting scope gives a visual cue * on the span of the transaction as well. * @@ -96,23 +96,26 @@ public: * is built to explicitly request vsyncs one at the time. A delayed * request must be made before closing the transaction or the test * thread stalls until SurfaceFlinger does an emergency vsync by - * itself. GlobalTransactionScope encapsulates this vsync magic. + * itself. TransactionScope encapsulates this vsync magic. */ -class GlobalTransactionScope { +class TransactionScope : public android::SurfaceComposerClient::Transaction { public: - GlobalTransactionScope(FakeComposerClient& composer) : mComposer(composer) { - android::SurfaceComposerClient::openGlobalTransaction(); + TransactionScope(FakeComposerClient& composer) : + Transaction(), + mComposer(composer) { } - ~GlobalTransactionScope() { + + ~TransactionScope() { int frameCount = mComposer.getFrameCount(); mComposer.runVSyncAfter(1ms); - android::SurfaceComposerClient::closeGlobalTransaction(true); + LOG_ALWAYS_FATAL_IF(android::NO_ERROR != apply()); // Make sure that exactly one frame has been rendered. mComposer.waitUntilFrame(frameCount + 1); LOG_ALWAYS_FATAL_IF(frameCount + 1 != mComposer.getFrameCount(), "Unexpected frame advance. Delta: %d", mComposer.getFrameCount() - frameCount); } + FakeComposerClient& mComposer; }; diff --git a/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp b/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp index 9ac3331892..7f4c58a9ba 100644 --- a/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp +++ b/services/surfaceflinger/tests/fakehwc/SFFakeHwc_test.cpp @@ -24,11 +24,11 @@ #include <gui/ISurfaceComposer.h> #include <gui/LayerDebugInfo.h> +#include <gui/LayerState.h> #include <gui/Surface.h> #include <gui/SurfaceComposerClient.h> #include <private/gui/ComposerService.h> -#include <private/gui/LayerState.h> #include <ui/DisplayInfo.h> @@ -62,6 +62,8 @@ using ::testing::Return; using ::testing::SetArgPointee; using ::testing::_; +using Transaction = SurfaceComposerClient::Transaction; + /////////////////////////////////////////////// struct TestColor { @@ -248,11 +250,11 @@ TEST_F(DisplayTest, Hotplug) { fillSurfaceRGBA8(surfaceControl, BLUE); { - GlobalTransactionScope gts(*mMockComposer); - mComposerClient->setDisplayLayerStack(display, 0); + TransactionScope ts(*mMockComposer); + ts.setDisplayLayerStack(display, 0); - ASSERT_EQ(NO_ERROR, surfaceControl->setLayer(INT32_MAX - 2)); - ASSERT_EQ(NO_ERROR, surfaceControl->show()); + ts.setLayer(surfaceControl, INT32_MAX - 2) + .show(surfaceControl); } } @@ -278,11 +280,11 @@ TEST_F(DisplayTest, Hotplug) { fillSurfaceRGBA8(surfaceControl, BLUE); { - GlobalTransactionScope gts(*mMockComposer); - mComposerClient->setDisplayLayerStack(display, 0); + TransactionScope ts(*mMockComposer); + ts.setDisplayLayerStack(display, 0); - ASSERT_EQ(NO_ERROR, surfaceControl->setLayer(INT32_MAX - 2)); - ASSERT_EQ(NO_ERROR, surfaceControl->show()); + ts.setLayer(surfaceControl, INT32_MAX - 2) + .show(surfaceControl); } } mMockComposer->hotplugDisplay(EXTERNAL_DISPLAY, IComposerCallback::Connection::DISCONNECTED); @@ -370,25 +372,24 @@ void TransactionTest::SetUp() { fillSurfaceRGBA8(mFGSurfaceControl, RED); - SurfaceComposerClient::openGlobalTransaction(); - - mComposerClient->setDisplayLayerStack(display, 0); + Transaction t; + t.setDisplayLayerStack(display, 0); - ASSERT_EQ(NO_ERROR, mBGSurfaceControl->setLayer(INT32_MAX - 2)); - ASSERT_EQ(NO_ERROR, mBGSurfaceControl->show()); + t.setLayer(mBGSurfaceControl, INT32_MAX - 2); + t.show(mBGSurfaceControl); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT32_MAX - 1)); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(64, 64)); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->show()); + t.setLayer(mFGSurfaceControl, INT32_MAX - 1); + t.setPosition(mFGSurfaceControl, 64, 64); + t.show(mFGSurfaceControl); // Synchronous transaction will stop this thread, so we set up a // delayed, off-thread vsync request before closing the // transaction. In the test code this is usually done with - // GlobalTransactionScope. Leaving here in the 'vanilla' form for + // TransactionScope. Leaving here in the 'vanilla' form for // reference. ASSERT_EQ(0, sFakeComposer->getFrameCount()); sFakeComposer->runVSyncAfter(1ms); - SurfaceComposerClient::closeGlobalTransaction(true); + t.apply(); sFakeComposer->waitUntilFrame(1); // Reference data. This is what the HWC should see. @@ -445,8 +446,8 @@ TEST_F(TransactionTest, LayerMove) { // should be available in the latest frame stored by the fake // composer. { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(128, 128)); + TransactionScope ts(*sFakeComposer); + ts.setPosition(mFGSurfaceControl, 128, 128); // NOTE: No changes yet, so vsync will do nothing, HWC does not get any calls. // (How to verify that? Throw in vsync and wait a 2x frame time? Separate test?) // @@ -473,8 +474,8 @@ TEST_F(TransactionTest, LayerMove) { TEST_F(TransactionTest, LayerResize) { ALOGD("TransactionTest::LayerResize"); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setSize(128, 128)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); } fillSurfaceRGBA8(mFGSurfaceControl, GREEN); @@ -497,9 +498,9 @@ TEST_F(TransactionTest, LayerResize) { TEST_F(TransactionTest, LayerCrop) { // TODO: Add scaling to confirm that crop happens in buffer space? { - GlobalTransactionScope gts(*sFakeComposer); + TransactionScope ts(*sFakeComposer); Rect cropRect(16, 16, 32, 32); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setCrop(cropRect)); + ts.setCrop(mFGSurfaceControl, cropRect); } ASSERT_EQ(2, sFakeComposer->getFrameCount()); @@ -512,9 +513,9 @@ TEST_F(TransactionTest, LayerCrop) { TEST_F(TransactionTest, LayerFinalCrop) { // TODO: Add scaling to confirm that crop happens in display space? { - GlobalTransactionScope gts(*sFakeComposer); + TransactionScope ts(*sFakeComposer); Rect cropRect(32, 32, 32 + 64, 32 + 64); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setFinalCrop(cropRect)); + ts.setFinalCrop(mFGSurfaceControl, cropRect); } ASSERT_EQ(2, sFakeComposer->getFrameCount()); @@ -530,9 +531,9 @@ TEST_F(TransactionTest, LayerFinalCrop) { TEST_F(TransactionTest, LayerFinalCropEmpty) { // TODO: Add scaling to confirm that crop happens in display space? { - GlobalTransactionScope gts(*sFakeComposer); + TransactionScope ts(*sFakeComposer); Rect cropRect(16, 16, 32, 32); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setFinalCrop(cropRect)); + ts.setFinalCrop(mFGSurfaceControl, cropRect); } ASSERT_EQ(2, sFakeComposer->getFrameCount()); @@ -545,8 +546,8 @@ TEST_F(TransactionTest, LayerFinalCropEmpty) { TEST_F(TransactionTest, LayerSetLayer) { { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT_MAX - 3)); + TransactionScope ts(*sFakeComposer); + ts.setLayer(mFGSurfaceControl, INT_MAX - 3); } ASSERT_EQ(2, sFakeComposer->getFrameCount()); @@ -560,11 +561,10 @@ TEST_F(TransactionTest, LayerSetLayer) { TEST_F(TransactionTest, LayerSetLayerOpaque) { { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayer(INT_MAX - 3)); - ASSERT_EQ(NO_ERROR, - mBGSurfaceControl->setFlags(layer_state_t::eLayerOpaque, - layer_state_t::eLayerOpaque)); + TransactionScope ts(*sFakeComposer); + ts.setLayer(mFGSurfaceControl, INT_MAX - 3); + ts.setFlags(mBGSurfaceControl, layer_state_t::eLayerOpaque, + layer_state_t::eLayerOpaque); } ASSERT_EQ(2, sFakeComposer->getFrameCount()); @@ -577,8 +577,8 @@ TEST_F(TransactionTest, LayerSetLayerOpaque) { TEST_F(TransactionTest, SetLayerStack) { ALOGD("TransactionTest::SetLayerStack"); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setLayerStack(1)); + TransactionScope ts(*sFakeComposer); + ts.setLayerStack(mFGSurfaceControl, 1); } // Foreground layer should have disappeared. @@ -591,8 +591,8 @@ TEST_F(TransactionTest, SetLayerStack) { TEST_F(TransactionTest, LayerShowHide) { ALOGD("TransactionTest::LayerShowHide"); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->hide()); + TransactionScope ts(*sFakeComposer); + ts.hide(mFGSurfaceControl); } // Foreground layer should have disappeared. @@ -602,8 +602,8 @@ TEST_F(TransactionTest, LayerShowHide) { EXPECT_TRUE(framesAreSame(refFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->show()); + TransactionScope ts(*sFakeComposer); + ts.show(mFGSurfaceControl); } // Foreground layer should be back @@ -613,8 +613,8 @@ TEST_F(TransactionTest, LayerShowHide) { TEST_F(TransactionTest, LayerSetAlpha) { { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.75f)); + TransactionScope ts(*sFakeComposer); + ts.setAlpha(mFGSurfaceControl, 0.75f); } ASSERT_EQ(2, sFakeComposer->getFrameCount()); @@ -625,10 +625,9 @@ TEST_F(TransactionTest, LayerSetAlpha) { TEST_F(TransactionTest, LayerSetFlags) { { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, - mFGSurfaceControl->setFlags(layer_state_t::eLayerHidden, - layer_state_t::eLayerHidden)); + TransactionScope ts(*sFakeComposer); + ts.setFlags(mFGSurfaceControl, layer_state_t::eLayerHidden, + layer_state_t::eLayerHidden); } // Foreground layer should have disappeared. @@ -667,10 +666,9 @@ TEST_F(TransactionTest, LayerSetMatrix) { const matrixTestData& xform = MATRIX_TESTS[i]; SCOPED_TRACE(i); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, - mFGSurfaceControl->setMatrix(xform.matrix[0], xform.matrix[1], - xform.matrix[2], xform.matrix[3])); + TransactionScope ts(*sFakeComposer); + ts.setMatrix(mFGSurfaceControl, xform.matrix[0], xform.matrix[1], + xform.matrix[2], xform.matrix[3]); } auto referenceFrame = mBaseFrame; @@ -684,10 +682,10 @@ TEST_F(TransactionTest, LayerSetMatrix) { #if 0 TEST_F(TransactionTest, LayerSetMatrix2) { { - GlobalTransactionScope gts(*sFakeComposer); + TransactionScope ts(*sFakeComposer); // TODO: PLEASE SPEC THE FUNCTION! - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setMatrix(0.11f, 0.123f, - -2.33f, 0.22f)); + ts.setMatrix(mFGSurfaceControl, 0.11f, 0.123f, + -2.33f, 0.22f); } auto referenceFrame = mBaseFrame; // TODO: Is this correct for sure? @@ -708,10 +706,10 @@ TEST_F(TransactionTest, DeferredTransaction) { fillSurfaceRGBA8(syncSurfaceControl, DARK_GRAY); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, syncSurfaceControl->setLayer(INT32_MAX - 1)); - ASSERT_EQ(NO_ERROR, syncSurfaceControl->setPosition(mDisplayWidth - 2, mDisplayHeight - 2)); - ASSERT_EQ(NO_ERROR, syncSurfaceControl->show()); + TransactionScope ts(*sFakeComposer); + ts.setLayer(syncSurfaceControl, INT32_MAX - 1); + ts.setPosition(syncSurfaceControl, mDisplayWidth - 2, mDisplayHeight - 2); + ts.show(syncSurfaceControl); } auto referenceFrame = mBaseFrame; referenceFrame.push_back(makeSimpleRect(mDisplayWidth - 2, mDisplayHeight - 2, @@ -723,20 +721,20 @@ TEST_F(TransactionTest, DeferredTransaction) { // set up two deferred transactions on different frames - these should not yield composited // frames { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.75)); - mFGSurfaceControl - ->deferTransactionUntil(syncSurfaceControl->getHandle(), - syncSurfaceControl->getSurface()->getNextFrameNumber()); + TransactionScope ts(*sFakeComposer); + ts.setAlpha(mFGSurfaceControl, 0.75); + ts.deferTransactionUntil(mFGSurfaceControl, + syncSurfaceControl->getHandle(), + syncSurfaceControl->getSurface()->getNextFrameNumber()); } EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(128, 128)); - mFGSurfaceControl - ->deferTransactionUntil(syncSurfaceControl->getHandle(), - syncSurfaceControl->getSurface()->getNextFrameNumber() + 1); + TransactionScope ts(*sFakeComposer); + ts.setPosition(mFGSurfaceControl, 128, 128); + ts.deferTransactionUntil(mFGSurfaceControl, + syncSurfaceControl->getHandle(), + syncSurfaceControl->getSurface()->getNextFrameNumber() + 1); } EXPECT_EQ(4, sFakeComposer->getFrameCount()); EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); @@ -752,8 +750,8 @@ TEST_F(TransactionTest, DeferredTransaction) { // should show up immediately since it's not deferred { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(1.0)); + TransactionScope ts(*sFakeComposer); + ts.setAlpha(mFGSurfaceControl, 1.0); } referenceFrame[FG_LAYER].mPlaneAlpha = 1.f; EXPECT_EQ(6, sFakeComposer->getFrameCount()); @@ -777,10 +775,10 @@ TEST_F(TransactionTest, SetRelativeLayer) { // Now we stack the surface above the foreground surface and make sure it is visible. { - GlobalTransactionScope gts(*sFakeComposer); - relativeSurfaceControl->setPosition(64, 64); - relativeSurfaceControl->show(); - relativeSurfaceControl->setRelativeLayer(mFGSurfaceControl->getHandle(), 1); + TransactionScope ts(*sFakeComposer); + ts.setPosition(relativeSurfaceControl, 64, 64); + ts.show(relativeSurfaceControl); + ts.setRelativeLayer(relativeSurfaceControl, mFGSurfaceControl->getHandle(), 1); } auto referenceFrame = mBaseFrame; // NOTE: All three layers will be visible as the surfaces are @@ -791,8 +789,8 @@ TEST_F(TransactionTest, SetRelativeLayer) { // A call to setLayer will override a call to setRelativeLayer { - GlobalTransactionScope gts(*sFakeComposer); - relativeSurfaceControl->setLayer(0); + TransactionScope ts(*sFakeComposer); + ts.setLayer(relativeSurfaceControl, 0); } // Previous top layer will now appear at the bottom. @@ -828,11 +826,11 @@ protected: TEST_F(ChildLayerTest, Positioning) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(10, 10); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 10, 10); // Move to the same position as in the original setup. - mFGSurfaceControl->setPosition(64, 64); + ts.setPosition(mFGSurfaceControl, 64, 64); } auto referenceFrame = mBaseFrame; @@ -842,8 +840,8 @@ TEST_F(ChildLayerTest, Positioning) { EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setPosition(0, 0)); + TransactionScope ts(*sFakeComposer); + ts.setPosition(mFGSurfaceControl, 0, 0); } auto referenceFrame2 = mBaseFrame; @@ -855,11 +853,11 @@ TEST_F(ChildLayerTest, Positioning) { TEST_F(ChildLayerTest, Cropping) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - mFGSurfaceControl->setCrop(Rect(0, 0, 5, 5)); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 0, 0); + ts.setPosition(mFGSurfaceControl, 0, 0); + ts.setCrop(mFGSurfaceControl, Rect(0, 0, 5, 5)); } // NOTE: The foreground surface would be occluded by the child // now, but is included in the stack because the child is @@ -874,11 +872,11 @@ TEST_F(ChildLayerTest, Cropping) { TEST_F(ChildLayerTest, FinalCropping) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - mFGSurfaceControl->setFinalCrop(Rect(0, 0, 5, 5)); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 0, 0); + ts.setPosition(mFGSurfaceControl, 0, 0); + ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, 5, 5)); } auto referenceFrame = mBaseFrame; referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 0 + 5, 0 + 5}; @@ -890,10 +888,10 @@ TEST_F(ChildLayerTest, FinalCropping) { TEST_F(ChildLayerTest, Constraints) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mFGSurfaceControl->setPosition(0, 0); - mChild->setPosition(63, 63); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mFGSurfaceControl, 0, 0); + ts.setPosition(mChild, 63, 63); } auto referenceFrame = mBaseFrame; referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64}; @@ -904,8 +902,8 @@ TEST_F(ChildLayerTest, Constraints) { TEST_F(ChildLayerTest, Scaling) { { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setPosition(0, 0); + TransactionScope ts(*sFakeComposer); + ts.setPosition(mFGSurfaceControl, 0, 0); } auto referenceFrame = mBaseFrame; referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{0, 0, 64, 64}; @@ -913,8 +911,8 @@ TEST_F(ChildLayerTest, Scaling) { EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setMatrix(2.0, 0, 0, 2.0); + TransactionScope ts(*sFakeComposer); + ts.setMatrix(mFGSurfaceControl, 2.0, 0, 0, 2.0); } auto referenceFrame2 = mBaseFrame; @@ -925,11 +923,11 @@ TEST_F(ChildLayerTest, Scaling) { TEST_F(ChildLayerTest, LayerAlpha) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); - ASSERT_EQ(NO_ERROR, mChild->setAlpha(0.5)); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 0, 0); + ts.setPosition(mFGSurfaceControl, 0, 0); + ts.setAlpha(mChild, 0.5); } auto referenceFrame = mBaseFrame; @@ -939,8 +937,8 @@ TEST_F(ChildLayerTest, LayerAlpha) { EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - ASSERT_EQ(NO_ERROR, mFGSurfaceControl->setAlpha(0.5)); + TransactionScope ts(*sFakeComposer); + ts.setAlpha(mFGSurfaceControl, 0.5); } auto referenceFrame2 = referenceFrame; @@ -951,10 +949,10 @@ TEST_F(ChildLayerTest, LayerAlpha) { TEST_F(ChildLayerTest, ReparentChildren) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 10, 10); + ts.setPosition(mFGSurfaceControl, 64, 64); } auto referenceFrame = mBaseFrame; referenceFrame[FG_LAYER].mDisplayFrame = hwc_rect_t{64, 64, 64 + 64, 64 + 64}; @@ -963,8 +961,8 @@ TEST_F(ChildLayerTest, ReparentChildren) { EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->reparentChildren(mBGSurfaceControl->getHandle()); + TransactionScope ts(*sFakeComposer); + ts.reparentChildren(mFGSurfaceControl, mBGSurfaceControl->getHandle()); } auto referenceFrame2 = referenceFrame; @@ -975,10 +973,10 @@ TEST_F(ChildLayerTest, ReparentChildren) { TEST_F(ChildLayerTest, DetachChildren) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(10, 10); - mFGSurfaceControl->setPosition(64, 64); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 10, 10); + ts.setPosition(mFGSurfaceControl, 64, 64); } auto referenceFrame = mBaseFrame; @@ -988,13 +986,13 @@ TEST_F(ChildLayerTest, DetachChildren) { EXPECT_TRUE(framesAreSame(referenceFrame, sFakeComposer->getLatestFrame())); { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->detachChildren(); + TransactionScope ts(*sFakeComposer); + ts.detachChildren(mFGSurfaceControl); } { - GlobalTransactionScope gts(*sFakeComposer); - mChild->hide(); + TransactionScope ts(*sFakeComposer); + ts.hide(mChild); } // Nothing should have changed. The child control becomes a no-op @@ -1005,17 +1003,17 @@ TEST_F(ChildLayerTest, DetachChildren) { TEST_F(ChildLayerTest, InheritNonTransformScalingFromParent) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 0, 0); + ts.setPosition(mFGSurfaceControl, 0, 0); } { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setOverrideScalingMode(NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); + TransactionScope ts(*sFakeComposer); + ts.setOverrideScalingMode(mFGSurfaceControl, NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW); // We cause scaling by 2. - mFGSurfaceControl->setSize(128, 128); + ts.setSize(mFGSurfaceControl, 128, 128); } auto referenceFrame = mBaseFrame; @@ -1029,17 +1027,17 @@ TEST_F(ChildLayerTest, InheritNonTransformScalingFromParent) { // Regression test for b/37673612 TEST_F(ChildLayerTest, ChildrenWithParentBufferTransform) { { - GlobalTransactionScope gts(*sFakeComposer); - mChild->show(); - mChild->setPosition(0, 0); - mFGSurfaceControl->setPosition(0, 0); + TransactionScope ts(*sFakeComposer); + ts.show(mChild); + ts.setPosition(mChild, 0, 0); + ts.setPosition(mFGSurfaceControl, 0, 0); } // We set things up as in b/37673612 so that there is a mismatch between the buffer size and // the WM specified state size. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 64); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 64); } sp<Surface> s = mFGSurfaceControl->getSurface(); @@ -1070,10 +1068,10 @@ TEST_F(ChildLayerTest, Bug36858924) { // Show the child layer in a deferred transaction { - GlobalTransactionScope gts(*sFakeComposer); - mChild->deferTransactionUntil(mFGSurfaceControl->getHandle(), + TransactionScope ts(*sFakeComposer); + ts.deferTransactionUntil(mChild, mFGSurfaceControl->getHandle(), mFGSurfaceControl->getSurface()->getNextFrameNumber()); - mChild->show(); + ts.show(mChild); } // Render the foreground surface a few times @@ -1110,11 +1108,11 @@ protected: sFakeComposer->runVSyncAndWait(); } void restoreInitialState() { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(64, 64); - mFGSurfaceControl->setPosition(64, 64); - mFGSurfaceControl->setCrop(Rect(0, 0, 64, 64)); - mFGSurfaceControl->setFinalCrop(Rect(0, 0, -1, -1)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 64, 64); + ts.setPosition(mFGSurfaceControl, 64, 64); + ts.setCrop(mFGSurfaceControl, Rect(0, 0, 64, 64)); + ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1)); } }; @@ -1122,9 +1120,9 @@ TEST_F(LatchingTest, SurfacePositionLatching) { // By default position can be updated even while // a resize is pending. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(32, 32); - mFGSurfaceControl->setPosition(100, 100); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 32, 32); + ts.setPosition(mFGSurfaceControl, 100, 100); } // The size should not have updated as we have not provided a new buffer. @@ -1137,10 +1135,10 @@ TEST_F(LatchingTest, SurfacePositionLatching) { // Now we repeat with setGeometryAppliesWithResize // and verify the position DOESN'T latch. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setSize(32, 32); - mFGSurfaceControl->setPosition(100, 100); + TransactionScope ts(*sFakeComposer); + ts.setGeometryAppliesWithResize(mFGSurfaceControl); + ts.setSize(mFGSurfaceControl, 32, 32); + ts.setPosition(mFGSurfaceControl, 100, 100); } EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); @@ -1156,9 +1154,9 @@ TEST_F(LatchingTest, SurfacePositionLatching) { TEST_F(LatchingTest, CropLatching) { // Normally the crop applies immediately even while a resize is pending. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setCrop(Rect(0, 0, 63, 63)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63)); } auto referenceFrame1 = mBaseFrame; @@ -1169,10 +1167,10 @@ TEST_F(LatchingTest, CropLatching) { restoreInitialState(); { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setCrop(Rect(0, 0, 63, 63)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setGeometryAppliesWithResize(mFGSurfaceControl); + ts.setCrop(mFGSurfaceControl, Rect(0, 0, 63, 63)); } EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); @@ -1188,9 +1186,9 @@ TEST_F(LatchingTest, CropLatching) { TEST_F(LatchingTest, FinalCropLatching) { // Normally the crop applies immediately even while a resize is pending. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); } auto referenceFrame1 = mBaseFrame; @@ -1202,10 +1200,10 @@ TEST_F(LatchingTest, FinalCropLatching) { restoreInitialState(); { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setGeometryAppliesWithResize(mFGSurfaceControl); + ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); } EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); @@ -1224,9 +1222,9 @@ TEST_F(LatchingTest, FinalCropLatching) { TEST_F(LatchingTest, FinalCropLatchingBufferOldSize) { // Normally the crop applies immediately even while a resize is pending. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); } auto referenceFrame1 = mBaseFrame; @@ -1242,10 +1240,10 @@ TEST_F(LatchingTest, FinalCropLatchingBufferOldSize) { lockAndFillFGBuffer(); { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setGeometryAppliesWithResize(mFGSurfaceControl); + ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); } EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); @@ -1271,15 +1269,15 @@ TEST_F(LatchingTest, FinalCropLatchingRegressionForb37531386) { // is still pending, and ensure we are successful. Success meaning the second crop // is the one which eventually latches and not the first. { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setSize(128, 128); - mFGSurfaceControl->setGeometryAppliesWithResize(); - mFGSurfaceControl->setFinalCrop(Rect(64, 64, 127, 127)); + TransactionScope ts(*sFakeComposer); + ts.setSize(mFGSurfaceControl, 128, 128); + ts.setGeometryAppliesWithResize(mFGSurfaceControl); + ts.setFinalCrop(mFGSurfaceControl, Rect(64, 64, 127, 127)); } { - GlobalTransactionScope gts(*sFakeComposer); - mFGSurfaceControl->setFinalCrop(Rect(0, 0, -1, -1)); + TransactionScope ts(*sFakeComposer); + ts.setFinalCrop(mFGSurfaceControl, Rect(0, 0, -1, -1)); } EXPECT_TRUE(framesAreSame(mBaseFrame, sFakeComposer->getLatestFrame())); |