naming changes to udt::Socket handlers

ice-server/src/IceServer.cpp

@@ -36,10 +36,10 @@ IceServer::IceServer(int argc, char* argv[]) :
 
     // set processPacket as the verified packet callback for the udt::Socket
     using std::placeholders::_1;
-    _serverSocket.setVerifiedPacketCallback(std::bind(&IceServer::processPacket, this, _1));
+    _serverSocket.setVerifiedPacketHandler(std::bind(&IceServer::processPacket, this, _1));
     
     // set packetVersionMatch as the verify packet operator for the udt::Socket
-    _serverSocket.setVerifyPacketOperator(std::bind(&IceServer::packetVersionMatch, this, _1));
+    _serverSocket.setPacketVerificationHandler(std::bind(&IceServer::packetVersionMatch, this, _1));
 
     // setup our timer to clear inactive peers
     QTimer* inactivePeerTimer = new QTimer(this);

libraries/networking/src/LimitedNodeList.cpp

@@ -99,10 +99,10 @@ LimitedNodeList::LimitedNodeList(unsigned short socketListenPort, unsigned short
     
     // set &PacketReceiver::handleVerifiedPacket as the verified packet callback for the udt::Socket
     using std::placeholders::_1;
-    _nodeSocket.setVerifiedPacketCallback(std::bind(&PacketReceiver::handleVerifiedPacket, _packetReceiver, _1));
+    _nodeSocket.setVerifiedPacketHandler(std::bind(&PacketReceiver::handleVerifiedPacket, _packetReceiver, _1));
 
     // set our isPacketVerified method as the verify operator for the udt::Socket
-    _nodeSocket.setVerifyPacketOperator(std::bind(&LimitedNodeList::isPacketVerified, this, _1));
+    _nodeSocket.setPacketVerificationHandler(std::bind(&LimitedNodeList::isPacketVerified, this, _1));
     
     _packetStatTimer.start();
     

libraries/networking/src/udt/Socket.cpp

@@ -89,10 +89,11 @@ void Socket::readPendingDatagrams() {
         auto packet = Packet::fromReceivedPacket(std::move(buffer), packetSizeWithHeader, senderSockAddr);
         
         // call our verification operator to see if this packet is verified
-        if (_unfilteredSockAddrs.contains(senderSockAddr) || !_verifyPacketOperator || _verifyPacketOperator(*packet)) {
-            
-            // call the verified packet callback to let it handle this packet
-            return _verifiedPacketCallback(std::move(packet));
+        if (_unfilteredSockAddrs.contains(senderSockAddr) || !_packetVerificationHandler || _packetVerificationHandler(*packet)) {
+            if (_verifiedPacketHandler) {
+                // call the verified packet callback to let it handle this packet
+                return _verifiedPacketHandler(std::move(packet));
+            }
         }
     }
 }

libraries/networking/src/udt/Socket.h

@@ -24,8 +24,8 @@
 
 namespace udt {
 
-using VerifyPacketOperator = std::function<bool(const Packet&)>;
-using VerifiedPacketCallback = std::function<void(std::unique_ptr<Packet>)>;
+using PacketVerificationHandler = std::function<bool(const Packet&)>;
+using VerifiedPacketHandler = std::function<void(std::unique_ptr<Packet>)>;
 
 class Socket : public QObject {
     Q_OBJECT
@@ -43,9 +43,8 @@ public:
     void bind(const QHostAddress& address, quint16 port = 0) { _udpSocket.bind(address, port); }
     void rebind();
     
-    void setVerifyPacketOperator(VerifyPacketOperator verifyPacketOperator) { _verifyPacketOperator = verifyPacketOperator; }
-    void setVerifiedPacketCallback(VerifiedPacketCallback verifiedPacketCallback)
-        { _verifiedPacketCallback = verifiedPacketCallback; }
+    void setPacketVerificationHandler(PacketVerificationHandler handler) { _packetVerificationHandler = handler; }
+    void setVerifiedPacketHandler(VerifiedPacketHandler handler) { _verifiedPacketHandler = handler; }
     
     void setBufferSizes(int numBytes);
     
@@ -56,8 +55,8 @@ private slots:
     
 private:
     QUdpSocket _udpSocket { this };
-    VerifyPacketOperator _verifyPacketOperator;
-    VerifiedPacketCallback _verifiedPacketCallback;
+    PacketVerificationHandler _packetVerificationHandler;
+    VerifiedPacketHandler _verifiedPacketHandler;
     
     QSet<HifiSockAddr> _unfilteredSockAddrs;
 };