Refactor handling of Transfer-Encoding

sdk/lib/io/http_impl.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.io;
 
 // The close queue handles graceful closing of HTTP connections. When
 // a connection is added to the queue it will enter a wait state
 // waiting for all data written and possibly socket shutdown from
 // peer.
@@ skipping 109 matching lines @@
       headers.add(HttpHeaders.CONNECTION, "keep-alive");
     }
   }
 
 
   bool _write(List<int> data, bool copyBuffer) {
     if (_headResponse) return true;
     _ensureHeadersSent();
     bool allWritten = true;
     if (data.length > 0) {
-      if (_headers.contentLength < 0) {
+      if (_headers.chunkedTransferEncoding) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(data.length);
         _writeCRLF();
         _httpConnection._write(data, copyBuffer);
         allWritten = _writeCRLF();
       } else {
         _updateContentLength(data.length);
         allWritten = _httpConnection._write(data, copyBuffer);
       }
     }
     return allWritten;
   }
 
   bool _writeList(List<int> data, int offset, int count) {
     if (_headResponse) return true;
     _ensureHeadersSent();
     bool allWritten = true;
     if (count > 0) {
-      if (_headers.contentLength < 0) {
+      if (_headers.chunkedTransferEncoding) {
         // Write chunk size if transfer encoding is chunked.
         _writeHexString(count);
         _writeCRLF();
         _httpConnection._writeFrom(data, offset, count);
         allWritten = _writeCRLF();
       } else {
         _updateContentLength(count);
         allWritten = _httpConnection._writeFrom(data, offset, count);
       }
     }
     return allWritten;
   }
 
   bool _writeDone() {
     bool allWritten = true;
-    if (_headers.contentLength < 0) {
+    if (_headers.chunkedTransferEncoding) {
       // Terminate the content if transfer encoding is chunked.
       allWritten = _httpConnection._write(_Const.END_CHUNKED);
     } else {
       if (!_headResponse && _bodyBytesWritten < _headers.contentLength) {
         throw new HttpException("Sending less than specified content length");
       }
       assert(_headResponse || _bodyBytesWritten == _headers.contentLength);
     }
     return allWritten;
   }
 
   bool _writeHeaders() {
-    _headers._mutable = false;
     _headers._write(_httpConnection);
     // Terminate header.
     return _writeCRLF();
   }
 
   bool _writeHexString(int x) {
     final List<int> hexDigits = [0x30, 0x31, 0x32, 0x33, 0x34,
                                  0x35, 0x36, 0x37, 0x38, 0x39,
                                  0x41, 0x42, 0x43, 0x44, 0x45, 0x46];
     List<int> hex = new Uint8List(10);
@@ skipping 163 matching lines @@
       if (sessionId != null) {
         var sessionManager = _httpConnection._server._sessionManager;
         _session = sessionManager.getSession(sessionId);
         if (_session != null) {
           _session._markSeen();
         }
       }
     }
 
     // Prepare for receiving data.
-    _headers._mutable = false;
     _buffer = new _BufferList();
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
   void _onDataEnd() {
     if (_inputStream != null) {
@@ skipping 210 matching lines @@
       _httpConnection._write(_Const.HTTP10);
     }
     _writeSP();
     data = _statusCode.toString().charCodes;
     _httpConnection._write(data);
     _writeSP();
     data = reasonPhrase.charCodes;
     _httpConnection._write(data);
     _writeCRLF();
 
-    // Determine the value of the "Transfer-Encoding" header based on
-    // whether the content length is known. HTTP/1.0 does not support
-    // chunked.
-    if (_headers.contentLength < 0 && _protocolVersion == "1.1") {
-      _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
-    }
-
     var session = _httpConnection._request._session;
     if (session != null && !session._destroyed) {
       // Make sure we only send the current session id.
       bool found = false;
       for (int i = 0; i < cookies.length; i++) {
         if (cookies[i].name.toUpperCase() == _DART_SESSION_ID) {
           cookies[i].value = session.id;
           cookies[i].httpOnly = true;
           found = true;
           break;
         }
       }
       if (!found) {
         cookies.add(new Cookie(_DART_SESSION_ID, session.id)..httpOnly = true);
       }
     }
     // Add all the cookies set to the headers.
     if (_cookies != null) {
       _cookies.forEach((cookie) {
         _headers.add("set-cookie", cookie);
       });
     }
 
     // Write headers.
+    _headers._finalize(_protocolVersion);
     bool allWritten = _writeHeaders();
     _state = _HttpRequestResponseBase.HEADER_SENT;
     return allWritten;
   }
 
   int _statusCode;  // Response status code.
   String _reasonPhrase;  // Response reason phrase.
   _HttpOutputStream _outputStream;
   Function _streamErrorHandler;
 }
@@ skipping 610 matching lines @@
       }
       data = path.charCodes;
     } else {
       data = _uri.toString().charCodes;
     }
     _httpConnection._write(data);
     _writeSP();
     _httpConnection._write(_Const.HTTP11);
     _writeCRLF();
 
-    // Determine the value of the "Transfer-Encoding" header based on
-    // whether the content length is known. If there is no content
-    // neither "Content-Length" nor "Transfer-Encoding" is set.
-    if (_headers.contentLength < 0) {
-      _headers.set(HttpHeaders.TRANSFER_ENCODING, "chunked");
-    }
-
     // Add the cookies to the headers.
     if (_cookies != null) {
       StringBuffer sb = new StringBuffer();
       for (int i = 0; i < _cookies.length; i++) {
         if (i > 0) sb.add("; ");
         sb.add(_cookies[i].name);
         sb.add("=");
         sb.add(_cookies[i].value);
       }
       _headers.add("cookie", sb.toString());
     }
 
     // Write headers.
+    _headers._finalize("1.1");
     _writeHeaders();
     _state = _HttpRequestResponseBase.HEADER_SENT;
   }
 
   String _method;
   Uri _uri;
   _HttpClientConnection _connection;
   _HttpOutputStream _outputStream;
   Function _streamErrorHandler;
   bool _emptyBody = true;
@@ skipping 45 matching lines @@
   void _onResponseReceived(int statusCode,
                            String reasonPhrase,
                            String version,
                            _HttpHeaders headers,
                            bool hasBody) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
     _headers = headers;
 
     // Prepare for receiving data.
-    _headers._mutable = false;
     _buffer = new _BufferList();
     if (isRedirect && _connection.followRedirects) {
       if (_connection._redirects == null ||
           _connection._redirects.length < _connection.maxRedirects) {
         // Check the location header.
         List<String> location = headers[HttpHeaders.LOCATION];
         if (location == null || location.length > 1) {
            throw new RedirectException("Invalid redirect",
                                        _connection._redirects);
         }
@@ skipping 965 matching lines @@
 
 
 class _RedirectInfo implements RedirectInfo {
   const _RedirectInfo(int this.statusCode,
                       String this.method,
                       Uri this.location);
   final int statusCode;
   final String method;
   final Uri location;
 }