Make JSON.fuse(UTF8) be more efficient by not creating intermediate string.

runtime/lib/convert_patch.dart

 // Copyright (c) 2014, 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.
 
 import "dart:_internal" show POWERS_OF_TEN;
 
 // JSON conversion.
 
 patch _parseJson(String json, reviver(var key, var value)) {
   _BuildJsonListener listener;
   if (reviver == null) {
     listener = new _BuildJsonListener();
   } else {
     listener = new _ReviverJsonListener(reviver);
   }
   var parser = new _JsonStringParser(listener);
   parser.chunk = json;
   parser.chunkEnd = json.length;
   parser.parse(0);
   parser.close();
   return listener.result;
 }
 
+patch class Utf8Decoder {
+  /* patch */
+  Converter<List<int>, dynamic> fuse(Converter<String, dynamic> next) {
+    if (next is JsonDecoder) {
+      return new _JsonUtf8Decoder(next._reviver, this._allowMalformed);
+    }
+    // TODO(lrn): Recognize a fused decoder where the next step is JsonDecoder.
+    return super.fuse(next);
+  }
+}
+
+class _JsonUtf8Decoder extends Converter<List<int>, Object> {
+  final _Reviver _reviver;
+  final bool _allowMalformed;
+
+  _JsonUtf8Decoder(this._reviver, this._allowMalformed);
+
+  dynamic convert(List<int> input) {
+    var parser = _JsonUtf8DecoderSink._createParser(_reviver, _allowMalformed);
+    parser.chunk = input;
+    parser.chunkEnd = input.length;
+    parser.parse(0);
+    return parser.result;
+  }
+
+  ByteConversionSink startChunkedConversion(Sink<Object> sink) {
+    return new _JsonUtf8DecoderSink(_reviver, sink, _allowMalformed);
+  }
+}
+
 //// Implementation ///////////////////////////////////////////////////////////
 
 // Simple API for JSON parsing.
 
 /**
  * Listener for parsing events from [_ChunkedJsonParser].
  */
 abstract class _JsonListener {
   void handleString(String value) {}
   void handleNumber(num value) {}
@@ skipping 719 matching lines @@
    */
   void parse(int position) {
     int length = chunkEnd;
     if (partialState != NO_PARTIAL) {
       position = parsePartial(position);
       if (position == length) return;
     }
     int state = this.state;
     while (position < length) {
       int char = getChar(position);
+      if (char == null) {
+        print("[[[$chunk]]] - $position - ${chunk.runtimeType}");
+      }
       switch (char) {
         case SPACE:
         case CARRIAGE_RETURN:
         case NEWLINE:
         case TAB:
           position++;
           break;
         case QUOTE:
           if ((state & ALLOW_STRING_MASK) != 0) return fail(position);
           state |= VALUE_READ_BITS;
@@ skipping 67 matching lines @@
             listener.endObject();
           } else {
             return fail(position);
           }
           state = restoreState() | VALUE_READ_BITS;
           position++;
           break;
         default:
           if ((state & ALLOW_VALUE_MASK) != 0) fail(position);
           state |= VALUE_READ_BITS;
+          if (char == null) print("$chunk - $position");
           position = parseNumber(char, position);
           break;
       }
     }
     this.state = state;
   }
 
   /**
    * Parses a "true" literal starting at [position].
    *
@@ skipping 373 matching lines @@
           char = getChar(position);
           digit = char ^ CHAR_0;
         } while (digit <= 9);
         intValue += expSign * exponent;
       }
     }
     if (!isDouble) {
       listener.handleNumber(sign * intValue);
       return position;
     }
-    // Double values at or above this value (2**53) may have lost precission.
+    // Double values at or above this value (2 ** 53) may have lost precission.
     // Only trust results that are below this value.
     const double maxExactDouble = 9007199254740992.0;
     if (doubleValue < maxExactDouble) {
       int exponent = intValue;
       double signedMantissa = doubleValue * sign;
       if (exponent >= -22) {
         if (exponent < 0) {
           listener.handleNumber(signedMantissa / POWERS_OF_TEN[-exponent]);
           return position;
         }
@@ skipping 457 matching lines @@
     _parser.parse(start);
   }
 
   void close() {
     _parser.close();
     var decoded = _parser.result;
     _sink.add(decoded);
     _sink.close();
   }
 }