remove old PacketHeader methods

libraries/entities/src/EntityEditPacketSender.cpp

@@ -22,9 +22,9 @@ EntityEditPacketSender::EntityEditPacketSender() {
     packetReceiver.registerListener(PacketType::EntityEditNack, this, "processEntityEditNackPacket");
 }
 
-void EntityEditPacketSender::processEntityEditNackPacket(QSharedPointer<NLPacket> packet) {
+void EntityEditPacketSender::processEntityEditNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode) {
     if (_shouldNack) {
-        processNackPacket(QByteArray::fromRawData(packet->getData(), packet->getDataSize()));
+        processNackPacket(*packet, sendingNode);
     }
 }
 

libraries/entities/src/EntityEditPacketSender.h

@@ -37,7 +37,7 @@ public:
     virtual void adjustEditPacketForClockSkew(PacketType::Value type, QByteArray& buffer, int clockSkew);
 
 public slots:
-    void processEntityEditNackPacket(QSharedPointer<NLPacket> packet);
+    void processEntityEditNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode);
     void toggleNackPackets() { _shouldNack = !_shouldNack; }
 
 private:

libraries/networking/src/udt/PacketHeaders.cpp

@@ -155,32 +155,6 @@ int numSequenceNumberBytesForType(PacketType::Value packetType) {
     return (SEQUENCE_NUMBERED_PACKETS.contains(packetType) ? sizeof(PacketSequenceNumber) : 0);
 }
 
-QUuid uuidFromPacketHeader(const QByteArray& packet) {
-    return QUuid::fromRfc4122(packet.mid(numBytesArithmeticCodingFromBuffer(packet.data()) + sizeof(PacketVersion),
-                                         NUM_BYTES_RFC4122_UUID));
-}
-
-int hashOffsetForPacketType(PacketType::Value packetType) {
-    return numBytesForArithmeticCodedPacketType(packetType) + NUM_STATIC_HEADER_BYTES;
-}
-
-int sequenceNumberOffsetForPacketType(PacketType::Value packetType) {
-    return numBytesForPacketHeaderGivenPacketType(packetType) - sizeof(PacketSequenceNumber);
-}
-
-PacketSequenceNumber sequenceNumberFromHeader(const QByteArray& packet, PacketType::Value packetType) {
-    if (packetType == PacketType::Unknown) {
-        packetType = packetTypeForPacket(packet);
-    }
-
-    PacketSequenceNumber result = DEFAULT_SEQUENCE_NUMBER;
-
-    if (SEQUENCE_NUMBERED_PACKETS.contains(packetType)) {
-        memcpy(&result, packet.data() + sequenceNumberOffsetForPacketType(packetType), sizeof(PacketSequenceNumber));
-    }
-
-    return result;
-}
 
 PacketType::Value packetTypeForPacket(const QByteArray& packet) {
     return (PacketType::Value) arithmeticCodingValueFromBuffer(packet.data());

libraries/networking/src/udt/PacketHeaders.h

@@ -112,16 +112,6 @@ int numBytesForArithmeticCodedPacketType(PacketType::Value packetType);
 int numBytesForPacketHeaderGivenPacketType(PacketType::Value packetType);
 int packArithmeticallyCodedValue(int value, char* destination);
 
-QUuid uuidFromPacketHeader(const QByteArray& packet);
-
-int hashOffsetForPacketType(PacketType::Value packetType);
-int sequenceNumberOffsetForPacketType(PacketType::Value packetType);
-
-// NOTE: The following four methods accept a PacketType::Value which defaults to PacketType::Unknown.
-// If the caller has already looked at the packet type and can provide it then the methods below won't have to look it up.
-
-PacketSequenceNumber sequenceNumberFromHeader(const QByteArray& packet, PacketType::Value packetType = PacketType::Unknown);
-
 int arithmeticCodingValueFromBuffer(const char* checkValue);
 int numBytesArithmeticCodingFromBuffer(const char* checkValue);
 

libraries/octree/src/OctreeEditPacketSender.cpp

@@ -339,35 +339,24 @@ bool OctreeEditPacketSender::process() {
     return PacketSender::process();
 }
 
-void OctreeEditPacketSender::processNackPacket(const QByteArray& packet) {
+void OctreeEditPacketSender::processNackPacket(NLPacket& packet, SharedNodePointer sendingNode) {
     // parse sending node from packet, retrieve packet history for that node
-    QUuid sendingNodeUUID = uuidFromPacketHeader(packet);
 
     // if packet history doesn't exist for the sender node (somehow), bail
-    if (_sentPacketHistories.count(sendingNodeUUID) == 0) {
+    if (_sentPacketHistories.count(sendingNode->getUUID()) == 0) {
         return;
     }
-    const SentPacketHistory& sentPacketHistory = _sentPacketHistories[sendingNodeUUID];
+    const SentPacketHistory& sentPacketHistory = _sentPacketHistories[sendingNode->getSourceID()];
-
-    // TODO: these NAK packets no longer send the number of sequence numbers - just read out sequence numbers in blocks
-
-    int numBytesPacketHeader = numBytesForPacketHeader(packet);
-    const unsigned char* dataAt = reinterpret_cast<const unsigned char*>(packet.data()) + numBytesPacketHeader;
-
-    // read number of sequence numbers
-    uint16_t numSequenceNumbers = (*(uint16_t*)dataAt);
-    dataAt += sizeof(uint16_t);
 
     // read sequence numbers and queue packets for resend
-    for (int i = 0; i < numSequenceNumbers; i++) {
+    while (packet.bytesLeftToRead() > 0) {
-        unsigned short int sequenceNumber = (*(unsigned short int*)dataAt);
+        unsigned short int sequenceNumber;
-        dataAt += sizeof(unsigned short int);
+        packet.readPrimitive(&sequenceNumber);
-
+        
         // retrieve packet from history
         const NLPacket* packet = sentPacketHistory.getPacket(sequenceNumber);
         if (packet) {
-            const SharedNodePointer& node = DependencyManager::get<NodeList>()->nodeWithUUID(sendingNodeUUID);
+            queuePacketForSending(sendingNode, NLPacket::createCopy(*packet));
-            queuePacketForSending(node, NLPacket::createCopy(*packet));
         }
     }
 }

libraries/octree/src/OctreeEditPacketSender.h

@@ -83,7 +83,7 @@ public:
     virtual char getMyNodeType() const = 0;
     virtual void adjustEditPacketForClockSkew(PacketType::Value type, QByteArray& buffer, int clockSkew) { }
 
-    void processNackPacket(const QByteArray& packet);
+    void processNackPacket(NLPacket& packet, SharedNodePointer sendingNode);
 
 public slots:
     void nodeKilled(SharedNodePointer node);