Make 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.
 
 import "dart:_internal";
 import 'dart:math' show Random;
 
 patch class Int8List {
@@ skipping 281 matching lines @@
 
   /* patch */ factory Float64x2.fromFloat32x4(Float32x4 v) {
     return new _Float64x2.fromFloat32x4(v);
   }
 }
 
 
 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);
+    return new _ByteDataView(buffer._data, offsetInBytes, length);
+  }
+
+  // Called directly from C code.
+  factory ByteData._view(TypedData typedData, int offsetInBytes, int length) {
+    return 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.
@@ skipping 223 matching lines @@
     final count = end - start;
     if ((from.length - skipCount) < count) {
       throw new StateError("Not enough elements");
     }
 
     if (from is _TypedListBase) {
       if (this.elementSizeInBytes == from.elementSizeInBytes) {
         if ((count < 10) && (from.buffer != this.buffer)) {
           Lists.copy(from, skipCount, this, start, count);
           return;
-        } else if (this.buffer._setRange(
+        } else if (this.buffer._data._setRange(
               start * elementSizeInBytes + this.offsetInBytes,
               count * elementSizeInBytes,
-              from.buffer,
+              from.buffer._data,
               skipCount * elementSizeInBytes + from.offsetInBytes,
               this._cid, from._cid)) {
           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++) {
@@ skipping 33 matching lines @@
   // Element size of toCid and fromCid must match (test at caller).
   bool _setRange(int startInBytes, int lengthInBytes,
                  _TypedListBase from, int startFromInBytes,
                  int toCid, int fromCid)
       native "TypedData_setRange";
 
   int get _cid native "Object_cid";
 }
 
 
-abstract class _TypedList extends _TypedListBase implements ByteBuffer {
+class _ByteBuffer implements ByteBuffer {
+  final _TypedList _data;
+
+  _ByteBuffer(this._data);
+
+  // Forward calls to _data.
+  int get lengthInBytes => _data.lengthInBytes;
+  int get hashCode => _data.hashCode;
+  bool operator==(Object other) => identical(_data, other._data);

[siva, 2014/06/17 01:09:57]

shouldn't this say
other is _ByteBuffer && identical(_data, other._data);

[Cutch, 2014/06/17 14:31:17]

Done.

+}
+
+
+abstract class _TypedList extends _TypedListBase {
   // 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 get buffer => new _ByteBuffer(this);
 
   // 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 1873 matching lines @@
     _position = _length;
     _current = null;
     return false;
   }
 
   E get current => _current;
 }
 
 
 class _TypedListView extends _TypedListBase implements TypedData {
-  _TypedListView(ByteBuffer _buffer, int _offset, int _length)
-    : _typedData = _buffer,  // This assignment is type safe.
+  _TypedListView(_ByteBuffer _buffer, int _offset, int _length)
+    : _typedData = _buffer._data,  // This assignment is type safe.

[Ivan Posva, 2014/06/17 01:07:02]

You can drop the assignment comment now.

[Cutch, 2014/06/17 14:31:17]

Done.

       offsetInBytes = _offset,
       length = _length {
   }
 
   // Method(s) implementing the TypedData interface.
 
   int get lengthInBytes {
     return length * elementSizeInBytes;
   }
 
@@ skipping 727 matching lines @@
 
   // Internal utility methods.
 
   Float64x2List _createList(int length) {
     return new Float64x2List(length);
   }
 }
 
 
 class _ByteDataView implements ByteData {
-  _ByteDataView(ByteBuffer _buffer, int _offsetInBytes, int _lengthInBytes)
-    : _typedData = _buffer,  // _buffer is guaranteed to be a TypedData here.
+  _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 {
@@ skipping 349 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);
 }