Moved protocol independent code to NativeProtocol.swift

Moved HTTPURLProtocol. _ParsedResponseHeader from HTTPMessage.swift to NativeProtocol.swift under _NativeProtocol._ParsedResponseHeader.
This implementation basically does header parsing based on \r\n delimiters.
Except the fact that empty header is received in case of HTTP to mark as Header completion and 150 status marks the open of data communication in FTP.

Author: saiHemak

Foundation/URLSession/http/HTTPMessage.swift

@@ -19,83 +19,6 @@
 
 import CoreFoundation
 
-
-extension _HTTPURLProtocol {
-    /// An HTTP header being parsed.
-    ///
-    /// It can either be complete (i.e. the final CR LF CR LF has been
-    /// received), or partial.
-    internal enum _ParsedResponseHeader {
-        case partial(_ResponseHeaderLines)
-        case complete(_ResponseHeaderLines)
-        init() {
-            self = .partial(_ResponseHeaderLines())
-        }
-    }
-    /// A type safe wrapper around multiple lines of headers.
-    ///
-    /// This can be converted into an `HTTPURLResponse`.
-    internal struct _ResponseHeaderLines {
-        let lines: [String]
-        init() {
-            self.lines = []
-        }
-        init(headerLines: [String]) {
-            self.lines = headerLines
-        }
-    }
-}
-
-extension _HTTPURLProtocol._ParsedResponseHeader {
-    /// Parse a header line passed by libcurl.
-    ///
-    /// These contain the <CRLF> ending and the final line contains nothing but
-    /// that ending.
-    /// - Returns: Returning nil indicates failure. Otherwise returns a new
-    ///     `ParsedResponseHeader` with the given line added.
-    func byAppending(headerLine data: Data) -> _HTTPURLProtocol._ParsedResponseHeader? {
-        // The buffer must end in CRLF
-        guard
-            2 <= data.count &&
-                data[data.endIndex - 2] == _HTTPCharacters.CR &&
-                data[data.endIndex - 1] == _HTTPCharacters.LF
-            else { return nil }
-        let lineBuffer = data.subdata(in: Range(data.startIndex..<data.endIndex-2))
-        guard let line = String(data: lineBuffer, encoding: String.Encoding.utf8) else { return nil}
-        return byAppending(headerLine: line)
-    }
-    /// Append a status line.
-    ///
-    /// If the line is empty, it marks the end of the header, and the result
-    /// is a complete header. Otherwise it's a partial header.
-    /// - Note: Appending a line to a complete header results in a partial
-    ///     header with just that line.
-    private func byAppending(headerLine line: String) -> _HTTPURLProtocol._ParsedResponseHeader {
-        if line.isEmpty {
-            switch self {
-            case .partial(let header): return .complete(header)
-            case .complete: return .partial(_HTTPURLProtocol._ResponseHeaderLines())
-            }
-        } else {
-            let header = partialResponseHeader
-            return .partial(header.byAppending(headerLine: line))
-        }
-    }
-    private var partialResponseHeader: _HTTPURLProtocol._ResponseHeaderLines {
-        switch self {
-        case .partial(let header): return header
-        case .complete: return _HTTPURLProtocol._ResponseHeaderLines()
-        }
-    }
-}
-private extension _HTTPURLProtocol._ResponseHeaderLines {
-    /// Returns a copy of the lines with the new line appended to it.
-    func byAppending(headerLine line: String) -> _HTTPURLProtocol._ResponseHeaderLines {
-        var l = self.lines
-        l.append(line)
-        return _HTTPURLProtocol._ResponseHeaderLines(headerLines: l)
-    }
-}
 internal extension _HTTPURLProtocol._ResponseHeaderLines {
     /// Create an `NSHTTPRULResponse` from the lines.
     ///