Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit fa6d4b27 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Move Connection off of RefBase" into udc-dev am: 60508923 

Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/native/+/22749830



Change-Id: I197991a851fd7de89774bbecafa57756e09182e4
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents b5648fc6 60508923

services/inputflinger/dispatcher/Connection.cpp

+0 −2
Original line number Diff line number Diff line
@@ -28,8 +28,6 @@ Connection::Connection(const std::shared_ptr<InputChannel>& inputChannel, bool m 
        inputPublisher(inputChannel),

        inputState(idGenerator) {}



Connection::~Connection() {}



const std::string Connection::getWindowName() const {

    if (inputChannel != nullptr) {

        return inputChannel->getName();

services/inputflinger/dispatcher/Connection.h

+1 −4
Original line number Diff line number Diff line
@@ -27,10 +27,7 @@ namespace android::inputdispatcher { 
struct DispatchEntry;



/* Manages the dispatch state associated with a single input channel. */

class Connection : public RefBase {

protected:

    virtual ~Connection();



class Connection {

public:

    enum class Status {

        // Everything is peachy.

services/inputflinger/dispatcher/InputDispatcher.cpp

+51 −44
Original line number Diff line number Diff line
@@ -688,7 +688,7 @@ InputDispatcher::~InputDispatcher() { 
    mCommandQueue.clear();



    while (!mConnectionsByToken.empty()) {

        sp<Connection> connection = mConnectionsByToken.begin()->second;

        std::shared_ptr<Connection> connection = mConnectionsByToken.begin()->second;

        removeInputChannelLocked(connection->inputChannel->getConnectionToken(), /*notify=*/false);

    }

}
@@ -802,7 +802,7 @@ nsecs_t InputDispatcher::processAnrsLocked() { 
    }



    // If we reached here, we have an unresponsive connection.

    sp<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());

    std::shared_ptr<Connection> connection = getConnectionLocked(mAnrTracker.firstToken());

    if (connection == nullptr) {

        ALOGE("Could not find connection for entry %" PRId64, mAnrTracker.firstTimeout());

        return nextAnrCheck;
@@ -815,7 +815,7 @@ nsecs_t InputDispatcher::processAnrsLocked() { 
}



std::chrono::nanoseconds InputDispatcher::getDispatchingTimeoutLocked(

        const sp<Connection>& connection) {

        const std::shared_ptr<Connection>& connection) {

    if (connection->monitor) {

        return mMonitorDispatchingTimeout;

    }
@@ -1058,7 +1058,8 @@ bool InputDispatcher::shouldPruneInboundQueueLocked(const MotionEntry& motionEnt 
        const std::vector<sp<WindowInfoHandle>> touchedSpies =

                findTouchedSpyWindowsAtLocked(displayId, x, y, isStylus);

        for (const auto& windowHandle : touchedSpies) {

            const sp<Connection> connection = getConnectionLocked(windowHandle->getToken());

            const std::shared_ptr<Connection> connection =

                    getConnectionLocked(windowHandle->getToken());

            if (connection != nullptr && connection->responsive) {

                // This spy window could take more input. Drop all events preceding this

                // event, so that the spy window can get a chance to receive the stream.
@@ -1895,7 +1896,7 @@ void InputDispatcher::dispatchEventLocked(nsecs_t currentTime, 
    pokeUserActivityLocked(*eventEntry);



    for (const InputTarget& inputTarget : inputTargets) {

        sp<Connection> connection =

        std::shared_ptr<Connection> connection =

                getConnectionLocked(inputTarget.inputChannel->getConnectionToken());

        if (connection != nullptr) {

            prepareDispatchCycleLocked(currentTime, connection, eventEntry, inputTarget);
@@ -1909,7 +1910,7 @@ void InputDispatcher::dispatchEventLocked(nsecs_t currentTime, 
    }

}



void InputDispatcher::cancelEventsForAnrLocked(const sp<Connection>& connection) {

void InputDispatcher::cancelEventsForAnrLocked(const std::shared_ptr<Connection>& connection) {

    // We will not be breaking any connections here, even if the policy wants us to abort dispatch.

    // If the policy decides to close the app, we will get a channel removal event via

    // unregisterInputChannel, and will clean up the connection that way. We are already not
@@ -2101,7 +2102,7 @@ std::vector<Monitor> InputDispatcher::selectResponsiveMonitorsLocked( 
    std::vector<Monitor> responsiveMonitors;

    std::copy_if(monitors.begin(), monitors.end(), std::back_inserter(responsiveMonitors),

                 [this](const Monitor& monitor) REQUIRES(mLock) {

                     sp<Connection> connection =

                     std::shared_ptr<Connection> connection =

                             getConnectionLocked(monitor.inputChannel->getConnectionToken());

                     if (connection == nullptr) {

                         ALOGE("Could not find connection for monitor %s",
@@ -3027,7 +3028,7 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry& eventEntry) { 
}



void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime,

                                                 const sp<Connection>& connection,

                                                 const std::shared_ptr<Connection>& connection,

                                                 std::shared_ptr<EventEntry> eventEntry,

                                                 const InputTarget& inputTarget) {

    if (ATRACE_ENABLED()) {
@@ -3097,7 +3098,7 @@ void InputDispatcher::prepareDispatchCycleLocked(nsecs_t currentTime, 
}



void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime,

                                                   const sp<Connection>& connection,

                                                   const std::shared_ptr<Connection>& connection,

                                                   std::shared_ptr<EventEntry> eventEntry,

                                                   const InputTarget& inputTarget) {

    if (ATRACE_ENABLED()) {
@@ -3131,7 +3132,7 @@ void InputDispatcher::enqueueDispatchEntriesLocked(nsecs_t currentTime, 
    }

}



void InputDispatcher::enqueueDispatchEntryLocked(const sp<Connection>& connection,

void InputDispatcher::enqueueDispatchEntryLocked(const std::shared_ptr<Connection>& connection,

                                                 std::shared_ptr<EventEntry> eventEntry,

                                                 const InputTarget& inputTarget,

                                                 ftl::Flags<InputTarget::Flags> dispatchMode) {
@@ -3316,14 +3317,14 @@ void InputDispatcher::updateInteractionTokensLocked(const EventEntry& entry, 
    }



    std::unordered_set<sp<IBinder>, StrongPointerHash<IBinder>> newConnectionTokens;

    std::vector<sp<Connection>> newConnections;

    std::vector<std::shared_ptr<Connection>> newConnections;

    for (const InputTarget& target : targets) {

        if (target.flags.test(InputTarget::Flags::DISPATCH_AS_OUTSIDE)) {

            continue; // Skip windows that receive ACTION_OUTSIDE

        }



        sp<IBinder> token = target.inputChannel->getConnectionToken();

        sp<Connection> connection = getConnectionLocked(token);

        std::shared_ptr<Connection> connection = getConnectionLocked(token);

        if (connection == nullptr) {

            continue;

        }
@@ -3336,7 +3337,7 @@ void InputDispatcher::updateInteractionTokensLocked(const EventEntry& entry, 
    mInteractionConnectionTokens = newConnectionTokens;



    std::string targetList;

    for (const sp<Connection>& connection : newConnections) {

    for (const std::shared_ptr<Connection>& connection : newConnections) {

        targetList += connection->getWindowName() + ", ";

    }

    std::string message = "Interaction with: " + targetList;
@@ -3416,7 +3417,7 @@ status_t InputDispatcher::publishMotionEvent(Connection& connection, 
}



void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime,

                                               const sp<Connection>& connection) {

                                               const std::shared_ptr<Connection>& connection) {

    if (ATRACE_ENABLED()) {

        std::string message = StringPrintf("startDispatchCycleLocked(inputChannel=%s)",

                                           connection->getInputChannelName().c_str());
@@ -3596,8 +3597,8 @@ const std::array<uint8_t, 32> InputDispatcher::getSignature( 
}



void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,

                                                const sp<Connection>& connection, uint32_t seq,

                                                bool handled, nsecs_t consumeTime) {

                                                const std::shared_ptr<Connection>& connection,

                                                uint32_t seq, bool handled, nsecs_t consumeTime) {

    if (DEBUG_DISPATCH_CYCLE) {

        ALOGD("channel '%s' ~ finishDispatchCycle - seq=%u, handled=%s",

              connection->getInputChannelName().c_str(), seq, toString(handled));
@@ -3616,7 +3617,7 @@ void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime, 
}



void InputDispatcher::abortBrokenDispatchCycleLocked(nsecs_t currentTime,

                                                     const sp<Connection>& connection,

                                                     const std::shared_ptr<Connection>& connection,

                                                     bool notify) {

    if (DEBUG_DISPATCH_CYCLE) {

        LOG(DEBUG) << "channel '" << connection->getInputChannelName() << "'~ " << __func__
@@ -3665,7 +3666,7 @@ void InputDispatcher::releaseDispatchEntry(DispatchEntry* dispatchEntry) { 


int InputDispatcher::handleReceiveCallback(int events, sp<IBinder> connectionToken) {

    std::scoped_lock _l(mLock);

    sp<Connection> connection = getConnectionLocked(connectionToken);

    std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);

    if (connection == nullptr) {

        ALOGW("Received looper callback for unknown input channel token %p.  events=0x%x",

              connectionToken.get(), events);
@@ -3757,7 +3758,7 @@ void InputDispatcher::synthesizeCancelationEventsForMonitorsLocked( 


void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked(

        const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options) {

    sp<Connection> connection = getConnectionLocked(channel->getConnectionToken());

    std::shared_ptr<Connection> connection = getConnectionLocked(channel->getConnectionToken());

    if (connection == nullptr) {

        return;

    }
@@ -3766,7 +3767,7 @@ void InputDispatcher::synthesizeCancelationEventsForInputChannelLocked( 
}



void InputDispatcher::synthesizeCancelationEventsForConnectionLocked(

        const sp<Connection>& connection, const CancelationOptions& options) {

        const std::shared_ptr<Connection>& connection, const CancelationOptions& options) {

    if (connection->status == Connection::Status::BROKEN) {

        return;

    }
@@ -3844,7 +3845,7 @@ void InputDispatcher::synthesizeCancelationEventsForConnectionLocked( 
}



void InputDispatcher::synthesizePointerDownEventsForConnectionLocked(

        const nsecs_t downTime, const sp<Connection>& connection,

        const nsecs_t downTime, const std::shared_ptr<Connection>& connection,

        ftl::Flags<InputTarget::Flags> targetFlags) {

    if (connection->status == Connection::Status::BROKEN) {

        return;
@@ -3909,7 +3910,8 @@ void InputDispatcher::synthesizePointerDownEventsForConnectionLocked( 
void InputDispatcher::synthesizeCancelationEventsForWindowLocked(

        const sp<WindowInfoHandle>& windowHandle, const CancelationOptions& options) {

    if (windowHandle != nullptr) {

        sp<Connection> wallpaperConnection = getConnectionLocked(windowHandle->getToken());

        std::shared_ptr<Connection> wallpaperConnection =

                getConnectionLocked(windowHandle->getToken());

        if (wallpaperConnection != nullptr) {

            synthesizeCancelationEventsForConnectionLocked(wallpaperConnection, options);

        }
@@ -4796,7 +4798,7 @@ bool InputDispatcher::canWindowReceiveMotionLocked(const sp<WindowInfoHandle>& w 
        return false;

    }



    sp<Connection> connection = getConnectionLocked(window->getToken());

    std::shared_ptr<Connection> connection = getConnectionLocked(window->getToken());

    if (connection == nullptr) {

        ALOGW("Not sending touch to %s because there's no corresponding connection",

              window->getName().c_str());
@@ -5318,8 +5320,8 @@ bool InputDispatcher::transferTouchFocus(const sp<IBinder>& fromToken, const sp< 
        }



        // Synthesize cancel for old window and down for new window.

        sp<Connection> fromConnection = getConnectionLocked(fromToken);

        sp<Connection> toConnection = getConnectionLocked(toToken);

        std::shared_ptr<Connection> fromConnection = getConnectionLocked(fromToken);

        std::shared_ptr<Connection> toConnection = getConnectionLocked(toToken);

        if (fromConnection != nullptr && toConnection != nullptr) {

            fromConnection->inputState.mergePointerStateTo(toConnection->inputState);

            CancelationOptions
@@ -5685,8 +5687,9 @@ Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputChannel(const 
        std::scoped_lock _l(mLock);

        const sp<IBinder>& token = serverChannel->getConnectionToken();

        int fd = serverChannel->getFd();

        sp<Connection> connection =

                sp<Connection>::make(std::move(serverChannel), /*monitor=*/false, mIdGenerator);

        std::shared_ptr<Connection> connection =

                std::make_shared<Connection>(std::move(serverChannel), /*monitor=*/false,

                                             mIdGenerator);



        if (mConnectionsByToken.find(token) != mConnectionsByToken.end()) {

            ALOGE("Created a new connection, but the token %p is already known", token.get());
@@ -5723,8 +5726,8 @@ Result<std::unique_ptr<InputChannel>> InputDispatcher::createInputMonitor(int32_ 
                                          << " without a specified display.";

        }



        sp<Connection> connection =

                sp<Connection>::make(serverChannel, /*monitor=*/true, mIdGenerator);

        std::shared_ptr<Connection> connection =

                std::make_shared<Connection>(serverChannel, /*monitor=*/true, mIdGenerator);

        const sp<IBinder>& token = serverChannel->getConnectionToken();

        const int fd = serverChannel->getFd();
@@ -5764,7 +5767,7 @@ status_t InputDispatcher::removeInputChannel(const sp<IBinder>& connectionToken) 


status_t InputDispatcher::removeInputChannelLocked(const sp<IBinder>& connectionToken,

                                                   bool notify) {

    sp<Connection> connection = getConnectionLocked(connectionToken);

    std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);

    if (connection == nullptr) {

        // Connection can be removed via socket hang up or an explicit call to 'removeInputChannel'

        return BAD_VALUE;
@@ -5910,7 +5913,8 @@ std::optional<int32_t> InputDispatcher::findMonitorPidByTokenLocked(const sp<IBi 
    return std::nullopt;

}



sp<Connection> InputDispatcher::getConnectionLocked(const sp<IBinder>& inputConnectionToken) const {

std::shared_ptr<Connection> InputDispatcher::getConnectionLocked(

        const sp<IBinder>& inputConnectionToken) const {

    if (inputConnectionToken == nullptr) {

        return nullptr;

    }
@@ -5925,21 +5929,22 @@ sp<Connection> InputDispatcher::getConnectionLocked(const sp<IBinder>& inputConn 
}



std::string InputDispatcher::getConnectionNameLocked(const sp<IBinder>& connectionToken) const {

    sp<Connection> connection = getConnectionLocked(connectionToken);

    std::shared_ptr<Connection> connection = getConnectionLocked(connectionToken);

    if (connection == nullptr) {

        return "<nullptr>";

    }

    return connection->getInputChannelName();

}



void InputDispatcher::removeConnectionLocked(const sp<Connection>& connection) {

void InputDispatcher::removeConnectionLocked(const std::shared_ptr<Connection>& connection) {

    mAnrTracker.eraseToken(connection->inputChannel->getConnectionToken());

    mConnectionsByToken.erase(connection->inputChannel->getConnectionToken());

}



void InputDispatcher::doDispatchCycleFinishedCommand(nsecs_t finishTime,

                                                     const sp<Connection>& connection, uint32_t seq,

                                                     bool handled, nsecs_t consumeTime) {

                                                     const std::shared_ptr<Connection>& connection,

                                                     uint32_t seq, bool handled,

                                                     nsecs_t consumeTime) {

    // Handle post-event policy actions.

    std::deque<DispatchEntry*>::iterator dispatchEntryIt = connection->findWaitQueueEntry(seq);

    if (dispatchEntryIt == connection->waitQueue.end()) {
@@ -6017,7 +6022,7 @@ void InputDispatcher::sendDropWindowCommandLocked(const sp<IBinder>& token, floa 
    postCommandLocked(std::move(command));

}



void InputDispatcher::onAnrLocked(const sp<Connection>& connection) {

void InputDispatcher::onAnrLocked(const std::shared_ptr<Connection>& connection) {

    if (connection == nullptr) {

        LOG_ALWAYS_FATAL("Caller must check for nullness");

    }
@@ -6179,8 +6184,8 @@ void InputDispatcher::processConnectionResponsiveLocked(const Connection& connec 
    sendWindowResponsiveCommandLocked(connectionToken, pid);

}



bool InputDispatcher::afterKeyEventLockedInterruptable(const sp<Connection>& connection,

                                                       DispatchEntry* dispatchEntry,

bool InputDispatcher::afterKeyEventLockedInterruptable(

        const std::shared_ptr<Connection>& connection, DispatchEntry* dispatchEntry,

        KeyEntry& keyEntry, bool handled) {

    if (keyEntry.flags & AKEY_EVENT_FLAG_FALLBACK) {

        if (!handled) {
@@ -6356,8 +6361,8 @@ bool InputDispatcher::afterKeyEventLockedInterruptable(const sp<Connection>& con 
    return false;

}



bool InputDispatcher::afterMotionEventLockedInterruptable(const sp<Connection>& connection,

                                                          DispatchEntry* dispatchEntry,

bool InputDispatcher::afterMotionEventLockedInterruptable(

        const std::shared_ptr<Connection>& connection, DispatchEntry* dispatchEntry,

        MotionEntry& motionEntry, bool handled) {

    return false;

}
@@ -6680,9 +6685,11 @@ void InputDispatcher::transferWallpaperTouch(ftl::Flags<InputTarget::Flags> oldT 
        wallpaperFlags |= InputTarget::Flags::WINDOW_IS_OBSCURED |

                InputTarget::Flags::WINDOW_IS_PARTIALLY_OBSCURED;

        state.addOrUpdateWindow(newWallpaper, wallpaperFlags, pointerIds, downTimeInTarget);

        sp<Connection> wallpaperConnection = getConnectionLocked(newWallpaper->getToken());

        std::shared_ptr<Connection> wallpaperConnection =

                getConnectionLocked(newWallpaper->getToken());

        if (wallpaperConnection != nullptr) {

            sp<Connection> toConnection = getConnectionLocked(toWindowHandle->getToken());

            std::shared_ptr<Connection> toConnection =

                    getConnectionLocked(toWindowHandle->getToken());

            toConnection->inputState.mergePointerStateTo(wallpaperConnection->inputState);

            synthesizePointerDownEventsForConnectionLocked(downTimeInTarget, wallpaperConnection,

                                                           wallpaperFlags);

services/inputflinger/dispatcher/InputDispatcher.h

+31 −28
Original line number Diff line number Diff line
@@ -249,12 +249,12 @@ private: 
    sp<android::gui::WindowInfoHandle> findTouchedForegroundWindowLocked(int32_t displayId) const

            REQUIRES(mLock);



    sp<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const

    std::shared_ptr<Connection> getConnectionLocked(const sp<IBinder>& inputConnectionToken) const

            REQUIRES(mLock);



    std::string getConnectionNameLocked(const sp<IBinder>& connectionToken) const REQUIRES(mLock);



    void removeConnectionLocked(const sp<Connection>& connection) REQUIRES(mLock);

    void removeConnectionLocked(const std::shared_ptr<Connection>& connection) REQUIRES(mLock);



    status_t pilferPointersLocked(const sp<IBinder>& token) REQUIRES(mLock);
@@ -264,8 +264,8 @@ private: 
    };



    // All registered connections mapped by input channel token.

    std::unordered_map<sp<IBinder>, sp<Connection>, StrongPointerHash<IBinder>> mConnectionsByToken

            GUARDED_BY(mLock);

    std::unordered_map<sp<IBinder>, std::shared_ptr<Connection>, StrongPointerHash<IBinder>>

            mConnectionsByToken GUARDED_BY(mLock);



    // Find a monitor pid by the provided token.

    std::optional<int32_t> findMonitorPidByTokenLocked(const sp<IBinder>& token) REQUIRES(mLock);
@@ -328,8 +328,8 @@ private: 
    std::chrono::nanoseconds mMonitorDispatchingTimeout GUARDED_BY(mLock);



    nsecs_t processAnrsLocked() REQUIRES(mLock);

    std::chrono::nanoseconds getDispatchingTimeoutLocked(const sp<Connection>& connection)

            REQUIRES(mLock);

    std::chrono::nanoseconds getDispatchingTimeoutLocked(

            const std::shared_ptr<Connection>& connection) REQUIRES(mLock);



    // Input filter processing.

    bool shouldSendKeyToInputFilterLocked(const NotifyKeyArgs& args) REQUIRES(mLock);
@@ -533,7 +533,7 @@ private: 
    // prevent unneeded wakeups.

    AnrTracker mAnrTracker GUARDED_BY(mLock);



    void cancelEventsForAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);

    void cancelEventsForAnrLocked(const std::shared_ptr<Connection>& connection) REQUIRES(mLock);

    // If a focused application changes, we should stop counting down the "no focused window" time,

    // because we will have no way of knowing when the previous application actually added a window.

    // This also means that we will miss cases like pulling down notification shade when the
@@ -594,22 +594,26 @@ private: 
    // These methods are deliberately not Interruptible because doing all of the work

    // with the mutex held makes it easier to ensure that connection invariants are maintained.

    // If needed, the methods post commands to run later once the critical bits are done.

    void prepareDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

    void prepareDispatchCycleLocked(nsecs_t currentTime,

                                    const std::shared_ptr<Connection>& connection,

                                    std::shared_ptr<EventEntry>, const InputTarget& inputTarget)

            REQUIRES(mLock);

    void enqueueDispatchEntriesLocked(nsecs_t currentTime, const sp<Connection>& connection,

    void enqueueDispatchEntriesLocked(nsecs_t currentTime,

                                      const std::shared_ptr<Connection>& connection,

                                      std::shared_ptr<EventEntry>, const InputTarget& inputTarget)

            REQUIRES(mLock);

    void enqueueDispatchEntryLocked(const sp<Connection>& connection, std::shared_ptr<EventEntry>,

                                    const InputTarget& inputTarget,

    void enqueueDispatchEntryLocked(const std::shared_ptr<Connection>& connection,

                                    std::shared_ptr<EventEntry>, const InputTarget& inputTarget,

                                    ftl::Flags<InputTarget::Flags> dispatchMode) REQUIRES(mLock);

    status_t publishMotionEvent(Connection& connection, DispatchEntry& dispatchEntry) const;

    void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection)

    void startDispatchCycleLocked(nsecs_t currentTime,

                                  const std::shared_ptr<Connection>& connection) REQUIRES(mLock);

    void finishDispatchCycleLocked(nsecs_t currentTime,

                                   const std::shared_ptr<Connection>& connection, uint32_t seq,

                                   bool handled, nsecs_t consumeTime) REQUIRES(mLock);

    void abortBrokenDispatchCycleLocked(nsecs_t currentTime,

                                        const std::shared_ptr<Connection>& connection, bool notify)

            REQUIRES(mLock);

    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

                                   uint32_t seq, bool handled, nsecs_t consumeTime) REQUIRES(mLock);

    void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

                                        bool notify) REQUIRES(mLock);

    void drainDispatchQueue(std::deque<DispatchEntry*>& queue);

    void releaseDispatchEntry(DispatchEntry* dispatchEntry);

    int handleReceiveCallback(int events, sp<IBinder> connectionToken);
@@ -624,14 +628,13 @@ private: 
    void synthesizeCancelationEventsForInputChannelLocked(

            const std::shared_ptr<InputChannel>& channel, const CancelationOptions& options)

            REQUIRES(mLock);

    void synthesizeCancelationEventsForConnectionLocked(const sp<Connection>& connection,

                                                        const CancelationOptions& options)

    void synthesizeCancelationEventsForConnectionLocked(

            const std::shared_ptr<Connection>& connection, const CancelationOptions& options)

            REQUIRES(mLock);



    void synthesizePointerDownEventsForConnectionLocked(const nsecs_t downTime,

                                                        const sp<Connection>& connection,

                                                        ftl::Flags<InputTarget::Flags> targetFlags)

            REQUIRES(mLock);

    void synthesizePointerDownEventsForConnectionLocked(

            const nsecs_t downTime, const std::shared_ptr<Connection>& connection,

            ftl::Flags<InputTarget::Flags> targetFlags) REQUIRES(mLock);



    void synthesizeCancelationEventsForWindowLocked(

            const sp<android::gui::WindowInfoHandle>& windowHandle,
@@ -658,16 +661,16 @@ private: 
            REQUIRES(mLock);



    // Interesting events that we might like to log or tell the framework about.

    void doDispatchCycleFinishedCommand(nsecs_t finishTime, const sp<Connection>& connection,

                                        uint32_t seq, bool handled, nsecs_t consumeTime)

            REQUIRES(mLock);

    void doDispatchCycleFinishedCommand(nsecs_t finishTime,

                                        const std::shared_ptr<Connection>& connection, uint32_t seq,

                                        bool handled, nsecs_t consumeTime) REQUIRES(mLock);

    void doInterceptKeyBeforeDispatchingCommand(const sp<IBinder>& focusedWindowToken,

                                                KeyEntry& entry) REQUIRES(mLock);

    void onFocusChangedLocked(const FocusResolver::FocusChanges& changes) REQUIRES(mLock);

    void sendFocusChangedCommandLocked(const sp<IBinder>& oldToken, const sp<IBinder>& newToken)

            REQUIRES(mLock);

    void sendDropWindowCommandLocked(const sp<IBinder>& token, float x, float y) REQUIRES(mLock);

    void onAnrLocked(const sp<Connection>& connection) REQUIRES(mLock);

    void onAnrLocked(const std::shared_ptr<Connection>& connection) REQUIRES(mLock);

    void onAnrLocked(std::shared_ptr<InputApplicationHandle> application) REQUIRES(mLock);

    void updateLastAnrStateLocked(const sp<android::gui::WindowInfoHandle>& window,

                                  const std::string& reason) REQUIRES(mLock);
@@ -675,10 +678,10 @@ private: 
                                  const std::string& reason) REQUIRES(mLock);

    void updateLastAnrStateLocked(const std::string& windowLabel, const std::string& reason)

            REQUIRES(mLock);

    bool afterKeyEventLockedInterruptable(const sp<Connection>& connection,

    bool afterKeyEventLockedInterruptable(const std::shared_ptr<Connection>& connection,

                                          DispatchEntry* dispatchEntry, KeyEntry& keyEntry,

                                          bool handled) REQUIRES(mLock);

    bool afterMotionEventLockedInterruptable(const sp<Connection>& connection,

    bool afterMotionEventLockedInterruptable(const std::shared_ptr<Connection>& connection,

                                             DispatchEntry* dispatchEntry, MotionEntry& motionEntry,

                                             bool handled) REQUIRES(mLock);