SF: Clang format selected sources
Bug: None
Test: None
Change-Id: Icef36ab31252e0e785d1088cbde2aaa0cf356fdf
diff --git a/services/surfaceflinger/DispSync.cpp b/services/surfaceflinger/DispSync.cpp
index bef12ea..b5fc365 100644
--- a/services/surfaceflinger/DispSync.cpp
+++ b/services/surfaceflinger/DispSync.cpp
@@ -33,8 +33,8 @@
#include <ui/FenceTime.h>
#include "DispSync.h"
-#include "SurfaceFlinger.h"
#include "EventLog/EventLog.h"
+#include "SurfaceFlinger.h"
using std::max;
using std::min;
@@ -53,15 +53,14 @@
// needed to re-synchronize the software vsync model with the hardware. The
// error metric used is the mean of the squared difference between each
// present time and the nearest software-predicted vsync.
-static const nsecs_t kErrorThreshold = 160000000000; // 400 usec squared
+static const nsecs_t kErrorThreshold = 160000000000; // 400 usec squared
#undef LOG_TAG
#define LOG_TAG "DispSyncThread"
-class DispSyncThread: public Thread {
+class DispSyncThread : public Thread {
public:
-
- explicit DispSyncThread(const char* name):
- mName(name),
+ explicit DispSyncThread(const char* name)
+ : mName(name),
mStop(false),
mPeriod(0),
mPhase(0),
@@ -78,8 +77,8 @@
mPhase = phase;
mReferenceTime = referenceTime;
ALOGV("[%s] updateModel: mPeriod = %" PRId64 ", mPhase = %" PRId64
- " mReferenceTime = %" PRId64, mName, ns2us(mPeriod),
- ns2us(mPhase), ns2us(mReferenceTime));
+ " mReferenceTime = %" PRId64,
+ mName, ns2us(mPeriod), ns2us(mPhase), ns2us(mReferenceTime));
mCond.signal();
}
@@ -115,8 +114,7 @@
if (mPeriod == 0) {
err = mCond.wait(mMutex);
if (err != NO_ERROR) {
- ALOGE("error waiting for new events: %s (%d)",
- strerror(-err), err);
+ ALOGE("error waiting for new events: %s (%d)", strerror(-err), err);
return false;
}
continue;
@@ -133,16 +131,14 @@
ALOGV("[%s] Waiting forever", mName);
err = mCond.wait(mMutex);
} else {
- ALOGV("[%s] Waiting until %" PRId64, mName,
- ns2us(targetTime));
+ ALOGV("[%s] Waiting until %" PRId64, mName, ns2us(targetTime));
err = mCond.waitRelative(mMutex, targetTime - now);
}
if (err == TIMED_OUT) {
isWakeup = true;
} else if (err != NO_ERROR) {
- ALOGE("error waiting for next event: %s (%d)",
- strerror(-err), err);
+ ALOGE("error waiting for next event: %s (%d)", strerror(-err), err);
return false;
}
}
@@ -153,8 +149,7 @@
static const nsecs_t kMaxWakeupLatency = us2ns(1500);
if (isWakeup) {
- mWakeupLatency = ((mWakeupLatency * 63) +
- (now - targetTime)) / 64;
+ mWakeupLatency = ((mWakeupLatency * 63) + (now - targetTime)) / 64;
mWakeupLatency = min(mWakeupLatency, kMaxWakeupLatency);
if (kTraceDetailedInfo) {
ATRACE_INT64("DispSync:WakeupLat", now - targetTime);
@@ -174,7 +169,7 @@
}
status_t addEventListener(const char* name, nsecs_t phase,
- const sp<DispSync::Callback>& callback) {
+ const sp<DispSync::Callback>& callback) {
if (kTraceDetailedInfo) ATRACE_CALL();
Mutex::Autolock lock(mMutex);
@@ -191,8 +186,7 @@
// We want to allow the firstmost future event to fire without
// allowing any past events to fire
- listener.mLastEventTime = systemTime() - mPeriod / 2 + mPhase -
- mWakeupLatency;
+ listener.mLastEventTime = systemTime() - mPeriod / 2 + mPhase - mWakeupLatency;
mEventListeners.push(listener);
@@ -225,7 +219,6 @@
}
private:
-
struct EventListener {
const char* mName;
nsecs_t mPhase;
@@ -243,8 +236,7 @@
ALOGV("[%s] computeNextEventTimeLocked", mName);
nsecs_t nextEventTime = INT64_MAX;
for (size_t i = 0; i < mEventListeners.size(); i++) {
- nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i],
- now);
+ nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], now);
if (t < nextEventTime) {
nextEventTime = t;
@@ -257,22 +249,19 @@
Vector<CallbackInvocation> gatherCallbackInvocationsLocked(nsecs_t now) {
if (kTraceDetailedInfo) ATRACE_CALL();
- ALOGV("[%s] gatherCallbackInvocationsLocked @ %" PRId64, mName,
- ns2us(now));
+ ALOGV("[%s] gatherCallbackInvocationsLocked @ %" PRId64, mName, ns2us(now));
Vector<CallbackInvocation> callbackInvocations;
nsecs_t onePeriodAgo = now - mPeriod;
for (size_t i = 0; i < mEventListeners.size(); i++) {
- nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i],
- onePeriodAgo);
+ nsecs_t t = computeListenerNextEventTimeLocked(mEventListeners[i], onePeriodAgo);
if (t < now) {
CallbackInvocation ci;
ci.mCallback = mEventListeners[i].mCallback;
ci.mEventTime = t;
- ALOGV("[%s] [%s] Preparing to fire", mName,
- mEventListeners[i].mName);
+ ALOGV("[%s] [%s] Preparing to fire", mName, mEventListeners[i].mName);
callbackInvocations.push(ci);
mEventListeners.editItemAt(i).mLastEventTime = t;
}
@@ -281,18 +270,16 @@
return callbackInvocations;
}
- nsecs_t computeListenerNextEventTimeLocked(const EventListener& listener,
- nsecs_t baseTime) {
+ nsecs_t computeListenerNextEventTimeLocked(const EventListener& listener, nsecs_t baseTime) {
if (kTraceDetailedInfo) ATRACE_CALL();
- ALOGV("[%s] [%s] computeListenerNextEventTimeLocked(%" PRId64 ")",
- mName, listener.mName, ns2us(baseTime));
+ ALOGV("[%s] [%s] computeListenerNextEventTimeLocked(%" PRId64 ")", mName, listener.mName,
+ ns2us(baseTime));
nsecs_t lastEventTime = listener.mLastEventTime + mWakeupLatency;
ALOGV("[%s] lastEventTime: %" PRId64, mName, ns2us(lastEventTime));
if (baseTime < lastEventTime) {
baseTime = lastEventTime;
- ALOGV("[%s] Clamping baseTime to lastEventTime -> %" PRId64, mName,
- ns2us(baseTime));
+ ALOGV("[%s] Clamping baseTime to lastEventTime -> %" PRId64, mName, ns2us(baseTime));
}
baseTime -= mReferenceTime;
@@ -374,11 +361,8 @@
bool mParity;
};
-DispSync::DispSync(const char* name) :
- mName(name),
- mRefreshSkipCount(0),
- mThread(new DispSyncThread(name)) {
-}
+DispSync::DispSync(const char* name)
+ : mName(name), mRefreshSkipCount(0), mThread(new DispSyncThread(name)) {}
DispSync::~DispSync() {}
@@ -451,8 +435,8 @@
mPhase = 0;
mReferenceTime = timestamp;
ALOGV("[%s] First resync sample: mPeriod = %" PRId64 ", mPhase = 0, "
- "mReferenceTime = %" PRId64, mName, ns2us(mPeriod),
- ns2us(mReferenceTime));
+ "mReferenceTime = %" PRId64,
+ mName, ns2us(mPeriod), ns2us(mReferenceTime));
mThread->updateModel(mPeriod, mPhase, mReferenceTime);
}
@@ -480,16 +464,13 @@
// Check against kErrorThreshold / 2 to add some hysteresis before having to
// resync again
bool modelLocked = mModelUpdated && mError < (kErrorThreshold / 2);
- ALOGV("[%s] addResyncSample returning %s", mName,
- modelLocked ? "locked" : "unlocked");
+ ALOGV("[%s] addResyncSample returning %s", mName, modelLocked ? "locked" : "unlocked");
return !modelLocked;
}
-void DispSync::endResync() {
-}
+void DispSync::endResync() {}
-status_t DispSync::addEventListener(const char* name, nsecs_t phase,
- const sp<Callback>& callback) {
+status_t DispSync::addEventListener(const char* name, nsecs_t phase, const sp<Callback>& callback) {
Mutex::Autolock lock(mMutex);
return mThread->addEventListener(name, phase, callback);
}
@@ -597,8 +578,7 @@
// call getSignalTime() periodically so the cache is updated when the
// fence signals.
nsecs_t time = mPresentFences[i]->getCachedSignalTime();
- if (time == Fence::SIGNAL_TIME_PENDING ||
- time == Fence::SIGNAL_TIME_INVALID) {
+ if (time == Fence::SIGNAL_TIME_PENDING || time == Fence::SIGNAL_TIME_INVALID) {
continue;
}
@@ -622,9 +602,8 @@
mError = 0;
// Use mod ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT to avoid log spam.
mZeroErrSamplesCount++;
- ALOGE_IF(
- (mZeroErrSamplesCount % ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT) == 0,
- "No present times for model error.");
+ ALOGE_IF((mZeroErrSamplesCount % ACCEPTABLE_ZERO_ERR_SAMPLES_COUNT) == 0,
+ "No present times for model error.");
}
if (kTraceDetailedInfo) {
@@ -650,17 +629,14 @@
void DispSync::dump(String8& result) const {
Mutex::Autolock lock(mMutex);
- result.appendFormat("present fences are %s\n",
- mIgnorePresentFences ? "ignored" : "used");
- result.appendFormat("mPeriod: %" PRId64 " ns (%.3f fps; skipCount=%d)\n",
- mPeriod, 1000000000.0 / mPeriod, mRefreshSkipCount);
+ result.appendFormat("present fences are %s\n", mIgnorePresentFences ? "ignored" : "used");
+ result.appendFormat("mPeriod: %" PRId64 " ns (%.3f fps; skipCount=%d)\n", mPeriod,
+ 1000000000.0 / mPeriod, mRefreshSkipCount);
result.appendFormat("mPhase: %" PRId64 " ns\n", mPhase);
- result.appendFormat("mError: %" PRId64 " ns (sqrt=%.1f)\n",
- mError, sqrt(mError));
+ result.appendFormat("mError: %" PRId64 " ns (sqrt=%.1f)\n", mError, sqrt(mError));
result.appendFormat("mNumResyncSamplesSincePresent: %d (limit %d)\n",
- mNumResyncSamplesSincePresent, MAX_RESYNC_SAMPLES_WITHOUT_PRESENT);
- result.appendFormat("mNumResyncSamples: %zd (max %d)\n",
- mNumResyncSamples, MAX_RESYNC_SAMPLES);
+ mNumResyncSamplesSincePresent, MAX_RESYNC_SAMPLES_WITHOUT_PRESENT);
+ result.appendFormat("mNumResyncSamples: %zd (max %d)\n", mNumResyncSamples, MAX_RESYNC_SAMPLES);
result.appendFormat("mResyncSamples:\n");
nsecs_t previous = -1;
@@ -670,14 +646,13 @@
if (i == 0) {
result.appendFormat(" %" PRId64 "\n", sampleTime);
} else {
- result.appendFormat(" %" PRId64 " (+%" PRId64 ")\n",
- sampleTime, sampleTime - previous);
+ result.appendFormat(" %" PRId64 " (+%" PRId64 ")\n", sampleTime,
+ sampleTime - previous);
}
previous = sampleTime;
}
- result.appendFormat("mPresentFences [%d]:\n",
- NUM_PRESENT_SAMPLES);
+ result.appendFormat("mPresentFences [%d]:\n", NUM_PRESENT_SAMPLES);
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
previous = Fence::SIGNAL_TIME_INVALID;
for (size_t i = 0; i < NUM_PRESENT_SAMPLES; i++) {
@@ -685,17 +660,16 @@
nsecs_t presentTime = mPresentFences[idx]->getSignalTime();
if (presentTime == Fence::SIGNAL_TIME_PENDING) {
result.appendFormat(" [unsignaled fence]\n");
- } else if(presentTime == Fence::SIGNAL_TIME_INVALID) {
+ } else if (presentTime == Fence::SIGNAL_TIME_INVALID) {
result.appendFormat(" [invalid fence]\n");
} else if (previous == Fence::SIGNAL_TIME_PENDING ||
- previous == Fence::SIGNAL_TIME_INVALID) {
+ previous == Fence::SIGNAL_TIME_INVALID) {
result.appendFormat(" %" PRId64 " (%.3f ms ago)\n", presentTime,
- (now - presentTime) / 1000000.0);
+ (now - presentTime) / 1000000.0);
} else {
- result.appendFormat(" %" PRId64 " (+%" PRId64 " / %.3f) (%.3f ms ago)\n",
- presentTime, presentTime - previous,
- (presentTime - previous) / (double) mPeriod,
- (now - presentTime) / 1000000.0);
+ result.appendFormat(" %" PRId64 " (+%" PRId64 " / %.3f) (%.3f ms ago)\n", presentTime,
+ presentTime - previous, (presentTime - previous) / (double)mPeriod,
+ (now - presentTime) / 1000000.0);
}
previous = presentTime;
}
diff --git a/services/surfaceflinger/DispSync.h b/services/surfaceflinger/DispSync.h
index 880a24d..d066d55 100644
--- a/services/surfaceflinger/DispSync.h
+++ b/services/surfaceflinger/DispSync.h
@@ -20,8 +20,8 @@
#include <stddef.h>
#include <utils/Mutex.h>
-#include <utils/Timers.h>
#include <utils/RefBase.h>
+#include <utils/Timers.h>
#include <ui/FenceTime.h>
@@ -47,12 +47,10 @@
// false to indicate that a resynchronization (via addResyncSample) is not
// needed.
class DispSync {
-
public:
-
- class Callback: public virtual RefBase {
+ class Callback : public virtual RefBase {
public:
- virtual ~Callback() {};
+ virtual ~Callback(){};
virtual void onDispSyncEvent(nsecs_t when) = 0;
};
@@ -108,8 +106,7 @@
// given phase offset from the hardware vsync events. The callback is
// called from a separate thread and it should return reasonably quickly
// (i.e. within a few hundred microseconds).
- status_t addEventListener(const char* name, nsecs_t phase,
- const sp<Callback>& callback);
+ status_t addEventListener(const char* name, nsecs_t phase, const sp<Callback>& callback);
// removeEventListener removes an already-registered event callback. Once
// this method returns that callback will no longer be called by the
@@ -126,7 +123,6 @@
void dump(String8& result) const;
private:
-
void updateModelLocked();
void updateErrorLocked();
void resetErrorLocked();
@@ -174,8 +170,7 @@
// These member variables store information about the present fences used
// to validate the currently computed model.
- std::shared_ptr<FenceTime>
- mPresentFences[NUM_PRESENT_SAMPLES] {FenceTime::NO_FENCE};
+ std::shared_ptr<FenceTime> mPresentFences[NUM_PRESENT_SAMPLES]{FenceTime::NO_FENCE};
size_t mPresentSampleOffset;
int mRefreshSkipCount;
@@ -195,6 +190,6 @@
bool mIgnorePresentFences;
};
-}
+} // namespace android
#endif // ANDROID_DISPSYNC_H
diff --git a/services/surfaceflinger/EventControlThread.cpp b/services/surfaceflinger/EventControlThread.cpp
index 02eea47..6fd4cdf 100644
--- a/services/surfaceflinger/EventControlThread.cpp
+++ b/services/surfaceflinger/EventControlThread.cpp
@@ -19,10 +19,8 @@
namespace android {
-EventControlThread::EventControlThread(const sp<SurfaceFlinger>& flinger):
- mFlinger(flinger),
- mVsyncEnabled(false) {
-}
+EventControlThread::EventControlThread(const sp<SurfaceFlinger>& flinger)
+ : mFlinger(flinger), mVsyncEnabled(false) {}
void EventControlThread::setVsyncEnabled(bool enabled) {
Mutex::Autolock lock(mMutex);
@@ -31,24 +29,21 @@
}
bool EventControlThread::threadLoop() {
- enum class VsyncState {Unset, On, Off};
+ enum class VsyncState { Unset, On, Off };
auto currentVsyncState = VsyncState::Unset;
while (true) {
auto requestedVsyncState = VsyncState::On;
{
Mutex::Autolock lock(mMutex);
- requestedVsyncState =
- mVsyncEnabled ? VsyncState::On : VsyncState::Off;
+ requestedVsyncState = mVsyncEnabled ? VsyncState::On : VsyncState::Off;
while (currentVsyncState == requestedVsyncState) {
status_t err = mCond.wait(mMutex);
if (err != NO_ERROR) {
- ALOGE("error waiting for new events: %s (%d)",
- strerror(-err), err);
+ ALOGE("error waiting for new events: %s (%d)", strerror(-err), err);
return false;
}
- requestedVsyncState =
- mVsyncEnabled ? VsyncState::On : VsyncState::Off;
+ requestedVsyncState = mVsyncEnabled ? VsyncState::On : VsyncState::Off;
}
}
diff --git a/services/surfaceflinger/EventThread.cpp b/services/surfaceflinger/EventThread.cpp
index 5c0e3b3..6b92cc8 100644
--- a/services/surfaceflinger/EventThread.cpp
+++ b/services/surfaceflinger/EventThread.cpp
@@ -21,8 +21,8 @@
#include <cutils/compiler.h>
-#include <gui/IDisplayEventConnection.h>
#include <gui/DisplayEventReceiver.h>
+#include <gui/IDisplayEventConnection.h>
#include <utils/Errors.h>
#include <utils/String8.h>
@@ -36,18 +36,17 @@
// ---------------------------------------------------------------------------
EventThread::EventThread(const sp<VSyncSource>& src, SurfaceFlinger& flinger, bool interceptVSyncs)
- : mVSyncSource(src),
- mFlinger(flinger),
- mUseSoftwareVSync(false),
- mVsyncEnabled(false),
- mDebugVsyncEnabled(false),
- mInterceptVSyncs(interceptVSyncs) {
-
- for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
+ : mVSyncSource(src),
+ mFlinger(flinger),
+ mUseSoftwareVSync(false),
+ mVsyncEnabled(false),
+ mDebugVsyncEnabled(false),
+ mInterceptVSyncs(interceptVSyncs) {
+ for (int32_t i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; i++) {
mVSyncEvent[i].header.type = DisplayEventReceiver::DISPLAY_EVENT_VSYNC;
mVSyncEvent[i].header.id = 0;
mVSyncEvent[i].header.timestamp = 0;
- mVSyncEvent[i].vsync.count = 0;
+ mVSyncEvent[i].vsync.count = 0;
}
}
@@ -72,14 +71,12 @@
return NO_ERROR;
}
-void EventThread::removeDisplayEventConnection(
- const wp<EventThread::Connection>& connection) {
+void EventThread::removeDisplayEventConnection(const wp<EventThread::Connection>& connection) {
Mutex::Autolock _l(mLock);
mDisplayEventConnections.remove(connection);
}
-void EventThread::setVsyncRate(uint32_t count,
- const sp<EventThread::Connection>& connection) {
+void EventThread::setVsyncRate(uint32_t count, const sp<EventThread::Connection>& connection) {
if (int32_t(count) >= 0) { // server must protect against bad params
Mutex::Autolock _l(mLock);
const int32_t new_count = (count == 0) ? -1 : count;
@@ -90,8 +87,7 @@
}
}
-void EventThread::requestNextVsync(
- const sp<EventThread::Connection>& connection) {
+void EventThread::requestNextVsync(const sp<EventThread::Connection>& connection) {
Mutex::Autolock _l(mLock);
mFlinger.resyncWithRateLimit();
@@ -131,7 +127,7 @@
void EventThread::onHotplugReceived(int type, bool connected) {
ALOGE_IF(type >= DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES,
- "received hotplug event for an invalid display (id=%d)", type);
+ "received hotplug event for an invalid display (id=%d)", type);
Mutex::Autolock _l(mLock);
if (type < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES) {
@@ -147,12 +143,12 @@
bool EventThread::threadLoop() {
DisplayEventReceiver::Event event;
- Vector< sp<EventThread::Connection> > signalConnections;
+ Vector<sp<EventThread::Connection> > signalConnections;
signalConnections = waitForEvent(&event);
// dispatch events to listeners...
const size_t count = signalConnections.size();
- for (size_t i=0 ; i<count ; i++) {
+ for (size_t i = 0; i < count; i++) {
const sp<Connection>& conn(signalConnections[i]);
// now see if we still need to report this event
status_t err = conn->postEvent(event);
@@ -162,8 +158,8 @@
// FIXME: Note that some events cannot be dropped and would have
// to be re-sent later.
// Right-now we don't have the ability to do this.
- ALOGW("EventThread: dropping event (%08x) for connection %p",
- event.header.type, conn.get());
+ ALOGW("EventThread: dropping event (%08x) for connection %p", event.header.type,
+ conn.get());
} else if (err < 0) {
// handle any other error on the pipe as fatal. the only
// reasonable thing to do is to clean-up this connection.
@@ -176,11 +172,9 @@
// This will return when (1) a vsync event has been received, and (2) there was
// at least one connection interested in receiving it when we started waiting.
-Vector< sp<EventThread::Connection> > EventThread::waitForEvent(
- DisplayEventReceiver::Event* event)
-{
+Vector<sp<EventThread::Connection> > EventThread::waitForEvent(DisplayEventReceiver::Event* event) {
Mutex::Autolock _l(mLock);
- Vector< sp<EventThread::Connection> > signalConnections;
+ Vector<sp<EventThread::Connection> > signalConnections;
do {
bool eventPending = false;
@@ -188,7 +182,7 @@
size_t vsyncCount = 0;
nsecs_t timestamp = 0;
- for (int32_t i=0 ; i<DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES ; i++) {
+ for (int32_t i = 0; i < DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES; i++) {
timestamp = mVSyncEvent[i].header.timestamp;
if (timestamp) {
// we have a vsync event to dispatch
@@ -214,7 +208,7 @@
// find out connections waiting for events
size_t count = mDisplayEventConnections.size();
- for (size_t i=0 ; i<count ; ) {
+ for (size_t i = 0; i < count;) {
sp<Connection> connection(mDisplayEventConnections[i].promote());
if (connection != nullptr) {
bool added = false;
@@ -231,7 +225,7 @@
signalConnections.add(connection);
added = true;
} else if (connection->count == 1 ||
- (vsyncCount % connection->count) == 0) {
+ (vsyncCount % connection->count) == 0) {
// continuous event, and time to report it
signalConnections.add(connection);
added = true;
@@ -335,28 +329,22 @@
void EventThread::dump(String8& result) const {
Mutex::Autolock _l(mLock);
- result.appendFormat("VSYNC state: %s\n",
- mDebugVsyncEnabled?"enabled":"disabled");
- result.appendFormat(" soft-vsync: %s\n",
- mUseSoftwareVSync?"enabled":"disabled");
+ result.appendFormat("VSYNC state: %s\n", mDebugVsyncEnabled ? "enabled" : "disabled");
+ result.appendFormat(" soft-vsync: %s\n", mUseSoftwareVSync ? "enabled" : "disabled");
result.appendFormat(" numListeners=%zu,\n events-delivered: %u\n",
- mDisplayEventConnections.size(),
- mVSyncEvent[DisplayDevice::DISPLAY_PRIMARY].vsync.count);
- for (size_t i=0 ; i<mDisplayEventConnections.size() ; i++) {
- sp<Connection> connection =
- mDisplayEventConnections.itemAt(i).promote();
- result.appendFormat(" %p: count=%d\n",
- connection.get(), connection != nullptr ? connection->count : 0);
+ mDisplayEventConnections.size(),
+ mVSyncEvent[DisplayDevice::DISPLAY_PRIMARY].vsync.count);
+ for (size_t i = 0; i < mDisplayEventConnections.size(); i++) {
+ sp<Connection> connection = mDisplayEventConnections.itemAt(i).promote();
+ result.appendFormat(" %p: count=%d\n", connection.get(),
+ connection != nullptr ? connection->count : 0);
}
}
// ---------------------------------------------------------------------------
-EventThread::Connection::Connection(
- const sp<EventThread>& eventThread)
- : count(-1), mEventThread(eventThread), mChannel(gui::BitTube::DefaultSize)
-{
-}
+EventThread::Connection::Connection(const sp<EventThread>& eventThread)
+ : count(-1), mEventThread(eventThread), mChannel(gui::BitTube::DefaultSize) {}
EventThread::Connection::~Connection() {
// do nothing here -- clean-up will happen automatically
@@ -382,8 +370,7 @@
mEventThread->requestNextVsync(this);
}
-status_t EventThread::Connection::postEvent(
- const DisplayEventReceiver::Event& event) {
+status_t EventThread::Connection::postEvent(const DisplayEventReceiver::Event& event) {
ssize_t size = DisplayEventReceiver::sendEvents(&mChannel, &event, 1);
return size < 0 ? status_t(size) : status_t(NO_ERROR);
}
diff --git a/services/surfaceflinger/EventThread.h b/services/surfaceflinger/EventThread.h
index 0823839..b4d718c 100644
--- a/services/surfaceflinger/EventThread.h
+++ b/services/surfaceflinger/EventThread.h
@@ -20,13 +20,13 @@
#include <stdint.h>
#include <sys/types.h>
-#include <private/gui/BitTube.h>
#include <gui/DisplayEventReceiver.h>
#include <gui/IDisplayEventConnection.h>
+#include <private/gui/BitTube.h>
#include <utils/Errors.h>
-#include <utils/threads.h>
#include <utils/SortedVector.h>
+#include <utils/threads.h>
#include "DisplayDevice.h"
@@ -39,10 +39,9 @@
// ---------------------------------------------------------------------------
-
class VSyncSource : public virtual RefBase {
public:
- class Callback: public virtual RefBase {
+ class Callback : public virtual RefBase {
public:
virtual ~Callback() {}
virtual void onVSyncEvent(nsecs_t when) = 0;
@@ -70,13 +69,12 @@
virtual void onFirstRef();
status_t stealReceiveChannel(gui::BitTube* outChannel) override;
status_t setVsyncRate(uint32_t count) override;
- void requestNextVsync() override; // asynchronous
+ void requestNextVsync() override; // asynchronous
sp<EventThread> const mEventThread;
gui::BitTube mChannel;
};
public:
-
EventThread(const sp<VSyncSource>& src, SurfaceFlinger& flinger, bool interceptVSyncs);
sp<Connection> createEventConnection() const;
@@ -94,16 +92,15 @@
// called when receiving a hotplug event
void onHotplugReceived(int type, bool connected);
- Vector< sp<EventThread::Connection> > waitForEvent(
- DisplayEventReceiver::Event* event);
+ Vector<sp<EventThread::Connection> > waitForEvent(DisplayEventReceiver::Event* event);
void dump(String8& result) const;
void setPhaseOffset(nsecs_t phaseOffset);
private:
- virtual bool threadLoop();
- virtual void onFirstRef();
+ virtual bool threadLoop();
+ virtual void onFirstRef();
virtual void onVSyncEvent(nsecs_t timestamp);
@@ -119,8 +116,8 @@
mutable Condition mCondition;
// protected by mLock
- SortedVector< wp<Connection> > mDisplayEventConnections;
- Vector< DisplayEventReceiver::Event > mPendingEvents;
+ SortedVector<wp<Connection> > mDisplayEventConnections;
+ Vector<DisplayEventReceiver::Event> mPendingEvents;
DisplayEventReceiver::Event mVSyncEvent[DisplayDevice::NUM_BUILTIN_DISPLAY_TYPES];
bool mUseSoftwareVSync;
bool mVsyncEnabled;
diff --git a/services/surfaceflinger/MessageQueue.cpp b/services/surfaceflinger/MessageQueue.cpp
index 0b1199c..c9c3989 100644
--- a/services/surfaceflinger/MessageQueue.cpp
+++ b/services/surfaceflinger/MessageQueue.cpp
@@ -14,32 +14,29 @@
* limitations under the License.
*/
-#include <stdint.h>
#include <errno.h>
+#include <stdint.h>
#include <sys/types.h>
#include <binder/IPCThreadState.h>
-#include <utils/threads.h>
-#include <utils/Timers.h>
#include <utils/Log.h>
+#include <utils/Timers.h>
+#include <utils/threads.h>
#include <gui/IDisplayEventConnection.h>
-#include "MessageQueue.h"
#include "EventThread.h"
+#include "MessageQueue.h"
#include "SurfaceFlinger.h"
namespace android {
// ---------------------------------------------------------------------------
-MessageBase::MessageBase()
- : MessageHandler() {
-}
+MessageBase::MessageBase() : MessageHandler() {}
-MessageBase::~MessageBase() {
-}
+MessageBase::~MessageBase() {}
void MessageBase::handleMessage(const Message&) {
this->handler();
@@ -75,22 +72,17 @@
// ---------------------------------------------------------------------------
-MessageQueue::MessageQueue()
-{
-}
+MessageQueue::MessageQueue() {}
-MessageQueue::~MessageQueue() {
-}
+MessageQueue::~MessageQueue() {}
-void MessageQueue::init(const sp<SurfaceFlinger>& flinger)
-{
+void MessageQueue::init(const sp<SurfaceFlinger>& flinger) {
mFlinger = flinger;
mLooper = new Looper(true);
mHandler = new Handler(*this);
}
-void MessageQueue::setEventThread(const sp<EventThread>& eventThread)
-{
+void MessageQueue::setEventThread(const sp<EventThread>& eventThread) {
if (mEventThread == eventThread) {
return;
}
@@ -102,8 +94,8 @@
mEventThread = eventThread;
mEvents = eventThread->createEventConnection();
mEvents->stealReceiveChannel(&mEventTube);
- mLooper->addFd(mEventTube.getFd(), 0, Looper::EVENT_INPUT,
- MessageQueue::cb_eventReceiver, this);
+ mLooper->addFd(mEventTube.getFd(), 0, Looper::EVENT_INPUT, MessageQueue::cb_eventReceiver,
+ this);
}
void MessageQueue::waitMessage() {
@@ -128,9 +120,7 @@
} while (true);
}
-status_t MessageQueue::postMessage(
- const sp<MessageBase>& messageHandler, nsecs_t relTime)
-{
+status_t MessageQueue::postMessage(const sp<MessageBase>& messageHandler, nsecs_t relTime) {
const Message dummyMessage;
if (relTime > 0) {
mLooper->sendMessageDelayed(relTime, messageHandler, dummyMessage);
@@ -140,7 +130,6 @@
return NO_ERROR;
}
-
void MessageQueue::invalidate() {
mEvents->requestNextVsync();
}
@@ -150,7 +139,7 @@
}
int MessageQueue::cb_eventReceiver(int fd, int events, void* data) {
- MessageQueue* queue = reinterpret_cast<MessageQueue *>(data);
+ MessageQueue* queue = reinterpret_cast<MessageQueue*>(data);
return queue->eventReceiver(fd, events);
}
@@ -158,7 +147,7 @@
ssize_t n;
DisplayEventReceiver::Event buffer[8];
while ((n = DisplayEventReceiver::getEvents(&mEventTube, buffer, 8)) > 0) {
- for (int i=0 ; i<n ; i++) {
+ for (int i = 0; i < n; i++) {
if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
mHandler->dispatchInvalidate();
break;
diff --git a/services/surfaceflinger/MessageQueue.h b/services/surfaceflinger/MessageQueue.h
index 14f50bb..fe1bf08 100644
--- a/services/surfaceflinger/MessageQueue.h
+++ b/services/surfaceflinger/MessageQueue.h
@@ -17,16 +17,16 @@
#ifndef ANDROID_MESSAGE_QUEUE_H
#define ANDROID_MESSAGE_QUEUE_H
-#include <stdint.h>
#include <errno.h>
+#include <stdint.h>
#include <sys/types.h>
-#include <utils/threads.h>
-#include <utils/Timers.h>
#include <utils/Looper.h>
+#include <utils/Timers.h>
+#include <utils/threads.h>
-#include <private/gui/BitTube.h>
#include <gui/DisplayEventReceiver.h>
+#include <private/gui/BitTube.h>
#include "Barrier.h"
@@ -40,11 +40,10 @@
// ---------------------------------------------------------------------------
-class MessageBase : public MessageHandler
-{
+class MessageBase : public MessageHandler {
public:
MessageBase();
-
+
// return true if message has a handler
virtual bool handler() = 0;
@@ -79,15 +78,12 @@
class MessageQueue {
class Handler : public MessageHandler {
- enum {
- eventMaskInvalidate = 0x1,
- eventMaskRefresh = 0x2,
- eventMaskTransaction = 0x4
- };
+ enum { eventMaskInvalidate = 0x1, eventMaskRefresh = 0x2, eventMaskTransaction = 0x4 };
MessageQueue& mQueue;
int32_t mEventMask;
+
public:
- explicit Handler(MessageQueue& queue) : mQueue(queue), mEventMask(0) { }
+ explicit Handler(MessageQueue& queue) : mQueue(queue), mEventMask(0) {}
virtual void handleMessage(const Message& message);
void dispatchRefresh();
void dispatchInvalidate();
@@ -102,14 +98,13 @@
gui::BitTube mEventTube;
sp<Handler> mHandler;
-
static int cb_eventReceiver(int fd, int events, void* data);
int eventReceiver(int fd, int events);
public:
enum {
- INVALIDATE = 0,
- REFRESH = 1,
+ INVALIDATE = 0,
+ REFRESH = 1,
};
MessageQueue();
@@ -118,7 +113,7 @@
void setEventThread(const sp<EventThread>& events);
void waitMessage();
- status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime=0);
+ status_t postMessage(const sp<MessageBase>& message, nsecs_t reltime = 0);
// sends INVALIDATE message at next VSYNC
void invalidate();