Start using the dart2js type conversions in Dartium as well.

sdk/lib/html/html_common/conversions.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.
 
 
 // Conversions for IDBKey.
 //
 // Per http://www.w3.org/TR/IndexedDB/#key-construct
 //
 // "A value is said to be a valid key if it is one of the following types: Array
@@ skipping 10 matching lines @@
 // JavaScript arrays, and any Dates are JavaScript Dates.
 
 // Conversions for Window.  These check if the window is the local
 // window, and if it's not, wraps or unwraps it with a secure wrapper.
 // We need to test for EventTarget here as well as it's a base type.
 // We omit an unwrapper for Window as no methods take a non-local
 // window as a parameter.
 
 part of html_common;
 
-
-/// Converts a JavaScript object with properties into a Dart Map.
-/// Not suitable for nested objects.
-Map convertNativeToDart_Dictionary(object) {
-  if (object == null) return null;
-  var dict = {};
-  var keys = JS('JSExtendableArray', 'Object.getOwnPropertyNames(#)', object);
-  for (final key in keys) {
-    dict[key] = JS('var', '#[#]', object, key);
-  }
-  return dict;
-}
-
-/// Converts a flat Dart map into a JavaScript object with properties.
-convertDartToNative_Dictionary(Map dict) {
-  if (dict == null) return null;
-  var object = JS('var', '{}');
-  dict.forEach((String key, value) {
-      JS('void', '#[#] = #', object, key, value);
-    });
-  return object;
-}
-
-
-/**
- * Ensures that the input is a JavaScript Array.
- *
- * Creates a new JavaScript array if necessary, otherwise returns the original.
- */
-List convertDartToNative_StringArray(List<String> input) {
-  // TODO(sra).  Implement this.
-  return input;
-}
-
-DateTime convertNativeToDart_DateTime(date) {
-  var millisSinceEpoch = JS('int', '#.getTime()', date);
-  return new DateTime.fromMillisecondsSinceEpoch(millisSinceEpoch, isUtc: true);
-}
-
-convertDartToNative_DateTime(DateTime date) {
-  return JS('', 'new Date(#)', date.millisecondsSinceEpoch);
-}
-
-
-// -----------------------------------------------------------------------------
-
 /// Converts a Dart value into a JavaScript SerializedScriptValue.
 convertDartToNative_SerializedScriptValue(value) {
-  return _convertDartToNative_PrepareForStructuredClone(value);
+  return convertDartToNative_PrepareForStructuredClone(value);
 }
 
 /// Since the source object may be viewed via a JavaScript event listener the
 /// original may not be modified.
 convertNativeToDart_SerializedScriptValue(object) {
   return convertNativeToDart_AcceptStructuredClone(object, mustCopy: true);
 }
 
 
 /**
  * Converts a Dart value into a JavaScript SerializedScriptValue.  Returns the
  * original input or a functional 'copy'.  Does not mutate the original.
  *
  * The main transformation is the translation of Dart Maps are converted to
  * JavaScript Objects.
  *
  * The algorithm is essentially a dry-run of the structured clone algorithm
  * described at
  * http://www.whatwg.org/specs/web-apps/current-work/multipage/common-dom-interfaces.html#structured-clone
  * https://www.khronos.org/registry/typedarray/specs/latest/#9
  *
  * Since the result of this function is expected to be passed only to JavaScript
  * operations that perform the structured clone algorithm which does not mutate
  * its output, the result may share structure with the input [value].
  */
-_convertDartToNative_PrepareForStructuredClone(value) {
+abstract class _StructuredClone {
 
   // TODO(sra): Replace slots with identity hash table.
   var values = [];
   var copies = [];  // initially 'null', 'true' during initial DFS, then a copy.
 
   int findSlot(value) {
     int length = values.length;
     for (int i = 0; i < length; i++) {
       if (identical(values[i], value)) return i;
     }
     values.add(value);
     copies.add(null);
     return length;
   }
   readSlot(int i) => copies[i];
   writeSlot(int i, x) { copies[i] = x; }
   cleanupSlots() {}  // Will be needed if we mark objects with a property.
+  bool cloneNotRequired(object);
+  newJsMap();
+  newJsList(length);
+  void putIntoMap(map, key, value);
 
   // Returns the input, or a clone of the input.
   walk(e) {
     if (e == null) return e;
     if (e is bool) return e;
     if (e is num) return e;
     if (e is String) return e;
     if (e is DateTime) {
       return convertDartToNative_DateTime(e);
     }
     if (e is RegExp) {
       // TODO(sra).
       throw new UnimplementedError('structured clone of RegExp');
     }
 
     // The browser's internal structured cloning algorithm will copy certain
     // types of object, but it will copy only its own implementations and not
     // just any Dart implementations of the interface.
 
     // TODO(sra): The JavaScript objects suitable for direct cloning by the
     // structured clone algorithm could be tagged with an private interface.
 
     if (e is File) return e;
     if (e is Blob) return e;
     if (e is FileList) return e;
 
     // TODO(sra): Firefox: How to convert _TypedImageData on the other end?
     if (e is ImageData) return e;
-    if (e is NativeByteBuffer) return e;
-
-    if (e is NativeTypedData) return e;
+    if (cloneNotRequired(e)) return e;
 
     if (e is Map) {
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) return copy;
-      copy = JS('var', '{}');
+      copy = newJsMap();
       writeSlot(slot, copy);
       e.forEach((key, value) {
-          JS('void', '#[#] = #', copy, key, walk(value));
-        });
+        putIntoMap(copy, key, walk(value));
+      });
       return copy;
     }
 
     if (e is List) {
-      // Since a JavaScript Array is an instance of Dart List it is possible to
-      // avoid making a copy of the list if there is no need to copy anything
-      // reachable from the array.  We defer creating a new array until a cycle
-      // is detected or a subgraph was copied.
-      int length = e.length;
+      // Since a JavaScript Array is an instance of Dart List it is tempting
+      // in dart2js to avoid making a copy of the list if there is no need
+      // to copy anything reachable from the array.  However, the list may have
+      // non-native properties or methods from interceptors and such, e.g.
+      // an immutability marker. So we  had to stop doing that.
       var slot = findSlot(e);
       var copy = readSlot(slot);
-      if (copy != null) {
-        if (true == copy) {  // Cycle, so commit to making a copy.
-          copy = JS('JSExtendableArray', 'new Array(#)', length);
-          writeSlot(slot, copy);
-        }
-        return copy;
-      }
-
-      int i = 0;
-
-      // Always clone the list, as it may have non-native properties or methods
-      // from interceptors and such.
-      copy = JS('JSExtendableArray', 'new Array(#)', length);
-      writeSlot(slot, copy);
-
-      for ( ; i < length; i++) {
-        copy[i] = walk(e[i]);
-      }
+      if (copy != null) return copy;
+      copy = copyList(e, slot);
       return copy;
     }
 
     throw new UnimplementedError('structured clone of other type');
   }
 
-  var copy = walk(value);
-  cleanupSlots();
-  return copy;
+  copyList(List e, int slot) {
+    int i = 0;
+    int length = e.length;
+    var copy = newJsList(length);
+    writeSlot(slot, copy);
+    for ( ; i < length; i++) {
+      copy[i] = walk(e[i]);
+    }
+    return copy;
+  }
+
+  convertDartToNative_PrepareForStructuredClone(value) {
+    var copy = walk(value);
+    cleanupSlots();
+    return copy;
+  }
 }
 
 /**
  * Converts a native value into a Dart object.
  *
  * If [mustCopy] is [:false:], may return the original input.  May mutate the
  * original input (but will be idempotent if mutation occurs).  It is assumed
  * that this conversion happens on native serializable script values such values
  * from native DOM calls.
  *
  * [object] is the result of a structured clone operation.
  *
  * If necessary, JavaScript Dates are converted into Dart Dates.
  *
  * If [mustCopy] is [:true:], the entire object is copied and the original input
  * is not mutated.  This should be the case where Dart and JavaScript code can
  * access the value, for example, via multiple event listeners for
  * MessageEvents.  Mutating the object to make it more 'Dart-like' would corrupt
  * the value as seen from the JavaScript listeners.
  */
-convertNativeToDart_AcceptStructuredClone(object, {mustCopy: false}) {
+abstract class _AcceptStructuredClone {
 
-  // TODO(sra): Replace slots with identity hash table that works on non-dart
-  // objects.
+  // TODO(sra): Replace slots with identity hash table.
   var values = [];
-  var copies = [];
+  var copies = [];  // initially 'null', 'true' during initial DFS, then a copy.
+  bool mustCopy = false;
 
   int findSlot(value) {
     int length = values.length;
     for (int i = 0; i < length; i++) {
-      if (identical(values[i], value)) return i;
+      if (identicalInJs(values[i], value)) return i;
     }
     values.add(value);
     copies.add(null);
     return length;
   }
+
+  /// Are the two objects identical, but taking into account that two JsObject
+  /// wrappers may not be identical, but their underlying Js Object might be.
+  bool identicalInJs(a, b);
   readSlot(int i) => copies[i];
   writeSlot(int i, x) { copies[i] = x; }
 
+  /// Iterate over the JS properties.
+  forEachJsField(object, action);
+
+  /// Create a new Dart list of the given length. May create a native List or
+  /// a JsArray, depending if we're in Dartium or dart2js.
+  newDartList(length);
+
   walk(e) {
     if (e == null) return e;
     if (e is bool) return e;
     if (e is num) return e;
     if (e is String) return e;
 
     if (isJavaScriptDate(e)) {
       return convertNativeToDart_DateTime(e);
     }
 
     if (isJavaScriptRegExp(e)) {
       // TODO(sra).
       throw new UnimplementedError('structured clone of RegExp');
     }
 
+    if (isJavaScriptPromise(e)) {
+      return convertNativePromiseToDartFuture(e);
+    }
+
     if (isJavaScriptSimpleObject(e)) {
       // TODO(sra): If mustCopy is false, swizzle the prototype for one of a Map
       // implementation that uses the properies as storage.
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) return copy;
       copy = {};
 
       writeSlot(slot, copy);
-      for (final key in JS('JSExtendableArray', 'Object.keys(#)', e)) {
-        copy[key] = walk(JS('var', '#[#]', e, key));
-      }
+      forEachJsField(e, (key, value) => copy[key] = walk(value));
       return copy;
     }
 
     if (isJavaScriptArray(e)) {
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) return copy;
 
       int length = e.length;
       // Since a JavaScript Array is an instance of Dart List, we can modify it
       // in-place unless we must copy.
-      copy = mustCopy ? JS('JSExtendableArray', 'new Array(#)', length) : e;
+      copy = mustCopy ? newDartList(length) : e;
       writeSlot(slot, copy);
 
       for (int i = 0; i < length; i++) {
         copy[i] = walk(e[i]);
       }
       return copy;
     }
 
     // Assume anything else is already a valid Dart object, either by having
     // already been processed, or e.g. a clonable native class.
     return e;
   }
 
-  var copy = walk(object);
-  return copy;
+  convertNativeToDart_AcceptStructuredClone(object, {mustCopy: false}) {
+    this.mustCopy = mustCopy;
+    var copy = walk(object);
+    return copy;
+  }
 }
 
 // Conversions for ContextAttributes.
 //
 // On Firefox, the returned ContextAttributes is a plain object.
 class _TypedContextAttributes implements gl.ContextAttributes {
   bool alpha;
   bool antialias;
   bool depth;
   bool premultipliedAlpha;
@@ skipping 76 matching lines @@
 // We can get rid of this conversion if _TypedImageData implements the fields
 // with native names.
 convertDartToNative_ImageData(ImageData imageData) {
   if (imageData is _TypedImageData) {
     return JS('', '{data: #, height: #, width: #}',
         imageData.data, imageData.height, imageData.width);
   }
   return imageData;
 }
 
-
-bool isJavaScriptDate(value) => JS('bool', '# instanceof Date', value);
-bool isJavaScriptRegExp(value) => JS('bool', '# instanceof RegExp', value);
-bool isJavaScriptArray(value) => JS('bool', '# instanceof Array', value);
-bool isJavaScriptSimpleObject(value) {
-  var proto = JS('', 'Object.getPrototypeOf(#)', value);
-  return JS('bool', '# === Object.prototype', proto) ||
-      JS('bool', '# === null', proto);
-}
-bool isImmutableJavaScriptArray(value) =>
-    JS('bool', r'!!(#.immutable$list)', value);
-
-
-
 const String _serializedScriptValue =
     'num|String|bool|'
     'JSExtendableArray|=Object|'
     'Blob|File|NativeByteBuffer|NativeTypedData'
     // TODO(sra): Add Date, RegExp.
     ;
 const annotation_Creates_SerializedScriptValue =
     const Creates(_serializedScriptValue);
 const annotation_Returns_SerializedScriptValue =
     const Returns(_serializedScriptValue);