1 files changed, 14 insertions, 20 deletions
diff --git a/Swiften/EventLoop/EventLoop.cpp b/Swiften/EventLoop/EventLoop.cpp
index 186616f..1852f3f 100644
--- a/Swiften/EventLoop/EventLoop.cpp
+++ b/Swiften/EventLoop/EventLoop.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010-2016 Isode Limited.
+ * Copyright (c) 2010-2019 Isode Limited.
  * All rights reserved.
  * See the COPYING file for more information.
  */
@@ -10,15 +10,10 @@
 #include <cassert>
 #include <vector>
 
-#include <boost/bind.hpp>
-#include <boost/lambda/bind.hpp>
-#include <boost/lambda/lambda.hpp>
 #include <boost/optional.hpp>
 
 #include <Swiften/Base/Log.h>
 
-namespace lambda = boost::lambda;
-
 namespace Swift {
 
 inline void invokeCallback(const Event& event) {
@@ -27,10 +22,10 @@ inline void invokeCallback(const Event& event) {
         event.callback();
     }
     catch (const std::exception& e) {
-        SWIFT_LOG(error) << "Uncaught exception in event loop: " << e.what() << std::endl;
+        SWIFT_LOG(error) << "Uncaught exception in event loop: " << e.what();
     }
     catch (...) {
-        SWIFT_LOG(error) << "Uncaught non-exception in event loop" << std::endl;
+        SWIFT_LOG(error) << "Uncaught non-exception in event loop";
     }
 }
 
@@ -40,9 +35,8 @@ EventLoop::EventLoop() : nextEventID_(0), handlingEvents_(false) {
 EventLoop::~EventLoop() {
 }
 
-void EventLoop::handleNextEvents() {
-    const int eventsBatched = 100;
-    // If handleNextEvents is already in progress, e.g. in case of a recursive call due to
+void EventLoop::handleNextEvent() {
+    // If handleNextEvent is already in progress, e.g. in case of a recursive call due to
     // the event loop implementation, then do no handle further events. Instead call
     // eventPosted() to continue event handling later.
     bool callEventPosted = handlingEvents_;
@@ -50,19 +44,17 @@ void EventLoop::handleNextEvents() {
         handlingEvents_ = true;
         std::unique_lock<std::recursive_mutex> lock(removeEventsMutex_);
         {
-            std::vector<Event> nextEvents;
+            boost::optional<Event> nextEvent;
             {
-                std::unique_lock<std::recursive_mutex> lock(eventsMutex_);
-                for (int n = 0; ((n < eventsBatched) && !events_.empty()); n++) {
-                    nextEvents.push_back(events_.front());
+                std::unique_lock<std::recursive_mutex> eventsLock(eventsMutex_);
+                if (!events_.empty()) {
+                    nextEvent = events_.front();
                     events_.pop_front();
                 }
                 callEventPosted = !events_.empty();
             }
-            if (!nextEvents.empty()) {
-                for (const auto& event : nextEvents) {
-                    invokeCallback(event);
-                }
+            if (nextEvent) {
+                invokeCallback(*nextEvent);
             }
         }
         handlingEvents_ = false;
@@ -96,7 +88,9 @@ void EventLoop::removeEventsFromOwner(std::shared_ptr<EventOwner> owner) {
 
     std::lock(removeLock, eventsLock);
 
-    events_.remove_if(lambda::bind(&Event::owner, lambda::_1) == owner);
+    events_.remove_if([&](const Event& event) {
+        return event.owner == owner;
+    });
 }
 
 }