Code review

Author: fabianfett

Diff for: Sources/AsyncHTTPClient/ConnectionPool/HTTPRequestStateMachine+Demand.swift

@@ -40,8 +40,8 @@ extension HTTPRequestStateMachine {
 
         private var state: State
 
-        init(expectingBody: Bool) {
-            self.state = .waitingForBytes(CircularBuffer(initialCapacity: expectingBody ? 16 : 0))
+        init() {
+            self.state = .waitingForBytes(CircularBuffer())
         }
 
         mutating func receivedBodyPart(_ body: ByteBuffer) {
@@ -137,8 +137,6 @@ extension HTTPRequestStateMachine {
         mutating func end() -> CircularBuffer<ByteBuffer> {
             switch self.state {
             case .waitingForBytes(let buffer):
-                // This should never happen. But we don't want to precondition this behavior. Let's just
-                // pass the read event on
                 return buffer
 
             case .waitingForReadOrDemand,

Diff for: Sources/AsyncHTTPClient/ConnectionPool/HTTPRequestStateMachine.swift

@@ -444,43 +444,34 @@ struct HTTPRequestStateMachine {
             return .wait
         }
 
-        var expectingBody: Bool = false
-        if let length = head.headers.first(name: "content-length").flatMap({ Int($0) }) {
-            if length > 0 {
-                expectingBody = true
-            }
-        } else if head.headers.contains(name: "transfer-encoding") {
-            expectingBody = true
-        }
-
         switch self.state {
         case .initialized, .waitForChannelToBecomeWritable:
             preconditionFailure("How can we receive a response head before sending a request head ourselves")
 
         case .running(.streaming(let expectedBodyLength, let sentBodyBytes, producer: .paused), .waitingForHead):
             self.state = .running(
                 .streaming(expectedBodyLength: expectedBodyLength, sentBodyBytes: sentBodyBytes, producer: .paused),
-                .receivingBody(head, .init(expectingBody: expectingBody))
+                .receivingBody(head, .init())
             )
             return .forwardResponseHead(head, pauseRequestBodyStream: false)
 
         case .running(.streaming(let expectedBodyLength, let sentBodyBytes, producer: .producing), .waitingForHead):
             if head.status.code >= 300 {
                 self.state = .running(
                     .streaming(expectedBodyLength: expectedBodyLength, sentBodyBytes: sentBodyBytes, producer: .paused),
-                    .receivingBody(head, .init(expectingBody: expectingBody))
+                    .receivingBody(head, .init())
                 )
                 return .forwardResponseHead(head, pauseRequestBodyStream: true)
             } else {
                 self.state = .running(
                     .streaming(expectedBodyLength: expectedBodyLength, sentBodyBytes: sentBodyBytes, producer: .producing),
-                    .receivingBody(head, .init(expectingBody: expectingBody))
+                    .receivingBody(head, .init())
                 )
                 return .forwardResponseHead(head, pauseRequestBodyStream: false)
             }
 
         case .running(.endSent, .waitingForHead):
-            self.state = .running(.endSent, .receivingBody(head, .init(expectingBody: expectingBody)))
+            self.state = .running(.endSent, .receivingBody(head, .init()))
             return .forwardResponseHead(head, pauseRequestBodyStream: false)
 
         case .running(_, .receivingBody), .running(_, .endReceived), .finished: