Feature/send large message (#14)

* introduce send fragment

* can pass a fin frame

* can send messages which are a perfect multiple of the chunk size

* set fin only for last fragment

* cleanup

* last fragment should be of type CONTINUATION

* Add simple send and receive programs

* speedups receiving + better way to wait for thing

* receive speedup by using linked list of chunks instead of large array

* document bug

* use chunks to receive data

* trailing spaces

ixwebsocket/IXWebSocketTransport.h

@@ -16,6 +16,7 @@
 #include <memory>
 #include <mutex>
 #include <atomic>
+#include <list>
 
 #include "IXWebSocketSendInfo.h"
 #include "IXWebSocketPerMessageDeflate.h"
@@ -23,8 +24,9 @@
 #include "IXWebSocketHttpHeaders.h"
 #include "IXCancellationRequest.h"
 #include "IXWebSocketHandshake.h"
+#include "IXProgressCallback.h"
 
-namespace ix 
+namespace ix
 {
     class Socket;
 
@@ -66,7 +68,8 @@ namespace ix
                                             int timeoutSecs);
 
         void poll();
-        WebSocketSendInfo sendBinary(const std::string& message);
+        WebSocketSendInfo sendBinary(const std::string& message,
+                                     const OnProgressCallback& onProgressCallback);
         WebSocketSendInfo sendPing(const std::string& message);
         void close();
         ReadyStateValues getReadyState() const;
@@ -76,7 +79,6 @@ namespace ix
 
     private:
         std::string _url;
-        std::string _origin;
 
         struct wsheader_type {
             unsigned header_size;
@@ -96,13 +98,31 @@ namespace ix
             uint8_t masking_key[4];
         };
 
+        // Buffer for reading from our socket. That buffer is never resized.
+        std::vector<uint8_t> _readbuf;
+
+        // Contains all messages that were fetched in the last socket read.
+        // This could be a mix of control messages (Close, Ping, etc...) and
+        // data messages. That buffer
         std::vector<uint8_t> _rxbuf;
+
+        // Contains all messages that are waiting to be sent
         std::vector<uint8_t> _txbuf;
         mutable std::mutex _txbufMutex;
-        std::vector<uint8_t> _receivedData;
 
+        // Hold fragments for multi-fragments messages in a list. We support receiving very large
+        // messages (tested messages up to 700M) and we cannot put them in a single
+        // buffer that is resized, as this operation can be slow when a buffer has its
+        // size increased 2 fold, while appending to a list has a fixed cost.
+        std::list<std::vector<uint8_t>> _chunks;
+
+        // Fragments are 32K long
+        static constexpr size_t kChunkSize = 1 << 15;
+
+        // Underlying TCP socket
         std::shared_ptr<Socket> _socket;
 
+        // Hold the state of the connection (OPEN, CLOSED, etc...)
         std::atomic<ReadyStateValues> _readyState;
 
         OnCloseCallback _onCloseCallback;
@@ -111,13 +131,14 @@ namespace ix
         size_t _closeWireSize;
         mutable std::mutex _closeDataMutex;
 
+        // Data used for Per Message Deflate compression (with zlib)
         WebSocketPerMessageDeflate _perMessageDeflate;
         WebSocketPerMessageDeflateOptions _perMessageDeflateOptions;
         std::atomic<bool> _enablePerMessageDeflate;
 
         // Used to cancel dns lookup + socket connect + http upgrade
         std::atomic<bool> _requestInitCancellation;
-        
+
         // Optional Heartbeat
         int _heartBeatPeriod;
         static const int kDefaultHeartBeatPeriod;
@@ -129,11 +150,18 @@ namespace ix
         bool heartBeatPeriodExceeded();
 
         void sendOnSocket();
-        WebSocketSendInfo sendData(wsheader_type::opcode_type type, 
+        WebSocketSendInfo sendData(wsheader_type::opcode_type type,
                                    const std::string& message,
-                                   bool compress);
+                                   bool compress,
+                                   const OnProgressCallback& onProgressCallback = nullptr);
 
-        void emitMessage(MessageKind messageKind, 
+        void sendFragment(wsheader_type::opcode_type type,
+                          bool fin,
+                          std::string::const_iterator begin,
+                          std::string::const_iterator end,
+                          bool compress);
+
+        void emitMessage(MessageKind messageKind,
                          const std::string& message,
                          const wsheader_type& ws,
                          const OnMessageCallback& onMessageCallback);
@@ -148,5 +176,7 @@ namespace ix
 
         unsigned getRandomUnsigned();
         void unmaskReceiveBuffer(const wsheader_type& ws);
+
+        std::string getMergedChunks() const;
     };
 }