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

Commit 1c2e089a authored by Chris Ye's avatar Chris Ye
Browse files

Get Input device information in locked context 

Call getInputDevicesLocked with mutex locked, annotate InputReader member
variables and method functions to enforce the mutex lock check.

Bug: 173326051
Test: atest inputflinger_tests
Change-Id: I3009fbfd15d72b92a5691167037af9ea0197028f
parent a859b8be

services/inputflinger/reader/EventHub.cpp

+31 −32
Original line number Diff line number Diff line
@@ -475,25 +475,25 @@ EventHub::~EventHub(void) { 
}



InputDeviceIdentifier EventHub::getDeviceIdentifier(int32_t deviceId) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    return device != nullptr ? device->identifier : InputDeviceIdentifier();

}



Flags<InputDeviceClass> EventHub::getDeviceClasses(int32_t deviceId) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    return device != nullptr ? device->classes : Flags<InputDeviceClass>(0);

}



int32_t EventHub::getDeviceControllerNumber(int32_t deviceId) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    return device != nullptr ? device->controllerNumber : 0;

}



void EventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->configuration) {

        *outConfiguration = *device->configuration;
@@ -507,7 +507,7 @@ status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis, 
    outAxisInfo->clear();



    if (axis >= 0 && axis <= ABS_MAX) {

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        Device* device = getDeviceLocked(deviceId);

        if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
@@ -534,7 +534,7 @@ status_t EventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis, 


bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const {

    if (axis >= 0 && axis <= REL_MAX) {

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);

        Device* device = getDeviceLocked(deviceId);

        return device != nullptr ? device->relBitmask.test(axis) : false;

    }
@@ -542,7 +542,7 @@ bool EventHub::hasRelativeAxis(int32_t deviceId, int axis) const { 
}



bool EventHub::hasInputProperty(int32_t deviceId, int property) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    Device* device = getDeviceLocked(deviceId);

    return property >= 0 && property <= INPUT_PROP_MAX && device != nullptr
@@ -552,7 +552,7 @@ bool EventHub::hasInputProperty(int32_t deviceId, int property) const { 


int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {

    if (scanCode >= 0 && scanCode <= KEY_MAX) {

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        Device* device = getDeviceLocked(deviceId);

        if (device != nullptr && device->hasValidFd() && device->keyBitmask.test(scanCode)) {
@@ -565,7 +565,7 @@ int32_t EventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const { 
}



int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->hasValidFd() && device->keyMap.haveKeyLayout()) {
@@ -588,7 +588,7 @@ int32_t EventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const { 


int32_t EventHub::getSwitchState(int32_t deviceId, int32_t sw) const {

    if (sw >= 0 && sw <= SW_MAX) {

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        Device* device = getDeviceLocked(deviceId);

        if (device != nullptr && device->hasValidFd() && device->swBitmask.test(sw)) {
@@ -604,7 +604,7 @@ status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* 
    *outValue = 0;



    if (axis >= 0 && axis <= ABS_MAX) {

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        Device* device = getDeviceLocked(deviceId);

        if (device != nullptr && device->hasValidFd() && device->absBitmask.test(axis)) {
@@ -624,7 +624,7 @@ status_t EventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* 


bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,

                                     uint8_t* outFlags) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->keyMap.haveKeyLayout()) {
@@ -652,7 +652,7 @@ bool EventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const in 


status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,

                          int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    status_t status = NAME_NOT_FOUND;
@@ -692,7 +692,7 @@ status_t EventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, 
}



status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);



    if (device != nullptr && device->keyMap.haveKeyLayout()) {
@@ -706,13 +706,13 @@ status_t EventHub::mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxis 
}



void EventHub::setExcludedDevices(const std::vector<std::string>& devices) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    mExcludedDevices = devices;

}



bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && scanCode >= 0 && scanCode <= KEY_MAX) {

        return device->keyBitmask.test(scanCode);
@@ -721,7 +721,7 @@ bool EventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const { 
}



bool EventHub::hasLed(int32_t deviceId, int32_t led) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    int32_t sc;

    if (device != nullptr && device->mapLed(led, &sc) == NO_ERROR) {
@@ -731,7 +731,7 @@ bool EventHub::hasLed(int32_t deviceId, int32_t led) const { 
}



void EventHub::setLedState(int32_t deviceId, int32_t led, bool on) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->hasValidFd()) {

        device->setLedStateLocked(led, on);
@@ -742,7 +742,7 @@ void EventHub::getVirtualKeyDefinitions(int32_t deviceId, 
                                        std::vector<VirtualKeyDefinition>& outVirtualKeys) const {

    outVirtualKeys.clear();



    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->virtualKeyMap) {

        const std::vector<VirtualKeyDefinition> virtualKeys =
@@ -752,7 +752,7 @@ void EventHub::getVirtualKeyDefinitions(int32_t deviceId, 
}



const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t deviceId) const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr) {

        return device->getKeyCharacterMap();
@@ -761,7 +761,7 @@ const std::shared_ptr<KeyCharacterMap> EventHub::getKeyCharacterMap(int32_t devi 
}



bool EventHub::setKeyboardLayoutOverlay(int32_t deviceId, std::shared_ptr<KeyCharacterMap> map) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && map != nullptr && device->keyMap.keyCharacterMap != nullptr) {

        device->keyMap.keyCharacterMap->combine(*map);
@@ -822,7 +822,7 @@ void EventHub::assignDescriptorLocked(InputDeviceIdentifier& identifier) { 
}



void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->hasValidFd()) {

        ff_effect effect;
@@ -857,7 +857,7 @@ void EventHub::vibrate(int32_t deviceId, const VibrationElement& element) { 
}



void EventHub::cancelVibrate(int32_t deviceId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device != nullptr && device->hasValidFd()) {

        if (device->ffEffectPlaying) {
@@ -930,7 +930,7 @@ EventHub::Device* EventHub::getDeviceByFdLocked(int fd) const { 
size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) {

    ALOG_ASSERT(bufferSize >= 1);



    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    struct input_event readBuffer[bufferSize];
@@ -1184,7 +1184,7 @@ size_t EventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSiz 
}



std::vector<TouchVideoFrame> EventHub::getVideoFrames(int32_t deviceId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    Device* device = getDeviceLocked(deviceId);

    if (device == nullptr || !device->videoDevice) {
@@ -1593,7 +1593,7 @@ bool EventHub::tryAddVideoDevice(EventHub::Device& device, 
}



bool EventHub::isDeviceEnabled(int32_t deviceId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device == nullptr) {

        ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
@@ -1603,7 +1603,7 @@ bool EventHub::isDeviceEnabled(int32_t deviceId) { 
}



status_t EventHub::enableDevice(int32_t deviceId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device == nullptr) {

        ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
@@ -1625,7 +1625,7 @@ status_t EventHub::enableDevice(int32_t deviceId) { 
}



status_t EventHub::disableDevice(int32_t deviceId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    Device* device = getDeviceLocked(deviceId);

    if (device == nullptr) {

        ALOGE("Invalid device id=%" PRId32 " provided to %s", deviceId, __func__);
@@ -1809,7 +1809,7 @@ status_t EventHub::scanVideoDirLocked(const std::string& dirname) { 
void EventHub::requestReopenDevices() {

    ALOGV("requestReopenDevices() called");



    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    mNeedToReopenDevices = true;

}
@@ -1817,7 +1817,7 @@ void EventHub::dump(std::string& dump) { 
    dump += "Event Hub State:\n";



    { // acquire lock

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        dump += StringPrintf(INDENT "BuiltInKeyboardId: %d\n", mBuiltInKeyboardId);
@@ -1868,8 +1868,7 @@ void EventHub::dump(std::string& dump) { 


void EventHub::monitor() {

    // Acquire and release the lock to ensure that the event hub has not deadlocked.

    mLock.lock();

    mLock.unlock();

    std::unique_lock<std::mutex> lock(mLock);

}



}; // namespace android

services/inputflinger/reader/InputReader.cpp

+33 −31
Original line number Diff line number Diff line
@@ -56,7 +56,7 @@ InputReader::InputReader(std::shared_ptr<EventHubInterface> eventHub, 
    mQueuedListener = new QueuedInputListener(listener);



    { // acquire lock

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        refreshConfigurationLocked(0);

        updateGlobalMetaStateLocked();
@@ -87,8 +87,9 @@ void InputReader::loopOnce() { 
    int32_t oldGeneration;

    int32_t timeoutMillis;

    bool inputDevicesChanged = false;

    std::vector<InputDeviceInfo> inputDevices;

    { // acquire lock

        AutoMutex _l(mLock);

        std::lock_guard<std::mutex> lock(mLock);



        oldGeneration = mGeneration;

        timeoutMillis = -1;
@@ -107,8 +108,8 @@ void InputReader::loopOnce() { 
    size_t count = mEventHub->getEvents(timeoutMillis, mEventBuffer, EVENT_BUFFER_SIZE);



    { // acquire lock

        AutoMutex _l(mLock);

        mReaderIsAliveCondition.broadcast();

        std::lock_guard<std::mutex> lock(mLock);

        mReaderIsAliveCondition.notify_all();



        if (count) {

            processEventsLocked(mEventBuffer, count);
@@ -127,12 +128,13 @@ void InputReader::loopOnce() { 


        if (oldGeneration != mGeneration) {

            inputDevicesChanged = true;

            inputDevices = getInputDevicesLocked();

        }

    } // release lock



    // Send out a message that the describes the changed input devices.

    if (inputDevicesChanged) {

        mPolicy->notifyInputDevicesChanged(getInputDevicesLocked());

        mPolicy->notifyInputDevicesChanged(inputDevices);

    }



    // Flush queued events out to the listener.
@@ -216,7 +218,7 @@ void InputReader::addDeviceLocked(nsecs_t when, int32_t eventHubId) { 
    bumpGenerationLocked();



    if (device->getClasses().test(InputDeviceClass::EXTERNAL_STYLUS)) {

        notifyExternalStylusPresenceChanged();

        notifyExternalStylusPresenceChangedLocked();

    }

}
@@ -256,7 +258,7 @@ void InputReader::removeDeviceLocked(nsecs_t when, int32_t eventHubId) { 
    device->removeEventHubDevice(eventHubId);



    if (device->getClasses().test(InputDeviceClass::EXTERNAL_STYLUS)) {

        notifyExternalStylusPresenceChanged();

        notifyExternalStylusPresenceChangedLocked();

    }



    if (device->hasEventHubDevices()) {
@@ -301,7 +303,7 @@ void InputReader::processEventsForDeviceLocked(int32_t eventHubId, const RawEven 
    device->process(rawEvents, count);

}



InputDevice* InputReader::findInputDevice(int32_t deviceId) {

InputDevice* InputReader::findInputDeviceLocked(int32_t deviceId) {

    auto deviceIt =

            std::find_if(mDevices.begin(), mDevices.end(), [deviceId](const auto& devicePair) {

                return devicePair.second->getId() == deviceId;
@@ -389,7 +391,7 @@ int32_t InputReader::getLedMetaStateLocked() { 
    return mLedMetaState;

}



void InputReader::notifyExternalStylusPresenceChanged() {

void InputReader::notifyExternalStylusPresenceChangedLocked() {

    refreshConfigurationLocked(InputReaderConfiguration::CHANGE_EXTERNAL_STYLUS_PRESENCE);

}
@@ -405,6 +407,7 @@ void InputReader::getExternalStylusDevicesLocked(std::vector<InputDeviceInfo>& o 
}



void InputReader::dispatchExternalStylusState(const StylusState& state) {

    std::lock_guard<std::mutex> lock(mLock);

    for (auto& devicePair : mDevices) {

        std::shared_ptr<InputDevice>& device = devicePair.second;

        device->updateExternalStylusState(state);
@@ -479,7 +482,7 @@ int32_t InputReader::bumpGenerationLocked() { 
}



std::vector<InputDeviceInfo> InputReader::getInputDevices() const {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);

    return getInputDevicesLocked();

}
@@ -498,19 +501,19 @@ std::vector<InputDeviceInfo> InputReader::getInputDevicesLocked() const { 
}



int32_t InputReader::getKeyCodeState(int32_t deviceId, uint32_t sourceMask, int32_t keyCode) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    return getStateLocked(deviceId, sourceMask, keyCode, &InputDevice::getKeyCodeState);

}



int32_t InputReader::getScanCodeState(int32_t deviceId, uint32_t sourceMask, int32_t scanCode) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    return getStateLocked(deviceId, sourceMask, scanCode, &InputDevice::getScanCodeState);

}



int32_t InputReader::getSwitchState(int32_t deviceId, uint32_t sourceMask, int32_t switchCode) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    return getStateLocked(deviceId, sourceMask, switchCode, &InputDevice::getSwitchState);

}
@@ -519,7 +522,7 @@ int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32 
                                    GetStateFunc getStateFunc) {

    int32_t result = AKEY_STATE_UNKNOWN;

    if (deviceId >= 0) {

        InputDevice* device = findInputDevice(deviceId);

        InputDevice* device = findInputDeviceLocked(deviceId);

        if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {

            result = (device->*getStateFunc)(sourceMask, code);

        }
@@ -542,7 +545,8 @@ int32_t InputReader::getStateLocked(int32_t deviceId, uint32_t sourceMask, int32 
}



void InputReader::toggleCapsLockState(int32_t deviceId) {

    InputDevice* device = findInputDevice(deviceId);

    std::lock_guard<std::mutex> lock(mLock);

    InputDevice* device = findInputDeviceLocked(deviceId);

    if (!device) {

        ALOGW("Ignoring toggleCapsLock for unknown deviceId %" PRId32 ".", deviceId);

        return;
@@ -557,7 +561,7 @@ void InputReader::toggleCapsLockState(int32_t deviceId) { 


bool InputReader::hasKeys(int32_t deviceId, uint32_t sourceMask, size_t numCodes,

                          const int32_t* keyCodes, uint8_t* outFlags) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    memset(outFlags, 0, numCodes);

    return markSupportedKeyCodesLocked(deviceId, sourceMask, numCodes, keyCodes, outFlags);
@@ -568,7 +572,7 @@ bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceM 
                                              uint8_t* outFlags) {

    bool result = false;

    if (deviceId >= 0) {

        InputDevice* device = findInputDevice(deviceId);

        InputDevice* device = findInputDeviceLocked(deviceId);

        if (device && !device->isIgnored() && sourcesMatchMask(device->getSources(), sourceMask)) {

            result = device->markSupportedKeyCodes(sourceMask, numCodes, keyCodes, outFlags);

        }
@@ -584,7 +588,7 @@ bool InputReader::markSupportedKeyCodesLocked(int32_t deviceId, uint32_t sourceM 
}



void InputReader::requestRefreshConfiguration(uint32_t changes) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    if (changes) {

        bool needWake = !mConfigurationChangesToRefresh;
@@ -598,26 +602,26 @@ void InputReader::requestRefreshConfiguration(uint32_t changes) { 


void InputReader::vibrate(int32_t deviceId, const std::vector<VibrationElement>& pattern,

                          ssize_t repeat, int32_t token) {

    AutoMutex _l(mLock);

    InputDevice* device = findInputDevice(deviceId);

    std::lock_guard<std::mutex> lock(mLock);

    InputDevice* device = findInputDeviceLocked(deviceId);

    if (device) {

        device->vibrate(pattern, repeat, token);

    }

}



void InputReader::cancelVibrate(int32_t deviceId, int32_t token) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    InputDevice* device = findInputDevice(deviceId);

    InputDevice* device = findInputDeviceLocked(deviceId);

    if (device) {

        device->cancelVibrate(token);

    }

}



bool InputReader::isInputDeviceEnabled(int32_t deviceId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    InputDevice* device = findInputDevice(deviceId);

    InputDevice* device = findInputDeviceLocked(deviceId);

    if (device) {

        return device->isEnabled();

    }
@@ -626,9 +630,9 @@ bool InputReader::isInputDeviceEnabled(int32_t deviceId) { 
}



bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    InputDevice* device = findInputDevice(deviceId);

    InputDevice* device = findInputDeviceLocked(deviceId);

    if (!device) {

        ALOGW("Ignoring invalid device id %" PRId32 ".", deviceId);

        return false;
@@ -654,7 +658,7 @@ bool InputReader::canDispatchToDisplay(int32_t deviceId, int32_t displayId) { 
}



void InputReader::dump(std::string& dump) {

    AutoMutex _l(mLock);

    std::lock_guard<std::mutex> lock(mLock);



    mEventHub->dump(dump);

    dump += "\n";
@@ -729,11 +733,9 @@ void InputReader::dump(std::string& dump) { 


void InputReader::monitor() {

    // Acquire and release the lock to ensure that the reader has not deadlocked.

    mLock.lock();

    std::unique_lock<std::mutex> lock(mLock);

    mEventHub->wake();

    mReaderIsAliveCondition.wait(mLock);

    mLock.unlock();



    mReaderIsAliveCondition.wait(lock);

    // Check the EventHub

    mEventHub->monitor();

}

services/inputflinger/reader/include/EventHub.h

+1 −1
Original line number Diff line number Diff line
@@ -502,7 +502,7 @@ private: 
    void releaseControllerNumberLocked(int32_t num);



    // Protect all internal state.

    mutable Mutex mLock;

    mutable std::mutex mLock;



    // The actual id of the built-in keyboard, or NO_BUILT_IN_KEYBOARD if none.

    // EventHub remaps the built-in keyboard to id 0 externally as required by the API.

services/inputflinger/reader/include/InputReader.h

+67 −58

File changed.

Preview size limit exceeded, changes collapsed.

services/inputflinger/tests/InputReader_test.cpp

+3 −2
Original line number Diff line number Diff line
@@ -1030,8 +1030,9 @@ public: 
    using InputReader::loopOnce;



protected:

    virtual std::shared_ptr<InputDevice> createDeviceLocked(

            int32_t eventHubId, const InputDeviceIdentifier& identifier) {

    virtual std::shared_ptr<InputDevice> createDeviceLocked(int32_t eventHubId,

                                                            const InputDeviceIdentifier& identifier)

            REQUIRES(mLock) {

        if (!mNextDevices.empty()) {

            std::shared_ptr<InputDevice> device(std::move(mNextDevices.front()));

            mNextDevices.pop();