diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index 3c8df2b..bf34987 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -73,7 +73,6 @@
         "android/gui/FocusRequest.aidl",
         "android/gui/InputApplicationInfo.aidl",
         "android/gui/IWindowInfosListener.aidl",
-        "android/gui/IWindowInfosPublisher.aidl",
         "android/gui/IWindowInfosReportedListener.aidl",
         "android/gui/WindowInfo.aidl",
         "android/gui/WindowInfosUpdate.aidl",
@@ -91,7 +90,6 @@
         "android/gui/FocusRequest.aidl",
         "android/gui/InputApplicationInfo.aidl",
         "android/gui/IWindowInfosListener.aidl",
-        "android/gui/IWindowInfosPublisher.aidl",
         "android/gui/IWindowInfosReportedListener.aidl",
         "android/gui/WindowInfosUpdate.aidl",
         "android/gui/WindowInfo.aidl",
diff --git a/libs/gui/WindowInfosListenerReporter.cpp b/libs/gui/WindowInfosListenerReporter.cpp
index 0929b8e..76e7b6e 100644
--- a/libs/gui/WindowInfosListenerReporter.cpp
+++ b/libs/gui/WindowInfosListenerReporter.cpp
@@ -22,6 +22,7 @@
 namespace android {
 
 using gui::DisplayInfo;
+using gui::IWindowInfosReportedListener;
 using gui::WindowInfo;
 using gui::WindowInfosListener;
 using gui::aidl_utils::statusTFromBinderStatus;
@@ -39,13 +40,8 @@
     {
         std::scoped_lock lock(mListenersMutex);
         if (mWindowInfosListeners.empty()) {
-            gui::WindowInfosListenerInfo listenerInfo;
-            binder::Status s = surfaceComposer->addWindowInfosListener(this, &listenerInfo);
+            binder::Status s = surfaceComposer->addWindowInfosListener(this);
             status = statusTFromBinderStatus(s);
-            if (status == OK) {
-                mWindowInfosPublisher = std::move(listenerInfo.windowInfosPublisher);
-                mListenerId = listenerInfo.listenerId;
-            }
         }
 
         if (status == OK) {
@@ -89,7 +85,8 @@
 }
 
 binder::Status WindowInfosListenerReporter::onWindowInfosChanged(
-        const gui::WindowInfosUpdate& update) {
+        const gui::WindowInfosUpdate& update,
+        const sp<IWindowInfosReportedListener>& windowInfosReportedListener) {
     std::unordered_set<sp<WindowInfosListener>, gui::SpHash<WindowInfosListener>>
             windowInfosListeners;
 
@@ -107,7 +104,9 @@
         listener->onWindowInfosChanged(update);
     }
 
-    mWindowInfosPublisher->ackWindowInfosReceived(update.vsyncId, mListenerId);
+    if (windowInfosReportedListener) {
+        windowInfosReportedListener->onWindowInfosReported();
+    }
 
     return binder::Status::ok();
 }
@@ -115,10 +114,7 @@
 void WindowInfosListenerReporter::reconnect(const sp<gui::ISurfaceComposer>& composerService) {
     std::scoped_lock lock(mListenersMutex);
     if (!mWindowInfosListeners.empty()) {
-        gui::WindowInfosListenerInfo listenerInfo;
-        composerService->addWindowInfosListener(this, &listenerInfo);
-        mWindowInfosPublisher = std::move(listenerInfo.windowInfosPublisher);
-        mListenerId = listenerInfo.listenerId;
+        composerService->addWindowInfosListener(this);
     }
 }
 
diff --git a/libs/gui/aidl/android/gui/ISurfaceComposer.aidl b/libs/gui/aidl/android/gui/ISurfaceComposer.aidl
index 539a1c1..ec3266c 100644
--- a/libs/gui/aidl/android/gui/ISurfaceComposer.aidl
+++ b/libs/gui/aidl/android/gui/ISurfaceComposer.aidl
@@ -40,14 +40,12 @@
 import android.gui.ISurfaceComposerClient;
 import android.gui.ITunnelModeEnabledListener;
 import android.gui.IWindowInfosListener;
-import android.gui.IWindowInfosPublisher;
 import android.gui.LayerCaptureArgs;
 import android.gui.LayerDebugInfo;
 import android.gui.OverlayProperties;
 import android.gui.PullAtomData;
 import android.gui.ARect;
 import android.gui.StaticDisplayInfo;
-import android.gui.WindowInfosListenerInfo;
 
 /** @hide */
 interface ISurfaceComposer {
@@ -502,7 +500,7 @@
      */
     int getMaxAcquiredBufferCount();
 
-    WindowInfosListenerInfo addWindowInfosListener(IWindowInfosListener windowInfosListener);
+    void addWindowInfosListener(IWindowInfosListener windowInfosListener);
 
     void removeWindowInfosListener(IWindowInfosListener windowInfosListener);
 
diff --git a/libs/gui/aidl/android/gui/WindowInfosListenerInfo.aidl b/libs/gui/aidl/android/gui/WindowInfosListenerInfo.aidl
deleted file mode 100644
index 0ca13b7..0000000
--- a/libs/gui/aidl/android/gui/WindowInfosListenerInfo.aidl
+++ /dev/null
@@ -1,25 +0,0 @@
-/**
- * Copyright (c) 2023, 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.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.gui;
-
-import android.gui.IWindowInfosPublisher;
-
-/** @hide */
-parcelable WindowInfosListenerInfo {
-    long listenerId;
-    IWindowInfosPublisher windowInfosPublisher;
-}
\ No newline at end of file
diff --git a/libs/gui/android/gui/IWindowInfosListener.aidl b/libs/gui/android/gui/IWindowInfosListener.aidl
index 07cb5ed..400229d 100644
--- a/libs/gui/android/gui/IWindowInfosListener.aidl
+++ b/libs/gui/android/gui/IWindowInfosListener.aidl
@@ -16,9 +16,11 @@
 
 package android.gui;
 
+import android.gui.IWindowInfosReportedListener;
 import android.gui.WindowInfosUpdate;
 
 /** @hide */
 oneway interface IWindowInfosListener {
-    void onWindowInfosChanged(in WindowInfosUpdate update);
+    void onWindowInfosChanged(
+        in WindowInfosUpdate update, in @nullable IWindowInfosReportedListener windowInfosReportedListener);
 }
diff --git a/libs/gui/android/gui/IWindowInfosPublisher.aidl b/libs/gui/android/gui/IWindowInfosPublisher.aidl
deleted file mode 100644
index 5a9c328..0000000
--- a/libs/gui/android/gui/IWindowInfosPublisher.aidl
+++ /dev/null
@@ -1,23 +0,0 @@
-/**
- * Copyright (c) 2023, 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.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package android.gui;
-
-/** @hide */
-oneway interface IWindowInfosPublisher
-{
-    void ackWindowInfosReceived(long vsyncId, long listenerId);
-}
diff --git a/libs/gui/fuzzer/libgui_fuzzer_utils.h b/libs/gui/fuzzer/libgui_fuzzer_utils.h
index 4c7d056..8c003d8 100644
--- a/libs/gui/fuzzer/libgui_fuzzer_utils.h
+++ b/libs/gui/fuzzer/libgui_fuzzer_utils.h
@@ -153,8 +153,8 @@
     MOCK_METHOD(binder::Status, setOverrideFrameRate, (int32_t, float), (override));
     MOCK_METHOD(binder::Status, getGpuContextPriority, (int32_t*), (override));
     MOCK_METHOD(binder::Status, getMaxAcquiredBufferCount, (int32_t*), (override));
-    MOCK_METHOD(binder::Status, addWindowInfosListener,
-                (const sp<gui::IWindowInfosListener>&, gui::WindowInfosListenerInfo*), (override));
+    MOCK_METHOD(binder::Status, addWindowInfosListener, (const sp<gui::IWindowInfosListener>&),
+                (override));
     MOCK_METHOD(binder::Status, removeWindowInfosListener, (const sp<gui::IWindowInfosListener>&),
                 (override));
     MOCK_METHOD(binder::Status, getOverlaySupport, (gui::OverlayProperties*), (override));
diff --git a/libs/gui/include/gui/ISurfaceComposer.h b/libs/gui/include/gui/ISurfaceComposer.h
index 3ff6735..7c150d5 100644
--- a/libs/gui/include/gui/ISurfaceComposer.h
+++ b/libs/gui/include/gui/ISurfaceComposer.h
@@ -26,7 +26,6 @@
 #include <android/gui/IScreenCaptureListener.h>
 #include <android/gui/ITunnelModeEnabledListener.h>
 #include <android/gui/IWindowInfosListener.h>
-#include <android/gui/IWindowInfosPublisher.h>
 #include <binder/IBinder.h>
 #include <binder/IInterface.h>
 #include <gui/ITransactionCompletedListener.h>
diff --git a/libs/gui/include/gui/WindowInfosListenerReporter.h b/libs/gui/include/gui/WindowInfosListenerReporter.h
index 684e21a..38cb108 100644
--- a/libs/gui/include/gui/WindowInfosListenerReporter.h
+++ b/libs/gui/include/gui/WindowInfosListenerReporter.h
@@ -18,7 +18,7 @@
 
 #include <android/gui/BnWindowInfosListener.h>
 #include <android/gui/ISurfaceComposer.h>
-#include <android/gui/IWindowInfosPublisher.h>
+#include <android/gui/IWindowInfosReportedListener.h>
 #include <binder/IBinder.h>
 #include <gui/SpHash.h>
 #include <gui/WindowInfosListener.h>
@@ -30,7 +30,8 @@
 class WindowInfosListenerReporter : public gui::BnWindowInfosListener {
 public:
     static sp<WindowInfosListenerReporter> getInstance();
-    binder::Status onWindowInfosChanged(const gui::WindowInfosUpdate& update) override;
+    binder::Status onWindowInfosChanged(const gui::WindowInfosUpdate& update,
+                                        const sp<gui::IWindowInfosReportedListener>&) override;
     status_t addWindowInfosListener(
             const sp<gui::WindowInfosListener>& windowInfosListener,
             const sp<gui::ISurfaceComposer>&,
@@ -46,8 +47,5 @@
 
     std::vector<gui::WindowInfo> mLastWindowInfos GUARDED_BY(mListenersMutex);
     std::vector<gui::DisplayInfo> mLastDisplayInfos GUARDED_BY(mListenersMutex);
-
-    sp<gui::IWindowInfosPublisher> mWindowInfosPublisher;
-    int64_t mListenerId;
 };
 } // namespace android
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index 8d7cf07..096a43c 100644
--- a/libs/gui/tests/Surface_test.cpp
+++ b/libs/gui/tests/Surface_test.cpp
@@ -998,8 +998,7 @@
     }
 
     binder::Status addWindowInfosListener(
-            const sp<gui::IWindowInfosListener>& /*windowInfosListener*/,
-            gui::WindowInfosListenerInfo* /*outInfo*/) override {
+            const sp<gui::IWindowInfosListener>& /*windowInfosListener*/) override {
         return binder::Status::ok();
     }
 
diff --git a/services/surfaceflinger/BackgroundExecutor.cpp b/services/surfaceflinger/BackgroundExecutor.cpp
index 5a1ec6f..6ddf790 100644
--- a/services/surfaceflinger/BackgroundExecutor.cpp
+++ b/services/surfaceflinger/BackgroundExecutor.cpp
@@ -20,7 +20,6 @@
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 
 #include <utils/Log.h>
-#include <mutex>
 
 #include "BackgroundExecutor.h"
 
@@ -61,17 +60,4 @@
     LOG_ALWAYS_FATAL_IF(sem_post(&mSemaphore), "sem_post failed");
 }
 
-void BackgroundExecutor::flushQueue() {
-    std::mutex mutex;
-    std::condition_variable cv;
-    bool flushComplete = false;
-    sendCallbacks({[&]() {
-        std::scoped_lock lock{mutex};
-        flushComplete = true;
-        cv.notify_one();
-    }});
-    std::unique_lock<std::mutex> lock{mutex};
-    cv.wait(lock, [&]() { return flushComplete; });
-}
-
 } // namespace android
diff --git a/services/surfaceflinger/BackgroundExecutor.h b/services/surfaceflinger/BackgroundExecutor.h
index 66b7d7a..0fae5a5 100644
--- a/services/surfaceflinger/BackgroundExecutor.h
+++ b/services/surfaceflinger/BackgroundExecutor.h
@@ -34,7 +34,6 @@
     // Queues callbacks onto a work queue to be executed by a background thread.
     // This is safe to call from multiple threads.
     void sendCallbacks(Callbacks&& tasks);
-    void flushQueue();
 
 private:
     sem_t mSemaphore;
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index db205b8..fe2db94 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -6158,7 +6158,8 @@
                   windowInfosDebug.maxSendDelayVsyncId.value);
     StringAppendF(&result, "  max send delay (ns): %" PRId64 " ns\n",
                   windowInfosDebug.maxSendDelayDuration);
-    StringAppendF(&result, "  unsent messages: %zu\n", windowInfosDebug.pendingMessageCount);
+    StringAppendF(&result, "  unsent messages: %" PRIu32 "\n",
+                  windowInfosDebug.pendingMessageCount);
     result.append("\n");
 }
 
@@ -7991,9 +7992,9 @@
                                    forceApplyPolicy);
 }
 
-status_t SurfaceFlinger::addWindowInfosListener(const sp<IWindowInfosListener>& windowInfosListener,
-                                                gui::WindowInfosListenerInfo* outInfo) {
-    mWindowInfosListenerInvoker->addWindowInfosListener(windowInfosListener, outInfo);
+status_t SurfaceFlinger::addWindowInfosListener(
+        const sp<IWindowInfosListener>& windowInfosListener) {
+    mWindowInfosListenerInvoker->addWindowInfosListener(windowInfosListener);
     setTransactionFlags(eInputInfoUpdateNeeded);
     return NO_ERROR;
 }
@@ -9075,8 +9076,7 @@
 }
 
 binder::Status SurfaceComposerAIDL::addWindowInfosListener(
-        const sp<gui::IWindowInfosListener>& windowInfosListener,
-        gui::WindowInfosListenerInfo* outInfo) {
+        const sp<gui::IWindowInfosListener>& windowInfosListener) {
     status_t status;
     const int pid = IPCThreadState::self()->getCallingPid();
     const int uid = IPCThreadState::self()->getCallingUid();
@@ -9084,7 +9084,7 @@
     // WindowInfosListeners
     if (uid == AID_SYSTEM || uid == AID_GRAPHICS ||
         checkPermission(sAccessSurfaceFlinger, pid, uid)) {
-        status = mFlinger->addWindowInfosListener(windowInfosListener, outInfo);
+        status = mFlinger->addWindowInfosListener(windowInfosListener);
     } else {
         status = PERMISSION_DENIED;
     }
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index d4700a4..0bc506f 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -612,8 +612,7 @@
 
     status_t getMaxAcquiredBufferCount(int* buffers) const;
 
-    status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
-                                    gui::WindowInfosListenerInfo* outResult);
+    status_t addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener);
     status_t removeWindowInfosListener(
             const sp<gui::IWindowInfosListener>& windowInfosListener) const;
 
@@ -1557,8 +1556,8 @@
     binder::Status setOverrideFrameRate(int32_t uid, float frameRate) override;
     binder::Status getGpuContextPriority(int32_t* outPriority) override;
     binder::Status getMaxAcquiredBufferCount(int32_t* buffers) override;
-    binder::Status addWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener,
-                                          gui::WindowInfosListenerInfo* outInfo) override;
+    binder::Status addWindowInfosListener(
+            const sp<gui::IWindowInfosListener>& windowInfosListener) override;
     binder::Status removeWindowInfosListener(
             const sp<gui::IWindowInfosListener>& windowInfosListener) override;
 
diff --git a/services/surfaceflinger/WindowInfosListenerInvoker.cpp b/services/surfaceflinger/WindowInfosListenerInvoker.cpp
index 7062a4e..20699ef 100644
--- a/services/surfaceflinger/WindowInfosListenerInvoker.cpp
+++ b/services/surfaceflinger/WindowInfosListenerInvoker.cpp
@@ -14,9 +14,7 @@
  * limitations under the License.
  */
 
-#include <android/gui/BnWindowInfosPublisher.h>
-#include <android/gui/IWindowInfosPublisher.h>
-#include <android/gui/WindowInfosListenerInfo.h>
+#include <ftl/small_vector.h>
 #include <gui/ISurfaceComposer.h>
 #include <gui/TraceUtils.h>
 #include <gui/WindowInfosUpdate.h>
@@ -25,130 +23,162 @@
 #include "BackgroundExecutor.h"
 #include "WindowInfosListenerInvoker.h"
 
-#undef ATRACE_TAG
-#define ATRACE_TAG ATRACE_TAG_GRAPHICS
-
 namespace android {
 
 using gui::DisplayInfo;
 using gui::IWindowInfosListener;
 using gui::WindowInfo;
 
-void WindowInfosListenerInvoker::addWindowInfosListener(sp<IWindowInfosListener> listener,
-                                                        gui::WindowInfosListenerInfo* outInfo) {
-    int64_t listenerId = mNextListenerId++;
-    outInfo->listenerId = listenerId;
-    outInfo->windowInfosPublisher = sp<gui::IWindowInfosPublisher>::fromExisting(this);
+using WindowInfosListenerVector = ftl::SmallVector<const sp<gui::IWindowInfosListener>, 3>;
 
-    BackgroundExecutor::getInstance().sendCallbacks(
-            {[this, listener = std::move(listener), listenerId]() {
-                ATRACE_NAME("WindowInfosListenerInvoker::addWindowInfosListener");
+struct WindowInfosReportedListenerInvoker : gui::BnWindowInfosReportedListener,
+                                            IBinder::DeathRecipient {
+    WindowInfosReportedListenerInvoker(WindowInfosListenerVector windowInfosListeners,
+                                       WindowInfosReportedListenerSet windowInfosReportedListeners)
+          : mCallbacksPending(windowInfosListeners.size()),
+            mWindowInfosListeners(std::move(windowInfosListeners)),
+            mWindowInfosReportedListeners(std::move(windowInfosReportedListeners)) {}
+
+    binder::Status onWindowInfosReported() override {
+        if (--mCallbacksPending == 0) {
+            for (const auto& listener : mWindowInfosReportedListeners) {
                 sp<IBinder> asBinder = IInterface::asBinder(listener);
-                asBinder->linkToDeath(sp<DeathRecipient>::fromExisting(this));
-                mWindowInfosListeners.try_emplace(asBinder,
-                                                  std::make_pair(listenerId, std::move(listener)));
-            }});
+                if (asBinder->isBinderAlive()) {
+                    listener->onWindowInfosReported();
+                }
+            }
+
+            auto wpThis = wp<WindowInfosReportedListenerInvoker>::fromExisting(this);
+            for (const auto& listener : mWindowInfosListeners) {
+                sp<IBinder> binder = IInterface::asBinder(listener);
+                binder->unlinkToDeath(wpThis);
+            }
+        }
+        return binder::Status::ok();
+    }
+
+    void binderDied(const wp<IBinder>&) { onWindowInfosReported(); }
+
+private:
+    std::atomic<size_t> mCallbacksPending;
+    static constexpr size_t kStaticCapacity = 3;
+    const WindowInfosListenerVector mWindowInfosListeners;
+    WindowInfosReportedListenerSet mWindowInfosReportedListeners;
+};
+
+void WindowInfosListenerInvoker::addWindowInfosListener(sp<IWindowInfosListener> listener) {
+    sp<IBinder> asBinder = IInterface::asBinder(listener);
+    asBinder->linkToDeath(sp<DeathRecipient>::fromExisting(this));
+
+    std::scoped_lock lock(mListenersMutex);
+    mWindowInfosListeners.try_emplace(asBinder, std::move(listener));
 }
 
 void WindowInfosListenerInvoker::removeWindowInfosListener(
         const sp<IWindowInfosListener>& listener) {
-    BackgroundExecutor::getInstance().sendCallbacks({[this, listener]() {
-        ATRACE_NAME("WindowInfosListenerInvoker::removeWindowInfosListener");
-        sp<IBinder> asBinder = IInterface::asBinder(listener);
-        asBinder->unlinkToDeath(sp<DeathRecipient>::fromExisting(this));
-        mWindowInfosListeners.erase(asBinder);
-    }});
+    sp<IBinder> asBinder = IInterface::asBinder(listener);
+
+    std::scoped_lock lock(mListenersMutex);
+    asBinder->unlinkToDeath(sp<DeathRecipient>::fromExisting(this));
+    mWindowInfosListeners.erase(asBinder);
 }
 
 void WindowInfosListenerInvoker::binderDied(const wp<IBinder>& who) {
-    BackgroundExecutor::getInstance().sendCallbacks({[this, who]() {
-        ATRACE_NAME("WindowInfosListenerInvoker::binderDied");
-        auto it = mWindowInfosListeners.find(who);
-        int64_t listenerId = it->second.first;
-        mWindowInfosListeners.erase(who);
-
-        std::vector<int64_t> vsyncIds;
-        for (auto& [vsyncId, state] : mUnackedState) {
-            if (std::find(state.unackedListenerIds.begin(), state.unackedListenerIds.end(),
-                          listenerId) != state.unackedListenerIds.end()) {
-                vsyncIds.push_back(vsyncId);
-            }
-        }
-
-        for (int64_t vsyncId : vsyncIds) {
-            ackWindowInfosReceived(vsyncId, listenerId);
-        }
-    }});
+    std::scoped_lock lock(mListenersMutex);
+    mWindowInfosListeners.erase(who);
 }
 
 void WindowInfosListenerInvoker::windowInfosChanged(
         gui::WindowInfosUpdate update, WindowInfosReportedListenerSet reportedListeners,
         bool forceImmediateCall) {
-    if (!mDelayInfo) {
-        mDelayInfo = DelayInfo{
-                .vsyncId = update.vsyncId,
-                .frameTime = update.timestamp,
-        };
-    }
+    WindowInfosListenerVector listeners;
+    {
+        std::scoped_lock lock{mMessagesMutex};
 
-    // If there are unacked messages and this isn't a forced call, then return immediately.
-    // If a forced window infos change doesn't happen first, the update will be sent after
-    // the WindowInfosReportedListeners are called. If a forced window infos change happens or
-    // if there are subsequent delayed messages before this update is sent, then this message
-    // will be dropped and the listeners will only be called with the latest info. This is done
-    // to reduce the amount of binder memory used.
-    if (!mUnackedState.empty() && !forceImmediateCall) {
-        mDelayedUpdate = std::move(update);
-        mReportedListeners.merge(reportedListeners);
-        return;
-    }
+        if (!mDelayInfo) {
+            mDelayInfo = DelayInfo{
+                    .vsyncId = update.vsyncId,
+                    .frameTime = update.timestamp,
+            };
+        }
 
-    if (mDelayedUpdate) {
-        mDelayedUpdate.reset();
-    }
+        // If there are unacked messages and this isn't a forced call, then return immediately.
+        // If a forced window infos change doesn't happen first, the update will be sent after
+        // the WindowInfosReportedListeners are called. If a forced window infos change happens or
+        // if there are subsequent delayed messages before this update is sent, then this message
+        // will be dropped and the listeners will only be called with the latest info. This is done
+        // to reduce the amount of binder memory used.
+        if (mActiveMessageCount > 0 && !forceImmediateCall) {
+            mDelayedUpdate = std::move(update);
+            mReportedListeners.merge(reportedListeners);
+            return;
+        }
 
-    if (CC_UNLIKELY(mWindowInfosListeners.empty())) {
-        mReportedListeners.merge(reportedListeners);
+        if (mDelayedUpdate) {
+            mDelayedUpdate.reset();
+        }
+
+        {
+            std::scoped_lock lock{mListenersMutex};
+            for (const auto& [_, listener] : mWindowInfosListeners) {
+                listeners.push_back(listener);
+            }
+        }
+        if (CC_UNLIKELY(listeners.empty())) {
+            mReportedListeners.merge(reportedListeners);
+            mDelayInfo.reset();
+            return;
+        }
+
+        reportedListeners.insert(sp<WindowInfosListenerInvoker>::fromExisting(this));
+        reportedListeners.merge(mReportedListeners);
+        mReportedListeners.clear();
+
+        mActiveMessageCount++;
+        updateMaxSendDelay();
         mDelayInfo.reset();
-        return;
     }
 
-    reportedListeners.merge(mReportedListeners);
-    mReportedListeners.clear();
+    auto reportedInvoker =
+            sp<WindowInfosReportedListenerInvoker>::make(listeners, std::move(reportedListeners));
 
-    // Update mUnackedState to include the message we're about to send
-    auto [it, _] = mUnackedState.try_emplace(update.vsyncId,
-                                             UnackedState{.reportedListeners =
-                                                                  std::move(reportedListeners)});
-    auto& unackedState = it->second;
-    for (auto& pair : mWindowInfosListeners) {
-        int64_t listenerId = pair.second.first;
-        unackedState.unackedListenerIds.push_back(listenerId);
-    }
+    for (const auto& listener : listeners) {
+        sp<IBinder> asBinder = IInterface::asBinder(listener);
 
-    mDelayInfo.reset();
-    updateMaxSendDelay();
+        // linkToDeath is used here to ensure that the windowInfosReportedListeners
+        // are called even if one of the windowInfosListeners dies before
+        // calling onWindowInfosReported.
+        asBinder->linkToDeath(reportedInvoker);
 
-    // Call the listeners
-    for (auto& pair : mWindowInfosListeners) {
-        auto& [listenerId, listener] = pair.second;
-        auto status = listener->onWindowInfosChanged(update);
+        auto status = listener->onWindowInfosChanged(update, reportedInvoker);
         if (!status.isOk()) {
-            ackWindowInfosReceived(update.vsyncId, listenerId);
+            reportedInvoker->onWindowInfosReported();
         }
     }
 }
 
-WindowInfosListenerInvoker::DebugInfo WindowInfosListenerInvoker::getDebugInfo() {
-    DebugInfo result;
-    BackgroundExecutor::getInstance().sendCallbacks({[&, this]() {
-        ATRACE_NAME("WindowInfosListenerInvoker::getDebugInfo");
-        updateMaxSendDelay();
-        result = mDebugInfo;
-        result.pendingMessageCount = mUnackedState.size();
+binder::Status WindowInfosListenerInvoker::onWindowInfosReported() {
+    BackgroundExecutor::getInstance().sendCallbacks({[this]() {
+        gui::WindowInfosUpdate update;
+        {
+            std::scoped_lock lock{mMessagesMutex};
+            mActiveMessageCount--;
+            if (!mDelayedUpdate || mActiveMessageCount > 0) {
+                return;
+            }
+            update = std::move(*mDelayedUpdate);
+            mDelayedUpdate.reset();
+        }
+        windowInfosChanged(std::move(update), {}, false);
     }});
-    BackgroundExecutor::getInstance().flushQueue();
-    return result;
+    return binder::Status::ok();
+}
+
+WindowInfosListenerInvoker::DebugInfo WindowInfosListenerInvoker::getDebugInfo() {
+    std::scoped_lock lock{mMessagesMutex};
+    updateMaxSendDelay();
+    mDebugInfo.pendingMessageCount = mActiveMessageCount;
+    return mDebugInfo;
 }
 
 void WindowInfosListenerInvoker::updateMaxSendDelay() {
@@ -162,41 +192,4 @@
     }
 }
 
-binder::Status WindowInfosListenerInvoker::ackWindowInfosReceived(int64_t vsyncId,
-                                                                  int64_t listenerId) {
-    BackgroundExecutor::getInstance().sendCallbacks({[this, vsyncId, listenerId]() {
-        ATRACE_NAME("WindowInfosListenerInvoker::ackWindowInfosReceived");
-        auto it = mUnackedState.find(vsyncId);
-        if (it == mUnackedState.end()) {
-            return;
-        }
-
-        auto& state = it->second;
-        state.unackedListenerIds.unstable_erase(std::find(state.unackedListenerIds.begin(),
-                                                          state.unackedListenerIds.end(),
-                                                          listenerId));
-        if (!state.unackedListenerIds.empty()) {
-            return;
-        }
-
-        WindowInfosReportedListenerSet reportedListeners{std::move(state.reportedListeners)};
-        mUnackedState.erase(vsyncId);
-
-        for (const auto& reportedListener : reportedListeners) {
-            sp<IBinder> asBinder = IInterface::asBinder(reportedListener);
-            if (asBinder->isBinderAlive()) {
-                reportedListener->onWindowInfosReported();
-            }
-        }
-
-        if (!mDelayedUpdate || !mUnackedState.empty()) {
-            return;
-        }
-        gui::WindowInfosUpdate update{std::move(*mDelayedUpdate)};
-        mDelayedUpdate.reset();
-        windowInfosChanged(std::move(update), {}, false);
-    }});
-    return binder::Status::ok();
-}
-
 } // namespace android
diff --git a/services/surfaceflinger/WindowInfosListenerInvoker.h b/services/surfaceflinger/WindowInfosListenerInvoker.h
index f36b0ed..bc465a3 100644
--- a/services/surfaceflinger/WindowInfosListenerInvoker.h
+++ b/services/surfaceflinger/WindowInfosListenerInvoker.h
@@ -19,12 +19,11 @@
 #include <optional>
 #include <unordered_set>
 
-#include <android/gui/BnWindowInfosPublisher.h>
+#include <android/gui/BnWindowInfosReportedListener.h>
 #include <android/gui/IWindowInfosListener.h>
 #include <android/gui/IWindowInfosReportedListener.h>
 #include <binder/IBinder.h>
 #include <ftl/small_map.h>
-#include <ftl/small_vector.h>
 #include <gui/SpHash.h>
 #include <utils/Mutex.h>
 
@@ -36,22 +35,22 @@
         std::unordered_set<sp<gui::IWindowInfosReportedListener>,
                            gui::SpHash<gui::IWindowInfosReportedListener>>;
 
-class WindowInfosListenerInvoker : public gui::BnWindowInfosPublisher,
+class WindowInfosListenerInvoker : public gui::BnWindowInfosReportedListener,
                                    public IBinder::DeathRecipient {
 public:
-    void addWindowInfosListener(sp<gui::IWindowInfosListener>, gui::WindowInfosListenerInfo*);
+    void addWindowInfosListener(sp<gui::IWindowInfosListener>);
     void removeWindowInfosListener(const sp<gui::IWindowInfosListener>& windowInfosListener);
 
     void windowInfosChanged(gui::WindowInfosUpdate update,
                             WindowInfosReportedListenerSet windowInfosReportedListeners,
                             bool forceImmediateCall);
 
-    binder::Status ackWindowInfosReceived(int64_t, int64_t) override;
+    binder::Status onWindowInfosReported() override;
 
     struct DebugInfo {
         VsyncId maxSendDelayVsyncId;
         nsecs_t maxSendDelayDuration;
-        size_t pendingMessageCount;
+        uint32_t pendingMessageCount;
     };
     DebugInfo getDebugInfo();
 
@@ -59,28 +58,24 @@
     void binderDied(const wp<IBinder>& who) override;
 
 private:
-    static constexpr size_t kStaticCapacity = 3;
-    std::atomic<int64_t> mNextListenerId{0};
-    ftl::SmallMap<wp<IBinder>, const std::pair<int64_t, sp<gui::IWindowInfosListener>>,
-                  kStaticCapacity>
-            mWindowInfosListeners;
+    std::mutex mListenersMutex;
 
-    std::optional<gui::WindowInfosUpdate> mDelayedUpdate;
+    static constexpr size_t kStaticCapacity = 3;
+    ftl::SmallMap<wp<IBinder>, const sp<gui::IWindowInfosListener>, kStaticCapacity>
+            mWindowInfosListeners GUARDED_BY(mListenersMutex);
+
+    std::mutex mMessagesMutex;
+    uint32_t mActiveMessageCount GUARDED_BY(mMessagesMutex) = 0;
+    std::optional<gui::WindowInfosUpdate> mDelayedUpdate GUARDED_BY(mMessagesMutex);
     WindowInfosReportedListenerSet mReportedListeners;
 
-    struct UnackedState {
-        ftl::SmallVector<int64_t, kStaticCapacity> unackedListenerIds;
-        WindowInfosReportedListenerSet reportedListeners;
-    };
-    ftl::SmallMap<int64_t /* vsyncId */, UnackedState, 5> mUnackedState;
-
-    DebugInfo mDebugInfo;
+    DebugInfo mDebugInfo GUARDED_BY(mMessagesMutex);
     struct DelayInfo {
         int64_t vsyncId;
         nsecs_t frameTime;
     };
-    std::optional<DelayInfo> mDelayInfo;
-    void updateMaxSendDelay();
+    std::optional<DelayInfo> mDelayInfo GUARDED_BY(mMessagesMutex);
+    void updateMaxSendDelay() REQUIRES(mMessagesMutex);
 };
 
 } // namespace android
diff --git a/services/surfaceflinger/tests/unittests/WindowInfosListenerInvokerTest.cpp b/services/surfaceflinger/tests/unittests/WindowInfosListenerInvokerTest.cpp
index c7b845e..af4971b 100644
--- a/services/surfaceflinger/tests/unittests/WindowInfosListenerInvokerTest.cpp
+++ b/services/surfaceflinger/tests/unittests/WindowInfosListenerInvokerTest.cpp
@@ -15,23 +15,35 @@
     WindowInfosListenerInvokerTest() : mInvoker(sp<WindowInfosListenerInvoker>::make()) {}
 
     ~WindowInfosListenerInvokerTest() {
+        std::mutex mutex;
+        std::condition_variable cv;
+        bool flushComplete = false;
         // Flush the BackgroundExecutor thread to ensure any scheduled tasks are complete.
         // Otherwise, references those tasks hold may go out of scope before they are done
         // executing.
-        BackgroundExecutor::getInstance().flushQueue();
+        BackgroundExecutor::getInstance().sendCallbacks({[&]() {
+            std::scoped_lock lock{mutex};
+            flushComplete = true;
+            cv.notify_one();
+        }});
+        std::unique_lock<std::mutex> lock{mutex};
+        cv.wait(lock, [&]() { return flushComplete; });
     }
 
     sp<WindowInfosListenerInvoker> mInvoker;
 };
 
-using WindowInfosUpdateConsumer = std::function<void(const gui::WindowInfosUpdate&)>;
+using WindowInfosUpdateConsumer = std::function<void(const gui::WindowInfosUpdate&,
+                                                     const sp<gui::IWindowInfosReportedListener>&)>;
 
 class Listener : public gui::BnWindowInfosListener {
 public:
     Listener(WindowInfosUpdateConsumer consumer) : mConsumer(std::move(consumer)) {}
 
-    binder::Status onWindowInfosChanged(const gui::WindowInfosUpdate& update) override {
-        mConsumer(update);
+    binder::Status onWindowInfosChanged(
+            const gui::WindowInfosUpdate& update,
+            const sp<gui::IWindowInfosReportedListener>& reportedListener) override {
+        mConsumer(update, reportedListener);
         return binder::Status::ok();
     }
 
@@ -46,17 +58,15 @@
 
     int callCount = 0;
 
-    gui::WindowInfosListenerInfo listenerInfo;
-    mInvoker->addWindowInfosListener(sp<Listener>::make([&](const gui::WindowInfosUpdate& update) {
-                                         std::scoped_lock lock{mutex};
-                                         callCount++;
-                                         cv.notify_one();
+    mInvoker->addWindowInfosListener(
+            sp<Listener>::make([&](const gui::WindowInfosUpdate&,
+                                   const sp<gui::IWindowInfosReportedListener>& reportedListener) {
+                std::scoped_lock lock{mutex};
+                callCount++;
+                cv.notify_one();
 
-                                         listenerInfo.windowInfosPublisher
-                                                 ->ackWindowInfosReceived(update.vsyncId,
-                                                                          listenerInfo.listenerId);
-                                     }),
-                                     &listenerInfo);
+                reportedListener->onWindowInfosReported();
+            }));
 
     BackgroundExecutor::getInstance().sendCallbacks(
             {[this]() { mInvoker->windowInfosChanged({}, {}, false); }});
@@ -71,27 +81,21 @@
     std::mutex mutex;
     std::condition_variable cv;
 
-    size_t callCount = 0;
-    const size_t expectedCallCount = 3;
-    std::vector<gui::WindowInfosListenerInfo> listenerInfos{expectedCallCount,
-                                                            gui::WindowInfosListenerInfo{}};
+    int callCount = 0;
+    const int expectedCallCount = 3;
 
-    for (size_t i = 0; i < expectedCallCount; i++) {
-        mInvoker->addWindowInfosListener(sp<Listener>::make([&, &listenerInfo = listenerInfos[i]](
-                                                                    const gui::WindowInfosUpdate&
-                                                                            update) {
-                                             std::scoped_lock lock{mutex};
-                                             callCount++;
-                                             if (callCount == expectedCallCount) {
-                                                 cv.notify_one();
-                                             }
+    for (int i = 0; i < expectedCallCount; i++) {
+        mInvoker->addWindowInfosListener(sp<Listener>::make(
+                [&](const gui::WindowInfosUpdate&,
+                    const sp<gui::IWindowInfosReportedListener>& reportedListener) {
+                    std::scoped_lock lock{mutex};
+                    callCount++;
+                    if (callCount == expectedCallCount) {
+                        cv.notify_one();
+                    }
 
-                                             listenerInfo.windowInfosPublisher
-                                                     ->ackWindowInfosReceived(update.vsyncId,
-                                                                              listenerInfo
-                                                                                      .listenerId);
-                                         }),
-                                         &listenerInfos[i]);
+                    reportedListener->onWindowInfosReported();
+                }));
     }
 
     BackgroundExecutor::getInstance().sendCallbacks(
@@ -110,20 +114,17 @@
 
     int callCount = 0;
 
-    // Simulate a slow ack by not calling IWindowInfosPublisher.ackWindowInfosReceived
-    gui::WindowInfosListenerInfo listenerInfo;
-    mInvoker->addWindowInfosListener(sp<Listener>::make([&](const gui::WindowInfosUpdate&) {
-                                         std::scoped_lock lock{mutex};
-                                         callCount++;
-                                         cv.notify_one();
-                                     }),
-                                     &listenerInfo);
+    // Simulate a slow ack by not calling the WindowInfosReportedListener.
+    mInvoker->addWindowInfosListener(sp<Listener>::make(
+            [&](const gui::WindowInfosUpdate&, const sp<gui::IWindowInfosReportedListener>&) {
+                std::scoped_lock lock{mutex};
+                callCount++;
+                cv.notify_one();
+            }));
 
     BackgroundExecutor::getInstance().sendCallbacks({[&]() {
-        mInvoker->windowInfosChanged(gui::WindowInfosUpdate{{}, {}, /* vsyncId= */ 0, 0}, {},
-                                     false);
-        mInvoker->windowInfosChanged(gui::WindowInfosUpdate{{}, {}, /* vsyncId= */ 1, 0}, {},
-                                     false);
+        mInvoker->windowInfosChanged({}, {}, false);
+        mInvoker->windowInfosChanged({}, {}, false);
     }});
 
     {
@@ -133,7 +134,7 @@
     EXPECT_EQ(callCount, 1);
 
     // Ack the first message.
-    listenerInfo.windowInfosPublisher->ackWindowInfosReceived(0, listenerInfo.listenerId);
+    mInvoker->onWindowInfosReported();
 
     {
         std::unique_lock lock{mutex};
@@ -151,21 +152,19 @@
     int callCount = 0;
     const int expectedCallCount = 2;
 
-    // Simulate a slow ack by not calling IWindowInfosPublisher.ackWindowInfosReceived
-    gui::WindowInfosListenerInfo listenerInfo;
-    mInvoker->addWindowInfosListener(sp<Listener>::make([&](const gui::WindowInfosUpdate&) {
-                                         std::scoped_lock lock{mutex};
-                                         callCount++;
-                                         if (callCount == expectedCallCount) {
-                                             cv.notify_one();
-                                         }
-                                     }),
-                                     &listenerInfo);
+    // Simulate a slow ack by not calling the WindowInfosReportedListener.
+    mInvoker->addWindowInfosListener(sp<Listener>::make(
+            [&](const gui::WindowInfosUpdate&, const sp<gui::IWindowInfosReportedListener>&) {
+                std::scoped_lock lock{mutex};
+                callCount++;
+                if (callCount == expectedCallCount) {
+                    cv.notify_one();
+                }
+            }));
 
     BackgroundExecutor::getInstance().sendCallbacks({[&]() {
-        mInvoker->windowInfosChanged(gui::WindowInfosUpdate{{}, {}, /* vsyncId= */ 0, 0}, {},
-                                     false);
-        mInvoker->windowInfosChanged(gui::WindowInfosUpdate{{}, {}, /* vsyncId= */ 1, 0}, {}, true);
+        mInvoker->windowInfosChanged({}, {}, false);
+        mInvoker->windowInfosChanged({}, {}, true);
     }});
 
     {
@@ -183,14 +182,14 @@
 
     int64_t lastUpdateId = -1;
 
-    // Simulate a slow ack by not calling IWindowInfosPublisher.ackWindowInfosReceived
-    gui::WindowInfosListenerInfo listenerInfo;
-    mInvoker->addWindowInfosListener(sp<Listener>::make([&](const gui::WindowInfosUpdate& update) {
-                                         std::scoped_lock lock{mutex};
-                                         lastUpdateId = update.vsyncId;
-                                         cv.notify_one();
-                                     }),
-                                     &listenerInfo);
+    // Simulate a slow ack by not calling the WindowInfosReportedListener.
+    mInvoker->addWindowInfosListener(
+            sp<Listener>::make([&](const gui::WindowInfosUpdate& update,
+                                   const sp<gui::IWindowInfosReportedListener>&) {
+                std::scoped_lock lock{mutex};
+                lastUpdateId = update.vsyncId;
+                cv.notify_one();
+            }));
 
     BackgroundExecutor::getInstance().sendCallbacks({[&]() {
         mInvoker->windowInfosChanged({{}, {}, /* vsyncId= */ 1, 0}, {}, false);
@@ -205,7 +204,7 @@
     EXPECT_EQ(lastUpdateId, 1);
 
     // Ack the first message. The third update should be sent.
-    listenerInfo.windowInfosPublisher->ackWindowInfosReceived(1, listenerInfo.listenerId);
+    mInvoker->onWindowInfosReported();
 
     {
         std::unique_lock lock{mutex};
@@ -226,17 +225,14 @@
     // delayed.
     BackgroundExecutor::getInstance().sendCallbacks({[&]() {
         mInvoker->windowInfosChanged({}, {}, false);
-        gui::WindowInfosListenerInfo listenerInfo;
-        mInvoker->addWindowInfosListener(sp<Listener>::make([&](const gui::WindowInfosUpdate&) {
-                                             std::scoped_lock lock{mutex};
-                                             callCount++;
-                                             cv.notify_one();
-                                         }),
-                                         &listenerInfo);
+        mInvoker->addWindowInfosListener(sp<Listener>::make(
+                [&](const gui::WindowInfosUpdate&, const sp<gui::IWindowInfosReportedListener>&) {
+                    std::scoped_lock lock{mutex};
+                    callCount++;
+                    cv.notify_one();
+                }));
+        mInvoker->windowInfosChanged({}, {}, false);
     }});
-    BackgroundExecutor::getInstance().flushQueue();
-    BackgroundExecutor::getInstance().sendCallbacks(
-            {[&]() { mInvoker->windowInfosChanged({}, {}, false); }});
 
     {
         std::unique_lock lock{mutex};