Introduce class Sink<T>.

sdk/lib/convert/string_conversion.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.convert;
 
 /**
  * This class provides an interface for converters to
  * efficiently transmit String data.
  *
  * Instead of limiting the interface to one non-chunked String it accepts
  * partial strings or can be transformed into a byte sink that
  * accepts UTF-8 code units.
  *
  * This abstract class will likely get more methods over time. Implementers are
  * urged to extend [StringConversionSinkBase] or to mix in
  * [StringConversionSinkMixin], to ensure that their class covers the newly
  * added methods.
  */
 abstract class StringConversionSink
     extends ChunkedConversionSink<String> {
   StringConversionSink();
   factory StringConversionSink.withCallback(void callback(String accumulated))
       = _StringCallbackSink;
-  factory StringConversionSink.from(ChunkedConversionSink<String> sink)
+  factory StringConversionSink.from(Sink<String> sink)
       = _StringAdapterSink;
 
   /**
    * Creates a new instance wrapping the given [sink].
    *
    * Every string that is added to the returned instance is forwarded to
    * the [sink]. The instance is allowed to buffer and is not required to
    * forward immediately.
    */
   factory StringConversionSink.fromStringSink(StringSink sink) =
@@ skipping 207 matching lines @@
 }
 
 /**
  * This class adapts a simple [ChunkedConversionSink] to a
  * [StringConversionSink].
  *
  * All additional methods of the [StringConversionSink] (compared to the
  * ChunkedConversionSink) are redirected to the `add` method.
  */
 class _StringAdapterSink extends StringConversionSinkBase {
-  final ChunkedConversionSink<String> _sink;
+  final Sink<String> _sink;
 
   _StringAdapterSink(this._sink);
 
   void add(String str) => _sink.add(str);
 
   void addSlice(String str, int start, int end, bool isLast) {
     if (start == 0 && end == str.length) {
       add(str);
     } else {
       add(str.substring(start, end));
     }
     if (isLast) close();
   }
 
   void close() => _sink.close();
 }
 
 
 /**
  * Decodes UTF-8 code units and stores them in a [StringSink].
  */
 class _Utf8StringSinkAdapter extends ByteConversionSink {
   final _Utf8Decoder _decoder;
-  final ChunkedConversionSink _chunkedSink;
+  final Sink _sink;
 
-  _Utf8StringSinkAdapter(ChunkedConversionSink chunkedSink,
-                         StringSink sink, bool allowMalformed)
-      : _chunkedSink = chunkedSink,
-        _decoder = new _Utf8Decoder(sink, allowMalformed);
+  _Utf8StringSinkAdapter(this._sink,
+                         StringSink stringSink, bool allowMalformed)
+      : _decoder = new _Utf8Decoder(stringSink, allowMalformed);
 
   void close() {
     _decoder.close();
-    if(_chunkedSink != null) _chunkedSink.close();
+    if(_sink != null) _sink.close();
   }
 
   void add(List<int> chunk) {
     addSlice(chunk, 0, chunk.length, false);
   }
 
   void addSlice(List<int> codeUnits, int startIndex, int endIndex,
                 bool isLast) {
     _decoder.convert(codeUnits, startIndex, endIndex);
     if (isLast) close();
@@ skipping 38 matching lines @@
     _decoder.convert(chunk, startIndex, endIndex);
     if (_buffer.isNotEmpty) {
       String accumulated = _buffer.toString();
       _chunkedSink.addSlice(accumulated, 0, accumulated.length, isLast);
       _buffer.clear();
       return;
     }
     if (isLast) close();
   }
 }