Creating a common library for all DOM types.

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
 // JavaScript objects [ECMA-262], DOMString [WEBIDL], Date [ECMA-262] or float
 // [WEBIDL]. However Arrays are only valid keys if every item in the array is
 // defined and is a valid key (i.e. sparse arrays can not be valid keys) and if
 // the Array doesn't directly or indirectly contain itself. Any non-numeric
 // properties are ignored, and thus does not affect whether the Array is a valid
 // key. Additionally, if the value is of type float, it is only a valid key if
 // it is not NaN, and if the value is of type Date it is only a valid key if its
 // [[PrimitiveValue]] internal property, as defined by [ECMA-262], is not NaN."
 
 // What is required is to ensure that an Lists in the key are actually
 // 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;
-
-Window _convertNativeToDart_Window(win) {
-  return _DOMWindowCrossFrame._createSafe(win);
-}
-
-EventTarget _convertNativeToDart_EventTarget(e) {
-  // Assume it's a Window if it contains the setInterval property.  It may be
-  // from a different frame - without a patched prototype - so we cannot
-  // rely on Dart type checking.
-  if (JS('bool', r'"setInterval" in #', e))
-    return _DOMWindowCrossFrame._createSafe(e);
-  else
-    return e;
-}
-
-EventTarget _convertDartToNative_EventTarget(e) {
-  if (e is _DOMWindowCrossFrame) {
-    return e._window;
-  } else {
-    return e;
-  }
-}
-
-// Conversions for ImageData
-//
-// On Firefox, the returned ImageData is a plain object.
-
-class _TypedImageData implements ImageData {
-  final Uint8ClampedArray data;
-  final int height;
-  final int width;
-
-  _TypedImageData(this.data, this.height, this.width);
-}
-
-ImageData _convertNativeToDart_ImageData(nativeImageData) {
-
-  // None of the native getters that return ImageData have the type ImageData
-  // since that is incorrect for FireFox (which returns a plain Object).  So we
-  // need something that tells the compiler that the ImageData class has been
-  // instantiated.
-  // TODO(sra): Remove this when all the ImageData returning APIs have been
-  // annotated as returning the union ImageData + Object.
-  JS('ImageData', '0');
-
-  if (nativeImageData is ImageData) return nativeImageData;
-
-  // On Firefox the above test fails because imagedata is a plain object.
-  // So we create a _TypedImageData.
-
-  return new _TypedImageData(
-      JS('var', '#.data', nativeImageData),
-      JS('var', '#.height', nativeImageData),
-      JS('var', '#.width', nativeImageData));
-}
-
-// 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;
-}
+part of html_common;
 
 
 /// Converts a JavaScript object with properties into a Dart Map.
 /// Not suitable for nested objects.
-Map _convertNativeToDart_Dictionary(object) {
+Map convertNativeToDart_Dictionary(object) {
   if (object == null) return null;
   var dict = {};
   for (final key in JS('=List', 'Object.getOwnPropertyNames(#)', object)) {
     dict[key] = JS('var', '#[#]', object, key);
   }
   return dict;
 }
 
 /// Converts a flat Dart map into a JavaScript object with properties.
-_convertDartToNative_Dictionary(Map dict) {
+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) {
+List convertDartToNative_StringArray(List<String> input) {
   // TODO(sra).  Implement this.
   return input;
 }
 
 
 // -----------------------------------------------------------------------------
 
-/**
- * Converts a native IDBKey into a Dart object.
- *
- * 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 IDBKeys on all paths that return IDBKeys from native DOM calls.
- *
- * If necessary, JavaScript Dates are converted into Dart Dates.
- */
-_convertNativeToDart_IDBKey(nativeKey) {
-  containsDate(object) {
-    if (_isJavaScriptDate(object)) return true;
-    if (object is List) {
-      for (int i = 0; i < object.length; i++) {
-        if (containsDate(object[i])) return true;
-      }
-    }
-    return false;  // number, string.
-  }
-  if (containsDate(nativeKey)) {
-    throw new UnimplementedError('IDBKey containing Date');
-  }
-  // TODO: Cache conversion somewhere?
-  return nativeKey;
-}
-
-/**
- * Converts a Dart object into a valid IDBKey.
- *
- * May return the original input.  Does not mutate input.
- *
- * If necessary, [dartKey] may be copied to ensure all lists are converted into
- * JavaScript Arrays and Dart Dates into JavaScript Dates.
- */
-_convertDartToNative_IDBKey(dartKey) {
-  // TODO: Implement.
-  return dartKey;
-}
-
-
-
-/// May modify original.  If so, action is idempotent.
-_convertNativeToDart_IDBAny(object) {
-  return _convertNativeToDart_AcceptStructuredClone(object, mustCopy: false);
-}
-
 /// Converts a Dart value into a JavaScript SerializedScriptValue.
-_convertDartToNative_SerializedScriptValue(value) {
+convertDartToNative_SerializedScriptValue(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);
+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.
  *
@@ skipping 42 matching lines @@
 
     // 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;
+    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 ArrayBuffer) return e;
 
     if (e is ArrayBufferView) return e;
 
     if (e is Map) {
       var slot = findSlot(e);
       var copy = readSlot(slot);
@@ skipping 17 matching lines @@
       if (copy != null) {
         if (true == copy) {  // Cycle, so commit to making a copy.
           copy = JS('=List', 'new Array(#)', length);
           writeSlot(slot, copy);
         }
         return copy;
       }
 
       int i = 0;
 
-      if (_isJavaScriptArray(e) &&
+      if (isJavaScriptArray(e) &&
           // We have to copy immutable lists, otherwise the structured clone
           // algorithm will copy the .immutable$list marker property, making the
           // list immutable when received!
-          !_isImmutableJavaScriptArray(e)) {
+          !isImmutableJavaScriptArray(e)) {
         writeSlot(slot, true);  // Deferred copy.
         for ( ; i < length; i++) {
           var element = e[i];
           var elementCopy = walk(element);
           if (!identical(elementCopy, element)) {
             copy = readSlot(slot);   // Cyclic reference may have created it.
             if (true == copy) {
               copy = JS('=List', 'new Array(#)', length);
               writeSlot(slot, copy);
             }
@@ skipping 40 matching lines @@
  * [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}) {
+convertNativeToDart_AcceptStructuredClone(object, {mustCopy = false}) {
 
   // TODO(sra): Replace slots with identity hash table that works on non-dart
   // objects.
   var values = [];
   var copies = [];
 
   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; }
 
   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)) {
+    if (isJavaScriptDate(e)) {
       // TODO(sra).
       throw new UnimplementedError('structured clone of Date');
     }
 
-    if (_isJavaScriptRegExp(e)) {
+    if (isJavaScriptRegExp(e)) {
       // TODO(sra).
       throw new UnimplementedError('structured clone of RegExp');
     }
 
-    if (_isJavaScriptSimpleObject(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('=List', 'Object.keys(#)', e)) {
         copy[key] = walk(JS('var', '#[#]', e, key));
       }
       return copy;
     }
 
-    if (_isJavaScriptArray(e)) {
+    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('=List', 'new Array(#)', 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;
 }
 
 
-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) =>
+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) =>
     JS('bool', 'Object.getPrototypeOf(#) === Object.prototype', value);
-bool _isImmutableJavaScriptArray(value) =>
+bool isImmutableJavaScriptArray(value) =>
     JS('bool', r'!!(#.immutable$list)', value);
 
 
 
 const String _serializedScriptValue =
     'num|String|bool|'
     '=List|=Object|'
     'Blob|File|ArrayBuffer|ArrayBufferView'
     // TODO(sra): Add Date, RegExp.
     ;
-const _annotation_Creates_SerializedScriptValue =
+const annotation_Creates_SerializedScriptValue =
     const Creates(_serializedScriptValue);
-const _annotation_Returns_SerializedScriptValue =
+const annotation_Returns_SerializedScriptValue =
     const Returns(_serializedScriptValue);
-
-const String _idbKey = '=List|=Object|num|String';  // TODO(sra): Add Date.
-const _annotation_Creates_IDBKey = const Creates(_idbKey);
-const _annotation_Returns_IDBKey = const Returns(_idbKey);