Use VsyncEventData in DisplayEventReceiver::Event.
Clean-up that re-uses VsyncEventData so it's easier to maintain.
The ParcelableVsyncEventData is used in AIDL. It is separated from
VsyncEventData because of the union in
DisplayEventReceiver::Event and Parcelable has non-trivial
constructors.
Bug: 218563993
Test: atest ChoreographerNativeTest
Test: atest libsurfaceflinger_unittest
Test: atest libgui_test
Change-Id: I3ebeb1c7826300c27c4a12d4dba6fbd16305e9e1
diff --git a/services/surfaceflinger/Scheduler/EventThread.cpp b/services/surfaceflinger/Scheduler/EventThread.cpp
index 2d0da46..5ba8a1b 100644
--- a/services/surfaceflinger/Scheduler/EventThread.cpp
+++ b/services/surfaceflinger/Scheduler/EventThread.cpp
@@ -87,9 +87,10 @@
to_string(event.header.displayId).c_str(),
event.hotplug.connected ? "connected" : "disconnected");
case DisplayEventReceiver::DISPLAY_EVENT_VSYNC:
- return StringPrintf("VSync{displayId=%s, count=%u, expectedVSyncTimestamp=%" PRId64 "}",
+ return StringPrintf("VSync{displayId=%s, count=%u, expectedPresentationTime=%" PRId64
+ "}",
to_string(event.header.displayId).c_str(), event.vsync.count,
- event.vsync.expectedVSyncTimestamp);
+ event.vsync.vsyncData.preferredExpectedPresentationTime());
case DisplayEventReceiver::DISPLAY_EVENT_MODE_CHANGE:
return StringPrintf("ModeChanged{displayId=%s, modeId=%u}",
to_string(event.header.displayId).c_str(), event.modeChange.modeId);
@@ -107,13 +108,19 @@
}
DisplayEventReceiver::Event makeVSync(PhysicalDisplayId displayId, nsecs_t timestamp,
- uint32_t count, nsecs_t expectedVSyncTimestamp,
+ uint32_t count, nsecs_t expectedPresentationTime,
nsecs_t deadlineTimestamp) {
DisplayEventReceiver::Event event;
event.header = {DisplayEventReceiver::DISPLAY_EVENT_VSYNC, displayId, timestamp};
event.vsync.count = count;
- event.vsync.expectedVSyncTimestamp = expectedVSyncTimestamp;
- event.vsync.deadlineTimestamp = deadlineTimestamp;
+ event.vsync.vsyncData.preferredFrameTimelineIndex = 0;
+ // Temporarily store the current vsync information in frameTimelines[0], marked as
+ // platform-preferred. When the event is dispatched later, the frame interval at that time is
+ // used with this information to generate multiple frame timeline choices.
+ event.vsync.vsyncData.frameTimelines[0] = {.vsyncId = FrameTimelineInfo::INVALID_VSYNC_ID,
+ .deadlineTimestamp = deadlineTimestamp,
+ .expectedPresentationTime =
+ expectedPresentationTime};
return event;
}
@@ -186,9 +193,10 @@
return binder::Status::ok();
}
-binder::Status EventThreadConnection::getLatestVsyncEventData(VsyncEventData* outVsyncEventData) {
+binder::Status EventThreadConnection::getLatestVsyncEventData(
+ ParcelableVsyncEventData* outVsyncEventData) {
ATRACE_CALL();
- *outVsyncEventData = mEventThread->getLatestVsyncEventData(this);
+ outVsyncEventData->vsync = mEventThread->getLatestVsyncEventData(this);
return binder::Status::ok();
}
@@ -338,10 +346,16 @@
VsyncEventData EventThread::getLatestVsyncEventData(
const sp<EventThreadConnection>& connection) const {
- nsecs_t frameInterval = mGetVsyncPeriodFunction(connection->mOwnerUid);
VsyncEventData vsyncEventData;
+ nsecs_t frameInterval = mGetVsyncPeriodFunction(connection->mOwnerUid);
vsyncEventData.frameInterval = frameInterval;
- generateFrameTimeline(vsyncEventData, frameInterval, systemTime(SYSTEM_TIME_MONOTONIC));
+ VSyncSource::VSyncData vsyncData;
+ {
+ std::lock_guard<std::mutex> lock(mMutex);
+ vsyncData = mVSyncSource->getLatestVSyncData();
+ }
+ generateFrameTimeline(vsyncEventData, frameInterval, systemTime(SYSTEM_TIME_MONOTONIC),
+ vsyncData.expectedPresentationTime, vsyncData.deadlineTimestamp);
return vsyncEventData;
}
@@ -370,7 +384,7 @@
LOG_FATAL_IF(!mVSyncState);
mPendingEvents.push_back(makeVSync(mVSyncState->displayId, timestamp, ++mVSyncState->count,
- vsyncData.expectedVSyncTimestamp,
+ vsyncData.expectedPresentationTime,
vsyncData.deadlineTimestamp));
mCondition.notify_all();
}
@@ -518,7 +532,8 @@
const sp<EventThreadConnection>& connection) const {
const auto throttleVsync = [&] {
return mThrottleVsyncCallback &&
- mThrottleVsyncCallback(event.vsync.expectedVSyncTimestamp, connection->mOwnerUid);
+ mThrottleVsyncCallback(event.vsync.vsyncData.preferredExpectedPresentationTime(),
+ connection->mOwnerUid);
};
switch (event.header.type) {
@@ -568,79 +583,49 @@
}
int64_t EventThread::generateToken(nsecs_t timestamp, nsecs_t deadlineTimestamp,
- nsecs_t expectedVSyncTimestamp) const {
+ nsecs_t expectedPresentationTime) const {
if (mTokenManager != nullptr) {
return mTokenManager->generateTokenForPredictions(
- {timestamp, deadlineTimestamp, expectedVSyncTimestamp});
+ {timestamp, deadlineTimestamp, expectedPresentationTime});
}
return FrameTimelineInfo::INVALID_VSYNC_ID;
}
-void EventThread::generateFrameTimeline(
- nsecs_t frameInterval, nsecs_t timestamp, nsecs_t preferredExpectedVSyncTimestamp,
- nsecs_t preferredDeadlineTimestamp,
- std::function<void(int64_t index)> setPreferredFrameTimelineIndex,
- std::function<void(int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp)>
- setFrameTimeline) const {
+void EventThread::generateFrameTimeline(VsyncEventData& outVsyncEventData, nsecs_t frameInterval,
+ nsecs_t timestamp,
+ nsecs_t preferredExpectedPresentationTime,
+ nsecs_t preferredDeadlineTimestamp) const {
// Add 1 to ensure the preferredFrameTimelineIndex entry (when multiplier == 0) is included.
for (int64_t multiplier = -VsyncEventData::kFrameTimelinesLength + 1, currentIndex = 0;
currentIndex < VsyncEventData::kFrameTimelinesLength; multiplier++) {
- nsecs_t deadline = preferredDeadlineTimestamp + multiplier * frameInterval;
+ nsecs_t deadlineTimestamp = preferredDeadlineTimestamp + multiplier * frameInterval;
// Valid possible frame timelines must have future values.
- if (deadline > timestamp) {
+ if (deadlineTimestamp > timestamp) {
if (multiplier == 0) {
- setPreferredFrameTimelineIndex(currentIndex);
+ outVsyncEventData.preferredFrameTimelineIndex = currentIndex;
}
- nsecs_t expectedVSyncTimestamp =
- preferredExpectedVSyncTimestamp + multiplier * frameInterval;
- setFrameTimeline(currentIndex,
- generateToken(timestamp, deadline, expectedVSyncTimestamp),
- expectedVSyncTimestamp, deadline);
+ nsecs_t expectedPresentationTime =
+ preferredExpectedPresentationTime + multiplier * frameInterval;
+ outVsyncEventData.frameTimelines[currentIndex] =
+ {.vsyncId =
+ generateToken(timestamp, deadlineTimestamp, expectedPresentationTime),
+ .deadlineTimestamp = deadlineTimestamp,
+ .expectedPresentationTime = expectedPresentationTime};
currentIndex++;
}
}
}
-void EventThread::generateFrameTimeline(DisplayEventReceiver::Event& event) const {
- generateFrameTimeline(
- event.vsync.frameInterval, event.header.timestamp, event.vsync.expectedVSyncTimestamp,
- event.vsync.deadlineTimestamp,
- [&](int index) { event.vsync.preferredFrameTimelineIndex = index; },
- [&](int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp) {
- event.vsync.frameTimelines[index] = {.vsyncId = vsyncId,
- .deadlineTimestamp = deadlineTimestamp,
- .expectedVSyncTimestamp =
- expectedVSyncTimestamp};
- });
-}
-
-void EventThread::generateFrameTimeline(VsyncEventData& out, const nsecs_t frameInterval,
- const nsecs_t timestamp) const {
- VSyncSource::VSyncData vsyncData;
- {
- std::lock_guard<std::mutex> lock(mMutex);
- vsyncData = mVSyncSource->getLatestVSyncData();
- }
- generateFrameTimeline(
- frameInterval, timestamp, vsyncData.expectedVSyncTimestamp, vsyncData.deadlineTimestamp,
- [&](int index) { out.preferredFrameTimelineIndex = index; },
- [&](int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp) {
- out.frameTimelines[index] =
- VsyncEventData::FrameTimeline(vsyncId, deadlineTimestamp,
- expectedVSyncTimestamp);
- });
-}
-
void EventThread::dispatchEvent(const DisplayEventReceiver::Event& event,
const DisplayEventConsumers& consumers) {
for (const auto& consumer : consumers) {
DisplayEventReceiver::Event copy = event;
if (event.header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
- copy.vsync.frameInterval = mGetVsyncPeriodFunction(consumer->mOwnerUid);
- generateFrameTimeline(copy);
+ const int64_t frameInterval = mGetVsyncPeriodFunction(consumer->mOwnerUid);
+ copy.vsync.vsyncData.frameInterval = frameInterval;
+ generateFrameTimeline(copy.vsync.vsyncData, frameInterval, copy.header.timestamp,
+ event.vsync.vsyncData.preferredExpectedPresentationTime(),
+ event.vsync.vsyncData.preferredDeadlineTimestamp());
}
switch (consumer->postEvent(copy)) {
case NO_ERROR:
diff --git a/services/surfaceflinger/Scheduler/EventThread.h b/services/surfaceflinger/Scheduler/EventThread.h
index a858169..c406478 100644
--- a/services/surfaceflinger/Scheduler/EventThread.h
+++ b/services/surfaceflinger/Scheduler/EventThread.h
@@ -45,6 +45,7 @@
class TokenManager;
} // namespace frametimeline
+using gui::ParcelableVsyncEventData;
using gui::VsyncEventData;
// ---------------------------------------------------------------------------
@@ -66,7 +67,7 @@
public:
class VSyncData {
public:
- nsecs_t expectedVSyncTimestamp;
+ nsecs_t expectedPresentationTime;
nsecs_t deadlineTimestamp;
};
@@ -99,7 +100,7 @@
binder::Status stealReceiveChannel(gui::BitTube* outChannel) override;
binder::Status setVsyncRate(int rate) override;
binder::Status requestNextVsync() override; // asynchronous
- binder::Status getLatestVsyncEventData(VsyncEventData* outVsyncEventData) override;
+ binder::Status getLatestVsyncEventData(ParcelableVsyncEventData* outVsyncEventData) override;
// Called in response to requestNextVsync.
const ResyncCallback resyncCallback;
@@ -217,17 +218,10 @@
void onVSyncEvent(nsecs_t timestamp, VSyncSource::VSyncData vsyncData) override;
int64_t generateToken(nsecs_t timestamp, nsecs_t deadlineTimestamp,
- nsecs_t expectedVSyncTimestamp) const;
- void generateFrameTimeline(DisplayEventReceiver::Event& event) const;
- void generateFrameTimeline(VsyncEventData& out, const nsecs_t frameInterval,
- const nsecs_t timestamp) const;
- void generateFrameTimeline(
- nsecs_t frameInterval, nsecs_t timestamp, nsecs_t preferredExpectedVSyncTimestamp,
- nsecs_t preferredDeadlineTimestamp,
- std::function<void(int64_t index)> setPreferredFrameTimelineIndex,
- std::function<void(int64_t index, int64_t vsyncId, nsecs_t expectedVSyncTimestamp,
- nsecs_t deadlineTimestamp)>
- setFrameTimeline) const;
+ nsecs_t expectedPresentationTime) const;
+ void generateFrameTimeline(VsyncEventData& outVsyncEventData, nsecs_t frameInterval,
+ nsecs_t timestamp, nsecs_t preferredExpectedPresentationTime,
+ nsecs_t preferredDeadlineTimestamp) const;
const std::unique_ptr<VSyncSource> mVSyncSource GUARDED_BY(mMutex);
frametimeline::TokenManager* const mTokenManager;
diff --git a/services/surfaceflinger/Scheduler/MessageQueue.cpp b/services/surfaceflinger/Scheduler/MessageQueue.cpp
index a020e2c..712cd5b 100644
--- a/services/surfaceflinger/Scheduler/MessageQueue.cpp
+++ b/services/surfaceflinger/Scheduler/MessageQueue.cpp
@@ -191,7 +191,8 @@
for (int i = 0; i < n; i++) {
if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
auto& vsync = buffer[i].vsync;
- mHandler->dispatchFrame(vsync.vsyncId, vsync.expectedVSyncTimestamp);
+ mHandler->dispatchFrame(vsync.vsyncData.preferredVsyncId(),
+ vsync.vsyncData.preferredExpectedPresentationTime());
break;
}
}
diff --git a/services/surfaceflinger/tests/DisplayEventReceiver_test.cpp b/services/surfaceflinger/tests/DisplayEventReceiver_test.cpp
index 01adbc8..0e54664 100644
--- a/services/surfaceflinger/tests/DisplayEventReceiver_test.cpp
+++ b/services/surfaceflinger/tests/DisplayEventReceiver_test.cpp
@@ -28,23 +28,24 @@
TEST_F(DisplayEventReceiverTest, getLatestVsyncEventData) {
const nsecs_t now = systemTime();
- VsyncEventData vsyncEventData;
- EXPECT_EQ(NO_ERROR, mDisplayEventReceiver.getLatestVsyncEventData(&vsyncEventData));
+ ParcelableVsyncEventData parcelableVsyncEventData;
+ EXPECT_EQ(NO_ERROR, mDisplayEventReceiver.getLatestVsyncEventData(&parcelableVsyncEventData));
+ const VsyncEventData& vsyncEventData = parcelableVsyncEventData.vsync;
EXPECT_NE(std::numeric_limits<size_t>::max(), vsyncEventData.preferredFrameTimelineIndex);
EXPECT_GT(vsyncEventData.frameTimelines[0].deadlineTimestamp, now)
<< "Deadline timestamp should be greater than frame time";
- for (size_t i = 0; i < vsyncEventData.frameTimelines.size(); i++) {
- EXPECT_NE(FrameTimelineInfo::INVALID_VSYNC_ID, vsyncEventData.frameTimelines[i].id);
- EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentTime,
+ for (size_t i = 0; i < VsyncEventData::kFrameTimelinesLength; i++) {
+ EXPECT_NE(FrameTimelineInfo::INVALID_VSYNC_ID, vsyncEventData.frameTimelines[i].vsyncId);
+ EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentationTime,
vsyncEventData.frameTimelines[i].deadlineTimestamp)
<< "Expected vsync timestamp should be greater than deadline";
if (i > 0) {
EXPECT_GT(vsyncEventData.frameTimelines[i].deadlineTimestamp,
vsyncEventData.frameTimelines[i - 1].deadlineTimestamp)
<< "Deadline timestamp out of order for frame timeline " << i;
- EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentTime,
- vsyncEventData.frameTimelines[i - 1].expectedPresentTime)
+ EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentationTime,
+ vsyncEventData.frameTimelines[i - 1].expectedPresentationTime)
<< "Expected vsync timestamp out of order for frame timeline " << i;
}
}
diff --git a/services/surfaceflinger/tests/LayerCallback_test.cpp b/services/surfaceflinger/tests/LayerCallback_test.cpp
index 5c16fee..8a2305b 100644
--- a/services/surfaceflinger/tests/LayerCallback_test.cpp
+++ b/services/surfaceflinger/tests/LayerCallback_test.cpp
@@ -141,11 +141,12 @@
continue;
}
- vsync = {event.vsync.vsyncId, event.vsync.expectedVSyncTimestamp};
+ vsync = {event.vsync.vsyncData.preferredVsyncId(),
+ event.vsync.vsyncData.preferredExpectedPresentationTime()};
}
EXPECT_GE(vsync.vsyncId, 1);
- EXPECT_GT(event.vsync.expectedVSyncTimestamp, systemTime());
+ EXPECT_GT(vsync.expectedPresentTime, systemTime());
return vsync;
}
diff --git a/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp b/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp
index 0b6b475..ec27eda 100644
--- a/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp
+++ b/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp
@@ -229,7 +229,7 @@
ASSERT_TRUE(callbackData.has_value());
const auto [when, vsyncData] = callbackData.value();
EXPECT_EQ(when,
- vsyncData.expectedVSyncTimestamp - mWorkDuration.count() -
+ vsyncData.expectedPresentationTime - mWorkDuration.count() -
mReadyDuration.count());
}
}
@@ -261,7 +261,7 @@
ASSERT_TRUE(callbackData.has_value());
const auto [when, vsyncData] = callbackData.value();
EXPECT_EQ(when,
- vsyncData.expectedVSyncTimestamp - mWorkDuration.count() -
+ vsyncData.expectedPresentationTime - mWorkDuration.count() -
mReadyDuration.count());
}
@@ -283,7 +283,7 @@
const auto callbackData = mVSyncEventCallRecorder.waitForCall();
ASSERT_TRUE(callbackData.has_value());
const auto [when, vsyncData] = callbackData.value();
- EXPECT_EQ(when, vsyncData.expectedVSyncTimestamp - newDuration.count());
+ EXPECT_EQ(when, vsyncData.expectedPresentationTime - newDuration.count());
}
EXPECT_CALL(*mVSyncDispatch, cancel(_)).Times(1);
@@ -307,9 +307,9 @@
const auto vsyncData = mDispSyncSource->getLatestVSyncData();
ASSERT_GT(vsyncData.deadlineTimestamp, now);
- ASSERT_GT(vsyncData.expectedVSyncTimestamp, vsyncData.deadlineTimestamp);
+ ASSERT_GT(vsyncData.expectedPresentationTime, vsyncData.deadlineTimestamp);
EXPECT_EQ(vsyncData.deadlineTimestamp,
- vsyncData.expectedVSyncTimestamp - vsyncInternalDuration);
+ vsyncData.expectedPresentationTime - vsyncInternalDuration);
}
} // namespace
diff --git a/services/surfaceflinger/tests/unittests/EventThreadTest.cpp b/services/surfaceflinger/tests/unittests/EventThreadTest.cpp
index cc0a40f..14d8f98 100644
--- a/services/surfaceflinger/tests/unittests/EventThreadTest.cpp
+++ b/services/surfaceflinger/tests/unittests/EventThreadTest.cpp
@@ -99,7 +99,7 @@
nsecs_t expectedTimestamp, unsigned expectedCount);
void expectVsyncEventReceivedByConnection(nsecs_t expectedTimestamp, unsigned expectedCount);
void expectVsyncEventFrameTimelinesCorrect(nsecs_t expectedTimestamp,
- nsecs_t preferredDeadline);
+ VSyncSource::VSyncData preferredVsyncData);
void expectHotplugEventReceivedByConnection(PhysicalDisplayId expectedDisplayId,
bool expectedConnected);
void expectConfigChangedEventReceivedByConnection(PhysicalDisplayId expectedDisplayId,
@@ -252,40 +252,42 @@
expectedCount);
}
-void EventThreadTest::expectVsyncEventFrameTimelinesCorrect(nsecs_t expectedTimestamp,
- nsecs_t preferredDeadline) {
+void EventThreadTest::expectVsyncEventFrameTimelinesCorrect(
+ nsecs_t expectedTimestamp, VSyncSource::VSyncData preferredVsyncData) {
auto args = mConnectionEventCallRecorder.waitForCall();
ASSERT_TRUE(args.has_value()) << " did not receive an event for timestamp "
<< expectedTimestamp;
const auto& event = std::get<0>(args.value());
for (int i = 0; i < VsyncEventData::kFrameTimelinesLength; i++) {
- auto prediction =
- mTokenManager->getPredictionsForToken(event.vsync.frameTimelines[i].vsyncId);
+ auto prediction = mTokenManager->getPredictionsForToken(
+ event.vsync.vsyncData.frameTimelines[i].vsyncId);
EXPECT_TRUE(prediction.has_value());
- EXPECT_EQ(prediction.value().endTime, event.vsync.frameTimelines[i].deadlineTimestamp)
+ EXPECT_EQ(prediction.value().endTime,
+ event.vsync.vsyncData.frameTimelines[i].deadlineTimestamp)
<< "Deadline timestamp does not match cached value";
EXPECT_EQ(prediction.value().presentTime,
- event.vsync.frameTimelines[i].expectedVSyncTimestamp)
- << "Expected vsync timestamp does not match cached value";
+ event.vsync.vsyncData.frameTimelines[i].expectedPresentationTime)
+ << "Expected vsync.vsyncData timestamp does not match cached value";
if (i > 0) {
- EXPECT_GT(event.vsync.frameTimelines[i].deadlineTimestamp,
- event.vsync.frameTimelines[i - 1].deadlineTimestamp)
+ EXPECT_GT(event.vsync.vsyncData.frameTimelines[i].deadlineTimestamp,
+ event.vsync.vsyncData.frameTimelines[i - 1].deadlineTimestamp)
<< "Deadline timestamp out of order for frame timeline " << i;
- EXPECT_GT(event.vsync.frameTimelines[i].expectedVSyncTimestamp,
- event.vsync.frameTimelines[i - 1].expectedVSyncTimestamp)
- << "Expected vsync timestamp out of order for frame timeline " << i;
+ EXPECT_GT(event.vsync.vsyncData.frameTimelines[i].expectedPresentationTime,
+ event.vsync.vsyncData.frameTimelines[i - 1].expectedPresentationTime)
+ << "Expected vsync.vsyncData timestamp out of order for frame timeline " << i;
}
// Vsync ID order lines up with registration into test token manager.
- EXPECT_EQ(i, event.vsync.frameTimelines[i].vsyncId)
+ EXPECT_EQ(i, event.vsync.vsyncData.frameTimelines[i].vsyncId)
<< "Vsync ID incorrect for frame timeline " << i;
- if (i == event.vsync.preferredFrameTimelineIndex) {
- EXPECT_EQ(event.vsync.frameTimelines[i].deadlineTimestamp, preferredDeadline)
+ if (i == event.vsync.vsyncData.preferredFrameTimelineIndex) {
+ EXPECT_EQ(event.vsync.vsyncData.frameTimelines[i].deadlineTimestamp,
+ preferredVsyncData.deadlineTimestamp)
<< "Preferred deadline timestamp incorrect" << i;
- EXPECT_EQ(event.vsync.frameTimelines[i].expectedVSyncTimestamp,
- event.vsync.expectedVSyncTimestamp)
- << "Preferred expected vsync timestamp incorrect" << i;
+ EXPECT_EQ(event.vsync.vsyncData.frameTimelines[i].expectedPresentationTime,
+ preferredVsyncData.expectedPresentationTime)
+ << "Preferred expected vsync.vsyncData timestamp incorrect" << i;
}
}
}
@@ -397,16 +399,17 @@
// Use the received callback to signal a vsync event.
// The interceptor should receive the event, as well as the connection.
- mCallback->onVSyncEvent(123, {456, 789});
+ VSyncSource::VSyncData vsyncData = {456, 789};
+ mCallback->onVSyncEvent(123, vsyncData);
expectInterceptCallReceived(123);
- expectVsyncEventFrameTimelinesCorrect(123, 789);
+ expectVsyncEventFrameTimelinesCorrect(123, vsyncData);
}
TEST_F(EventThreadTest, getLatestVsyncEventData) {
const nsecs_t now = systemTime();
const nsecs_t preferredDeadline = now + 10000000;
- const nsecs_t preferredExpectedVSyncTimestamp = now + 20000000;
- const VSyncSource::VSyncData preferredData = {preferredExpectedVSyncTimestamp,
+ const nsecs_t preferredExpectedPresentationTime = now + 20000000;
+ const VSyncSource::VSyncData preferredData = {preferredExpectedPresentationTime,
preferredDeadline};
EXPECT_CALL(*mVSyncSource, getLatestVSyncData()).WillOnce(Return(preferredData));
@@ -415,14 +418,14 @@
<< "Deadline timestamp should be greater than frame time";
for (size_t i = 0; i < VsyncEventData::kFrameTimelinesLength; i++) {
auto prediction =
- mTokenManager->getPredictionsForToken(vsyncEventData.frameTimelines[i].id);
+ mTokenManager->getPredictionsForToken(vsyncEventData.frameTimelines[i].vsyncId);
EXPECT_TRUE(prediction.has_value());
EXPECT_EQ(prediction.value().endTime, vsyncEventData.frameTimelines[i].deadlineTimestamp)
<< "Deadline timestamp does not match cached value";
EXPECT_EQ(prediction.value().presentTime,
- vsyncEventData.frameTimelines[i].expectedPresentTime)
+ vsyncEventData.frameTimelines[i].expectedPresentationTime)
<< "Expected vsync timestamp does not match cached value";
- EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentTime,
+ EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentationTime,
vsyncEventData.frameTimelines[i].deadlineTimestamp)
<< "Expected vsync timestamp should be greater than deadline";
@@ -430,19 +433,19 @@
EXPECT_GT(vsyncEventData.frameTimelines[i].deadlineTimestamp,
vsyncEventData.frameTimelines[i - 1].deadlineTimestamp)
<< "Deadline timestamp out of order for frame timeline " << i;
- EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentTime,
- vsyncEventData.frameTimelines[i - 1].expectedPresentTime)
+ EXPECT_GT(vsyncEventData.frameTimelines[i].expectedPresentationTime,
+ vsyncEventData.frameTimelines[i - 1].expectedPresentationTime)
<< "Expected vsync timestamp out of order for frame timeline " << i;
}
// Vsync ID order lines up with registration into test token manager.
- EXPECT_EQ(i, vsyncEventData.frameTimelines[i].id)
+ EXPECT_EQ(i, vsyncEventData.frameTimelines[i].vsyncId)
<< "Vsync ID incorrect for frame timeline " << i;
if (i == vsyncEventData.preferredFrameTimelineIndex) {
EXPECT_EQ(vsyncEventData.frameTimelines[i].deadlineTimestamp, preferredDeadline)
<< "Preferred deadline timestamp incorrect" << i;
- EXPECT_EQ(vsyncEventData.frameTimelines[i].expectedPresentTime,
- preferredExpectedVSyncTimestamp)
+ EXPECT_EQ(vsyncEventData.frameTimelines[i].expectedPresentationTime,
+ preferredExpectedPresentationTime)
<< "Preferred expected vsync timestamp incorrect" << i;
}
}