Make VM TypedList not implement ByteBuffer.

runtime/lib/typed_data.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.
 
 // patch classes for Int8List ..... Float64List and ByteData implementations.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
@@ skipping 280 matching lines @@
   }
   /* patch */ factory Int32x4.fromFloat32x4Bits(Float32x4 x) {
     return new _Int32x4.fromFloat32x4Bits(x);
   }
 }
 
 
 patch class ByteData {
   /* patch */ factory ByteData(int length) {
     var list = new _Uint8Array(length);
-    return new _ByteDataView(list.buffer, 0, length);
+    return new _ByteDataView(list, 0, length);
   }
 
   /* patch */ factory ByteData.view(ByteBuffer buffer,
                                     [int offsetInBytes = 0, int length]) {
     if (length == null) {
       length = buffer.lengthInBytes - offsetInBytes;
     }
-    return new _ByteDataView(buffer, offsetInBytes, length);
+    _ByteBuffer internalBuffer = buffer;
+    return new _ByteDataView(internalBuffer._typedData, offsetInBytes, length);
   }
+
+  // Called directly from C code.
+  factory ByteData._view(TypedData typedData, int offsetInBytes, int length)
+      => new _ByteDataView(typedData, offsetInBytes, length);
 }
 
 
 // Based class for _TypedList that provides common methods for implementing
 // the collection and list interfaces.
 
 abstract class _TypedListBase {
 
   // Method(s) implementing the Collection interface.
   bool contains(element) => IterableMixinWorkaround.contains(this, element);
@@ skipping 226 matching lines @@
       throw new StateError("Not enough elements");
     }
 
     if (from is _TypedListBase) {
       final needsClamping =
           this._isClamped() && (this._isClamped() != from._isClamped());
       if (this.elementSizeInBytes == from.elementSizeInBytes) {
         if (needsClamping) {
           Lists.copy(from, skipCount, this, start, count);
           return;
-        } else if (this.buffer._setRange(
-                     start * elementSizeInBytes + this.offsetInBytes,
-                     count * elementSizeInBytes,
-                     from.buffer,
-                     skipCount * elementSizeInBytes + from.offsetInBytes)) {
+        }
+        _ByteBuffer buffer = this.buffer;
+        _ByteBuffer fromBuffer = from.buffer;
+        if (buffer._typedData._setRange(
+                start * elementSizeInBytes + this.offsetInBytes,
+                count * elementSizeInBytes,
+                fromBuffer._typedData,
+                skipCount * elementSizeInBytes + from.offsetInBytes)) {
           return;
         }
       } else if (from.buffer == this.buffer) {
         // Different element sizes, but same buffer means that we need
         // an intermediate structure.
         // TODO(srdjan): Optimize to skip copying if the range does not overlap.
         final temp_buffer = new List(count);
         for (int i = 0; i < count; i++) {
           temp_buffer[i] = from[skipCount + i];
         }
@@ skipping 28 matching lines @@
 
   // Returns true if operation succeeds.
   // Returns false if 'from' and 'this' do not have the same element types.
   // The copy occurs using a memory copy (no clamping, conversion, etc).
   bool _setRange(int startInBytes, int lengthInBytes,
                  _TypedListBase from, int startFromInBytes)
       native "TypedData_setRange";
 }
 
 
-abstract class _TypedList extends _TypedListBase implements ByteBuffer {
+abstract class _TypedList extends _TypedListBase {
+  // The [buffer] getter should return the same value each time.
+  // Store it here the first time it is created.
+  // We don't want to store it on the object, since not all typed lists
+  // have a buffer extracted.
+  static var _buffers = new Expando();

[siva, 2014/01/14 22:02:17]

Why does the wrapper buffer object have to be the same value each time?
The underlying typedData will be the same and your == operator in _ByteBuffer
would return true even with different objects right.

[Lasse Reichstein Nielsen, 2014/01/15 09:47:58]

There are co19 tests that assume the buffers to be identical.

If we don't want that, I can easily change it back (I found those tests because
I initially returned a new ByteBuffer object each time).

[siva, 2014/01/15 18:29:07]

I don't think anywhere in the spec we state that the buffers have to be
identical, I don't think the co19 tests should be construed as a standard. I
would file a bug stating those tests are invalid and needs to be fixed.

On 2014/01/15 09:47:58, Lasse Reichstein Nielsen wrote:

+
   // Default method implementing parts of the TypedData interface.
   int get offsetInBytes {
     return 0;
   }
 
   int get lengthInBytes {
     return length * elementSizeInBytes;
   }
 
   ByteBuffer get buffer {
-    return this;
+    _ByteBuffer buffer = _buffers[this];
+    if (buffer == null) {
+      buffer = new _ByteBuffer(this);
+      _buffers[this] = buffer;
+    }
+    return buffer;
   }
 
   // Methods implementing the collection interface.
 
   int get length native "TypedData_length";
 
   // Internal utility methods.
 
   int _getInt8(int offsetInBytes) native "TypedData_GetInt8";
   void _setInt8(int offsetInBytes, int value) native "TypedData_SetInt8";
@@ skipping 1695 matching lines @@
     _position = _length;
     _current = null;
     return false;
   }
 
   E get current => _current;
 }
 
 
 class _TypedListView extends _TypedListBase implements TypedData {
+  final TypedData _typedData;
+  final int offsetInBytes;
+  final int length;
+
   _TypedListView(ByteBuffer _buffer, int _offset, int _length)
-    : _typedData = _buffer,  // This assignment is type safe.
-      offsetInBytes = _offset,
-      length = _length {
-  }
+      : _typedData = (_buffer as _ByteBuffer)._typedData,
+        offsetInBytes = _offset,
+        length = _length;
 
   // Method(s) implementing the TypedData interface.
 
   int get lengthInBytes {
     return length * elementSizeInBytes;
   }
 
   ByteBuffer get buffer {
     return _typedData.buffer;
   }
-
-  final TypedData _typedData;
-  final int offsetInBytes;
-  final int length;
 }
 
 
 class _Int8ArrayView extends _TypedListView implements Int8List {
   // Constructor.
   _Int8ArrayView(ByteBuffer buffer, [int _offsetInBytes = 0, int _length])
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Int8List.BYTES_PER_ELEMENT))) {
@@ skipping 660 matching lines @@
 
   // Internal utility methods.
 
   Int32x4List _createList(int length) {
     return new Int32x4List(length);
   }
 }
 
 
 class _ByteDataView implements ByteData {
-  _ByteDataView(ByteBuffer _buffer, int _offsetInBytes, int _lengthInBytes)
-    : _typedData = _buffer,  // _buffer is guaranteed to be a TypedData here.
+  final TypedData _typedData;
+  final int _offset;
+  final int length;
+
+  _ByteDataView(TypedData typedData, int _offsetInBytes, int _lengthInBytes)
+    : _typedData = typedData,
       _offset = _offsetInBytes,
       length = _lengthInBytes {
-    _rangeCheck(_buffer.lengthInBytes, _offset, length);
+    _rangeCheck(typedData.lengthInBytes, _offset, length);
   }
 
-
   // Method(s) implementing TypedData interface.
 
   ByteBuffer get buffer {
     return _typedData.buffer;
   }
 
   int get lengthInBytes {
     return length;
   }
 
@@ skipping 250 matching lines @@
   static int _toEndianUint32(int host_value, bool little_endian)
       native "ByteData_ToEndianUint32";
   static int _toEndianInt64(int host_value, bool little_endian)
       native "ByteData_ToEndianInt64";
   static int _toEndianUint64(int host_value, bool little_endian)
       native "ByteData_ToEndianUint64";
   static double _toEndianFloat32(double host_value, bool little_endian)
       native "ByteData_ToEndianFloat32";
   static double _toEndianFloat64(double host_value, bool little_endian)
       native "ByteData_ToEndianFloat64";
-
-
-  final TypedData _typedData;
-  final int _offset;
-  final int length;
 }
 
 
 // Top level utility methods.
 int _toInt(int value, int mask) {
   value &= mask;
   if (value > (mask >> 1)) value -= mask + 1;
   return value;
 }
 
@@ skipping 71 matching lines @@
     return value;
   }
   return object;
 }
 
 
 void _throwRangeError(int index, int length) {
   String message = "$index must be in the range [0..$length)";
   throw new RangeError(message);
 }
+
+/**
+ * Internal implementation of [ByteBuffer].
+ */
+class _ByteBuffer implements ByteBuffer {
+  final _TypedList _typedData;
+
+  _ByteBuffer(this._typedData);
+
+  int get lengthInBytes => _typedData.lengthInBytes;
+
+  int get hashCode => _typedData.hashCode;
+  bool operator==(Object other) =>
+      other is _ByteBuffer && _typedData == other._typedData;
+}