SF: Renaming IdleTimer to OneShotTimer
IdleTimer class is used for more than just idle timer, so renaming the
class to a more appropriate name.
Test: manual
Bug: 132811842
Change-Id: Iabfaa28038dc90430a51536ef874618e35ed9014
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp
index 5b298b4..6e953f4 100644
--- a/services/surfaceflinger/Android.bp
+++ b/services/surfaceflinger/Android.bp
@@ -149,7 +149,7 @@
"Scheduler/DispSyncSource.cpp",
"Scheduler/EventControlThread.cpp",
"Scheduler/EventThread.cpp",
- "Scheduler/IdleTimer.cpp",
+ "Scheduler/OneShotTimer.cpp",
"Scheduler/LayerHistory.cpp",
"Scheduler/LayerInfo.cpp",
"Scheduler/MessageQueue.cpp",
diff --git a/services/surfaceflinger/RegionSamplingThread.h b/services/surfaceflinger/RegionSamplingThread.h
index 3c6fcf3..ac7339c 100644
--- a/services/surfaceflinger/RegionSamplingThread.h
+++ b/services/surfaceflinger/RegionSamplingThread.h
@@ -27,7 +27,7 @@
#include <ui/GraphicBuffer.h>
#include <ui/Rect.h>
#include <utils/StrongPointer.h>
-#include "Scheduler/IdleTimer.h"
+#include "Scheduler/OneShotTimer.h"
namespace android {
@@ -107,7 +107,7 @@
SurfaceFlinger& mFlinger;
Scheduler& mScheduler;
const TimingTunables mTunables;
- scheduler::IdleTimer mIdleTimer;
+ scheduler::OneShotTimer mIdleTimer;
std::unique_ptr<SamplingOffsetCallback> const mPhaseCallback;
diff --git a/services/surfaceflinger/Scheduler/IdleTimer.cpp b/services/surfaceflinger/Scheduler/OneShotTimer.cpp
similarity index 88%
rename from services/surfaceflinger/Scheduler/IdleTimer.cpp
rename to services/surfaceflinger/Scheduler/OneShotTimer.cpp
index 37fdfc7..4870a3b 100644
--- a/services/surfaceflinger/Scheduler/IdleTimer.cpp
+++ b/services/surfaceflinger/Scheduler/OneShotTimer.cpp
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-#include "IdleTimer.h"
+#include "OneShotTimer.h"
#include <chrono>
#include <thread>
@@ -22,23 +22,23 @@
namespace android {
namespace scheduler {
-IdleTimer::IdleTimer(const Interval& interval, const ResetCallback& resetCallback,
- const TimeoutCallback& timeoutCallback)
+OneShotTimer::OneShotTimer(const Interval& interval, const ResetCallback& resetCallback,
+ const TimeoutCallback& timeoutCallback)
: mInterval(interval), mResetCallback(resetCallback), mTimeoutCallback(timeoutCallback) {}
-IdleTimer::~IdleTimer() {
+OneShotTimer::~OneShotTimer() {
stop();
}
-void IdleTimer::start() {
+void OneShotTimer::start() {
{
std::lock_guard<std::mutex> lock(mMutex);
mState = TimerState::RESET;
}
- mThread = std::thread(&IdleTimer::loop, this);
+ mThread = std::thread(&OneShotTimer::loop, this);
}
-void IdleTimer::stop() {
+void OneShotTimer::stop() {
{
std::lock_guard<std::mutex> lock(mMutex);
mState = TimerState::STOPPED;
@@ -49,7 +49,7 @@
}
}
-void IdleTimer::loop() {
+void OneShotTimer::loop() {
while (true) {
bool triggerReset = false;
bool triggerTimeout = false;
@@ -100,7 +100,7 @@
}
} // namespace scheduler
-void IdleTimer::reset() {
+void OneShotTimer::reset() {
{
std::lock_guard<std::mutex> lock(mMutex);
mState = TimerState::RESET;
diff --git a/services/surfaceflinger/Scheduler/IdleTimer.h b/services/surfaceflinger/Scheduler/OneShotTimer.h
similarity index 93%
rename from services/surfaceflinger/Scheduler/IdleTimer.h
rename to services/surfaceflinger/Scheduler/OneShotTimer.h
index 2646688..fd1aa02 100644
--- a/services/surfaceflinger/Scheduler/IdleTimer.h
+++ b/services/surfaceflinger/Scheduler/OneShotTimer.h
@@ -29,15 +29,15 @@
* Class that sets off a timer for a given interval, and fires a callback when the
* interval expires.
*/
-class IdleTimer {
+class OneShotTimer {
public:
using Interval = std::chrono::milliseconds;
using ResetCallback = std::function<void()>;
using TimeoutCallback = std::function<void()>;
- IdleTimer(const Interval& interval, const ResetCallback& resetCallback,
- const TimeoutCallback& timeoutCallback);
- ~IdleTimer();
+ OneShotTimer(const Interval& interval, const ResetCallback& resetCallback,
+ const TimeoutCallback& timeoutCallback);
+ ~OneShotTimer();
// Initializes and turns on the idle timer.
void start();
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index bb24f73..e393f1b 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -38,9 +38,9 @@
#include "DispSyncSource.h"
#include "EventControlThread.h"
#include "EventThread.h"
-#include "IdleTimer.h"
#include "InjectVSyncSource.h"
#include "LayerInfo.h"
+#include "OneShotTimer.h"
#include "SchedulerUtils.h"
#include "SurfaceFlingerProperties.h"
@@ -86,34 +86,29 @@
if (mSetIdleTimerMs > 0) {
if (mSupportKernelTimer) {
- mIdleTimer =
- std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(
- mSetIdleTimerMs),
- [this] { resetKernelTimerCallback(); },
- [this] {
- expiredKernelTimerCallback();
- });
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(
+ std::chrono::milliseconds(mSetIdleTimerMs),
+ [this] { resetKernelTimerCallback(); },
+ [this] { expiredKernelTimerCallback(); });
} else {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(
- mSetIdleTimerMs),
- [this] { resetTimerCallback(); },
- [this] { expiredTimerCallback(); });
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(
+ std::chrono::milliseconds(mSetIdleTimerMs), [this] { resetTimerCallback(); },
+ [this] { expiredTimerCallback(); });
}
mIdleTimer->start();
}
if (mSetTouchTimerMs > 0) {
// Touch events are coming to SF every 100ms, so the timer needs to be higher than that
- mTouchTimer =
- std::make_unique<scheduler::IdleTimer>(std::chrono::milliseconds(mSetTouchTimerMs),
- [this] { resetTouchTimerCallback(); },
- [this] { expiredTouchTimerCallback(); });
+ mTouchTimer = std::make_unique<scheduler::OneShotTimer>(
+ std::chrono::milliseconds(mSetTouchTimerMs), [this] { resetTouchTimerCallback(); },
+ [this] { expiredTouchTimerCallback(); });
mTouchTimer->start();
}
}
Scheduler::~Scheduler() {
- // Ensure the IdleTimer thread is joined before we start destroying state.
+ // Ensure the OneShotTimer threads are joined before we start destroying state.
mTouchTimer.reset();
mIdleTimer.reset();
}
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index eaad37c..a307760 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -26,9 +26,9 @@
#include "DispSync.h"
#include "EventControlThread.h"
#include "EventThread.h"
-#include "IdleTimer.h"
#include "InjectVSyncSource.h"
#include "LayerHistory.h"
+#include "OneShotTimer.h"
#include "RefreshRateConfigs.h"
#include "SchedulerUtils.h"
@@ -273,14 +273,14 @@
// Timer that records time between requests for next vsync. If the time is higher than a given
// interval, a callback is fired. Set this variable to >0 to use this feature.
int64_t mSetIdleTimerMs = 0;
- std::unique_ptr<scheduler::IdleTimer> mIdleTimer;
+ std::unique_ptr<scheduler::OneShotTimer> mIdleTimer;
// Enables whether to use idle timer callbacks that support the kernel
// timer.
bool mSupportKernelTimer;
// Timer used to monitor touch events.
int64_t mSetTouchTimerMs = 0;
- std::unique_ptr<scheduler::IdleTimer> mTouchTimer;
+ std::unique_ptr<scheduler::OneShotTimer> mTouchTimer;
std::mutex mCallbackLock;
ChangeRefreshRateCallback mChangeRefreshRateCallback GUARDED_BY(mCallbackLock);
diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp
index f842d61..4917bc2 100644
--- a/services/surfaceflinger/tests/unittests/Android.bp
+++ b/services/surfaceflinger/tests/unittests/Android.bp
@@ -42,7 +42,7 @@
"DisplayTransactionTest.cpp",
"EventControlThreadTest.cpp",
"EventThreadTest.cpp",
- "IdleTimerTest.cpp",
+ "OneShotTimerTest.cpp",
"LayerHistoryTest.cpp",
"LayerMetadataTest.cpp",
"SchedulerTest.cpp",
diff --git a/services/surfaceflinger/tests/unittests/IdleTimerTest.cpp b/services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp
similarity index 75%
rename from services/surfaceflinger/tests/unittests/IdleTimerTest.cpp
rename to services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp
index eff22b6..0208728 100644
--- a/services/surfaceflinger/tests/unittests/IdleTimerTest.cpp
+++ b/services/surfaceflinger/tests/unittests/OneShotTimerTest.cpp
@@ -21,17 +21,17 @@
#include <utils/Log.h>
#include "AsyncCallRecorder.h"
-#include "Scheduler/IdleTimer.h"
+#include "Scheduler/OneShotTimer.h"
using namespace std::chrono_literals;
namespace android {
namespace scheduler {
-class IdleTimerTest : public testing::Test {
+class OneShotTimerTest : public testing::Test {
protected:
- IdleTimerTest() = default;
- ~IdleTimerTest() override = default;
+ OneShotTimerTest() = default;
+ ~OneShotTimerTest() override = default;
// This timeout should be used when a 3ms callback is expected.
// While the tests typically request a callback after 3ms, the scheduler
@@ -46,7 +46,7 @@
AsyncCallRecorder<void (*)()> mResetTimerCallback;
AsyncCallRecorder<void (*)()> mExpiredTimerCallback;
- std::unique_ptr<IdleTimer> mIdleTimer;
+ std::unique_ptr<OneShotTimer> mIdleTimer;
void clearPendingCallbacks() {
while (mExpiredTimerCallback.waitForCall(0us).has_value()) {
@@ -55,13 +55,14 @@
};
namespace {
-TEST_F(IdleTimerTest, createAndDestroyTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(3ms, [] {}, [] {});
+TEST_F(OneShotTimerTest, createAndDestroyTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(
+ 3ms, [] {}, [] {});
}
-TEST_F(IdleTimerTest, startStopTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(30ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, startStopTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(30ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
auto startTime = std::chrono::steady_clock::now();
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
@@ -70,7 +71,7 @@
bool callbackCalled = mExpiredTimerCallback.waitForCall(25ms).has_value();
// Under ideal conditions there should be no event. But occasionally
// it is possible that the wait just prior takes more than 30ms, and
- // a callback is observed. We check the elapsed time since before the IdleTimer
+ // a callback is observed. We check the elapsed time since before the OneShotTimer
// thread was started as a sanity check to not have a flakey test.
EXPECT_FALSE(callbackCalled && std::chrono::steady_clock::now() - startTime < 30ms);
@@ -79,9 +80,9 @@
mIdleTimer->stop();
}
-TEST_F(IdleTimerTest, resetTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(20ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, resetTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(20ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
// Observe any event that happens in about 25ms. We don't care if one was
@@ -104,9 +105,9 @@
EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
}
-TEST_F(IdleTimerTest, resetBackToBackTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(20ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, resetBackToBackTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(20ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
@@ -135,9 +136,9 @@
EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
}
-TEST_F(IdleTimerTest, startNotCalledTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(3ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, startNotCalledTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
// The start hasn't happened, so the callback does not happen.
EXPECT_FALSE(mExpiredTimerCallback.waitForCall(waitTimeForUnexpected3msCallback).has_value());
EXPECT_FALSE(mResetTimerCallback.waitForCall().has_value());
@@ -147,9 +148,9 @@
EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
}
-TEST_F(IdleTimerTest, idleTimerIdlesTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(3ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, idleTimerIdlesTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
@@ -167,18 +168,18 @@
EXPECT_FALSE(mResetTimerCallback.waitForCall(0ms).has_value());
}
-TEST_F(IdleTimerTest, timeoutCallbackExecutionTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(3ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, timeoutCallbackExecutionTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
EXPECT_TRUE(mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback).has_value());
mIdleTimer->stop();
}
-TEST_F(IdleTimerTest, noCallbacksAfterStopAndResetTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(3ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, noCallbacksAfterStopAndResetTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());
EXPECT_TRUE(mExpiredTimerCallback.waitForCall(waitTimeForExpected3msCallback).has_value());
@@ -190,9 +191,9 @@
EXPECT_FALSE(mResetTimerCallback.waitForCall().has_value());
}
-TEST_F(IdleTimerTest, noCallbacksAfterStopTest) {
- mIdleTimer = std::make_unique<scheduler::IdleTimer>(3ms, mResetTimerCallback.getInvocable(),
- mExpiredTimerCallback.getInvocable());
+TEST_F(OneShotTimerTest, noCallbacksAfterStopTest) {
+ mIdleTimer = std::make_unique<scheduler::OneShotTimer>(3ms, mResetTimerCallback.getInvocable(),
+ mExpiredTimerCallback.getInvocable());
mIdleTimer->start();
EXPECT_TRUE(mResetTimerCallback.waitForCall().has_value());