Merge remote-tracking branch 'origin/master' into response_queue

Author: willmmiles

src/ESPAsyncWebServer.h

@@ -254,7 +254,7 @@ class AsyncWebServerRequest {
     AsyncWebServerResponse *beginResponse(Stream &stream, const String& contentType, size_t len, AwsTemplateProcessor callback=nullptr);
     AsyncWebServerResponse *beginResponse(const String& contentType, size_t len, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
     AsyncWebServerResponse *beginChunkedResponse(const String& contentType, AwsResponseFiller callback, AwsTemplateProcessor templateCallback=nullptr);
-    AsyncResponseStream *beginResponseStream(const String& contentType, size_t bufferSize=1460);
+    AsyncResponseStream *beginResponseStream(const String& contentType, size_t bufferSize=TCP_MSS);
     AsyncWebServerResponse *beginResponse_P(int code, const String& contentType, const uint8_t * content, size_t len, AwsTemplateProcessor callback=nullptr);
     AsyncWebServerResponse *beginResponse_P(int code, const String& contentType, PGM_P content, AwsTemplateProcessor callback=nullptr);
 

src/WebResponseImpl.h

@@ -23,11 +23,11 @@
 
 #ifdef Arduino_h
 // arduino is not compatible with std::vector
+// It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max.
 #undef min
 #undef max
 #endif
 #include "DynamicBuffer.h"
-// It is possible to restore these defines, but one can use _min and _max instead. Or std::min, std::max.
 
 class AsyncBasicResponse: public AsyncWebServerResponse {
   private:
@@ -42,10 +42,6 @@ class AsyncBasicResponse: public AsyncWebServerResponse {
 class AsyncAbstractResponse: public AsyncWebServerResponse {
   private:
     String _head;
-    // Data is inserted into cache at begin(). 
-    // This is inefficient with vector, but if we use some other container, 
-    // we won't be able to access it as contiguous array of bytes when reading from it,
-    // so by gaining performance in one place, we'll lose it in another.
     Walkable<DynamicBuffer> _packet, _cache;
     size_t _readDataFromCacheOrContent(uint8_t* data, const size_t len);
     size_t _fillBufferAndProcessTemplates(uint8_t* buf, size_t maxLen);
@@ -118,13 +114,13 @@ class AsyncProgmemResponse: public AsyncAbstractResponse {
     virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;
 };
 
-class cbuf;
-
 class AsyncResponseStream: public AsyncAbstractResponse, public Print {
   private:
-    cbuf *_content;
+    DynamicBufferList _content;
+    DynamicBufferListPrint _print;
+    size_t _offset;
   public:
-    AsyncResponseStream(const String& contentType, size_t bufferSize);
+    AsyncResponseStream(const String& contentType, size_t bufferSize=TCP_MSS);
     ~AsyncResponseStream();
     bool _sourceValid() const { return (_state < RESPONSE_END); }
     virtual size_t _fillBuffer(uint8_t *buf, size_t maxLen) override;

src/WebResponses.cpp

@@ -730,32 +730,42 @@ size_t AsyncProgmemResponse::_fillBuffer(uint8_t *data, size_t len){
  * Response Stream (You can print/write/printf to it, up to the contentLen bytes)
  * */
 
-AsyncResponseStream::AsyncResponseStream(const String& contentType, size_t bufferSize){
+AsyncResponseStream::AsyncResponseStream(const String& contentType, size_t bufferSize) : _print(_content, bufferSize), _offset(0) {
   _code = 200;
   _contentLength = 0;
   _contentType = contentType;
-  _content = new cbuf(bufferSize);
 }
 
 AsyncResponseStream::~AsyncResponseStream(){
-  delete _content;
+  ;
 }
 
 size_t AsyncResponseStream::_fillBuffer(uint8_t *buf, size_t maxLen){
-  return _content->read((char*)buf, maxLen);
+  size_t read = 0;
+  while((maxLen > 0) && !_content.empty()) {
+    auto& dbuf = _content.front();
+    auto to_read = std::min(dbuf.size() - _offset, maxLen);
+    memcpy(buf, dbuf.data() + _offset, to_read);
+    buf += to_read;
+    maxLen -= to_read;
+    read += to_read;
+    _offset += to_read;
+    if (_offset == dbuf.size()) {
+      _content.pop_front();
+      _offset = 0;
+    }
+  }
+
+  return read;
 }
 
 size_t AsyncResponseStream::write(const uint8_t *data, size_t len){
   if(_started())
     return 0;
-
-  if(len > _content->room()){
-    size_t needed = len - _content->room();
-    _content->resizeAdd(needed);
-  }
-  size_t written = _content->write((const char*)data, len);
-  _contentLength += written;
-  return written;
+  
+  auto size = _print.write(data, len);
+  _contentLength += size;
+  return size;
 }
 
 size_t AsyncResponseStream::write(uint8_t data){