Don't share same name for js proxies cache.

sdk/lib/js/dart2js/js_dart2js.dart

 // Copyright (c) 2013, 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.
 
 /**
  * Support for interoperating with JavaScript.
- * 
+ *
  * This library provides access to JavaScript objects from Dart, allowing
  * Dart code to get and set properties, and call methods of JavaScript objects
  * and invoke JavaScript functions. The library takes care of converting
  * between Dart and JavaScript objects where possible, or providing proxies if
  * conversion isn't possible.
  *
  * This library does not yet make Dart objects usable from JavaScript, their
  * methods and proeprties are not accessible, though it does allow Dart
  * functions to be passed into and called from JavaScript.
  *
  * [JsObject] is the core type and represents a proxy of a JavaScript object.
  * JsObject gives access to the underlying JavaScript objects properties and
  * methods. `JsObject`s can be acquired by calls to JavaScript, or they can be
  * created from proxies to JavaScript constructors.
  *
  * The top-level getter [context] provides a [JsObject] that represents the
  * global object in JavaScript, usually `window`.
  *
  * The following example shows an alert dialog via a JavaScript call to the
  * global function `alert()`:
  *
  *     import 'dart:js';
- *     
+ *
  *     main() => context.callMethod('alert', ['Hello from Dart!']);
  *
  * This example shows how to create a [JsObject] from a JavaScript constructor
  * and access its properties:
  *
  *     import 'dart:js';
- *     
+ *
  *     main() {
  *       var object = new JsObject(context['Object']);
  *       object['greeting'] = 'Hello';
  *       object['greet'] = (name) => "${object['greeting']} $name";
  *       var message = object.callMethod('greet', ['JavaScript']);
  *       context['console'].callMethod('log', [message]);
  *     }
  *
  * ## Proxying and automatic conversion
- * 
+ *
  * When setting properties on a JsObject or passing arguments to a Javascript
  * method or function, Dart objects are automatically converted or proxied to
  * JavaScript objects. When accessing JavaScript properties, or when a Dart
  * closure is invoked from JavaScript, the JavaScript objects are also
  * converted to Dart.
  *
  * Functions and closures are proxied in such a way that they are callable. A
  * Dart closure assigned to a JavaScript property is proxied by a function in
  * JavaScript. A JavaScript function accessed from Dart is proxied by a
  * [JsFunction], which has a [apply] method to invoke it.
@@ skipping 15 matching lines @@
  * ## Converting collections with JsObject.jsify()
  *
  * To create a JavaScript collection from a Dart collection use the
  * [JsObject.jsify] constructor, which converts Dart [Map]s and [Iterable]s
  * into JavaScript Objects and Arrays.
  *
  * The following expression creats a new JavaScript object with the properties
  * `a` and `b` defined:
  *
  *     var jsMap = new JsObject.jsify({'a': 1, 'b': 2});
- * 
+ *
  * This expression creates a JavaScript array:
  *
  *     var jsArray = new JsObject.jsify([1, 2, 3]);
  */
 library dart.js;
 
 import 'dart:html' show Blob, Event, ImageData, Node, Window;
 import 'dart:collection' show HashMap, ListMixin;
 import 'dart:indexed_db' show KeyRange;
 import 'dart:typed_data' show TypedData;
@@ skipping 64 matching lines @@
     return _wrapToDart(jsObj);
   }
 
   /**
    * Constructs a [JsObject] that proxies a native Dart object; _for expert use
    * only_.
    *
    * Use this constructor only if you wish to get access to JavaScript
    * properties attached to a browser host object, such as a Node or Blob, that
    * is normally automatically converted into a native Dart object.
-   * 
+   *
    * An exception will be thrown if [object] either is `null` or has the type
    * `bool`, `num`, or `String`.
    */
   factory JsObject.fromBrowserObject(object) {
     if (object is num || object is String || object is bool || object == null) {
       throw new ArgumentError(
         "object cannot be a num, string, bool, or null");
     }
     return _wrapToDart(_convertToJS(object));
   }
@@ skipping 46 matching lines @@
    * object.
    *
    * The type of [property] must be either [String] or [num].
    */
   dynamic operator[](property) {
     if (property is! String && property is! num) {
       throw new ArgumentError("property is not a String or num");
     }
     return _convertToDart(JS('', '#[#]', _jsObject, property));
   }
-  
+
   /**
    * Sets the value associated with [property] on the proxied JavaScript
    * object.
    *
    * The type of [property] must be either [String] or [num].
    */
   operator[]=(property, value) {
     if (property is! String && property is! num) {
       throw new ArgumentError("property is not a String or num");
     }
@@ skipping 157 matching lines @@
   void set length(int length) { super['length'] = length; }
 
 
   // Methods overriden for better performance
 
   void add(E value) {
     callMethod('push', [value]);
   }
 
   void addAll(Iterable<E> iterable) {
-    var list = (JS('bool', '# instanceof Array', iterable)) 
+    var list = (JS('bool', '# instanceof Array', iterable))
         ? iterable
         : new List.from(iterable);
     callMethod('push', list);
   }
 
   void insert(int index, E element) {
     _checkInsertIndex(index);
     callMethod('splice', [index, 0, element]);
   }
 
@@ skipping 19 matching lines @@
     if (skipCount < 0) throw new ArgumentError(skipCount);
     var args = [start, length]..addAll(iterable.skip(skipCount).take(length));
     callMethod('splice', args);
   }
 
   void sort([int compare(E a, E b)]) {
     callMethod('sort', [compare]);
   }
 }
 
+// When multiple Dart programs are run in the same page we must make sure that
+// they don't share their Dart wrappers. We use a global (shared) counter in
+// the Object class to assign a unique id to every Dart program.
+int _getAndUpdateDisambiguationId() {
+  const DISAMBIGUATION_PROPERTY_NAME = "__DART_INTEROP_COUNTER_";
+  int counter = JS("int", 'Object[#]||0', DISAMBIGUATION_PROPERTY_NAME);
+  JS("", 'Object[#]=#', DISAMBIGUATION_PROPERTY_NAME, counter + 1);
+  return counter;
+}
+
+final int _disambiguationId = _getAndUpdateDisambiguationId();
+
+// Converts the given string to a v8 internal symbol which is faster.
+String _intern(String str) {
+  return JS("String", "convertToJSSymbol(#)", str);
+}
+
 // property added to a Dart object referencing its JS-side DartObject proxy
-const _DART_OBJECT_PROPERTY_NAME = r'_$dart_dartObject';
-const _DART_CLOSURE_PROPERTY_NAME = r'_$dart_dartClosure';
+final String _DART_OBJECT_PROPERTY_NAME =
+    _intern("_\$dart_dartObject$_disambiguationId");
+final String _DART_CLOSURE_PROPERTY_NAME =
+    _intern("_\$dart_dartObject$_disambiguationId");
 
 // property added to a JS object referencing its Dart-side JsObject proxy
 const _JS_OBJECT_PROPERTY_NAME = r'_$dart_jsObject';
 const _JS_FUNCTION_PROPERTY_NAME = r'$dart_jsFunction';
 
 bool _defineProperty(o, String name, value) {
   if (JS('bool', 'Object.isExtensible(#)', o)) {
     try {
       JS('void', 'Object.defineProperty(#, #, { value: #})', o, name, value);
       return true;
@@ skipping 91 matching lines @@
   // Dart in that context. The JS object will have a cached proxy
   // but it won't be a valid Dart object in this context.
   // For now we throw away the cached proxy, but we should be able
   // to cache proxies from multiple JS contexts and Dart isolates.
   if (dartProxy == null || !_isLocalObject(o)) {
     dartProxy = createProxy(o);
     _defineProperty(o, propertyName, dartProxy);
   }
   return dartProxy;
 }