Make JSON encoder take extra function argument to use instead of toJson calls.

sdk/lib/convert/json.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;
 
 /**
  * Error thrown by JSON serialization if an object cannot be serialized.
  *
  * The [unsupportedObject] field holds that object that failed to be serialized.
@@ skipping 72 matching lines @@
    * property that has been parsed during decoding. The `key` argument is either
    * the integer list index for a list property, the map string for object
    * properties, or `null` for the final result.
    *
    * The default [reviver] (when not provided) is the identity function.
    */
   Object decode(String str, {reviver(var key, var value)}) {
     return new JsonDecoder(reviver).convert(str);
   }
 
+  /**
+   * Converts [value] to a JSON string.
+   *
+   * If value contains objects that are not directly encodable to a JSON
+   * string (a value that is not a number, boolean, string, null, list or a map
+   * with string keys), the [toEncodable] function is used to convert it to an
+   * object that must be directly encodable.
+   *
+   * If [toEncodable] is omitted, it defaults to calling `.toJson()` on the
+   * unencodable object.
+   */
+  Object encode(Object value, {toEncodable(var object)}) {
+    return new JsonEncoder(toEncodable).convert(value);
+  }
+
   JsonEncoder get encoder => new JsonEncoder();
   JsonDecoder get decoder => new JsonDecoder(null);
 }
 
 typedef _Reviver(var key, var value);
 
 class _ReviverJsonCodec extends JsonCodec {
   final _Reviver _reviver;
   _ReviverJsonCodec(this._reviver);
 
   Object decode(String str, {reviver(var key, var value)}) {
     if (reviver == null) reviver = _reviver;
     return new JsonDecoder(reviver).convert(str);
   }
 
   JsonDecoder get decoder => new JsonDecoder(_reviver);
 }
 
 /**
  * This class converts JSON objects to strings.
  */
 class JsonEncoder extends Converter<Object, String> {
-  JsonEncoder();
+  final _toEncodableFunction;
+
+  /**
+   * Creates a JSON encoder.
+   *
+   * The JSON encoder handles numbers, strings, booleans, null, lists and
+   * maps directly.
+   *
+   * Any other object is attempted converted by [toEncodable] to an
+   * object that is of one of the convertible types.
+   *
+   * If [toEncodable] is omitted, it defaults to calling `.toJson()` on
+   * the object.
+   */
+  JsonEncoder([Object toEncodable(Object nonSerializable)])
+      : this._toEncodableFunction = toEncodable;
 
   /**
    * Converts the given object [o] to its JSON representation.
    *
    * Directly serializable values are [num], [String], [bool], and [Null], as
    * well as some [List] and [Map] values.
    * For [List], the elements must all be serializable.
    * For [Map], the keys must be [String] and the values must be serializable.
    *
-   * If a value is any other type is attempted serialized, a "toJson()" method
-   * is invoked on the object and the result, which must be a directly
-   * serializable value, is serialized instead of the original value.
+   * If a value is any other type is attempted serialized, the conversion
+   * function provided in the constructor is invoked with the object as argument
+   * and the result, which must be a directly serializable value,
+   * is serialized instead of the original value.
    *
-   * If the object does not support this method, throws, or returns a
-   * value that is not directly serializable, a [JsonUnsupportedObjectError]
-   * exception is thrown. If the call throws (including the case where there
-   * is no nullary "toJson" method, the error is caught and stored in the
+   * If the conversion throws, or returns a value that is not directly
+   * serializable, a [JsonUnsupportedObjectError] exception is thrown.
+   * If the call throws, the error is caught and stored in the
    * [JsonUnsupportedObjectError]'s [:cause:] field.
    *
    * If a [List] or [Map] contains a reference to itself, directly or through
    * other lists or maps, it cannot be serialized and a [JsonCyclicError] is
    * thrown.
    *
    * Json Objects should not change during serialization.
    * If an object is serialized more than once, [stringify] is allowed to cache
    * the JSON text for it. I.e., if an object changes after it is first
    * serialized, the new values may or may not be reflected in the result.
    */
-  String convert(Object o) => OLD_JSON_LIB.stringify(o);
+  String convert(Object o) => OLD_JSON_LIB.stringify(o, _toEncodableFunction);
 
   /**
    * Starts a chunked conversion.
    *
    * The converter works more efficiently if the given [sink] is a
    * [StringConversionSink].
    *
    * Returns a chunked-conversion sink that accepts at most one object. It is
    * an error to invoke `add` more than once on the returned sink.
    */
   ChunkedConversionSink<Object> startChunkedConversion(
       ChunkedConversionSink<String> sink) {
     if (sink is! StringConversionSink) {
       sink = new StringConversionSink.from(sink);
     }
-    return new _JsonEncoderSink(sink);
+    return new _JsonEncoderSink(sink, _toEncodableFunction);
   }
 
   // Override the base-classes bind, to provide a better type.
   Stream<String> bind(Stream<Object> stream) => super.bind(stream);
 }
 
 /**
  * Implements the chunked conversion from object to its JSON representation.
  *
  * The sink only accepts one value, but will produce output in a chunked way.
  */
 class _JsonEncoderSink extends ChunkedConversionSink<Object> {
+  final Function _toEncodableFunction;
   final StringConversionSink _sink;
   bool _isDone = false;
 
-  _JsonEncoderSink(this._sink);
+  _JsonEncoderSink(this._sink, this._toEncodableFunction);
 
   /**
    * Encodes the given object [o].
    *
    * It is an error to invoke this method more than once on any instance. While
    * this makes the input effectly non-chunked the output will be generated in
    * a chunked way.
    */
   void add(Object o) {
     if (_isDone) {
       throw new StateError("Only one call to add allowed");
     }
     _isDone = true;
     ClosableStringSink stringSink = _sink.asStringSink();
-    OLD_JSON_LIB.printOn(o, stringSink);
+    OLD_JSON_LIB.printOn(o, stringSink, _toEncodableFunction);
     stringSink.close();
   }
 
   void close() { /* do nothing */ }
 }
 
 /**
  * This class parses JSON strings and builds the corresponding objects.
  */
 class JsonDecoder extends Converter<String, Object> {
@@ skipping 57 matching lines @@
     String accumulated = buffer.toString();
     buffer.clear();
     Object decoded = _parseJson(accumulated, _reviver);
     _chunkedSink.add(decoded);
     _chunkedSink.close();
   }
 }
 
 // Internal optimized JSON parsing implementation.
 external _parseJson(String source, reviver(key, value));