Serialize Elements through PortSync

lib/html/src/Isolates.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.
 
 _serialize(var message) {
   return new _JsSerializer().traverse(message);
 }
 
 class JsProxy {
   SendPortSync _port;
   final _id;
 
   JsProxy._internal(this._port, this._id);
 
   noSuchMethod(method, args) {
     var result = _port.callSync([_id, method, args]);
     switch (result[0]) {
       case 'return': return result[1];
       case 'exception': throw result[1];
       case 'none': throw new NoSuchMethodException(this, method, args);
       default: throw 'Invalid return value';
     }
   }
 }
 
+int _localNextElementId = 0;
+
+const _DART_ID = 'data-dart_id';
+
+var _elementId(Element e) {
+  if (e.attributes.containsKey(_DART_ID)) return e.attributes[_DART_ID];
+  var id = '$_isolateId-${_localNextElementId++}';
+  e.attributes[_DART_ID] = id;
+  return id;
+}
+
+Element _getElement(var id) {
+  var list = queryAll('[$_DART_ID="$id"]');
+  if (list.length > 1) throw 'Non unique ID: $id';
+  if (list.length == 0) {
+    throw 'Only elements attached to document can be serialized: $id';
+  }
+  return list[0];
+}
+
 class _JsSerializer extends _Serializer {
 
   visitSendPortSync(SendPortSync x) {
     if (x is _JsSendPortSync) return visitJsSendPortSync(x);
     if (x is _LocalSendPortSync) return visitLocalSendPortSync(x);
     if (x is _RemoteSendPortSync) return visitRemoteSendPortSync(x);
     throw "Unknown port type $x";
   }
 
   visitJsSendPortSync(_JsSendPortSync x) {
     return [ 'sendport', 'nativejs', x._id ];
   }
 
   visitLocalSendPortSync(_LocalSendPortSync x) {
     return [ 'sendport', 'dart',
              ReceivePortSync._isolateId, x._receivePort._portId ];
   }
 
   visitRemoteSendPortSync(_RemoteSendPortSync x) {
     return [ 'sendport', 'dart',
              x._receivePort._isolateId, x._receivePort._portId ];
   }
 
   visitObject(Object x) {
     if (x is Function) return visitFunction(x);
     if (x is JsProxy) return visitJsProxy(x);
+    if (x is Element) return visitElement(x);
 
     // TODO: Handle DOM elements and proxy other objects.
     var proxyId = _dartProxyRegistry._add(x);
     return [ 'objref', proxyId,
              visitSendPortSync(_dartProxyRegistry._sendPort) ];
  }
 
   visitFunction(Function func) {
     return [ 'funcref',
              _functionRegistry._add(func),
              visitSendPortSync(_functionRegistry._sendPort), null ];
   }
 
   visitJsProxy(JsProxy proxy) {
     return [ 'objref', proxy._id, visitSendPortSync(proxy._port) ];
   }
+
+  visitElement(Element element) {
+    var id = _elementId(element);
+    // Verify that the element is connected to the document.
+    // Otherwise, we will not be able to find it on the other side.
+    _getElement(id);
+    return [ 'element', id ];
+  }
 }
 
 // Leaking implementation.  Later will be backend specific and hopefully
 // not leaking (at least in most of the cases.)
 // TODO: provide better, backend specific implementation.
 class _Registry<T> {
   final String _name;
   int _nextId;
   final Map<String, T> _registry;
   final ReceivePortSync _port;
@@ skipping 84 matching lines @@
       default:
         throw 'Illegal SendPortSync type: $tag';
     }
   }
 
   deserializeObject(List x) {
     String tag = x[0];
     switch (tag) {
       case 'funcref': return deserializeFunction(x);
       case 'objref': return deserializeProxy(x);
+      case 'element': return deserializeElement(x);
       default: throw 'Illegal object type: $x';
     }
   }
 
   deserializeFunction(List x) {
     var id = x[1];
     SendPortSync port = deserializeSendPort(x[2]);
     // TODO: Support varargs when there is support in the language.
     return ([arg0 = _UNSPECIFIED, arg1 = _UNSPECIFIED,
               arg2 = _UNSPECIFIED, arg3 = _UNSPECIFIED]) {
       var args = [arg0, arg1, arg2, arg3];
       var last = args.indexOf(_UNSPECIFIED);
       if (last >= 0) args = args.getRange(0, last);
       var message = [id, args];
       return port.callSync(message);
     };
   }
 
   deserializeProxy(x) {
     var id = x[1];
     var port = deserializeSendPort(x[2]);
     if (port is _JsSendPortSync) return new JsProxy._internal(port, id);
     if (port is _LocalSendPortSync) return _dartProxyRegistry._get(id);
     // TODO(vsm): Support this case.
     if (port is _RemoteSendPortSync) throw 'Remote Dart proxies unsupported';
     throw 'Illegal proxy: $port';
   }
+
+  deserializeElement(x) {
+    var id = x[1];
+    return _getElement(id);
+  }
 }
 
 // The receiver is JS.
 class _JsSendPortSync implements SendPortSync {
 
   num _id;
   _JsSendPortSync(this._id);
 
   callSync(var message) {
     var serialized = _serialize(message);
@@ skipping 117 matching lines @@
 
   static SendPortSync _lookup(int isolateId, int portId) {
     if (isolateId == _isolateId) {
       return _portMap[portId].toSendPort();
     } else {
       return new _RemoteSendPortSync(isolateId, portId);
     }
   }
 }
 
+get _isolateId => ReceivePortSync._isolateId;
+
 void _dispatchEvent(String receiver, var message) {
   var event = document.$dom_createEvent('TextEvent');
   event.initTextEvent(receiver, false, false, window, JSON.stringify(message));
   window.$dom_dispatchEvent(event);
 }