Remove usage of dart:utf from dart:io.

sdk/lib/io/stdio.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;
 
 const int _STDIO_HANDLE_TYPE_TERMINAL = 0;
 const int _STDIO_HANDLE_TYPE_PIPE = 1;
 const int _STDIO_HANDLE_TYPE_FILE = 2;
 const int _STDIO_HANDLE_TYPE_SOCKET = 3;
@@ skipping 12 matching lines @@
     return _stream.listen(
         onData,
         onError: onError,
         onDone: onDone,
         cancelOnError: cancelOnError);
   }
 }
 
 
 class _StdinEventSink implements EventSink<String> {
-  Function add;
-  Function addError;
-  Function close;
-  _StdinEventSink(this.add, this.addError, this.close);
+  Function _add;
+  Function _addError;
+  Function _close;
+  _StdinEventSink(this._add, this._addError, this._close);
+
+  void add(String string) => _add(string);
+  void addError(errorEvent) => _addError(errorEvent);
+  void close() => _close();
 }
 
 /**
  * [Stdin] allows both synchronous and asynchronous reads from the standard
  * input stream.
  *
  * Mixing synchronous and asynchronous reads is undefined.
  */
 class Stdin extends _StdStream implements Stream<List<int>> {
   Stdin._(Stream<List<int>> stream) : super(stream);
 
   /**
    * Synchronously read a line from stdin. This call will block until a full
    * line is available. The line will contain the newline character(s).
    *
    * If end-of-file is reached, `null` is returned.
    *
    * If end-of-file is reached after some data has already been read, that data
    * is returned.
    */
   String readLineSync({Encoding encoding: Encoding.SYSTEM,
                        bool retainNewlines: false}) {
-    var decoder = new StringDecoder(encoding)._decoder;
+    const CR = 13;
+    const LF = 10;
     var line = new StringBuffer();
     bool end = false;
     bool lastCharWasCR = false;
-    var sink = new _StdinEventSink(
-        (char) {
-          if (!retainNewlines && char == '\r') {
-            if (lastCharWasCR) line.write('\r');
-            lastCharWasCR = true;
-            return;
-          } else if (char == '\n') {
-            end = true;
-            if (!retainNewlines) return;
-          } else if (lastCharWasCR) {
-            lastCharWasCR = false;
-            line.write('\r');
-          }
-          line.write(char);
-        },
-        (error) {
-          throw error;
-        }, () {
-          if (lastCharWasCR) line.write('\r');
-        });
+    var error;
+
+    StreamController<List<int>> controller =
+        new StreamController<List<int>>(sync: true);
+    Stream stream = controller.stream.transform(new StringDecoder(encoding));
+    stream.listen((String str) {
+      line.write(str);
+    }, onError: (e) {
+      error = e;
+    }, onDone: () {
+      end = true;
+    });
 
     bool empty = true;
     while (!end) {
       int b = readByteSync();
-      if (b >= 0) {
+
+      if (b < 0) {
+        // We didn't write the carriage return in case a line feed would be
+        // the next character. Add it now.
+        if (lastCharWasCR && !retainNewlines) controller.add([CR]);
+        controller.close();
+      } else {
         empty = false;
-        decoder.handleData([b], sink);
-      } else {
-        decoder.handleDone(sink);
-        break;
+        // We consider \r\n and \n as new lines.
+        // A \r on its own is treated like a normal character.
+
+        if (b == CR) {
+          if (lastCharWasCR && !retainNewlines) {
+            // We didn't write the carriage return in case a line feed would be
+            // the next character.
+            // Add it now (since we treat it like a normal character now).
+            controller.add([CR]);
+          }
+          // We add the carriage return only if we keep new lines.
+          // Otherwise we need to wait for the next character (in case it is
+          // a line feed).
+          if (retainNewlines) controller.add([b]);
+          lastCharWasCR = true;
+        } else if (b == LF) {
+          end = true;
+          // We don't care if there was a carriage return before. If we keep
+          // the line separators it has already been added to the controller.
+          // Otherwise we don't want it anyway.
+          if (retainNewlines) controller.add([b]);
+          controller.close();
+        } else {
+          // Since the current character is not a line feed we flush the
+          // carriage return we didn't write last iteration.
+          if (lastCharWasCR) {
+            controller.add([CR]);
+            lastCharWasCR = false;
+          }
+          controller.add([b]);
+        }
+      }
+      if (error != null) {
+        // Error during decoding.
+        throw error;
       }
     }
 
     if (empty) return null;
     return line.toString();
   }
 
   /**
    * Enable or disable echo mode on the [Stdin].
    *
@@ skipping 110 matching lines @@
   }
   return StdioType.OTHER;
 }
 
 
 class _StdIOUtils {
   external static IOSink _getStdioOutputStream(int fd);
   external static Stdin _getStdioInputStream();
   external static int _socketType(nativeSocket);
 }