InputDispatcher_test: Verify all events dispatched to windows are traced

Bug: 210460522
Test: atest inputflinger_tests
Change-Id: I8ce95c44645f8c3bee7e2eb7cfefab2dae59f6e6

Author: prabirmsp

services/inputflinger/tests/FakeInputTracingBackend.cpp

@@ -33,18 +33,22 @@ base::ResultError<> error(const std::ostringstream& ss) {
     return base::ResultError(ss.str(), BAD_VALUE);
 }
 
+inline auto getId(const trace::TracedEvent& v) {
+    return std::visit([](const auto& event) { return event.id; }, v);
+}
+
 } // namespace
 
 // --- VerifyingTrace ---
 
-void VerifyingTrace::expectKeyDispatchTraced(const KeyEvent& event) {
+void VerifyingTrace::expectKeyDispatchTraced(const KeyEvent& event, int32_t windowId) {
     std::scoped_lock lock(mLock);
-    mExpectedEvents.emplace_back(event);
+    mExpectedEvents.emplace_back(event, windowId);
 }
 
-void VerifyingTrace::expectMotionDispatchTraced(const MotionEvent& event) {
+void VerifyingTrace::expectMotionDispatchTraced(const MotionEvent& event, int32_t windowId) {
     std::scoped_lock lock(mLock);
-    mExpectedEvents.emplace_back(event);
+    mExpectedEvents.emplace_back(event, windowId);
 }
 
 void VerifyingTrace::verifyExpectedEventsTraced() {
@@ -53,9 +57,9 @@ void VerifyingTrace::verifyExpectedEventsTraced() {
 
     base::Result<void> result;
     mEventTracedCondition.wait_for(lock, TRACE_TIMEOUT, [&]() REQUIRES(mLock) {
-        for (const auto& expectedEvent : mExpectedEvents) {
+        for (const auto& [expectedEvent, windowId] : mExpectedEvents) {
             std::visit([&](const auto& event)
-                               REQUIRES(mLock) { result = verifyEventTraced(event); },
+                               REQUIRES(mLock) { result = verifyEventTraced(event, windowId); },
                        expectedEvent);
             if (!result.ok()) {
                 return false;
@@ -72,11 +76,13 @@ void VerifyingTrace::verifyExpectedEventsTraced() {
 void VerifyingTrace::reset() {
     std::scoped_lock lock(mLock);
     mTracedEvents.clear();
+    mTracedWindowDispatches.clear();
     mExpectedEvents.clear();
 }
 
 template <typename Event>
-base::Result<void> VerifyingTrace::verifyEventTraced(const Event& expectedEvent) const {
+base::Result<void> VerifyingTrace::verifyEventTraced(const Event& expectedEvent,
+                                                     int32_t expectedWindowId) const {
     std::ostringstream msg;
 
     auto tracedEventsIt = mTracedEvents.find(expectedEvent.getId());
@@ -87,6 +93,19 @@ base::Result<void> VerifyingTrace::verifyEventTraced(const Event& expectedEvent)
         return error(msg);
     }
 
+    auto tracedDispatchesIt =
+            std::find_if(mTracedWindowDispatches.begin(), mTracedWindowDispatches.end(),
+                         [&](const WindowDispatchArgs& args) {
+                             return args.windowId == expectedWindowId &&
+                                     getId(args.eventEntry) == expectedEvent.getId();
+                         });
+    if (tracedDispatchesIt == mTracedWindowDispatches.end()) {
+        msg << "Expected dispatch of event with ID 0x" << std::hex << expectedEvent.getId()
+            << " to window with ID 0x" << expectedWindowId << " to be traced, but it was not."
+            << "\nExpected event: " << expectedEvent;
+        return error(msg);
+    }
+
     return {};
 }
 
@@ -108,4 +127,12 @@ void FakeInputTracingBackend::traceMotionEvent(const trace::TracedMotionEvent& e
     mTrace->mEventTracedCondition.notify_all();
 }
 
+void FakeInputTracingBackend::traceWindowDispatch(const WindowDispatchArgs& args) const {
+    {
+        std::scoped_lock lock(mTrace->mLock);
+        mTrace->mTracedWindowDispatches.push_back(args);
+    }
+    mTrace->mEventTracedCondition.notify_all();
+}
+
 } // namespace android::inputdispatcher

services/inputflinger/tests/FakeInputTracingBackend.h

@@ -39,10 +39,10 @@ class VerifyingTrace {
     VerifyingTrace() = default;
 
     /** Add an expectation for a key event to be traced. */
-    void expectKeyDispatchTraced(const KeyEvent& event);
+    void expectKeyDispatchTraced(const KeyEvent& event, int32_t windowId);
 
     /** Add an expectation for a motion event to be traced. */
-    void expectMotionDispatchTraced(const MotionEvent& event);
+    void expectMotionDispatchTraced(const MotionEvent& event, int32_t windowId);
 
     /**
      * Wait and verify that all expected events are traced.
@@ -59,14 +59,17 @@ class VerifyingTrace {
     std::mutex mLock;
     std::condition_variable mEventTracedCondition;
     std::unordered_set<uint32_t /*eventId*/> mTracedEvents GUARDED_BY(mLock);
-    std::vector<std::variant<KeyEvent, MotionEvent>> mExpectedEvents GUARDED_BY(mLock);
+    using WindowDispatchArgs = trace::InputTracingBackendInterface::WindowDispatchArgs;
+    std::vector<WindowDispatchArgs> mTracedWindowDispatches GUARDED_BY(mLock);
+    std::vector<std::pair<std::variant<KeyEvent, MotionEvent>, int32_t /*windowId*/>>
+            mExpectedEvents GUARDED_BY(mLock);
 
     friend class FakeInputTracingBackend;
 
     // Helper to verify that the given event appears as expected in the trace. If the verification
     // fails, the error message describes why.
     template <typename Event>
-    base::Result<void> verifyEventTraced(const Event&) const REQUIRES(mLock);
+    base::Result<void> verifyEventTraced(const Event&, int32_t windowId) const REQUIRES(mLock);
 };
 
 /**
@@ -82,7 +85,7 @@ class FakeInputTracingBackend : public trace::InputTracingBackendInterface {
 
     void traceKeyEvent(const trace::TracedKeyEvent& entry) const override;
     void traceMotionEvent(const trace::TracedMotionEvent& entry) const override;
-    void traceWindowDispatch(const WindowDispatchArgs& entry) const override {}
+    void traceWindowDispatch(const WindowDispatchArgs& entry) const override;
 };
 
 } // namespace android::inputdispatcher

services/inputflinger/tests/InputDispatcher_test.cpp

@@ -1482,11 +1482,12 @@ class FakeWindowHandle : public WindowInfoHandle {
 
         switch (event->getType()) {
             case InputEventType::KEY: {
-                gVerifyingTrace->expectKeyDispatchTraced(static_cast<KeyEvent&>(*event));
+                gVerifyingTrace->expectKeyDispatchTraced(static_cast<KeyEvent&>(*event), mInfo.id);
                 break;
             }
             case InputEventType::MOTION: {
-                gVerifyingTrace->expectMotionDispatchTraced(static_cast<MotionEvent&>(*event));
+                gVerifyingTrace->expectMotionDispatchTraced(static_cast<MotionEvent&>(*event),
+                                                            mInfo.id);
                 break;
             }
             default: