Name-based approach to cross frame support.

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.dart

 // Copyright (c) 2015, 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.
 
 /// This library defines the operations that define and manipulate Dart
 /// classes.  Included in this are:
 ///   - Generics
 ///   - Class metadata
 ///   - Extension methods
 ///
@@ skipping 373 matching lines @@
   return $name in sigObj;
 })()''');
 
 bool hasMethod(type, name) => _hasSigEntry(type, _methodSig, name);
 bool hasGetter(type, name) => _hasSigEntry(type, _getterSig, name);
 bool hasSetter(type, name) => _hasSigEntry(type, _setterSig, name);
 bool hasField(type, name) => _hasSigEntry(type, _fieldSig, name);
 
 final _extensionType = JS('', 'Symbol("extensionType")');
 
-getExtensionType(obj) => JS('', '#[#]', obj, _extensionType);
+getExtensionType(obj) {
+  var result = JS('', '#[#]', obj, _extensionType);
+  if (result != null) return result;
+
+  if (JS('bool', 'typeof # != "object" || # instanceof #.Object', obj, obj,
+      global_)) {
+    return null;
+  }
+
+  // This is an object from another frame.  Check to see if we have registered
+  // an extension in case this is a DOM/native type.
+  var jsType = JS('', '#.constructor', obj);
+  var tag = JS('', '#.name', jsType);
+  if (JS('bool', '#.has(#)', _extMap, tag)) {
+    var jsProto = JS('', '#.__proto__', obj);
+    var dartType = JS('', '#.get(#)', _extMap, tag);
+    _installExtension(jsType, jsProto, dartType);
+    return dartType;
+  }
+
+  return null;
+}
 
 final dartx = JS('', 'dartx');
 
 getExtensionSymbol(name) {
   var sym = JS('', 'dartx[#]', name);
   if (sym == null) {
     sym = JS('', 'Symbol("dartx." + #.toString())', name);
     JS('', 'dartx[#] = #', name, sym);
   }
   return sym;
@@ skipping 25 matching lines @@
   // symbol name.
   var coreObjProto = JS('', '#.prototype', Object);
   var names = getOwnPropertyNames(coreObjProto);
   for (int i = 0; i < JS('int', '#.length', names); ++i) {
     var name = JS('', '#[#]', names, i);
     var desc = getOwnPropertyDescriptor(coreObjProto, name);
     defineProperty(jsProto, getExtensionSymbol(name), desc);
   }
 }
 
+var _extMap;
+
+_cacheExtension(jsProto, dartType) {
+  if (_extMap == null) _extMap = JS('', 'new Map()');
+  // TODO(vsm): Make this work on non-Chrome browsers.
+  var tag = JS('', '#.constructor.name', jsProto);
+  JS('', '#.set(#, #)', _extMap, tag, dartType);
+}
+
 /// Copy symbols from the prototype of the source to destination.
 /// These are the only properties safe to copy onto an existing public
 /// JavaScript class.
 registerExtension(jsType, dartExtType) => JS(
     '',
     '''(() => {
   // TODO(vsm): Not all registered js types are real.
   if (!jsType) return;
 
   let jsProto = $jsType.prototype;
 
   // TODO(vsm): This sometimes doesn't exist on FF.  These types will be
   // broken.
   if (!jsProto) return;
 
-  $_installProperties(jsProto, $dartExtType, jsProto[$_extensionType]);
+  $_cacheExtension(jsProto, $dartExtType);
 
   // Mark the JS type's instances so we can easily check for extensions.
-  jsProto[$_extensionType] = $dartExtType;
+  $_installExtension(jsType, jsProto, dartExtType);
+})()''');
 
+_installExtension(jsType, jsProto, dartType) => JS(
+    '',
+    '''(() => {
+  $_installProperties(jsProto, $dartType, jsProto[$_extensionType]);
+
+  // Mark the JS type's instances so we can easily check for extensions.
+  jsProto[$_extensionType] = $dartType;
   function updateSig(sigF) {
-    let originalDesc = $getOwnPropertyDescriptor($dartExtType, sigF);
+    let originalDesc = $getOwnPropertyDescriptor($dartType, sigF);
     if (originalDesc === void 0) return;
     let originalSigFn = originalDesc.get;
     $assert_(originalSigFn);
     $defineMemoizedGetter($jsType, sigF, originalSigFn);
   }
   updateSig($_methodSig);
   updateSig($_fieldSig);
   updateSig($_getterSig);
   updateSig($_setterSig);
-})()''');
+ })()''');
 
 ///
 /// Mark a concrete type as implementing extension methods.
 /// For example: `class MyIter implements Iterable`.
 ///
 /// This takes a list of names, which are the extension methods implemented.
 /// It will add a forwarder, so the extension method name redirects to the
 /// normal Dart method name. For example:
 ///
 ///     defineExtensionMembers(MyType, ['add', 'remove']);
@@ skipping 70 matching lines @@
 
 defineEnumValues(enumClass, names) {
   var values = [];
   for (var i = 0; i < JS('int', '#.length', names); i++) {
     var value = const_(JS('', 'new #.new(#)', enumClass, i));
     JS('', '#.push(#)', values, value);
     defineValue(enumClass, JS('', '#[#]', names, i), value);
   }
   JS('', '#.values = #', enumClass, constList(values, enumClass));
 }