Change the HTTP Content-Length handling

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 69 matching lines @@
 
 class _HttpRequestResponseBase {
   static const int START = 0;
   static const int HEADER_SENT = 1;
   static const int DONE = 2;
   static const int UPGRADED = 3;
 
   _HttpRequestResponseBase(_HttpConnectionBase this._httpConnection)
       : _state = START, _headResponse = false;
 
-  int get contentLength => _contentLength;
+  int get contentLength => _headers.contentLength;
   HttpHeaders get headers => _headers;
 
   bool get persistentConnection {
     List<String> connection = headers[HttpHeaders.CONNECTION];
     if (_protocolVersion == "1.1") {
       if (connection == null) return true;
       return !headers[HttpHeaders.CONNECTION].some(
           (value) => value.toLowerCase() == "close");
     } else {
       if (connection == null) return false;
@@ skipping 19 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 (_contentLength < 0) {
+      if (_headers.contentLength < 0) {
         // 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 (_contentLength < 0) {
+      if (_headers.contentLength < 0) {
         // 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 (_contentLength < 0) {
+    if (_headers.contentLength < 0) {
       // Terminate the content if transfer encoding is chunked.
       allWritten = _httpConnection._write(_Const.END_CHUNKED);
     } else {
-      if (!_headResponse && _bodyBytesWritten < _contentLength) {
+      if (!_headResponse && _bodyBytesWritten < _headers.contentLength) {
         throw new HttpException("Sending less than specified content length");
       }
-      assert(_headResponse || _bodyBytesWritten == _contentLength);
+      assert(_headResponse || _bodyBytesWritten == _headers.contentLength);
     }
     return allWritten;
   }
 
   bool _writeHeaders() {
     _headers._mutable = false;
     _headers._write(_httpConnection);
     // Terminate header.
     return _writeCRLF();
   }
@@ skipping 23 matching lines @@
   }
 
   void _ensureHeadersSent() {
     // Ensure that headers are written.
     if (_state == START) {
       _writeHeader();
     }
   }
 
   void _updateContentLength(int bytes) {
-    if (_bodyBytesWritten + bytes > _contentLength) {
+    if (_bodyBytesWritten + bytes > _headers.contentLength) {
       throw new HttpException("Writing more than specified content length");
     }
     _bodyBytesWritten += bytes;
   }
 
   HttpConnectionInfo get connectionInfo => _httpConnection.connectionInfo;
 
   bool get _done => _state == DONE;
 
   int _state;
   bool _headResponse;
 
   _HttpConnectionBase _httpConnection;
   _HttpHeaders _headers;
   List<Cookie> _cookies;
   String _protocolVersion = "1.1";
 
-  // Length of the content body. If this is set to -1 (default value)
-  // when starting to send data chunked transfer encoding will be
-  // used.
-  int _contentLength = -1;
   // Number of body bytes written. This is only actual body data not
   // including headers or chunk information of using chinked transfer
   // encoding.
   int _bodyBytesWritten = 0;
 }
 
 
 // Parsed HTTP request providing information on the HTTP headers.
 class _HttpRequest extends _HttpRequestResponseBase implements HttpRequest {
   _HttpRequest(_HttpConnection connection) : super(connection);
@@ skipping 107 matching lines @@
       });
       if (sessionId != null) {
         var sessionManager = _httpConnection._server._sessionManager;
         _session = sessionManager.getSession(sessionId);
         if (_session != null) {
           _session._markSeen();
         }
       }
     }
 
-    // Get parsed content length.
-    _contentLength = _httpConnection._httpParser.contentLength;
-
     // Prepare for receiving data.
     _headers._mutable = false;
     _buffer = new _BufferList();
   }
 
   void _onDataReceived(List<int> data) {
     _buffer.add(data);
     if (_inputStream != null) _inputStream._dataReceived();
   }
 
@@ skipping 55 matching lines @@
   _HttpResponse(_HttpConnection httpConnection)
       : super(httpConnection),
         _statusCode = HttpStatus.OK {
     _headers = new _HttpHeaders();
   }
 
   void set contentLength(int contentLength) {
     if (_state >= _HttpRequestResponseBase.HEADER_SENT) {
       throw new HttpException("Header already sent");
     }
-    _contentLength = contentLength;
+    _headers.contentLength = contentLength;
   }
 
   int get statusCode => _statusCode;
   void set statusCode(int statusCode) {
     if (_outputStream != null) throw new HttpException("Header already sent");
     _statusCode = statusCode;
   }
 
   String get reasonPhrase => _findReasonPhrase(_statusCode);
   void set reasonPhrase(String reasonPhrase) {
@@ skipping 139 matching lines @@
     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 (_contentLength >= 0) {
-      _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
-    } else if (_contentLength < 0 && _protocolVersion == "1.1") {
+    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;
@@ skipping 314 matching lines @@
     if (_isReadClosed) {
       // If the client closes the conversation is ended.
       _server._closeQueue.add(this);
     } else if (_isAllDone) {
       // If we are done writing the response, and the connection is
       // not persistent, we must close. Also if using HTTP 1.0 and the
       // content length was not known we must close to indicate end of
       // body.
       bool close =
           !_response.persistentConnection ||
-          (_response._protocolVersion == "1.0" && _response._contentLength < 0);
+          (_response._protocolVersion == "1.0" && _response.contentLength < 0);
       _request = null;
       _response = null;
       if (close) {
         _httpParser.cancel();
         _server._closeQueue.add(this);
       } else {
         _state = _HttpConnectionBase.IDLE;
       }
     } else if (_isResponseDone && _hasBody) {
       // If the response is closed before the request is fully read
@@ skipping 209 matching lines @@
 class _HttpClientRequest
     extends _HttpRequestResponseBase implements HttpClientRequest {
   _HttpClientRequest(String this._method,
                      Uri this._uri,
                      _HttpClientConnection connection)
       : super(connection) {
     _headers = new _HttpHeaders();
     _connection = connection;
     // Default GET and HEAD requests to have no content.
     if (_method == "GET" || _method == "HEAD") {
-      _contentLength = 0;
+      contentLength = 0;
     }
   }
 
   void set contentLength(int contentLength) {
     if (_state >= _HttpRequestResponseBase.HEADER_SENT) {
       throw new HttpException("Header already sent");
     }
-    _contentLength = contentLength;
+    _headers.contentLength = contentLength;
   }
 
   List<Cookie> get cookies {
     if (_cookies == null) _cookies = new List<Cookie>();
     return _cookies;
   }
 
   OutputStream get outputStream {
     if (_done) throw new HttpException("Request closed");
     if (_outputStream == null) {
@@ skipping 67 matching lines @@
       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 (_contentLength > 0) {
-      _headers.set(HttpHeaders.CONTENT_LENGTH, _contentLength.toString());
-    } else if (_contentLength < 0) {
+    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("=");
@@ skipping 60 matching lines @@
 
   void _onResponseReceived(int statusCode,
                            String reasonPhrase,
                            String version,
                            _HttpHeaders headers,
                            bool hasBody) {
     _statusCode = statusCode;
     _reasonPhrase = reasonPhrase;
     _headers = headers;
     // Get parsed content length.
-    _contentLength = _httpConnection._httpParser.contentLength;
+    //_content-Length = _httpConnection._httpParser.contentLength;

[Anders Johnsen, 2012/12/19 15:43:58]

Out-commented code.

[Søren Gjesse, 2012/12/20 07:39:01]

Done.

 
     // 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) {
@@ skipping 968 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;
 }