final fixes to get ACs building again

assignment-client/src/Agent.cpp

@@ -60,34 +60,38 @@ Agent::Agent(NLPacket& packet) :
 }
 
 void Agent::handleOctreePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
-    QByteArray mutablePacket = QByteArray(packet->getData(), packet->getSizeWithHeader());
-    int messageLength = mutablePacket.size();
-
     auto packetType = packet->getType();
 
     if (packetType == PacketType::OctreeStats) {
 
         int statsMessageLength = OctreeHeadlessViewer::parseOctreeStats(packet, senderNode);
-        if (messageLength > statsMessageLength) {
+        if (packet->getSizeUsed() > statsMessageLength) {
-            mutablePacket = mutablePacket.mid(statsMessageLength);
+            // pull out the piggybacked packet and create a new QSharedPointer<NLPacket> for it
+            int packetSizeWithHeader = packet->getSizeUsed() - statsMessageLength;
+            
+            std::unique_ptr<char> buffer = std::unique_ptr<char>(new char[packetSizeWithHeader]);
+            memcpy(buffer.get(), packet->getPayload() + statsMessageLength, packetSizeWithHeader);
+
+            auto newPacket = NLPacket::fromReceivedPacket(std::move(buffer), packetSizeWithHeader, packet->getSenderSockAddr());
+            packet = QSharedPointer<NLPacket>(newPacket.release());
         } else {
             return; // bail since no piggyback data
         }
 
-        packetType = packetTypeForPacket(mutablePacket);
+        packetType = packet->getType();
     } // fall through to piggyback message
 
     if (packetType == PacketType::EntityData || packetType == PacketType::EntityErase) {
-        _entityViewer.processDatagram(mutablePacket, senderNode);
+        _entityViewer.processDatagram(*packet, senderNode);
     }
 }
 
-void Agent::handleJurisdictionPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void Agent::handleJurisdictionPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
-    QByteArray receivedPacket = QByteArray::fromRawData(packet->getData(), packet->getSizeWithHeader());
+    NodeType_t nodeType;
-    int headerBytes = numBytesForPacketHeader(receivedPacket);
+    packet->peek(reinterpret_cast<char*>(&nodeType), sizeof(nodeType));
-
+    
     // PacketType_JURISDICTION, first byte is the node type...
-    switch (receivedPacket[headerBytes]) {
+    switch (nodeType) {
         case NodeType::EntityServer:
             DependencyManager::get<EntityScriptingInterface>()->getJurisdictionListener()->
                 queueReceivedPacket(packet, senderNode);
@@ -95,8 +99,8 @@ void Agent::handleJurisdictionPacket(QSharedPointer<NLPacket> packet, SharedNode
     }
 }
 
-void Agent::handleAudioPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void Agent::handleAudioPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
-    _receivedAudioStream.parseData(QByteArray::fromRawData(packet->getData(), packet->getSizeWithHeader()));
+    _receivedAudioStream.parseData(*packet, senderNode);
 
     _lastReceivedAudioLoudness = _receivedAudioStream.getNextOutputFrameLoudness();
 

assignment-client/src/AssignmentClient.cpp

@@ -210,7 +210,7 @@ void AssignmentClient::handleCreateAssignmentPacket(QSharedPointer<NLPacket> pac
     qDebug() << "Received a PacketType::CreateAssignment - attempting to unpack.";
 
     // construct the deployed assignment from the packet data
-    _currentAssignment = AssignmentFactory::unpackAssignment(QByteArray::fromRawData(packet->getData(), packet->getSizeWithHeader()));
+    _currentAssignment = AssignmentFactory::unpackAssignment(*packet);
 
     if (_currentAssignment) {
         qDebug() << "Received an assignment -" << *_currentAssignment;

assignment-client/src/AssignmentFactory.cpp

@@ -17,12 +17,10 @@
 #include "avatars/AvatarMixer.h"
 #include "entities/EntityServer.h"
 
-ThreadedAssignment* AssignmentFactory::unpackAssignment(const QByteArray& packet) {
+ThreadedAssignment* AssignmentFactory::unpackAssignment(NLPacket& packet) {
-    QDataStream packetStream(packet);
-    packetStream.skipRawData(numBytesForPacketHeader(packet));
 
     quint8 packedType;
-    packetStream >> packedType;    
+    packet.peek(reinterpret_cast<char*>(&packedType), sizeof(packedType));
     
     Assignment::Type unpackedType = (Assignment::Type) packedType;
     

assignment-client/src/AssignmentFactory.h

@@ -16,7 +16,7 @@
 
 class AssignmentFactory {
 public:
-    static ThreadedAssignment* unpackAssignment(const QByteArray& packet);
+    static ThreadedAssignment* unpackAssignment(NLPacket& packet);
 };
 
 #endif // hifi_AssignmentFactory_h

assignment-client/src/entities/EntityServer.cpp

@@ -21,9 +21,10 @@ const char* MODEL_SERVER_NAME = "Entity";
 const char* MODEL_SERVER_LOGGING_TARGET_NAME = "entity-server";
 const char* LOCAL_MODELS_PERSIST_FILE = "resources/models.svo";
 
-EntityServer::EntityServer(const QByteArray& packet)
+EntityServer::EntityServer(NLPacket& packet) :
-    :   OctreeServer(packet), _entitySimulation(NULL) {
+    OctreeServer(packet),
-
+    _entitySimulation(NULL)
+{
     auto& packetReceiver = DependencyManager::get<NodeList>()->getPacketReceiver();
     packetReceiver.registerPacketListener(PacketType::EntityAdd, this, "handleEntityAddPacket");
     packetReceiver.registerPacketListener(PacketType::EntityEdit, this, "handleEntityEditPacket");
@@ -40,19 +41,19 @@ EntityServer::~EntityServer() {
     tree->removeNewlyCreatedHook(this);
 }
 
-void EntityServer::handleEntityAddPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void EntityServer::handleEntityAddPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
     if (_octreeInboundPacketProcessor) {
         _octreeInboundPacketProcessor->queueReceivedPacket(packet, senderNode);
     }
 }
 
-void EntityServer::handleEntityEditPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void EntityServer::handleEntityEditPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
     if (_octreeInboundPacketProcessor) {
         _octreeInboundPacketProcessor->queueReceivedPacket(packet, senderNode);
     }
 }
 
-void EntityServer::handleEntityErasePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void EntityServer::handleEntityErasePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
     if (_octreeInboundPacketProcessor) {
         _octreeInboundPacketProcessor->queueReceivedPacket(packet, senderNode);
     }

assignment-client/src/entities/EntityServer.h

@@ -22,7 +22,7 @@
 class EntityServer : public OctreeServer, public NewlyCreatedEntityHook {
     Q_OBJECT
 public:
-    EntityServer(const QByteArray& packet);
+    EntityServer(NLPacket& packet);
     ~EntityServer();
 
     // Subclasses must implement these methods
@@ -50,9 +50,9 @@ protected:
     virtual Octree* createTree();
 
 private slots:
-    void handleEntityAddPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
+    void handleEntityAddPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
-    void handleEntityEditPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
+    void handleEntityEditPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
-    void handleEntityErasePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
+    void handleEntityErasePacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
 
 private:
     EntitySimulation* _entitySimulation;

assignment-client/src/octree/OctreeServer.cpp

@@ -813,53 +813,11 @@ void OctreeServer::parsePayload() {
     }
 }
 
-void OctreeServer::readPendingDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr) {
+void OctreeServer::handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
-    auto nodeList = DependencyManager::get<NodeList>();
-
-    // If we know we're shutting down we just drop these packets on the floor.
-    // This stops us from initializing send threads we just shut down.
-
-    if (!_isShuttingDown) {
-        if (nodeList->packetVersionAndHashMatch(receivedPacket)) {
-            PacketType::Value packetType = packetTypeForPacket(receivedPacket);
-            SharedNodePointer matchingNode = nodeList->sendingNodeForPacket(receivedPacket);
-            if (packetType == getMyQueryMessageType()) {
-                // If we got a query packet, then we're talking to an agent, and we
-                // need to make sure we have it in our nodeList.
-                if (matchingNode) {
-                    nodeList->updateNodeWithDataFromPacket(matchingNode, receivedPacket);
-
-                    OctreeQueryNode* nodeData = (OctreeQueryNode*) matchingNode->getLinkedData();
-                    if (nodeData && !nodeData->isOctreeSendThreadInitalized()) {
-                        nodeData->initializeOctreeSendThread(this, matchingNode);
-                    }
-                }
-            } else if (packetType == PacketType::OctreeDataNack) {
-                // If we got a nack packet, then we're talking to an agent, and we
-                // need to make sure we have it in our nodeList.
-                if (matchingNode) {
-                    OctreeQueryNode* nodeData = (OctreeQueryNode*)matchingNode->getLinkedData();
-                    if (nodeData) {
-                        nodeData->parseNackPacket(receivedPacket);
-                    }
-                }
-            } else if (packetType == PacketType::JurisdictionRequest) {
-                _jurisdictionSender->queueReceivedPacket(matchingNode, receivedPacket);
-            } else if (_octreeInboundPacketProcessor && getOctree()->handlesEditPacketType(packetType)) {
-                _octreeInboundPacketProcessor->queueReceivedPacket(matchingNode, receivedPacket);
-            } else {
-                // let processNodeData handle it.
-                DependencyManager::get<NodeList>()->processNodeData(senderSockAddr, receivedPacket);
-            }
-        }
-    }
-}
-
-void OctreeServer::handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
     // If we got a query packet, then we're talking to an agent, and we
     // need to make sure we have it in our nodeList.
     auto nodeList = DependencyManager::get<NodeList>();
-    nodeList->updateNodeWithDataFromPacket(senderNode, packet->getData());
+    nodeList->updateNodeWithDataFromPacket(packet, senderNode);
 
     OctreeQueryNode* nodeData = (OctreeQueryNode*)senderNode->getLinkedData();
     if (nodeData && !nodeData->isOctreeSendThreadInitalized()) {
@@ -867,7 +825,7 @@ void OctreeServer::handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, Shar
     }
 }
 
-void OctreeServer::handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void OctreeServer::handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
     // If we got a nack packet, then we're talking to an agent, and we
     // need to make sure we have it in our nodeList.
     OctreeQueryNode* nodeData = (OctreeQueryNode*)senderNode->getLinkedData();
@@ -876,8 +834,8 @@ void OctreeServer::handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, S
     }
 }
 
-void OctreeServer::handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr) {
+void OctreeServer::handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode) {
-    _jurisdictionSender->queueReceivedPacket(senderNode, packet->getData());
+    _jurisdictionSender->queueReceivedPacket(packet, senderNode);
 }
 
 void OctreeServer::setupDatagramProcessingThread() {
@@ -902,9 +860,6 @@ void OctreeServer::setupDatagramProcessingThread() {
     connect(&nodeList->getNodeSocket(), &QUdpSocket::readyRead,
             datagramProcessor, &OctreeServerDatagramProcessor::readPendingDatagrams);
 
-    // connect to the datagram processing thread signal that tells us we have to handle a packet
-    connect(datagramProcessor, &OctreeServerDatagramProcessor::packetRequiresProcessing, this, &OctreeServer::readPendingDatagram);
-
     // delete the datagram processor and the associated thread when the QThread quits
     connect(_datagramProcessingThread, &QThread::finished, datagramProcessor, &QObject::deleteLater);
     connect(datagramProcessor, &QObject::destroyed, _datagramProcessingThread, &QThread::deleteLater);

assignment-client/src/octree/OctreeServer.h

@@ -125,13 +125,10 @@ public slots:
     void nodeKilled(SharedNodePointer node);
     void sendStatsPacket();
 
-    void readPendingDatagrams() { }; // this will not be called since our datagram processing thread will handle
-    void readPendingDatagram(const QByteArray& receivedPacket, const HifiSockAddr& senderSockAddr);
-
 private slots:
-    void handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
+    void handleOctreeQueryPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
-    void handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
+    void handleOctreeDataNackPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
-    void handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode, HifiSockAddr senderSockAddr);
+    void handleJurisdictionRequestPacket(QSharedPointer<NLPacket> packet, SharedNodePointer senderNode);
 
 protected:
     virtual Octree* createTree() = 0;

libraries/networking/src/NodeList.h

@@ -63,7 +63,6 @@ public:
     void resetNodeInterestSet() { _nodeTypesOfInterest.clear(); }
 
     void processReceivedPacket(std::unique_ptr<NLPacket>, HifiSockAddr senderSockAddr);
-    void processNodeData(const HifiSockAddr& senderSockAddr, const QByteArray& packet);
 
     void setAssignmentServerSocket(const HifiSockAddr& serverSocket) { _assignmentServerSocket = serverSocket; }
     void sendAssignment(Assignment& assignment);

libraries/octree/src/JurisdictionSender.h

@@ -38,7 +38,7 @@ public:
     void setNodeType(NodeType_t type) { _nodeType = type; }
 
 protected:
-    virtual void processPacket(QSharedPointer<NLPacket> pack, SharedNodePointer sendingNode);
+    virtual void processPacket(QSharedPointer<NLPacket> packet, SharedNodePointer sendingNode);
 
     /// Locks all the resources of the thread.
     void lockRequestingNodes() { _requestingNodeMutex.lock(); }