Cache function proxies

client/dart.js

 // 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.
 
 // Bootstrap support for Dart scripts on the page as this script.
 if (navigator.webkitStartDart) {
   if (!navigator.webkitStartDart()) {
     document.body.innerHTML = 'This build has expired.  Please download a new Dartium at http://www.dartlang.org/dartium/index.html';
   }
 } else {
@@ skipping 68 matching lines @@
           for (var i = 0; i < message.length; i++) {
             values[i] = doSerialize(message[i]);
           }
           return [ 'list', id, values ];
         });
       } else if (message instanceof LocalSendPortSync) {
         return [ 'sendport', 'nativejs', message.receivePort.id ];
       } else if (message instanceof DartSendPortSync) {
         return [ 'sendport', 'dart', message.isolateId, message.portId ];
       } else if (message instanceof Function) {
-        return [ 'funcref', functionRefTable.makeRef(message),
-                 doSerialize(functionRefTable.sendPort) ];
+        // In case we are reserializing a previously serialized
+        // function, use a cached value.
+        if (message._dart_serialized) return message._dart_serialized;
+        message._dart_serialized = [ 'funcref',
+                                     functionRefTable.makeRef(message),
+                                     doSerialize(functionRefTable.sendPort) ];
+        return message._dart_serialized;
       } else if (message instanceof HTMLElement) {
         var id = elementId(message);
         // 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 ];
       } else if (message instanceof DartProxy) {
         return [ 'objref', message._id, doSerialize(message._port) ];
       } else if (message.__proto__ != {}.__proto__) {
         // TODO(vsm): Is the above portable and what we want?
@@ skipping 72 matching lines @@
       result[i] = deserializeHelper(values[i]);
     }
     return result;
   }
 
   function deserializeFunction(message) {
     var ref = message[1];
     var sendPort = deserializeSendPort(message[2]);
     // Number of arguments is not used as of now
     // we cannot find it out for Dart function in pure Dart.
-    return _makeFunctionFromRef(ref, sendPort);
+    var result = _makeFunctionFromRef(ref, sendPort);
+    // Cache the serialized form in case we resend this.
+    result._dart_serialized = message;
+    return result;
   }
 
   function deserializeProxy(message) {
     var id = message[1];
     var port = deserializeSendPort(message[2]);
     if (port instanceof LocalSendPortSync) {
       return jsRefTable.map[id];
     } else if (port instanceof DartSendPortSync) {
       return new DartProxy(port, id);
     }
@@ skipping 123 matching lines @@
 
   RefTable.prototype.get = function (ref) {
     return this.map[ref];
   }
 
   function FunctionRefTable() {}
 
   FunctionRefTable.prototype = new RefTable('func-ref');
 
   FunctionRefTable.prototype.initialize = function () {
-    map = this.map;
+    var map = this.map;
     this.port.receive(function (message) {
       var id = message[0];
       var args = message[1];
       var f = map[id];
       // TODO(vsm): Should we capture this automatically?
       return f.apply(null, args);
     });
   }
 
   var functionRefTable = new FunctionRefTable();
 
   function JSRefTable() {}
 
   JSRefTable.prototype = new RefTable('js-ref');
 
   JSRefTable.prototype.initialize = function () {
-    map = this.map;
+    var map = this.map;
     this.port.receive(function (message) {
       // TODO(vsm): Support a mechanism to register a handler here.
       var receiver = map[message[0]];
       var method = message[1];
       var args = message[2];
       if (method.indexOf("get:") == 0) {
         // Getter.
         var field = method.substring(4);
         if (field in receiver && args.length == 0) {
           return [ 'return', receiver[field] ];
@@ skipping 22 matching lines @@
   var jsRefTable = new JSRefTable();
 
   function DartProxy(port, id) {
     this._port = port;
     this._id = id;
   }
 
   // Leaking implementation.
   // TODO(vsm): provide proper, backend-specific implementation.
   function _makeFunctionFromRef(ref, sendPort) {
+    // If the sendPort is local, just return the underlying function.
+    // Otherwise, create a new function that forwards to the remote
+    // port.
+    if (sendPort instanceof LocalSendPortSync) {
+      return functionRefTable.map[ref];
+    }
     return function() {
       return sendPort.callSync([ref, Array.prototype.slice.call(arguments)]);
-    }
+    };
   }
 
   var localNextElementId = 0;
   var _DART_ID = 'data-dart_id';
-  
+
   function elementId(e) {
     if (e.hasAttribute(_DART_ID)) return e.getAttribute(_DART_ID);
     var id = (localNextElementId++).toString();
     e.setAttribute(_DART_ID, id);
     return id;
   }
 
   function getElement(id) {
     var list = document.querySelectorAll('[' + _DART_ID + '="' + id + '"]');
 
     if (list.length > 1) throw 'Non unique ID: ' + id;
     if (list.length == 0) {
       throw 'Element must be attached to the document: ' + id;
     }
-    return list[0];    
+    return list[0];
   }
 })();