Remove usage of dart:utf from dart:io.

sdk/lib/io/string_transformer.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;
 
 /**
  * String encodings.
  */
 class Encoding {
@@ skipping 72 matching lines @@
 /**
  * Stream transformer that can decode a stream of bytes into a stream of
  * strings using [encoding].
  *
  * Invalid or forbidden byte-sequences will not produce errors, but will instead
  * insert [replacementChar] in the decoded strings.
  */
 class StringDecoder implements StreamTransformer<List<int>, String> {
   var _decoder;
 
+  static const _UNICODE_REPLACEMENT_CHARACTER_CODEPOINT = 0xFFFD;
+
   /**
    * Decodes a stream of bytes into a `String` with an optional
    * [encoding] and [replacementChar].
    *
    * The default value for [encoding] is [Encoding.UTF_8].
    *
    * The default value for [replacementChar] is code point U+FFFD.
    *
    * Completes with the decoded `String` when the stream is done.
    */
   static Future<String> decode(
       Stream<List<int>> stream,
       [Encoding encoding = Encoding.UTF_8,
-       int replacementChar = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
+       int replacementChar = _UNICODE_REPLACEMENT_CHARACTER_CODEPOINT]) {
+    if (replacementChar != null &&
+        replacementChar != _UNICODE_REPLACEMENT_CHARACTER_CODEPOINT) {
+      throw new UnsupportedError("replacement character must be null or "
+      "the Unicode replacement character");
+    }
     return stream
         .transform(new StringDecoder(encoding, replacementChar))
         .fold(
             new StringBuffer(),
             (prev, data) => prev..write(data))
         .then((sb) => sb.toString());
   }
 
   /**
    * Create a new [StringDecoder] with an optional [encoding] and
    * [replacementChar].
    *
    * The default value for [encoding] is [Encoding.UTF_8].
    *
    * The default value for [replacementChar] is code point U+FFFD.
    */
   StringDecoder([Encoding encoding = Encoding.UTF_8, int replacementChar]) {
     switch (encoding) {
       case Encoding.UTF_8:
-        if (replacementChar == null) {
-          replacementChar = UNICODE_REPLACEMENT_CHARACTER_CODEPOINT;
+        if (replacementChar != null &&
+            replacementChar != _UNICODE_REPLACEMENT_CHARACTER_CODEPOINT) {
+          throw new UnsupportedError("replacement character must be null or "
+              "the Unicode replacement character");
         }
-        _decoder = new Utf8DecoderTransformer(replacementChar);
+        _decoder = new Utf8Decoder(allowMalformed: true);
         break;
       case Encoding.ASCII:
         if (replacementChar == null) {
           replacementChar = '?'.codeUnitAt(0);
         } else if (replacementChar > 127) {
           throw new ArgumentError("Invalid replacement character for ASCII");
         }
         _decoder = new _AsciiDecoder(replacementChar);
         break;
       case Encoding.ISO_8859_1:
         if (replacementChar == null) {
           replacementChar = '?'.codeUnitAt(0);
         } else if (replacementChar > 255) {
           throw new ArgumentError(
               "Invalid replacement character for ISO_8859_1");
         }
         _decoder = new _Latin1Decoder(replacementChar);
         break;
       case Encoding.SYSTEM:
         if (Platform.operatingSystem == "windows") {
           _decoder = new _WindowsCodePageDecoder();
         } else {
           if (replacementChar != null) {
             // TODO(ajohnsen): Handle replacement character.
             throw new UnsupportedError(
                 "Replacement character is not supported for SYSTEM encoding");
           }
-          _decoder = new Utf8DecoderTransformer();
+          _decoder = new Utf8Decoder(allowMalformed: true);
         }
         break;
       default:
         throw new ArgumentError("Unsupported encoding '$encoding'");
     }
   }
 
   Stream<String> bind(Stream<List<int>> stream) => _decoder.bind(stream);
 }
 
 
 /**
  * Stream transformer that can encode a stream of strings info a stream of
  * bytes using [encoding].
  *
  * Strings that cannot be represented in the given encoding will result in an
  * error and a close event on the stream.
  */
 class StringEncoder implements StreamTransformer<String, List<int>> {
   var _encoder;
 
   /**
    * Create a new [StringDecoder] with an optional [encoding] and
    * [replacementChar].
    */
   StringEncoder([Encoding encoding = Encoding.UTF_8]) {
     switch (encoding) {
       case Encoding.UTF_8:
-        _encoder = new Utf8EncoderTransformer();
+        _encoder = new Utf8Encoder();
         break;
       case Encoding.ASCII:
         _encoder = new _AsciiEncoder();
         break;
       case Encoding.ISO_8859_1:
         _encoder = new _Latin1Encoder();
         break;
       case Encoding.SYSTEM:
         if (Platform.operatingSystem == "windows") {
           _encoder = new _WindowsCodePageEncoder();
         } else {
-          _encoder = new Utf8EncoderTransformer();
+          _encoder = new Utf8Encoder();
         }
         break;
       default:
         throw new ArgumentError("Unsupported encoding '$encoding'");
     }
   }
 
   Stream<List<int>> bind(Stream<String> stream) => _encoder.bind(stream);
 }
 
 
 // Utility function to synchronously decode a list of bytes.
 String _decodeString(List<int> bytes, [Encoding encoding = Encoding.UTF_8]) {
   if (bytes.length == 0) return "";
+  if (encoding == Encoding.UTF_8) {
+    return UTF8.decode(bytes, allowMalformed: true);
+  }
   var string;
   var error;
   var controller = new StreamController(sync: true);
   controller.stream
     .transform(new StringDecoder(encoding))
-    .listen((data) => string = data,
-            onError: (e) => error = e);
+    .listen((data) {
+      // The StringEncoder decodes every encoding (except UTF-8) in one go.
+      assert(string == null);
+      string = data;
+    }, onError: (e) => error = e);
   controller.add(bytes);
   controller.close();
   if (error != null) throw error;
   assert(string != null);
   return string;
 }
 
 
 // Utility function to synchronously decode a utf8-encoded list of bytes,
 // throwing on error.
 String _decodeUtf8Strict(List<int> bytes) {
   if (bytes.length == 0) return "";
-  var string;
-  var error;
-  var controller = new StreamController(sync: true);
-  controller.stream
-    .transform(new Utf8DecoderTransformer(null))
-    .listen((data) => string = data,
-            onError: (e) => error = e);
-  controller.add(bytes);
-  controller.close();
-  if (error != null) throw error;
-  assert(string != null);
-  return string;
+  return UTF8.decode(bytes);
 }
 
 
 // Utility function to synchronously encode a String.
 // Will throw an exception if the encoding is invalid.
 List<int> _encodeString(String string, [Encoding encoding = Encoding.UTF_8]) {
   if (string.length == 0) return [];
+  if (encoding == Encoding.UTF_8) return UTF8.encode(string);
   var bytes;
   var controller = new StreamController(sync: true);
   controller.stream
     .transform(new StringEncoder(encoding))
-    .listen((data) => bytes = data);
+    .listen((data) {
+      // The StringEncoder encodes every encoding (except UTF-8) in one go.
+      assert(bytes == null);
+      bytes = data;
+    });
   controller.add(string);
   controller.close();
   assert(bytes != null);
   return bytes;
 }
 
 
 abstract class _SingleByteDecoder
     extends StreamEventTransformer<List<int>, String> {
   final int _replacementChar;
@@ skipping 85 matching lines @@
 
 // Utility class for decoding Windows current code page data delivered
 // as a stream of bytes.
 class _WindowsCodePageDecoder extends StreamEventTransformer<List<int>, String> {
   void handleData(List<int> data, EventSink<String> sink) {
     sink.add(_decodeBytes(data));
   }
 
   external static String _decodeBytes(List<int> bytes);
 }