Remove Encoding-enum from dart:io and add interface in dart:convert.

sdk/lib/convert/utf.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;
 
+/** The Unicode Replacement character `U+FFFD` (�). */
+const UNICODE_REPLACEMENT_CHARACTER_RUNE = 0xFFFD;
+
 /**
  * An instance of the default implementation of the [Utf8Codec].
  *
  * This instance provides a convenient access to the most common UTF-8
  * use cases.
  *
  * Examples:
  *
  *     var encoded = UTF8.encode("Îñţérñåţîöñåļîžåţîờñ");
  *     var decoded = UTF8.decode([0x62, 0x6c, 0xc3, 0xa5, 0x62, 0xc3, 0xa6,
  *                                0x72, 0x67, 0x72, 0xc3, 0xb8, 0x64]);
  */
 const UTF8 = const Utf8Codec();
 
 /**
  * A [Utf8Codec] encodes strings to utf-8 code units (bytes) and decodes
  * UTF-8 code units to strings.
  */
-class Utf8Codec extends _Encoding {
+class Utf8Codec extends Encoding {
   final bool _allowMalformed;
 
   /**
    * Instantiates a new [Utf8Codec].
    *
    * The optional [allowMalformed] argument defines how [decoder] (and [decode])
    * deal with invalid or unterminated character sequences.
    *
    * If it is `true` (and not overriden at the method invocation) [decode] and
    * the [decoder] replace invalid (or unterminated) octet
    * sequences with the Unicode Replacement character `U+FFFD` (�). Otherwise
    * they throw a [FormatException].
    */
   const Utf8Codec({ bool allowMalformed: false })
       : _allowMalformed = allowMalformed;
 
+  String get name => "utf-8";
+
   /**
    * Decodes the UTF-8 [codeUnits] (a list of unsigned 8-bit integers) to the
    * corresponding string.
    *
    * If [allowMalformed] is `true` the decoder replaces invalid (or
    * unterminated) character sequences with the Unicode Replacement character
    * `U+FFFD` (�). Otherwise it throws a [FormatException].
    *
    * If [allowMalformed] is not given, it defaults to the `allowMalformed` that
    * was used to instantiate `this`.
    */
   String decode(List<int> codeUnits, { bool allowMalformed }) {
     if (allowMalformed == null) allowMalformed = _allowMalformed;
     return new Utf8Decoder(allowMalformed: allowMalformed).convert(codeUnits);
   }
 
   Converter<String, List<int>> get encoder => new Utf8Encoder();
   Converter<List<int>, String> get decoder {
     return new Utf8Decoder(allowMalformed: _allowMalformed);
   }
 }
 
 /**
  * This class converts strings to their UTF-8 code units (a list of
  * unsigned 8-bit integers).
  */
 class Utf8Encoder extends Converter<String, List<int>> {
+
+  const Utf8Encoder();
+
   /**
    * Converts [string] to its UTF-8 code units (a list of
    * unsigned 8-bit integers).
    */
   List<int> convert(String string) {
     // Create a new encoder with a length that is guaranteed to be big enough.
     // A single code unit uses at most 3 bytes. Two code units at most 4.
     _Utf8Encoder encoder = new _Utf8Encoder.withBufferSize(string.length * 3);
     int endPosition = encoder._fillBuffer(string, 0, string.length);
     assert(endPosition >= string.length - 1);
@@ skipping 203 matching lines @@
   /**
    * Instantiates a new [Utf8Decoder].
    *
    * The optional [allowMalformed] argument defines how [convert] deals
    * with invalid or unterminated character sequences.
    *
    * If it is `true` [convert] replaces invalid (or unterminated) character
    * sequences with the Unicode Replacement character `U+FFFD` (�). Otherwise
    * it throws a [FormatException].
    */
-  Utf8Decoder({ bool allowMalformed: false })
+  const Utf8Decoder({ bool allowMalformed: false })
       : this._allowMalformed = allowMalformed;
 
   /**
    * Converts the UTF-8 [codeUnits] (a list of unsigned 8-bit integers) to the
    * corresponding string.
    */
   String convert(List<int> codeUnits) {
     StringBuffer buffer = new StringBuffer();
     _Utf8Decoder decoder = new _Utf8Decoder(buffer, _allowMalformed);
     decoder.convert(codeUnits, 0, codeUnits.length);
@@ skipping 196 matching lines @@
       }
       break loop;
     }
     if (expectedUnits > 0) {
       _value = value;
       _expectedUnits = expectedUnits;
       _extraUnits = extraUnits;
     }
   }
 }