Isolates: allow sending of arbitrary objects in dart2js.

sdk/lib/_internal/compiler/js_lib/isolate_serialization.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.
+
+part of _isolate_helper;
+
+/// Serialize [message].
+_serializeMessage(message) {
+  return new _Serializer().serialize(message);
+}
+
+/// Deserialize [message].
+_deserializeMessage(message) {
+  return new _Deserializer().deserialize(message);
+}
+
+/// Clones the message.
+///
+/// Contrary to a `_deserializeMessage(_serializeMessage(x))` the `_clone`
+/// function will not try to adjust SendPort values and pass them through.
+_clone(message) {
+  _Serializer serializer = new _Serializer(serializeSendPorts: false);
+  _Deserializer deserializer = new _Deserializer();
+  return deserializer.deserialize(serializer.serialize(message));
+}
+
+class _Serializer {
+  final bool _serializeSendPorts;
+  Map<dynamic, int> serializedObjectIds = new Map<dynamic, int>.identity();
+
+  _Serializer({serializeSendPorts: true})
+      : _serializeSendPorts = serializeSendPorts;
+
+  /// Returns a message that can be transmitted through web-worker channels.
+  serialize(x) {
+    if (isPrimitive(x)) return serializePrimitive(x);
+
+    int serializationId = serializedObjectIds[x];
+    if (serializationId != null) return makeRef(serializationId);
+
+    serializationId = serializedObjectIds.length;
+    serializedObjectIds[x] = serializationId;
+
+    if (x is JSIndexable) return serializeJSIndexable(x);
+    if (x is InternalMap) return serializeMap(x);
+
+    if (x is JSObject) return serializeJSObject(x);
+
+    // We should not have any interceptors any more.
+    if (x is Interceptor) unsupported(x);
+
+    if (x is RawReceivePort) {
+      unsupported(x, "RawReceivePorts can't be transmitted:");
+    }
+
+    // SendPorts need their workerIds adjusted (either during serialization or
+    // deserialization).
+    if (x is _NativeJsSendPort) return serializeJsSendPort(x);
+    if (x is _WorkerSendPort) return serializeWorkerSendPort(x);
+
+    if (x is Closure) return serializeClosure(x);
+
+    return serializeDartObject(x);
+  }
+
+  void unsupported(x, [String message]) {
+    if (message == null) message = "Can't transmit:";
+    throw new UnsupportedError("$message $x");
+  }
+
+  makeRef(int serializationId) => ["ref", serializationId];
+
+  bool isPrimitive(x) => x == null || x is String || x is num || x is bool;
+  serializePrimitive(primitive) => primitive;
+
+  serializeJSIndexable(JSIndexable indexable) {
+    // Strings are JSIndexable but should have been treated earlier.
+    assert(indexable is! String);
+    if (indexable is TypedData) {
+      return ["typed", indexable];
+    }
+    List serialized = serializeArray(indexable);
+    if (indexable is JSFixedArray) return ["fixed", serialized];
+    if (indexable is JSExtendableArray) return ["extendable", serialized];
+    // MutableArray check must be last, since JSFixedArray and JSExtendableArray
+    // extend JSMutableArray.
+    if (indexable is JSMutableArray) return ["mutable", serialized];
+    // The only JSArrays left are the const Lists (as in `const [1, 2]`).
+    if (indexable is JSArray) return ["const", serialized];
+    unsupported(indexable, "Can't serialize indexable: ");
+    return null;
+  }
+
+  serializeArray(JSArray x) {
+    List serialized = [];
+    serialized.length = x.length;
+    for (int i = 0; i < x.length; i++) {
+      serialized[i] = serialize(x[i]);
+    }
+    return serialized;
+  }
+
+  serializeArrayInPlace(JSArray x) {
+    for (int i = 0; i < x.length; i++) {
+      x[i] = serialize(x[i]);
+    }
+    return x;
+  }
+
+  serializeMap(Map x) {
+    return ['map',
+            x.keys.map(serialize).toList(),
+            x.values.map(serialize).toList()];
+  }
+
+  serializeJSObject(JSObject x) {
+    if (JS('bool', '#.constructor', x) &&
+        JS('bool', 'x.constructor !== Object')) {

[Lasse Reichstein Nielsen, 2014/11/24 15:37:05]

Still document what the case is that you are guarding for/against.

I assume that what you want is to only allow objects with a prototype chain
containing only the (initial) value of Object.prototype (which is what you
create with `{}` or `new Object`).
The most precise test of that would be `#.__proto__ === Object.prototype`, but
using `# != null && #.constructor == Object` might be faster than using
__proto__, and almost as safe (nothing will prevent determined and malicious JS
code anyway).

(I assume `#.__proto__` is more efficient than `Object.getPrototype(#)` since
you are using that).

[floitsch, 2014/11/25 12:32:18]

Changed comment to:
    // We only serialize direct properties, and no properties from prototypes.
    // Check for the constructor and see if it's Object or undefined/null. This
    // should have no inheritance, and can't be functions either.

I prefer not to access "__proto__".
I don't use "__proto__".

[Lasse Reichstein Nielsen, 2014/11/25 13:07:53]

Not sure what "direct properties" mean. Is it "own properties" (like in
Object.getOwnPropertyKeys)?

Not sure what "This" refers to in last sentence.

How about: 
Don't serialize objects if their `constructor` property isn't `Object` or
undefined/null. 
A different constructor is taken as a sign that the object has complex internal
state, 
or that it is a function, and won't be serialized.

[floitsch, 2014/11/25 13:39:18]

Done.

+      unsupported(x, "Only plain JS Objects are supported:");
+    }
+    List keys = JS('JSArray', 'Object.keys(#)', x);
+    List values = [];
+    values.length = keys.length;
+    for (int i = 0; i < keys.length; i++) {
+      values[i] = serialize(JS('', '#[#]', x, keys[i]));
+    }
+    return ['js-object', keys, values];
+  }
+
+  serializeWorkerSendPort(_WorkerSendPort x) {
+    if (_serializeSendPorts) {
+      return ['sendport', x._workerId, x._isolateId, x._receivePortId];
+    }
+    return ['raw sendport', x];
+  }
+
+  serializeJsSendPort(_NativeJsSendPort x) {
+    if (_serializeSendPorts) {
+      int workerId = _globalState.currentManagerId;
+      return ['sendport', workerId, x._isolateId, x._receivePort._id];
+    }
+    return ['raw sendport', x];
+  }
+
+  serializeCapability(CapabilityImpl x) => ['capability', x._id];
+
+  serializeClosure(Closure x) {
+    final name = IsolateNatives._getJSFunctionName(x);
+    if (name == null) {
+      unsupported(x, "Closures can't be transmitted:");
+    }
+    return ['function', name];
+  }
+
+  serializeDartObject(x) {
+    var classExtractor = JS_EMBEDDED_GLOBAL('', CLASS_ID_EXTRACTOR);
+    var fieldsExtractor = JS_EMBEDDED_GLOBAL('', CLASS_FIELDS_EXTRACTOR);
+    String classId = JS('String', '#(#)', classExtractor, x);
+    List fields = JS('JSArray', '#(#)', fieldsExtractor, x);
+    return ['dart', classId, serializeArrayInPlace(fields)];
+  }
+}
+
+class _Deserializer {
+  /// When `true`, encodes sendports specially so that they can be adjusted on
+  /// the receiving end.
+  ///
+  /// When `false`, sendports are cloned like any other object.
+  final bool _adjustSendPorts;
+
+  List<dynamic> deserializedObjects = new List<dynamic>();
+
+  _Deserializer({adjustSendPorts: true}) : _adjustSendPorts = adjustSendPorts;
+
+  /// Returns a message that can be transmitted through web-worker channels.
+  deserialize(x) {
+    if (isPrimitive(x)) return deserializePrimitive(x);
+
+    assert(x is List);
+    switch (x.first) {
+      case "ref": return deserializeRef(x);
+      case "typed": return deserializeTyped(x);
+      case "fixed": return deserializeFixed(x);
+      case "extendable": return deserializeExtendable(x);
+      case "mutable": return deserializeMutable(x);
+      case "const": return deserializeConst(x);
+      case "map": return deserializeMap(x);
+      case "sendport": return deserializeSendPort(x);
+      case "raw sendport": return deserializeRawSendPort(x);
+      case "js-object": return deserializeJSObject(x);
+      case "function": return deserializeClosure(x);
+      case "dart": return deserializeDartObject(x);
+      default: throw "couldn't deserialize: $x";
+    }
+  }
+
+  bool isPrimitive(x) => x == null || x is String || x is num || x is bool;
+  deserializePrimitive(x) => x;
+
+  // ['ref', id].
+  deserializeRef(x) {
+    assert(x[0] == 'ref');
+    int serializationId = x[1];
+    return deserializedObjects[serializationId];
+  }
+
+  // ['typed', <typed array>].
+  TypedData deserializeTyped(x) {
+    assert(x[0] == 'typed');
+    TypedData result = x[1];
+    deserializedObjects.add(result);
+    return result;
+  }
+
+  // Updates the given array in place with its deserialized content.
+  List deserializeArrayInPlace(JSArray x) {
+    for (int i = 0; i < x.length; i++) {
+      x[i] = deserialize(x[i]);
+    }
+    return x;
+  }
+
+  // ['fixed', <array>].
+  List deserializeFixed(x) {
+    assert(x[0] == 'fixed');
+    List result = x[1];
+    deserializedObjects.add(result);
+    return new JSArray.markFixed(deserializeArrayInPlace(result));
+  }
+
+  // ['extendable', <array>].
+  List deserializeExtendable(x) {
+    assert(x[0] == 'extendable');
+    List result = x[1];
+    deserializedObjects.add(result);
+    return new JSArray.markGrowable(deserializeArrayInPlace(result));
+  }
+
+  // ['mutable', <array>].
+  List deserializeMutable(x) {
+    assert(x[0] == 'mutable');
+    List result = x[1];
+    deserializedObjects.add(result);
+    return deserializeArrayInPlace(result);
+  }
+
+  // ['const', <array>].
+  List deserializeConst(x) {
+    assert(x[0] == 'const');
+    List result = x[1];
+    deserializedObjects.add(result);
+    // TODO(floitsch): need to mark list as non-changeable.
+    return new JSArray.markFixed(deserializeArrayInPlace(result));
+  }
+
+  // ['map', <key-list>, <value-list>].
+  Map deserializeMap(x) {
+    assert(x[0] == 'map');
+    List keys = x[1];
+    List values = x[2];
+    Map result = {};
+    deserializedObjects.add(result);
+    // We need to keep the order of how objects were serialized.
+    // First deserialize all keys, and then only deserialize the values.
+    keys = keys.map(deserialize).toList();
+
+    for (int i = 0; i < keys.length; i++) {
+      result[keys[i]] = deserialize(values[i]);
+    }
+    return result;
+  }
+
+  // ['sendport', <managerId>, <isolateId>, <receivePortId>].
+  SendPort deserializeSendPort(x) {
+    assert(x[0] == 'sendport');
+    int managerId = x[1];
+    int isolateId = x[2];
+    int receivePortId = x[3];
+    SendPort result;
+    // If two isolates are in the same manager, we use NativeJsSendPorts to
+    // deliver messages directly without using postMessage.
+    if (managerId == _globalState.currentManagerId) {
+      var isolate = _globalState.isolates[isolateId];
+      if (isolate == null) return null; // Isolate has been closed.
+      var receivePort = isolate.lookup(receivePortId);
+      if (receivePort == null) return null; // Port has been closed.
+      result = new _NativeJsSendPort(receivePort, isolateId);
+    } else {
+      result = new _WorkerSendPort(managerId, isolateId, receivePortId);
+    }
+    deserializedObjects.add(result);
+    return result;
+  }
+
+  // ['raw sendport', <sendport>].
+  SendPort deserializeRawSendPort(x) {
+    assert(x[0] == 'raw sendport');
+    SendPort result = x[1];
+    deserializedObjects.add(result);
+    return result;
+  }
+
+  // ['js-object', <key-list>, <value-list>].
+  deserializeJSObject(x) {
+    assert(x[0] == 'js-object');
+    List keys = x[1];
+    List values = x[2];
+    var o = JS('', '{}');
+    deserializedObjects.add(o);
+    for (int i = 0; i < keys.length; i++) {
+      JS('', '#[#]=#', o, keys[i], deserialize(values[i]));
+    }
+    return o;
+  }
+
+  // ['function', <name>].
+  Function deserializeClosure(x) {
+    assert(x[0] == 'function');
+    String name = x[1];
+    Function result = IsolateNatives._getJSFunctionFromName(name);
+    deserializedObjects.add(result);
+    return result;
+  }
+
+  // ['dart', <class-id>, <field-list>].
+  deserializeDartObject(x) {
+    assert(x[0] == 'dart');
+    String classId = x[1];
+    List fields = x[2];
+    var instanceFromClassId = JS_EMBEDDED_GLOBAL('', INSTANCE_FROM_CLASS_ID);
+    var initializeObject = JS_EMBEDDED_GLOBAL('', INITIALIZE_EMPTY_INSTANCE);
+
+    var emptyInstance = JS('', '#(#)', instanceFromClassId, classId);
+    deserializedObjects.add(emptyInstance);
+    deserializeArrayInPlace(fields);
+    return JS('', '#(#, #, #)',
+              initializeObject, classId, emptyInstance, fields);
+  }
+}