SF: Remove composer sequence IDs
Multiple HWC instances are no longer supported since VR was nixed.
Also, rename HAL callbacks so their origin is clear.
Bug: 182939859
Test: Build
Change-Id: Ia09b120dce1a4659a3cbb8927d44da8fba266c54
Merged-In: Ia09b120dce1a4659a3cbb8927d44da8fba266c54
diff --git a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h
index 3ca13a6..64cbea9 100644
--- a/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h
+++ b/services/surfaceflinger/CompositionEngine/tests/MockHWComposer.h
@@ -39,7 +39,7 @@
HWComposer();
~HWComposer() override;
- MOCK_METHOD2(setConfiguration, void(HWC2::ComposerCallback*, int32_t));
+ MOCK_METHOD1(setCallback, void(HWC2::ComposerCallback*));
MOCK_CONST_METHOD3(getDisplayIdentificationData,
bool(hal::HWDisplayId, uint8_t*, DisplayIdentificationData*));
MOCK_CONST_METHOD1(hasCapability, bool(hal::Capability));
diff --git a/services/surfaceflinger/DisplayHardware/HWC2.h b/services/surfaceflinger/DisplayHardware/HWC2.h
index fae95e7..871465d 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2.h
+++ b/services/surfaceflinger/DisplayHardware/HWC2.h
@@ -56,20 +56,16 @@
// Implement this interface to receive hardware composer events.
//
// These callback functions will generally be called on a hwbinder thread, but
-// when first registering the callback the onHotplugReceived() function will
+// when first registering the callback the onComposerHalHotplug() function will
// immediately be called on the thread calling registerCallback().
-//
-// All calls receive a sequenceId, which will be the value that was supplied to
-// HWC2::Device::registerCallback(). It's used to help differentiate callbacks
-// from different hardware composer instances.
struct ComposerCallback {
- virtual void onHotplugReceived(int32_t sequenceId, hal::HWDisplayId, hal::Connection) = 0;
- virtual void onRefreshReceived(int32_t sequenceId, hal::HWDisplayId) = 0;
- virtual void onVsyncReceived(int32_t sequenceId, hal::HWDisplayId, int64_t timestamp,
- std::optional<hal::VsyncPeriodNanos>) = 0;
- virtual void onVsyncPeriodTimingChangedReceived(int32_t sequenceId, hal::HWDisplayId,
- const hal::VsyncPeriodChangeTimeline&) = 0;
- virtual void onSeamlessPossible(int32_t sequenceId, hal::HWDisplayId) = 0;
+ virtual void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) = 0;
+ virtual void onComposerHalRefresh(hal::HWDisplayId) = 0;
+ virtual void onComposerHalVsync(hal::HWDisplayId, int64_t timestamp,
+ std::optional<hal::VsyncPeriodNanos>) = 0;
+ virtual void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
+ const hal::VsyncPeriodChangeTimeline&) = 0;
+ virtual void onComposerHalSeamlessPossible(hal::HWDisplayId) = 0;
protected:
~ComposerCallback() = default;
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index b7bb924..32f04e5 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -82,25 +82,22 @@
class ComposerCallbackBridge : public hal::IComposerCallback {
public:
- ComposerCallbackBridge(ComposerCallback* callback, int32_t sequenceId,
- bool vsyncSwitchingSupported)
- : mCallback(callback),
- mSequenceId(sequenceId),
- mVsyncSwitchingSupported(vsyncSwitchingSupported) {}
+ ComposerCallbackBridge(ComposerCallback* callback, bool vsyncSwitchingSupported)
+ : mCallback(callback), mVsyncSwitchingSupported(vsyncSwitchingSupported) {}
- Return<void> onHotplug(hal::HWDisplayId display, hal::Connection conn) override {
- mCallback->onHotplugReceived(mSequenceId, display, conn);
+ Return<void> onHotplug(hal::HWDisplayId display, hal::Connection connection) override {
+ mCallback->onComposerHalHotplug(display, connection);
return Void();
}
Return<void> onRefresh(hal::HWDisplayId display) override {
- mCallback->onRefreshReceived(mSequenceId, display);
+ mCallback->onComposerHalRefresh(display);
return Void();
}
Return<void> onVsync(hal::HWDisplayId display, int64_t timestamp) override {
if (!mVsyncSwitchingSupported) {
- mCallback->onVsyncReceived(mSequenceId, display, timestamp, std::nullopt);
+ mCallback->onComposerHalVsync(display, timestamp, std::nullopt);
} else {
ALOGW("Unexpected onVsync callback on composer >= 2.4, ignoring.");
}
@@ -110,8 +107,7 @@
Return<void> onVsync_2_4(hal::HWDisplayId display, int64_t timestamp,
hal::VsyncPeriodNanos vsyncPeriodNanos) override {
if (mVsyncSwitchingSupported) {
- mCallback->onVsyncReceived(mSequenceId, display, timestamp,
- std::make_optional(vsyncPeriodNanos));
+ mCallback->onComposerHalVsync(display, timestamp, vsyncPeriodNanos);
} else {
ALOGW("Unexpected onVsync_2_4 callback on composer <= 2.3, ignoring.");
}
@@ -119,20 +115,18 @@
}
Return<void> onVsyncPeriodTimingChanged(
- hal::HWDisplayId display,
- const hal::VsyncPeriodChangeTimeline& updatedTimeline) override {
- mCallback->onVsyncPeriodTimingChangedReceived(mSequenceId, display, updatedTimeline);
+ hal::HWDisplayId display, const hal::VsyncPeriodChangeTimeline& timeline) override {
+ mCallback->onComposerHalVsyncPeriodTimingChanged(display, timeline);
return Void();
}
Return<void> onSeamlessPossible(hal::HWDisplayId display) override {
- mCallback->onSeamlessPossible(mSequenceId, display);
+ mCallback->onComposerHalSeamlessPossible(display);
return Void();
}
private:
- ComposerCallback* mCallback;
- const int32_t mSequenceId;
+ ComposerCallback* const mCallback;
const bool mVsyncSwitchingSupported;
};
@@ -155,7 +149,7 @@
mDisplayData.clear();
}
-void HWComposer::setConfiguration(HWC2::ComposerCallback* callback, int32_t sequenceId) {
+void HWComposer::setCallback(HWC2::ComposerCallback* callback) {
loadCapabilities();
loadLayerMetadataSupport();
@@ -164,10 +158,9 @@
return;
}
mRegisteredCallback = true;
- sp<ComposerCallbackBridge> callbackBridge(
- new ComposerCallbackBridge(callback, sequenceId,
- mComposer->isVsyncPeriodSwitchSupported()));
- mComposer->registerCallback(callbackBridge);
+
+ mComposer->registerCallback(
+ sp<ComposerCallbackBridge>::make(callback, mComposer->isVsyncPeriodSwitchSupported()));
}
bool HWComposer::getDisplayIdentificationData(hal::HWDisplayId hwcDisplayId, uint8_t* outPort,
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 3ddcdd8..cd6f9f5 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -100,7 +100,7 @@
virtual ~HWComposer();
- virtual void setConfiguration(HWC2::ComposerCallback* callback, int32_t sequenceId) = 0;
+ virtual void setCallback(HWC2::ComposerCallback*) = 0;
virtual bool getDisplayIdentificationData(hal::HWDisplayId, uint8_t* outPort,
DisplayIdentificationData* outData) const = 0;
@@ -252,7 +252,7 @@
~HWComposer() override;
- void setConfiguration(HWC2::ComposerCallback* callback, int32_t sequenceId) override;
+ void setCallback(HWC2::ComposerCallback*) override;
bool getDisplayIdentificationData(hal::HWDisplayId, uint8_t* outPort,
DisplayIdentificationData* outData) const override;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index 1deda9b..2b4f9ef 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -783,7 +783,7 @@
.build()));
mCompositionEngine->setTimeStats(mTimeStats);
mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
- mCompositionEngine->getHwComposer().setConfiguration(this, getBE().mComposerSequenceId);
+ mCompositionEngine->getHwComposer().setCallback(this);
ClientCache::getInstance().setRenderEngine(&getRenderEngine());
if (base::GetBoolProperty("debug.sf.enable_hwc_vds"s, false)) {
@@ -1663,16 +1663,11 @@
return 0;
}
-void SurfaceFlinger::onVsyncReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
- int64_t timestamp,
- std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
- ATRACE_NAME("SF onVsync");
+void SurfaceFlinger::onComposerHalVsync(hal::HWDisplayId hwcDisplayId, int64_t timestamp,
+ std::optional<hal::VsyncPeriodNanos> vsyncPeriod) {
+ ATRACE_CALL();
Mutex::Autolock lock(mStateLock);
- // Ignore any vsyncs from a previous hardware composer.
- if (sequenceId != getBE().mComposerSequenceId) {
- return;
- }
if (const auto displayId = getHwComposer().toPhysicalDisplayId(hwcDisplayId)) {
auto token = getPhysicalDisplayTokenLocked(*displayId);
@@ -1723,16 +1718,11 @@
setDesiredActiveMode({refreshRate.getModeId(), event});
}
-void SurfaceFlinger::onHotplugReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
- hal::Connection connection) {
- ALOGI("%s(%d, %" PRIu64 ", %s)", __FUNCTION__, sequenceId, hwcDisplayId,
+void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,
+ hal::Connection connection) {
+ ALOGI("%s(%" PRIu64 ", %s)", __func__, hwcDisplayId,
connection == hal::Connection::CONNECTED ? "connected" : "disconnected");
- // Ignore events that do not have the right sequenceId.
- if (sequenceId != getBE().mComposerSequenceId) {
- return;
- }
-
// Only lock if we're not on the main thread. This function is normally
// called on a hwbinder thread, but for the primary display it's called on
// the main thread with the state lock already held, so don't attempt to
@@ -1749,26 +1739,19 @@
setTransactionFlags(eDisplayTransactionNeeded);
}
-void SurfaceFlinger::onVsyncPeriodTimingChangedReceived(
- int32_t sequenceId, hal::HWDisplayId /*display*/,
- const hal::VsyncPeriodChangeTimeline& updatedTimeline) {
+void SurfaceFlinger::onComposerHalVsyncPeriodTimingChanged(
+ hal::HWDisplayId, const hal::VsyncPeriodChangeTimeline& timeline) {
Mutex::Autolock lock(mStateLock);
- if (sequenceId != getBE().mComposerSequenceId) {
- return;
- }
- mScheduler->onNewVsyncPeriodChangeTimeline(updatedTimeline);
+ mScheduler->onNewVsyncPeriodChangeTimeline(timeline);
}
-void SurfaceFlinger::onSeamlessPossible(int32_t /*sequenceId*/, hal::HWDisplayId /*display*/) {
+void SurfaceFlinger::onComposerHalSeamlessPossible(hal::HWDisplayId) {
// TODO(b/142753666): use constraints when calling to setActiveModeWithConstraints and
// use this callback to know when to retry in case of SEAMLESS_NOT_POSSIBLE.
}
-void SurfaceFlinger::onRefreshReceived(int sequenceId, hal::HWDisplayId /*hwcDisplayId*/) {
+void SurfaceFlinger::onComposerHalRefresh(hal::HWDisplayId) {
Mutex::Autolock lock(mStateLock);
- if (sequenceId != getBE().mComposerSequenceId) {
- return;
- }
repaintEverythingForHWC();
}
@@ -5651,7 +5634,7 @@
Mutex::Autolock lock(mStateLock);
hwcId = getHwComposer().getInternalHwcDisplayId();
}
- onHotplugReceived(getBE().mComposerSequenceId, *hwcId, hal::Connection::CONNECTED);
+ onComposerHalHotplug(*hwcId, hal::Connection::CONNECTED);
return NO_ERROR;
}
// Modify the max number of display frames stored within FrameTimeline
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 5616887..be3417b 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -170,11 +170,6 @@
};
mutable Mutex mBufferingStatsMutex;
std::unordered_map<std::string, BufferingStats> mBufferingStats;
-
- // The composer sequence id is a monotonically increasing integer that we
- // use to differentiate callbacks from different hardware composer
- // instances. Each hardware composer instance gets a different sequence id.
- int32_t mComposerSequenceId = 0;
};
class SurfaceFlinger : public BnSurfaceComposer,
@@ -718,18 +713,14 @@
// Implements RefBase.
void onFirstRef() override;
- /*
- * HWC2::ComposerCallback / HWComposer::EventHandler interface
- */
- void onVsyncReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId, int64_t timestamp,
- std::optional<hal::VsyncPeriodNanos> vsyncPeriod) override;
- void onHotplugReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId,
- hal::Connection connection) override;
- void onRefreshReceived(int32_t sequenceId, hal::HWDisplayId hwcDisplayId) override;
- void onVsyncPeriodTimingChangedReceived(
- int32_t sequenceId, hal::HWDisplayId display,
- const hal::VsyncPeriodChangeTimeline& updatedTimeline) override;
- void onSeamlessPossible(int32_t sequenceId, hal::HWDisplayId display) override;
+ // HWC2::ComposerCallback overrides:
+ void onComposerHalVsync(hal::HWDisplayId, int64_t timestamp,
+ std::optional<hal::VsyncPeriodNanos>) override;
+ void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) override;
+ void onComposerHalRefresh(hal::HWDisplayId) override;
+ void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
+ const hal::VsyncPeriodChangeTimeline&) override;
+ void onComposerHalSeamlessPossible(hal::HWDisplayId) override;
/*
* ISchedulerCallback
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index 736ef30..b5086fa 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -69,7 +69,7 @@
"SurfaceFlinger_GetDisplayNativePrimariesTest.cpp",
"SurfaceFlinger_HandleTransactionLockedTest.cpp",
"SurfaceFlinger_NotifyPowerBoostTest.cpp",
- "SurfaceFlinger_OnHotplugReceivedTest.cpp",
+ "SurfaceFlinger_HotplugTest.cpp",
"SurfaceFlinger_OnInitializeDisplaysTest.cpp",
"SurfaceFlinger_SetDisplayStateTest.cpp",
"SurfaceFlinger_SetPowerModeInternalTest.cpp",
diff --git a/services/surfaceflinger/tests/unittests/HWComposerTest.cpp b/services/surfaceflinger/tests/unittests/HWComposerTest.cpp
index 57f065a..655baf8 100644
--- a/services/surfaceflinger/tests/unittests/HWComposerTest.cpp
+++ b/services/surfaceflinger/tests/unittests/HWComposerTest.cpp
@@ -58,22 +58,21 @@
using ::testing::StrictMock;
struct MockHWC2ComposerCallback final : StrictMock<HWC2::ComposerCallback> {
- MOCK_METHOD3(onHotplugReceived, void(int32_t sequenceId, hal::HWDisplayId, hal::Connection));
- MOCK_METHOD2(onRefreshReceived, void(int32_t sequenceId, hal::HWDisplayId));
- MOCK_METHOD4(onVsyncReceived,
- void(int32_t sequenceId, hal::HWDisplayId, int64_t timestamp,
- std::optional<hal::VsyncPeriodNanos>));
- MOCK_METHOD3(onVsyncPeriodTimingChangedReceived,
- void(int32_t sequenceId, hal::HWDisplayId, const hal::VsyncPeriodChangeTimeline&));
- MOCK_METHOD2(onSeamlessPossible, void(int32_t sequenceId, hal::HWDisplayId));
+ MOCK_METHOD2(onComposerHalHotplug, void(hal::HWDisplayId, hal::Connection));
+ MOCK_METHOD1(onComposerHalRefresh, void(hal::HWDisplayId));
+ MOCK_METHOD3(onComposerHalVsync,
+ void(hal::HWDisplayId, int64_t timestamp, std::optional<hal::VsyncPeriodNanos>));
+ MOCK_METHOD2(onComposerHalVsyncPeriodTimingChanged,
+ void(hal::HWDisplayId, const hal::VsyncPeriodChangeTimeline&));
+ MOCK_METHOD1(onComposerHalSeamlessPossible, void(hal::HWDisplayId));
};
-struct HWComposerSetConfigurationTest : testing::Test {
+struct HWComposerSetCallbackTest : testing::Test {
Hwc2::mock::Composer* mHal = new StrictMock<Hwc2::mock::Composer>();
MockHWC2ComposerCallback mCallback;
};
-TEST_F(HWComposerSetConfigurationTest, loadsLayerMetadataSupport) {
+TEST_F(HWComposerSetCallbackTest, loadsLayerMetadataSupport) {
const std::string kMetadata1Name = "com.example.metadata.1";
constexpr bool kMetadata1Mandatory = false;
const std::string kMetadata2Name = "com.example.metadata.2";
@@ -90,7 +89,7 @@
EXPECT_CALL(*mHal, isVsyncPeriodSwitchSupported()).WillOnce(Return(false));
impl::HWComposer hwc{std::unique_ptr<Hwc2::Composer>(mHal)};
- hwc.setConfiguration(&mCallback, 123);
+ hwc.setCallback(&mCallback);
const auto& supported = hwc.getSupportedLayerGenericMetadata();
EXPECT_EQ(2u, supported.size());
@@ -100,7 +99,7 @@
EXPECT_EQ(kMetadata2Mandatory, supported.find(kMetadata2Name)->second);
}
-TEST_F(HWComposerSetConfigurationTest, handlesUnsupportedCallToGetLayerGenericMetadataKeys) {
+TEST_F(HWComposerSetCallbackTest, handlesUnsupportedCallToGetLayerGenericMetadataKeys) {
EXPECT_CALL(*mHal, getCapabilities()).WillOnce(Return(std::vector<hal::Capability>{}));
EXPECT_CALL(*mHal, getLayerGenericMetadataKeys(_))
.WillOnce(Return(hardware::graphics::composer::V2_4::Error::UNSUPPORTED));
@@ -108,7 +107,7 @@
EXPECT_CALL(*mHal, isVsyncPeriodSwitchSupported()).WillOnce(Return(false));
impl::HWComposer hwc{std::unique_ptr<Hwc2::Composer>(mHal)};
- hwc.setConfiguration(&mCallback, 123);
+ hwc.setCallback(&mCallback);
const auto& supported = hwc.getSupportedLayerGenericMetadata();
EXPECT_EQ(0u, supported.size());
diff --git a/services/surfaceflinger/tests/unittests/SurfaceFlinger_OnHotplugReceivedTest.cpp b/services/surfaceflinger/tests/unittests/SurfaceFlinger_HotplugTest.cpp
similarity index 62%
rename from services/surfaceflinger/tests/unittests/SurfaceFlinger_OnHotplugReceivedTest.cpp
rename to services/surfaceflinger/tests/unittests/SurfaceFlinger_HotplugTest.cpp
index 42f4cf3..bd89397 100644
--- a/services/surfaceflinger/tests/unittests/SurfaceFlinger_OnHotplugReceivedTest.cpp
+++ b/services/surfaceflinger/tests/unittests/SurfaceFlinger_HotplugTest.cpp
@@ -22,19 +22,15 @@
namespace android {
namespace {
-class OnHotplugReceivedTest : public DisplayTransactionTest {};
+class HotplugTest : public DisplayTransactionTest {};
-TEST_F(OnHotplugReceivedTest, hotplugEnqueuesEventsForDisplayTransaction) {
- constexpr int currentSequenceId = 123;
+TEST_F(HotplugTest, enqueuesEventsForDisplayTransaction) {
constexpr HWDisplayId hwcDisplayId1 = 456;
constexpr HWDisplayId hwcDisplayId2 = 654;
// --------------------------------------------------------------------
// Preconditions
- // Set the current sequence id for accepted events
- mFlinger.mutableComposerSequenceId() = currentSequenceId;
-
// Set the main thread id so that the current thread does not appear to be
// the main thread.
mFlinger.mutableMainThreadId() = std::thread::id();
@@ -50,8 +46,8 @@
// Invocation
// Simulate two hotplug events (a connect and a disconnect)
- mFlinger.onHotplugReceived(currentSequenceId, hwcDisplayId1, Connection::CONNECTED);
- mFlinger.onHotplugReceived(currentSequenceId, hwcDisplayId2, Connection::DISCONNECTED);
+ mFlinger.onComposerHalHotplug(hwcDisplayId1, Connection::CONNECTED);
+ mFlinger.onComposerHalHotplug(hwcDisplayId2, Connection::DISCONNECTED);
// --------------------------------------------------------------------
// Postconditions
@@ -68,52 +64,14 @@
EXPECT_EQ(Connection::DISCONNECTED, pendingEvents[1].connection);
}
-TEST_F(OnHotplugReceivedTest, hotplugDiscardsUnexpectedEvents) {
- constexpr int currentSequenceId = 123;
- constexpr int otherSequenceId = 321;
- constexpr HWDisplayId displayId = 456;
-
- // --------------------------------------------------------------------
- // Preconditions
-
- // Set the current sequence id for accepted events
- mFlinger.mutableComposerSequenceId() = currentSequenceId;
-
- // Set the main thread id so that the current thread does not appear to be
- // the main thread.
- mFlinger.mutableMainThreadId() = std::thread::id();
-
- // --------------------------------------------------------------------
- // Call Expectations
-
- // We do not expect any calls to invalidate().
- EXPECT_CALL(*mMessageQueue, invalidate()).Times(0);
-
- // --------------------------------------------------------------------
- // Invocation
-
- // Call with an unexpected sequence id
- mFlinger.onHotplugReceived(otherSequenceId, displayId, Connection::INVALID);
-
- // --------------------------------------------------------------------
- // Postconditions
-
- // The display transaction needed flag should not be set
- EXPECT_FALSE(hasTransactionFlagSet(eDisplayTransactionNeeded));
-
- // There should be no pending events
- EXPECT_TRUE(mFlinger.mutablePendingHotplugEvents().empty());
-}
-
-TEST_F(OnHotplugReceivedTest, hotplugProcessesEnqueuedEventsIfCalledOnMainThread) {
- constexpr int currentSequenceId = 123;
+TEST_F(HotplugTest, processesEnqueuedEventsIfCalledOnMainThread) {
constexpr HWDisplayId displayId1 = 456;
// --------------------------------------------------------------------
// Note:
// --------------------------------------------------------------------
// This test case is a bit tricky. We want to verify that
- // onHotplugReceived() calls processDisplayHotplugEventsLocked(), but we
+ // onComposerHalHotplug() calls processDisplayHotplugEventsLocked(), but we
// don't really want to provide coverage for everything the later function
// does as there are specific tests for it.
// --------------------------------------------------------------------
@@ -121,9 +79,6 @@
// --------------------------------------------------------------------
// Preconditions
- // Set the current sequence id for accepted events
- mFlinger.mutableComposerSequenceId() = currentSequenceId;
-
// Set the main thread id so that the current thread does appear to be the
// main thread.
mFlinger.mutableMainThreadId() = std::this_thread::get_id();
@@ -139,9 +94,9 @@
// Invocation
// Simulate a disconnect on a display id that is not connected. This should
- // be enqueued by onHotplugReceived(), and dequeued by
+ // be enqueued by onComposerHalHotplug(), and dequeued by
// processDisplayHotplugEventsLocked(), but then ignored as invalid.
- mFlinger.onHotplugReceived(currentSequenceId, displayId1, Connection::DISCONNECTED);
+ mFlinger.onComposerHalHotplug(displayId1, Connection::DISCONNECTED);
// --------------------------------------------------------------------
// Postconditions
@@ -155,4 +110,4 @@
}
} // namespace
-} // namespace android
\ No newline at end of file
+} // namespace android
diff --git a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
index 9b904d3..d78f36c 100644
--- a/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
+++ b/services/surfaceflinger/tests/unittests/TestableSurfaceFlinger.h
@@ -322,9 +322,8 @@
return mFlinger->handleTransactionLocked(transactionFlags);
}
- auto onHotplugReceived(int32_t sequenceId, hal::HWDisplayId display,
- hal::Connection connection) {
- return mFlinger->onHotplugReceived(sequenceId, display, connection);
+ void onComposerHalHotplug(hal::HWDisplayId hwcDisplayId, hal::Connection connection) {
+ mFlinger->onComposerHalHotplug(hwcDisplayId, connection);
}
auto setDisplayStateLocked(const DisplayState& s) {
@@ -438,7 +437,6 @@
auto& mutablePowerAdvisor() { return mFlinger->mPowerAdvisor; }
auto& mutableDebugDisableHWC() { return mFlinger->mDebugDisableHWC; }
- auto& mutableComposerSequenceId() { return mFlinger->getBE().mComposerSequenceId; }
auto& mutableHwcDisplayData() { return getHwComposer().mDisplayData; }
auto& mutableHwcPhysicalDisplayIdMap() { return getHwComposer().mPhysicalDisplayIdMap; }
auto& mutableInternalHwcDisplayId() { return getHwComposer().mInternalHwcDisplayId; }