Make IOSink implement StringSink

sdk/lib/io/http_impl.dart

 // Copyright (c) 2013, 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;
 
 class _HttpIncoming extends Stream<List<int>> {
   final int _transferLength;
   final Completer _dataCompleter = new Completer();
   Stream<List<int>> _stream;
@@ skipping 314 matching lines @@
   bool _headersWritten = false;
   bool _chunked = false;
 
   final IOSink _ioSink;
   final _HttpOutgoing _outgoing;
 
   final _HttpHeaders headers;
 
   _HttpOutboundMessage(String protocolVersion, _HttpOutgoing outgoing)
       : _outgoing = outgoing,
-        _ioSink = new IOSink(outgoing),
+      _ioSink = new IOSink(outgoing, Encoding.ASCII),
         headers = new _HttpHeaders(protocolVersion);
 
   int get contentLength => headers.contentLength;
   void set contentLength(int contentLength) {
     headers.contentLength = contentLength;
   }
 
   bool get persistentConnection => headers.persistentConnection;
   void set persistentConnection(bool p) {
     headers.persistentConnection = p;
   }
 
+  Encoding get encoding {
+    return headers.contentType != null ? headers.contentType.encoding
+                                       : Encoding.ISO_8859_1;
+  }
+  void set encoding(Encoding value) {
+    throw new StateError("IOSink encoding is not mutable");
+  }
+
+  void write(Object obj) {
+    _writeHeaders();
+    if (_ignoreBody) return;
+    // This comment is copied from runtime/lib/string_buffer_patch.dart.
+    // TODO(srdjan): The following four lines could be replaced by
+    // '$obj', but apparently this is too slow on the Dart VM.
+    String string;
+    if (obj is String) {
+      string = obj;
+    } else {
+      string = obj.toString();
+      if (string is! String) {
+        throw new ArgumentError('toString() did not return a string');
+      }
+    }
+    if (string.isEmpty) return;
+    if (_chunked) {
+      _ChunkedTransformer._addChunk(_encodeString(string, encoding),
+                                    _ioSink.writeBytes);
+    } else {
+      _ioSink.write(string);
+    }
+  }
+
+  void writeAll(Iterable objects) {
+    for (Object obj in objects) write(obj);
+  }
+
+  void writeln(Object obj) {
+    write(obj);
+    write("\n");
+  }
+
+  void writeCharCode(int charCode) {
+    write(new String.fromCharCode(charCode));
+  }
+
+  void writeBytes(List<int> data) {
+    _writeHeaders();
+    if (_ignoreBody || data.length == 0) return;
+    if (_chunked) {
+      _ChunkedTransformer._addChunk(data, _ioSink.writeBytes);
+    } else {
+      _ioSink.writeBytes(data);
+    }
+  }
+
   Future<T> consume(Stream<List<int>> stream) {
     _writeHeaders();
     if (_ignoreBody) return new Future.immediate(this);
     if (_chunked) {
       // Transform when chunked.
       stream = stream.transform(new _ChunkedTransformer());
     }
     return _ioSink.consume(stream).then((_) => this);
   }
 
-  void add(List<int> data) {
-    _writeHeaders();
-    if (_ignoreBody || data.length == 0) return;
-    if (_chunked) {
-      _ChunkedTransformer._addChunk(data, _ioSink.add);
-    } else {
-      _ioSink.add(data);
-    }
-  }
+  void add(List<int> data) => writeBytes(data);
 
   void addString(String string, [Encoding encoding = Encoding.UTF_8]) {
-    add(_encodeString(string, encoding));
+    writeBytes(_encodeString(string, encoding));
   }
 
   Future<T> addStream(Stream<List<int>> stream) {
     _writeHeaders();
     if (_ignoreBody) return new Future.immediate(this);
     if (_chunked) {
       // Transform when chunked.
       stream = stream.transform(new _ChunkedTransformer(writeEnd: false));
     }
     return _ioSink.addStream(stream).then((_) => this);
   }
 
   void close() {
     if (!_headersWritten && !_ignoreBody && headers.chunkedTransferEncoding) {
       // If no body was written, _ignoreBody is false (it's not a HEAD
       // request) and the content-length is unspecified, set contentLength to 0.
       headers.contentLength = 0;
     }
     _writeHeaders();
     if (!_ignoreBody) {
       if (_chunked) {
-        _ChunkedTransformer._addChunk([], _ioSink.add);
+        _ChunkedTransformer._addChunk([], _ioSink.writeBytes);
       }
     }
     _ioSink.close();
   }
 
   Future<T> get done => _ioSink.done.then((_) => this);
 
   void _writeHeaders() {
     if (_headersWritten) return;
     bool _tmpIgnoreBody = _ignoreBody;
     _ignoreBody = false;
     _headersWritten = true;
+    _ioSink.encoding = Encoding.ASCII;
     _writeHeader();
+    _ioSink.encoding =
+        headers.contentType != null ? headers.contentType.encoding
+                                    : Encoding.ISO_8859_1;
     _ignoreBody = _tmpIgnoreBody;
     if (_ignoreBody) {
       _ioSink.close();
       return;
     }
     _chunked = headers.chunkedTransferEncoding;
     if (headers.contentLength >= 0) {
       _outgoing.setTransferLength(headers.contentLength);
     }
   }
@@ skipping 33 matching lines @@
     done.catchError((_) {
       // Catch any error on done, as they automatically will be propegated to
       // the websocket.
     });
     return future;
   }
 
   HttpConnectionInfo get connectionInfo => _httpRequest.connectionInfo;
 
   void _writeHeader() {
-    writeSP() => add([_CharCode.SP]);
-    writeCRLF() => add([_CharCode.CR, _CharCode.LF]);
+    writeSP() => writeBytes([_CharCode.SP]);
+    writeCRLF() => writeBytes([_CharCode.CR, _CharCode.LF]);
 
     // Write status line.
     if (headers.protocolVersion == "1.1") {
-      add(_Const.HTTP11);
+      writeBytes(_Const.HTTP11);
     } else {
-      add(_Const.HTTP10);
+      writeBytes(_Const.HTTP10);
     }
     writeSP();
-    addString(statusCode.toString());
+    write(statusCode.toString());
     writeSP();
-    addString(reasonPhrase);
+    write(reasonPhrase);
     writeCRLF();
 
     var session = _httpRequest._session;
     if (session != null && !session._destroyed) {
       // Mark as not new.
       session._isNew = false;
       // 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) {
@@ skipping 160 matching lines @@
         onError: (e) {
           _responseCompleter.completeError(e);
         });
   }
 
   void _onError(AsyncError error) {
     _responseCompleter.completeError(error);
   }
 
   void _writeHeader() {
-    writeSP() => add([_CharCode.SP]);
-    writeCRLF() => add([_CharCode.CR, _CharCode.LF]);
+    writeSP() => writeBytes([_CharCode.SP]);
+    writeCRLF() => writeBytes([_CharCode.CR, _CharCode.LF]);
 
-    addString(method);
+    write(method);
     writeSP();
     // Send the path for direct connections and the whole URL for
     // proxy connections.
     if (!_usingProxy) {
       String path = uri.path;
       if (path.length == 0) path = "/";
       if (uri.query != "") {
         if (uri.fragment != "") {
           path = "${path}?${uri.query}#${uri.fragment}";
         } else {
           path = "${path}?${uri.query}";
         }
       }
-      addString(path);
+      write(path);
     } else {
-      addString(uri.toString());
+      write(uri.toString());
     }
     writeSP();
-    add(_Const.HTTP11);
+    writeBytes(_Const.HTTP11);
     writeCRLF();
 
     // Add the cookies to the headers.
     if (!cookies.isEmpty) {
       StringBuffer sb = new StringBuffer();
       for (int i = 0; i < cookies.length; i++) {
         if (i > 0) sb.write("; ");
         sb.write(cookies[i].name);
         sb.write("=");
         sb.write(cookies[i].value);
@@ skipping 87 matching lines @@
     var subscription;
     subscription = stream.listen(
         (data) {
           if (expectedTransferLength != null) {
             _bytesWritten += data.length;
             if (_bytesWritten > expectedTransferLength) {
               subscription.cancel();
               _controller.signalError(new HttpException(
                   "Content size exceeds specified contentLength. "
                   "$_bytesWritten bytes written while expected "
-                  "$expectedTransferLength."));
+                  "$expectedTransferLength. "
+                  "[${new String.fromCharCodes(data)}]"));
               _controller.close();
               return;
             }
           }
           _controller.add(data);
         },
         onError: (error) {
           _controller.signalError(error);
           _controller.close();
         },
@@ skipping 713 matching lines @@
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(AsyncError error),
                                         void onDone(),
                                         bool unsubscribeOnError}) {
     return _incoming.listen(onData,
                             onError: onError,
                             onDone: onDone,
                             unsubscribeOnError: unsubscribeOnError);
   }
 
+  Encoding get encoding => _socket.encoding;
+  void set encoding(Encoding value) => _socket.encoding = value;
+
+  void write(Object obj) => _socket.write(obj);
+  void writeln(Object obj) => _socket.writeln(obj);
+  void writeCharCode(int charCode) => _socket.writeCharCode(charCode);
+  void writeAll(Iterable objects) => _socket.writeAll(objects);
+

[Mads Ager (google), 2013/03/07 07:57:36]

Nit: consistently have blank line between write methods or remove this one?

[Søren Gjesse, 2013/03/07 16:28:47]

Done.

+  void writeBytes(List<int> bytes) => _socket.writeBytes(bytes);
+
   Future<Socket> consume(Stream<List<int>> stream) {
     return _socket.consume(stream);
   }
 
   Future<Socket> addStream(Stream<List<int>> stream) {
     return _socket.addStream(stream);
   }
 
   void addString(String string, [Encoding encoding = Encoding.UTF_8]) {
     return _socket.addString(string, encoding);
@@ skipping 114 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;
 }