Some fixes to work better with the services framework

pkg/serialization/lib/src/reader_writer.dart

 // Copyright (c) 2012, 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 serialization;
 
 /**
  * This writes out the state of the objects to an external format. It holds
  * all of the intermediate state needed. The primary API for it is the
  * [write] method.
@@ skipping 105 matching lines @@
    * track of it. Generate a [Reference] for this object if required.
    * When it's required is up to the particular rule, but generally everything
    * gets a reference except a primitive.
    * Note that at this point the states are just the same as the fields of the
    * object, and haven't been flattened.
    */
   void _record(object, SerializationRule rule) {
     if (rule.shouldUseReferenceFor(object, this)) {
       references.putIfAbsent(object, () =>
           new Reference(this, rule.number, _nextObjectNumberFor(rule)));
-      var state = rule.extractState(object, trace.note);
+      var state = rule.extractState(object, trace.note, this);
       _addStateForRule(rule, state);
     }
   }
 
   /**
    * Should we store primitive objects directly or create references for them.
    * That depends on which format we're using, so a flat format will want
    * references, but the Map format can store them directly.
    */
   bool get shouldUseReferencesForPrimitives
       => format.shouldUseReferencesForPrimitives;
 
   /**
    * Returns a serialized version of the [SerializationRule]s used to write
    * the data, if [selfDescribing] is true, otherwise returns null.
    */
   serializedRules() {
     if (!selfDescribing) return null;
     var meta = serialization.ruleSerialization();
-    var writer = new Writer(meta);
+    var writer = new Writer(meta, format);
     writer.selfDescribing = false;
     return writer.write(serialization._rules);
   }
 
   /** Record a [state] entry for a particular rule. */
   void _addStateForRule(eachRule, state) {
     _growStates(eachRule);
     states[eachRule.number].add(state);
   }
 
@@ skipping 145 matching lines @@
    * functions, mirrors, or other non-portable entities. The map in which we
    * look things up can be provided as an argument to read, but we can also
    * provide a map here, and objects will be looked up in both places.
    */
   Map namedObjects;
 
   /**
    * Look up the reference to an external object. This can be held either in
    * the reader-specific list of externals or in the serializer's
    */
-  objectNamed(key) {
+  objectNamed(key, [Function ifAbsent]) {
     var map = (namedObjects.containsKey(key))
         ? namedObjects : serialization.namedObjects;
     if (!map.containsKey(key)) {
-      throw 'Cannot find named object to link to: $key';
+      (ifAbsent == null ? keyNotFound : ifAbsent)(key);
     }
     return map[key];
   }
 
+  void keyNotFound(key) {
+    throw new SerializationException(
+        'Cannot find named object to link to: $key');
+  }
+
   /**
    * Return the list of rules to be used when writing. These come from the
    * [serialization].
    */
   List<SerializationRule> get rules => serialization._rules;
 
   /**
    * Internal use only, for testing purposes. Set the data for this reader
    * to a List of Lists whose size must match the number of rules.
    */
@@ skipping 12 matching lines @@
     var input = format.read(rawInput, this);
     data = input["data"];
     rules.forEach(inflateForRule);
     return inflateReference(input["roots"].first);
   }
 
   /**
    * If the data we are reading from has rules written to it, read them back
    * and set them as the rules we will use.
    */
-  void readRules(String newRules) {
+  void readRules(newRules) {
     // TODO(alanknight): Replacing the serialization is kind of confusing.
-    List rulesWeRead = (newRules == null) ?
-        null : serialization.ruleSerialization().read(newRules, namedObjects);
+    if (newRules == null) return;
+    var reader = serialization.ruleSerialization().newReader(format);
+    List rulesWeRead = reader.read(newRules, namedObjects);
     if (rulesWeRead != null && !rulesWeRead.isEmpty) {
       serialization = new Serialization.blank();
       rulesWeRead.forEach(serialization.addRule);
     }
   }
 
   /**
    * Inflate all of the objects for [rule]. Does the essential state for all
    * objects first, then the non-essential state. This avoids cycles in
    * non-essential state, because all the objects will have already been
@@ skipping 233 matching lines @@
  * for an example. It knows how to return its object and how to filter.
  */
 class DesignatedRuleForObject {
   Function rulePredicate;
   final target;
 
   DesignatedRuleForObject(this.target, this.rulePredicate);
 
   possibleRules(List rules) => rules.where(rulePredicate).toList();
 }