Convert between Dart and JavaScript SerializedScriptValues on postMessage.

lib/html/src/dart2js_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 111 matching lines @@
  * 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.
+/// May modify original.  If so, action is idempotent.
 _convertNativeToDart_IDBAny(object) {
-  return _convertNativeToDart_AcceptStructuredClone(object);
+  return _convertNativeToDart_AcceptStructuredClone(object, mustCopy: false);
 }
 
-/// Converts a Dart value into
+/// Converts a Dart value into a JavaScript SerializedScriptValue.
 _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);
+}
+
 
 /**
  * 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) {
 
   // 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++) {
@@ skipping 130 matching lines @@
   }
 
   var copy = walk(value);
   cleanupSlots();
   return copy;
 }
 
 /**
  * Converts a native value 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 serializable script values such values from native DOM calls.
+ * 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) {
+_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 (values[i] === value) return i;
@@ skipping 15 matching lines @@
       // TODO(sra).
       throw const NotImplementedException('structured clone of Date');
     }
 
     if (_isJavaScriptRegExp(e)) {
       // TODO(sra).
       throw const NotImplementedException('structured clone of RegExp');
     }
 
     if (_isJavaScriptSimpleObject(e)) {
-      // TODO(sra): Swizzle the prototype for one of a Map implementation that
-      // uses the properies as storage.
+      // 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)) {
-      // Since a JavaScript Array is an instance of Dart List, we can modify it
-      // in-place.
       var slot = findSlot(e);
       var copy = readSlot(slot);
       if (copy != null) return copy;
-      writeSlot(slot, e);
 
       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++) {
-        e[i] = walk(e[i]);
+        copy[i] = walk(e[i]);
       }
-      return e;
+      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) =>
     JS('bool', 'Object.getPrototypeOf(#) === Object.prototype', value);
 bool _isImmutableJavaScriptArray(value) =>
     JS('bool', r'!!(#.immutable$list)', value);