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: 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 {
+    var charset;
+    if (headers.contentType != null && headers.contentType.charset != null) {
+      charset = headers.contentType.charset;
+    } else {
+      charset = "iso-8859-1";
+    }
+    return Encoding.fromName(charset);
+  }
+
+  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 addString(String string, [Encoding encoding = Encoding.UTF_8]) {
-    add(_encodeString(string, encoding));
-  }
-
-  Future<T> addStream(Stream<List<int>> stream) {
+  Future<T> writeStream(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);
+    return _ioSink.writeStream(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;
     _headersWritten = true;
+    _ioSink.encoding = Encoding.ASCII;
     _writeHeader();
+    _ioSink.encoding = encoding;
     if (_ignoreBody) {
       _ioSink.close();
       return;
     }
     _chunked = headers.chunkedTransferEncoding;
     if (headers.contentLength >= 0) {
       _outgoing.setTransferLength(headers.contentLength);
     }
   }
 
@@ skipping 32 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() => _ioSink.add([_CharCode.SP]);
-    writeCRLF() => _ioSink.add([_CharCode.CR, _CharCode.LF]);
+    writeSP() => _ioSink.writeBytes([_CharCode.SP]);
+    writeCRLF() => _ioSink.writeBytes([_CharCode.CR, _CharCode.LF]);
 
     // Write status line.
     if (headers.protocolVersion == "1.1") {
-      _ioSink.add(_Const.HTTP11);
+      _ioSink.writeBytes(_Const.HTTP11);
     } else {
-      _ioSink.add(_Const.HTTP10);
+      _ioSink.writeBytes(_Const.HTTP10);
     }
     writeSP();
-    _ioSink.addString(statusCode.toString());
+    _ioSink.write(statusCode.toString());
     writeSP();
-    _ioSink.addString(reasonPhrase);
+    _ioSink.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() => _ioSink.add([_CharCode.SP]);
-    writeCRLF() => _ioSink.add([_CharCode.CR, _CharCode.LF]);
+    writeSP() => _ioSink.writeBytes([_CharCode.SP]);
+    writeCRLF() => _ioSink.writeBytes([_CharCode.CR, _CharCode.LF]);
 
-    _ioSink.addString(method);
+    _ioSink.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}";
         }
       }
-      _ioSink.addString(path);
+      _ioSink.write(path);
     } else {
-      _ioSink.addString(uri.toString());
+      _ioSink.write(uri.toString());
     }
     writeSP();
-    _ioSink.add(_Const.HTTP11);
+    _ioSink.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 105 matching lines @@
         cr.authorize(request);
       }
     }
     // Start sending the request (lazy, delayed until the user provides
     // data).
     _httpParser.responseToMethod = method;
     _streamFuture = outgoing.onStream((stream) {
         // Sending request, set up response completer.
         _nextResponseCompleter = new Completer();
 
-        var requestFuture = _socket.addStream(stream)
+        var requestFuture = _socket.writeStream(stream)
             .catchError((e) {
               destroy();
               throw e;
             });
 
         // Listen for response.
         _nextResponseCompleter.future
             .then((incoming) {
               incoming.dataDone.then((_) {
                 if (incoming.headers.persistentConnection &&
@@ skipping 306 matching lines @@
         (incoming) {
           // Only handle one incoming request at the time. Keep the
           // stream paused until the request has been send.
           _subscription.pause();
           _state = _ACTIVE;
           var outgoing = new _HttpOutgoing();
           var response = new _HttpResponse(incoming.headers.protocolVersion,
                                            outgoing);
           var request = new _HttpRequest(response, incoming, _httpServer, this);
           outgoing.onStream((stream) {
-            return _streamFuture = _socket.addStream(stream)
+            return _streamFuture = _socket.writeStream(stream)
                 .then((_) {
                   if (_state == _DETACHED) return;
                   if (response.persistentConnection &&
                       request.persistentConnection &&
                       incoming.fullBodyRead) {
                     _state = _IDLE;
                     // Resume the subscription for incoming requests as the
                     // request is now processed.
                     _subscription.resume();
                   } else {
@@ skipping 260 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);
+
+  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);
+  Future<Socket> writeStream(Stream<List<int>> stream) {
+    return _socket.writeStream(stream);
   }
 
   void destroy() => _socket.destroy();
-  void add(List<int> data) => _socket.add(data);
+
   void close() => _socket.close();
+
   Future<Socket> get done => _socket.done;
+
   int get port => _socket.port;
+
   String get remoteHost => _socket.remoteHost;
+
   int get remotePort => _socket.remotePort;
 }
 
 
 class _AuthenticationScheme {
   static const UNKNOWN = const _AuthenticationScheme(-1);
   static const BASIC = const _AuthenticationScheme(0);
   static const DIGEST = const _AuthenticationScheme(1);
 
   const _AuthenticationScheme(this._scheme);
@@ skipping 96 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;
 }