diff options
20 files changed, 181 insertions, 131 deletions
diff --git a/services/surfaceflinger/Android.bp b/services/surfaceflinger/Android.bp index 61ff53cfdf..9f4084959b 100644 --- a/services/surfaceflinger/Android.bp +++ b/services/surfaceflinger/Android.bp @@ -189,7 +189,6 @@ filegroup { "Scheduler/MessageQueue.cpp", "Scheduler/RefreshRateConfigs.cpp", "Scheduler/Scheduler.cpp", - "Scheduler/Timer.cpp", "Scheduler/VSyncDispatchTimerQueue.cpp", "Scheduler/VSyncPredictor.cpp", "Scheduler/VSyncReactor.cpp", diff --git a/services/surfaceflinger/Scheduler/Android.bp b/services/surfaceflinger/Scheduler/Android.bp index 409d09858f..5de796d742 100644 --- a/services/surfaceflinger/Scheduler/Android.bp +++ b/services/surfaceflinger/Scheduler/Android.bp @@ -16,6 +16,8 @@ cc_defaults { ], shared_libs: [ "libbase", + "libcutils", + "liblog", "libutils", ], } @@ -26,10 +28,36 @@ cc_library_headers { export_include_dirs: ["include"], } +// TODO(b/185535769): Remove libsurfaceflinger_unittest's dependency on AsyncCallRecorder. +cc_library_headers { + name: "libscheduler_test_headers", + defaults: ["libscheduler_defaults"], + export_include_dirs: ["tests"], +} + cc_library_static { name: "libscheduler", defaults: ["libscheduler_defaults"], - srcs: [], + srcs: [ + "src/Timer.cpp", + ], local_include_dirs: ["include"], export_include_dirs: ["include"], } + +cc_test { + name: "libscheduler_test", + test_suites: ["device-tests"], + defaults: ["libscheduler_defaults"], + srcs: [ + "tests/TimerTest.cpp", + ], + static_libs: [ + "libgmock", + "libgtest", + "libscheduler", + ], + sanitize: { + address: true, + }, +} diff --git a/services/surfaceflinger/Scheduler/VSyncDispatch.h b/services/surfaceflinger/Scheduler/VSyncDispatch.h index b52706f727..2bfe204a33 100644 --- a/services/surfaceflinger/Scheduler/VSyncDispatch.h +++ b/services/surfaceflinger/Scheduler/VSyncDispatch.h @@ -16,17 +16,15 @@ #pragma once -#include <utils/Log.h> -#include <utils/Timers.h> #include <functional> #include <optional> #include <string> +#include <utils/Timers.h> + #include "StrongTyping.h" namespace android::scheduler { -class TimeKeeper; -class VSyncTracker; using ScheduleResult = std::optional<nsecs_t>; @@ -64,8 +62,7 @@ public: * invocation of callbackFn. * */ - virtual CallbackToken registerCallback(Callback const& callbackFn, - std::string callbackName) = 0; + virtual CallbackToken registerCallback(Callback, std::string callbackName) = 0; /* * Unregisters a callback. @@ -142,8 +139,9 @@ public: protected: VSyncDispatch() = default; - VSyncDispatch(VSyncDispatch const&) = delete; - VSyncDispatch& operator=(VSyncDispatch const&) = delete; + + VSyncDispatch(const VSyncDispatch&) = delete; + VSyncDispatch& operator=(const VSyncDispatch&) = delete; }; /* @@ -152,11 +150,11 @@ protected: */ class VSyncCallbackRegistration { public: - VSyncCallbackRegistration(VSyncDispatch&, VSyncDispatch::Callback const& callbackFn, - std::string const& callbackName); + VSyncCallbackRegistration(VSyncDispatch&, VSyncDispatch::Callback, std::string callbackName); + ~VSyncCallbackRegistration(); + VSyncCallbackRegistration(VSyncCallbackRegistration&&); VSyncCallbackRegistration& operator=(VSyncCallbackRegistration&&); - ~VSyncCallbackRegistration(); // See documentation for VSyncDispatch::schedule. ScheduleResult schedule(VSyncDispatch::ScheduleTiming scheduleTiming); @@ -165,9 +163,6 @@ public: CancelResult cancel(); private: - VSyncCallbackRegistration(VSyncCallbackRegistration const&) = delete; - VSyncCallbackRegistration& operator=(VSyncCallbackRegistration const&) = delete; - std::reference_wrapper<VSyncDispatch> mDispatch; VSyncDispatch::CallbackToken mToken; bool mValidToken; diff --git a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp index c0646adead..27f43115c1 100644 --- a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp +++ b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.cpp @@ -22,7 +22,8 @@ #include <ftl/concat.h> #include <utils/Trace.h> -#include "TimeKeeper.h" +#include <scheduler/TimeKeeper.h> + #include "VSyncDispatchTimerQueue.h" #include "VSyncTracker.h" @@ -31,6 +32,7 @@ namespace android::scheduler { using base::StringAppendF; namespace { + nsecs_t getExpectedCallbackTime(nsecs_t nextVsyncTime, const VSyncDispatch::ScheduleTiming& timing) { return nextVsyncTime - timing.readyDuration - timing.workDuration; @@ -42,17 +44,17 @@ nsecs_t getExpectedCallbackTime(VSyncTracker& tracker, nsecs_t now, std::max(timing.earliestVsync, now + timing.workDuration + timing.readyDuration)); return getExpectedCallbackTime(nextVsyncTime, timing); } + } // namespace VSyncDispatch::~VSyncDispatch() = default; VSyncTracker::~VSyncTracker() = default; -TimeKeeper::~TimeKeeper() = default; -VSyncDispatchTimerQueueEntry::VSyncDispatchTimerQueueEntry(std::string const& name, - VSyncDispatch::Callback const& cb, +VSyncDispatchTimerQueueEntry::VSyncDispatchTimerQueueEntry(std::string name, + VSyncDispatch::Callback callback, nsecs_t minVsyncDistance) - : mName(name), - mCallback(cb), + : mName(std::move(name)), + mCallback(std::move(callback)), mMinVsyncDistance(minVsyncDistance) {} std::optional<nsecs_t> VSyncDispatchTimerQueueEntry::lastExecutedVsyncTarget() const { @@ -301,13 +303,13 @@ void VSyncDispatchTimerQueue::timerCallback() { } VSyncDispatchTimerQueue::CallbackToken VSyncDispatchTimerQueue::registerCallback( - Callback const& callbackFn, std::string callbackName) { + Callback callback, std::string callbackName) { std::lock_guard lock(mMutex); return CallbackToken{ mCallbacks .emplace(++mCallbackToken, - std::make_shared<VSyncDispatchTimerQueueEntry>(callbackName, - callbackFn, + std::make_shared<VSyncDispatchTimerQueueEntry>(std::move(callbackName), + std::move(callback), mMinVsyncDistance)) .first->first}; } @@ -402,10 +404,10 @@ void VSyncDispatchTimerQueue::dump(std::string& result) const { } VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncDispatch& dispatch, - VSyncDispatch::Callback const& callbackFn, - std::string const& callbackName) + VSyncDispatch::Callback callback, + std::string callbackName) : mDispatch(dispatch), - mToken(dispatch.registerCallback(callbackFn, callbackName)), + mToken(dispatch.registerCallback(std::move(callback), std::move(callbackName))), mValidToken(true) {} VSyncCallbackRegistration::VSyncCallbackRegistration(VSyncCallbackRegistration&& other) diff --git a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h index 76e1caf408..3186d6d399 100644 --- a/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h +++ b/services/surfaceflinger/Scheduler/VSyncDispatchTimerQueue.h @@ -16,7 +16,6 @@ #pragma once -#include <android-base/thread_annotations.h> #include <functional> #include <memory> #include <mutex> @@ -24,10 +23,14 @@ #include <string_view> #include <unordered_map> +#include <android-base/thread_annotations.h> + #include "VSyncDispatch.h" namespace android::scheduler { +class VSyncTracker; + // VSyncDispatchTimerQueueEntry is a helper class representing internal state for each entry in // VSyncDispatchTimerQueue hoisted to public for unit testing. class VSyncDispatchTimerQueueEntry { @@ -36,7 +39,7 @@ public: // Valid transition: disarmed -> armed ( when scheduled ) // Valid transition: armed -> running -> disarmed ( when timer is called) // Valid transition: armed -> disarmed ( when cancelled ) - VSyncDispatchTimerQueueEntry(std::string const& name, VSyncDispatch::Callback const& fn, + VSyncDispatchTimerQueueEntry(std::string name, VSyncDispatch::Callback, nsecs_t minVsyncDistance); std::string_view name() const; @@ -45,10 +48,9 @@ public: std::optional<nsecs_t> lastExecutedVsyncTarget() const; // This moves the state from disarmed->armed and will calculate the wakeupTime. - ScheduleResult schedule(VSyncDispatch::ScheduleTiming timing, VSyncTracker& tracker, - nsecs_t now); + ScheduleResult schedule(VSyncDispatch::ScheduleTiming, VSyncTracker&, nsecs_t now); // This will update armed entries with the latest vsync information. Entry remains armed. - void update(VSyncTracker& tracker, nsecs_t now); + void update(VSyncTracker&, nsecs_t now); // This will return empty if not armed, or the next calculated wakeup time if armed. // It will not update the wakeupTime. @@ -81,11 +83,11 @@ public: void dump(std::string& result) const; private: - std::string const mName; - VSyncDispatch::Callback const mCallback; + const std::string mName; + const VSyncDispatch::Callback mCallback; VSyncDispatch::ScheduleTiming mScheduleTiming; - nsecs_t const mMinVsyncDistance; + const nsecs_t mMinVsyncDistance; struct ArmingInfo { nsecs_t mActualWakeupTime; @@ -115,19 +117,19 @@ public: // should be grouped into one wakeup. // \param[in] minVsyncDistance The minimum distance between two vsync estimates before the // vsyncs are considered the same vsync event. - explicit VSyncDispatchTimerQueue(std::unique_ptr<TimeKeeper> tk, VSyncTracker& tracker, - nsecs_t timerSlack, nsecs_t minVsyncDistance); + VSyncDispatchTimerQueue(std::unique_ptr<TimeKeeper>, VSyncTracker&, nsecs_t timerSlack, + nsecs_t minVsyncDistance); ~VSyncDispatchTimerQueue(); - CallbackToken registerCallback(Callback const& callbackFn, std::string callbackName) final; - void unregisterCallback(CallbackToken token) final; - ScheduleResult schedule(CallbackToken token, ScheduleTiming scheduleTiming) final; - CancelResult cancel(CallbackToken token) final; - void dump(std::string& result) const final; + CallbackToken registerCallback(Callback, std::string callbackName) final; + void unregisterCallback(CallbackToken) final; + ScheduleResult schedule(CallbackToken, ScheduleTiming) final; + CancelResult cancel(CallbackToken) final; + void dump(std::string&) const final; private: - VSyncDispatchTimerQueue(VSyncDispatchTimerQueue const&) = delete; - VSyncDispatchTimerQueue& operator=(VSyncDispatchTimerQueue const&) = delete; + VSyncDispatchTimerQueue(const VSyncDispatchTimerQueue&) = delete; + VSyncDispatchTimerQueue& operator=(const VSyncDispatchTimerQueue&) = delete; using CallbackMap = std::unordered_map<CallbackToken, std::shared_ptr<VSyncDispatchTimerQueueEntry>>; diff --git a/services/surfaceflinger/Scheduler/VSyncReactor.cpp b/services/surfaceflinger/Scheduler/VSyncReactor.cpp index 1c9de1c452..bdcab515f2 100644 --- a/services/surfaceflinger/Scheduler/VSyncReactor.cpp +++ b/services/surfaceflinger/Scheduler/VSyncReactor.cpp @@ -18,21 +18,22 @@ #undef LOG_TAG #define LOG_TAG "VSyncReactor" //#define LOG_NDEBUG 0 -#include "VSyncReactor.h" + #include <cutils/properties.h> #include <log/log.h> #include <utils/Trace.h> + #include "../TracedOrdinal.h" -#include "TimeKeeper.h" #include "VSyncDispatch.h" +#include "VSyncReactor.h" #include "VSyncTracker.h" namespace android::scheduler { + using base::StringAppendF; VsyncController::~VsyncController() = default; -Clock::~Clock() = default; nsecs_t SystemClock::now() const { return systemTime(SYSTEM_TIME_MONOTONIC); } diff --git a/services/surfaceflinger/Scheduler/VSyncReactor.h b/services/surfaceflinger/Scheduler/VSyncReactor.h index a9d536be28..6a1950ac77 100644 --- a/services/surfaceflinger/Scheduler/VSyncReactor.h +++ b/services/surfaceflinger/Scheduler/VSyncReactor.h @@ -16,14 +16,18 @@ #pragma once -#include <android-base/thread_annotations.h> -#include <ui/FenceTime.h> #include <memory> #include <mutex> #include <unordered_map> #include <vector> -#include "TimeKeeper.h" + +#include <android-base/thread_annotations.h> +#include <ui/FenceTime.h> + +#include <scheduler/TimeKeeper.h> + #include "VsyncController.h" + namespace android::scheduler { class Clock; diff --git a/services/surfaceflinger/Scheduler/VsyncSchedule.cpp b/services/surfaceflinger/Scheduler/VsyncSchedule.cpp index 77d1223aeb..e611658bfd 100644 --- a/services/surfaceflinger/Scheduler/VsyncSchedule.cpp +++ b/services/surfaceflinger/Scheduler/VsyncSchedule.cpp @@ -15,10 +15,10 @@ */ #include <scheduler/Fps.h> +#include <scheduler/Timer.h> #include "VsyncSchedule.h" -#include "Timer.h" #include "VSyncDispatchTimerQueue.h" #include "VSyncPredictor.h" #include "VSyncReactor.h" diff --git a/services/surfaceflinger/Scheduler/TimeKeeper.h b/services/surfaceflinger/Scheduler/include/scheduler/TimeKeeper.h index 40dd8410a3..319390bfab 100644 --- a/services/surfaceflinger/Scheduler/TimeKeeper.h +++ b/services/surfaceflinger/Scheduler/include/scheduler/TimeKeeper.h @@ -16,14 +16,17 @@ #pragma once -#include <utils/Timers.h> #include <functional> +#include <string> + +#include <utils/Timers.h> namespace android::scheduler { class Clock { public: virtual ~Clock(); + /* * Returns the SYSTEM_TIME_MONOTONIC, used by testing infra to stub time. */ @@ -31,8 +34,9 @@ public: protected: Clock() = default; - Clock(Clock const&) = delete; - Clock& operator=(Clock const&) = delete; + + Clock(const Clock&) = delete; + Clock& operator=(const Clock&) = delete; }; /* @@ -46,19 +50,20 @@ public: * Arms callback to fired when time is current based on CLOCK_MONOTONIC * There is only one timer, and subsequent calls will reset the callback function and the time. */ - virtual void alarmAt(std::function<void()> const& callback, nsecs_t time) = 0; + virtual void alarmAt(std::function<void()>, nsecs_t time) = 0; /* * Cancels an existing pending callback */ virtual void alarmCancel() = 0; - virtual void dump(std::string& result) const = 0; + virtual void dump(std::string&) const = 0; protected: - TimeKeeper(TimeKeeper const&) = delete; - TimeKeeper& operator=(TimeKeeper const&) = delete; TimeKeeper() = default; + + TimeKeeper(const TimeKeeper&) = delete; + TimeKeeper& operator=(const TimeKeeper&) = delete; }; } // namespace android::scheduler diff --git a/services/surfaceflinger/Scheduler/Timer.h b/services/surfaceflinger/Scheduler/include/scheduler/Timer.h index eb659543eb..58ad6cb991 100644 --- a/services/surfaceflinger/Scheduler/Timer.h +++ b/services/surfaceflinger/Scheduler/include/scheduler/Timer.h @@ -16,25 +16,30 @@ #pragma once -#include "TimeKeeper.h" - -#include <android-base/thread_annotations.h> #include <array> +#include <functional> +#include <mutex> #include <thread> +#include <android-base/thread_annotations.h> + +#include <scheduler/TimeKeeper.h> + namespace android::scheduler { class Timer : public TimeKeeper { public: Timer(); ~Timer(); + nsecs_t now() const final; // NB: alarmAt and alarmCancel are threadsafe; with the last-returning function being effectual // Most users will want to serialize thes calls so as to be aware of the timer state. - void alarmAt(std::function<void()> const& cb, nsecs_t time) final; + void alarmAt(std::function<void()>, nsecs_t time) final; void alarmCancel() final; - void dump(std::string& result) const final; + + void dump(std::string&) const final; protected: // For unit testing @@ -54,7 +59,7 @@ private: void reset() EXCLUDES(mMutex); void cleanup() REQUIRES(mMutex); - void setDebugState(DebugState state) EXCLUDES(mMutex); + void setDebugState(DebugState) EXCLUDES(mMutex); int mTimerFd = -1; diff --git a/services/surfaceflinger/Scheduler/Timer.cpp b/services/surfaceflinger/Scheduler/src/Timer.cpp index 38e277cf62..a4cf57fbaa 100644 --- a/services/surfaceflinger/Scheduler/Timer.cpp +++ b/services/surfaceflinger/Scheduler/src/Timer.cpp @@ -16,7 +16,6 @@ #undef LOG_TAG #define LOG_TAG "SchedulerTimer" -#define ATRACE_TAG ATRACE_TAG_GRAPHICS #include <chrono> #include <cstdint> @@ -30,12 +29,15 @@ #include <log/log.h> #include <utils/Trace.h> -#include "Timer.h" +#include <scheduler/Timer.h> namespace android::scheduler { -static constexpr size_t kReadPipe = 0; -static constexpr size_t kWritePipe = 1; +constexpr size_t kReadPipe = 0; +constexpr size_t kWritePipe = 1; + +Clock::~Clock() = default; +TimeKeeper::~TimeKeeper() = default; Timer::Timer() { reset(); @@ -104,13 +106,13 @@ nsecs_t Timer::now() const { return systemTime(SYSTEM_TIME_MONOTONIC); } -void Timer::alarmAt(std::function<void()> const& cb, nsecs_t time) { +void Timer::alarmAt(std::function<void()> callback, nsecs_t time) { std::lock_guard lock(mMutex); using namespace std::literals; static constexpr int ns_per_s = std::chrono::duration_cast<std::chrono::nanoseconds>(1s).count(); - mCallback = cb; + mCallback = std::move(callback); mExpectingCallback = true; struct itimerspec old_timer; diff --git a/services/surfaceflinger/tests/unittests/AsyncCallRecorder.h b/services/surfaceflinger/Scheduler/tests/AsyncCallRecorder.h index 8bed766262..57f0dab200 100644 --- a/services/surfaceflinger/tests/unittests/AsyncCallRecorder.h +++ b/services/surfaceflinger/Scheduler/tests/AsyncCallRecorder.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018 The Android Open Source Project + * Copyright 2018 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. diff --git a/services/surfaceflinger/tests/unittests/TimerTest.cpp b/services/surfaceflinger/Scheduler/tests/TimerTest.cpp index 0a3639db90..47d968c94e 100644 --- a/services/surfaceflinger/tests/unittests/TimerTest.cpp +++ b/services/surfaceflinger/Scheduler/tests/TimerTest.cpp @@ -14,15 +14,13 @@ * limitations under the License. */ -#include "AsyncCallRecorder.h" -#include "Scheduler/TimeKeeper.h" -#include "Scheduler/Timer.h" - #include <gmock/gmock.h> #include <gtest/gtest.h> -using namespace testing; -using namespace std::literals; +#include <scheduler/TimeKeeper.h> +#include <scheduler/Timer.h> + +#include "AsyncCallRecorder.h" namespace android::scheduler { @@ -35,7 +33,7 @@ public: }; struct TimerTest : testing::Test { - static constexpr int mIterations = 20; + static constexpr int kIterations = 20; AsyncCallRecorder<void (*)()> mCallbackRecorder; TestableTimer mTimer; @@ -44,17 +42,17 @@ struct TimerTest : testing::Test { }; TEST_F(TimerTest, callsCallbackIfScheduledInPast) { - for (int i = 0; i < mIterations; i++) { - mTimer.alarmAt(std::bind(&TimerTest::timerCallback, this), systemTime() - 10'000'00); + for (int i = 0; i < kIterations; i++) { + mTimer.alarmAt(std::bind(&TimerTest::timerCallback, this), systemTime() - 1'000'000); EXPECT_TRUE(mCallbackRecorder.waitForCall().has_value()); EXPECT_FALSE(mCallbackRecorder.waitForUnexpectedCall().has_value()); } } TEST_F(TimerTest, recoversAfterEpollError) { - for (int i = 0; i < mIterations; i++) { + for (int i = 0; i < kIterations; i++) { mTimer.makeEpollError(); - mTimer.alarmAt(std::bind(&TimerTest::timerCallback, this), systemTime() - 10'000'00); + mTimer.alarmAt(std::bind(&TimerTest::timerCallback, this), systemTime() - 1'000'000); EXPECT_TRUE(mCallbackRecorder.waitForCall().has_value()); EXPECT_FALSE(mCallbackRecorder.waitForUnexpectedCall().has_value()); } diff --git a/services/surfaceflinger/TracedOrdinal.h b/services/surfaceflinger/TracedOrdinal.h index eee4bec344..558b3be273 100644 --- a/services/surfaceflinger/TracedOrdinal.h +++ b/services/surfaceflinger/TracedOrdinal.h @@ -15,12 +15,15 @@ */ #pragma once -#include <android-base/stringprintf.h> -#include <cutils/compiler.h> -#include <utils/Trace.h> + +#include <chrono> #include <cmath> +#include <functional> #include <string> +#include <cutils/compiler.h> +#include <utils/Trace.h> + namespace std { template <class Rep, class Period> bool signbit(std::chrono::duration<Rep, Period> v) { @@ -75,7 +78,7 @@ private: } if (mNameNegative.empty()) { - mNameNegative = base::StringPrintf("%sNegative", mName.c_str()); + mNameNegative = mName + "Negative"; } if (!std::signbit(mData)) { diff --git a/services/surfaceflinger/tests/unittests/Android.bp b/services/surfaceflinger/tests/unittests/Android.bp index c053d432b5..d3be0ea1bb 100644 --- a/services/surfaceflinger/tests/unittests/Android.bp +++ b/services/surfaceflinger/tests/unittests/Android.bp @@ -89,7 +89,6 @@ cc_test { "RegionSamplingTest.cpp", "TimeStatsTest.cpp", "FrameTracerTest.cpp", - "TimerTest.cpp", "TransactionApplicationTest.cpp", "TransactionFrameTracerTest.cpp", "TransactionProtoParserTest.cpp", @@ -178,11 +177,12 @@ cc_test { "server_configurable_flags", ], header_libs: [ + "android.hardware.graphics.composer3-command-buffer", "android.hardware.graphics.composer@2.1-command-buffer", "android.hardware.graphics.composer@2.2-command-buffer", "android.hardware.graphics.composer@2.3-command-buffer", "android.hardware.graphics.composer@2.4-command-buffer", - "android.hardware.graphics.composer3-command-buffer", + "libscheduler_test_headers", "libsurfaceflinger_headers", ], } diff --git a/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp b/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp index a9ad249383..f613e43324 100644 --- a/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp +++ b/services/surfaceflinger/tests/unittests/DispSyncSourceTest.cpp @@ -37,12 +37,11 @@ using namespace testing; class MockVSyncDispatch : public scheduler::VSyncDispatch { public: - MOCK_METHOD2(registerCallback, - CallbackToken(std::function<void(nsecs_t, nsecs_t, nsecs_t)> const&, std::string)); - MOCK_METHOD1(unregisterCallback, void(CallbackToken)); - MOCK_METHOD2(schedule, scheduler::ScheduleResult(CallbackToken, ScheduleTiming)); - MOCK_METHOD1(cancel, scheduler::CancelResult(CallbackToken token)); - MOCK_CONST_METHOD1(dump, void(std::string&)); + MOCK_METHOD(CallbackToken, registerCallback, (Callback, std::string), (override)); + MOCK_METHOD(void, unregisterCallback, (CallbackToken), (override)); + MOCK_METHOD(scheduler::ScheduleResult, schedule, (CallbackToken, ScheduleTiming), (override)); + MOCK_METHOD(scheduler::CancelResult, cancel, (CallbackToken), (override)); + MOCK_METHOD(void, dump, (std::string&), (const, override)); MockVSyncDispatch() { ON_CALL(*this, registerCallback) diff --git a/services/surfaceflinger/tests/unittests/MessageQueueTest.cpp b/services/surfaceflinger/tests/unittests/MessageQueueTest.cpp index bd4dc593ba..1dd7deaf8d 100644 --- a/services/surfaceflinger/tests/unittests/MessageQueueTest.cpp +++ b/services/surfaceflinger/tests/unittests/MessageQueueTest.cpp @@ -56,12 +56,11 @@ public: }; struct MockVSyncDispatch : scheduler::VSyncDispatch { - MOCK_METHOD2(registerCallback, - CallbackToken(const std::function<void(nsecs_t, nsecs_t, nsecs_t)>&, std::string)); - MOCK_METHOD1(unregisterCallback, void(CallbackToken)); - MOCK_METHOD2(schedule, scheduler::ScheduleResult(CallbackToken, ScheduleTiming)); - MOCK_METHOD1(cancel, scheduler::CancelResult(CallbackToken token)); - MOCK_CONST_METHOD1(dump, void(std::string&)); + MOCK_METHOD(CallbackToken, registerCallback, (Callback, std::string), (override)); + MOCK_METHOD(void, unregisterCallback, (CallbackToken), (override)); + MOCK_METHOD(scheduler::ScheduleResult, schedule, (CallbackToken, ScheduleTiming), (override)); + MOCK_METHOD(scheduler::CancelResult, cancel, (CallbackToken token), (override)); + MOCK_METHOD(void, dump, (std::string&), (const, override)); }; struct MockTokenManager : frametimeline::TokenManager { diff --git a/services/surfaceflinger/tests/unittests/VSyncDispatchRealtimeTest.cpp b/services/surfaceflinger/tests/unittests/VSyncDispatchRealtimeTest.cpp index 42b19933b4..2da266bd33 100644 --- a/services/surfaceflinger/tests/unittests/VSyncDispatchRealtimeTest.cpp +++ b/services/surfaceflinger/tests/unittests/VSyncDispatchRealtimeTest.cpp @@ -14,14 +14,15 @@ * limitations under the License. */ -#include "Scheduler/TimeKeeper.h" -#include "Scheduler/Timer.h" -#include "Scheduler/VSyncDispatchTimerQueue.h" -#include "Scheduler/VSyncTracker.h" +#include <thread> #include <gmock/gmock.h> #include <gtest/gtest.h> -#include <thread> + +#include <scheduler/Timer.h> + +#include "Scheduler/VSyncDispatchTimerQueue.h" +#include "Scheduler/VSyncTracker.h" using namespace testing; using namespace std::literals; diff --git a/services/surfaceflinger/tests/unittests/VSyncDispatchTimerQueueTest.cpp b/services/surfaceflinger/tests/unittests/VSyncDispatchTimerQueueTest.cpp index ddc02bfbe6..b7f968dc17 100644 --- a/services/surfaceflinger/tests/unittests/VSyncDispatchTimerQueueTest.cpp +++ b/services/surfaceflinger/tests/unittests/VSyncDispatchTimerQueueTest.cpp @@ -23,16 +23,19 @@ #define LOG_TAG "LibSurfaceFlingerUnittests" #define LOG_NDEBUG 0 -#include "Scheduler/TimeKeeper.h" -#include "Scheduler/VSyncDispatchTimerQueue.h" -#include "Scheduler/VSyncTracker.h" +#include <thread> #include <gmock/gmock.h> #include <gtest/gtest.h> -#include <thread> + +#include <scheduler/TimeKeeper.h> + +#include "Scheduler/VSyncDispatchTimerQueue.h" +#include "Scheduler/VSyncTracker.h" using namespace testing; using namespace std::literals; + namespace android::scheduler { class MockVSyncTracker : public VSyncTracker { @@ -71,10 +74,10 @@ public: ON_CALL(*this, now()).WillByDefault(Invoke(this, &ControllableClock::fakeTime)); } - MOCK_CONST_METHOD0(now, nsecs_t()); - MOCK_METHOD2(alarmAt, void(std::function<void()> const&, nsecs_t time)); - MOCK_METHOD0(alarmCancel, void()); - MOCK_CONST_METHOD1(dump, void(std::string&)); + MOCK_METHOD(nsecs_t, now, (), (const)); + MOCK_METHOD(void, alarmAt, (std::function<void()>, nsecs_t), (override)); + MOCK_METHOD(void, alarmCancel, (), (override)); + MOCK_METHOD(void, dump, (std::string&), (const, override)); void alarmAtDefaultBehavior(std::function<void()> const& callback, nsecs_t time) { mCallback = callback; @@ -196,11 +199,14 @@ protected: class TimeKeeperWrapper : public TimeKeeper { public: TimeKeeperWrapper(TimeKeeper& control) : mControllableClock(control) {} - void alarmAt(std::function<void()> const& callback, nsecs_t time) final { - mControllableClock.alarmAt(callback, time); + + nsecs_t now() const final { return mControllableClock.now(); } + + void alarmAt(std::function<void()> callback, nsecs_t time) final { + mControllableClock.alarmAt(std::move(callback), time); } + void alarmCancel() final { mControllableClock.alarmCancel(); } - nsecs_t now() const final { return mControllableClock.now(); } void dump(std::string&) const final {} private: diff --git a/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp b/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp index 5826a9b6cf..4eb90558ab 100644 --- a/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp +++ b/services/surfaceflinger/tests/unittests/VSyncReactorTest.cpp @@ -22,19 +22,22 @@ #define LOG_TAG "LibSurfaceFlingerUnittests" #define LOG_NDEBUG 0 -#include "Scheduler/TimeKeeper.h" -#include "Scheduler/VSyncDispatch.h" -#include "Scheduler/VSyncReactor.h" -#include "Scheduler/VSyncTracker.h" +#include <array> #include <gmock/gmock.h> #include <gtest/gtest.h> #include <ui/Fence.h> #include <ui/FenceTime.h> -#include <array> + +#include <scheduler/TimeKeeper.h> + +#include "Scheduler/VSyncDispatch.h" +#include "Scheduler/VSyncReactor.h" +#include "Scheduler/VSyncTracker.h" using namespace testing; using namespace std::literals; + namespace android::scheduler { class MockVSyncTracker : public VSyncTracker { @@ -65,14 +68,12 @@ private: std::shared_ptr<Clock> const mClock; }; -class MockVSyncDispatch : public VSyncDispatch { -public: - MOCK_METHOD2(registerCallback, - CallbackToken(std::function<void(nsecs_t, nsecs_t, nsecs_t)> const&, std::string)); - MOCK_METHOD1(unregisterCallback, void(CallbackToken)); - MOCK_METHOD2(schedule, ScheduleResult(CallbackToken, ScheduleTiming)); - MOCK_METHOD1(cancel, CancelResult(CallbackToken token)); - MOCK_CONST_METHOD1(dump, void(std::string&)); +struct MockVSyncDispatch : VSyncDispatch { + MOCK_METHOD(CallbackToken, registerCallback, (Callback, std::string), (override)); + MOCK_METHOD(void, unregisterCallback, (CallbackToken), (override)); + MOCK_METHOD(ScheduleResult, schedule, (CallbackToken, ScheduleTiming), (override)); + MOCK_METHOD(CancelResult, cancel, (CallbackToken), (override)); + MOCK_METHOD(void, dump, (std::string&), (const, override)); }; std::shared_ptr<android::FenceTime> generateInvalidFence() { @@ -497,4 +498,4 @@ TEST_F(VSyncReactorTest, periodIsMeasuredIfIgnoringComposer) { } // namespace android::scheduler // TODO(b/129481165): remove the #pragma below and fix conversion issues -#pragma clang diagnostic pop // ignored "-Wextra"
\ No newline at end of file +#pragma clang diagnostic pop // ignored "-Wextra" |