Remane io_stream_consumer.dart to io_sink and move out all implementation from IOSink to _IOSinkImp…

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 300 matching lines @@
           return this;
         }
       });
     }
     // No credentials were found and the callback was not set.
     return new Future.immediate(this);
   }
 }
 
 
-abstract class _HttpOutboundMessage<T> extends IOSink {
+abstract class _HttpOutboundMessage<T> implements IOSink {
   // Used to mark when the body should be written. This is used for HEAD
   // requests and in error handling.
   bool _ignoreBody = false;
+  bool _headersWritten = false;
+  bool _chunked = false;
+
+  final IOSink _ioSink;
+  final _HttpOutgoing _outgoing;
+
+  final _HttpHeaders headers;
 
   _HttpOutboundMessage(String protocolVersion, _HttpOutgoing outgoing)
-      : super(outgoing),
-        _outgoing = outgoing,
+      : _outgoing = outgoing,
+        _ioSink = new IOSink(outgoing),
         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;
   }
 
   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 super.consume(stream).then((_) => this);
+    return _ioSink.consume(stream).then((_) => this);
   }
 
   void add(List<int> data) {
     _writeHeaders();
     if (_ignoreBody || data.length == 0) return;
     if (_chunked) {
-      _ChunkedTransformer._addChunk(data, super.add);
+      _ChunkedTransformer._addChunk(data, _ioSink.add);
     } else {
-      super.add(data);
+      _ioSink.add(data);
     }
   }
 
-  Future addStream(Stream<List<int>> stream) {
+  void addString(String string, [Encoding encoding = Encoding.UTF_8]) {
+    add(_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 super.addStream(stream).then((_) => this);
+    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([], super.add);
+        _ChunkedTransformer._addChunk([], _ioSink.add);
       }
     }
-    super.close();
+    _ioSink.close();
   }
 
+  Future<T> get done => _ioSink.done.then((_) => this);
+
   void _writeHeaders() {
     if (_headersWritten) return;
     bool _tmpIgnoreBody = _ignoreBody;
     _ignoreBody = false;
     _headersWritten = true;
     _writeHeader();
     _ignoreBody = _tmpIgnoreBody;
     if (_ignoreBody) {
-      super.close();
+      _ioSink.close();
       return;
     }
     _chunked = headers.chunkedTransferEncoding;
     if (headers.contentLength >= 0) {
       _outgoing.setTransferLength(headers.contentLength);
     }
   }
 
   void _writeHeader();  // TODO(ajohnsen): Better name.
-
-  final _HttpHeaders headers;
-
-  final _HttpOutgoing _outgoing;
-  bool _headersWritten = false;
-  bool _chunked = false;
 }
 
 
 class _HttpResponse extends _HttpOutboundMessage<HttpResponse>
     implements HttpResponse {
   int statusCode = 200;
   String _reasonPhrase;
   List<Cookie> _cookies;
   _HttpRequest _httpRequest;
 
@@ skipping 1058 matching lines @@
   }
 
   _HttpConnectionInfo._();
 
   String remoteHost;
   int remotePort;
   int localPort;
 }
 
 
-class _DetachedSocket implements Socket {
+class _DetachedSocket extends Stream<List<int>> implements Socket {
   final Stream<List<int>> _incoming;
   final Socket _socket;
 
   _DetachedSocket(this._socket, this._incoming);
 
   StreamSubscription<List<int>> listen(void onData(List<int> event),
                                        {void onError(AsyncError error),
                                         void onDone(),
                                         bool unsubscribeOnError}) {
     return _incoming.listen(onData,
@@ skipping 11 matching lines @@
   }
 
   void addString(String string, [Encoding encoding = Encoding.UTF_8]) {
     return _socket.addString(string, encoding);
   }
 
   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 95 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;
 }