Fix performance of setRange by avoiding going to Lists.copy

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 38 matching lines @@
   /* patch */ factory Uint8ClampedList.fromList(List<int> elements) {
     return new _Uint8ClampedArray(elements.length)
         ..setRange(0, elements.length, elements);
   }
 
   /* patch */ factory Uint8ClampedList.view(ByteBuffer buffer,
                                             [int offsetInBytes = 0,
                                              int length]) {
     return new _Uint8ClampedArrayView(buffer, offsetInBytes, length);
   }
-
-  bool _isClamped() { return true; }
 }
 
 
 patch class Int16List {
   /* patch */ factory Int16List(int length) {
     return new _Int16Array(length);
   }
 
   /* patch */ factory Int16List.fromList(List<int> elements) {
     return new _Int16Array(elements.length)
@@ skipping 450 matching lines @@
     _rangeCheck(this.length, start, length);
     List result = _createList(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   Iterable getRange(int start, [int end]) {
     return IterableMixinWorkaround.getRangeList(this, start, end);
   }
 
-  bool _isClamped() { return false; }
-
   void setRange(int start, int end, Iterable from, [int skipCount = 0]) {
     // Check ranges.
     if ((start < 0) || (start > length)) {
       _throwRangeError(start, length + 1);
     }
     if ((end < 0) || (end > length)) {
       _throwRangeError(end, length + 1);
     }
     if (start > end) {
       _throwRangeError(start, end + 1);
     }
     if (skipCount < 0) {
       throw new ArgumentError(skipCount);
     }
 
     final count = end - start;
     if ((from.length - skipCount) < count) {
       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)) {
+        if (this.buffer._setRange(
+              start * elementSizeInBytes + this.offsetInBytes,
+              count * elementSizeInBytes,
+              from.buffer,
+              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++) {
           temp_buffer[i] = from[skipCount + i];
         }
@@ skipping 20 matching lines @@
   // Method(s) implementing Object interface.
 
   String toString() {
     return IterableMixinWorkaround.toStringIterable(this, '[', ']');
   }
 
 
   // Internal utility methods.
 
   // 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).
+  // 'fromCid' and 'toCid' may be cid-s of the views and therefore may not
+  // match the cids of 'this' and 'from'.
+  // Uses toCid and fromCid to decide if clamping is necessary.
+  // Element size of toCid and fromCid must match (test at caller).
   bool _setRange(int startInBytes, int lengthInBytes,
-                 _TypedListBase from, int startFromInBytes)
+                 _TypedListBase from, int startFromInBytes,
+                 int toCid, int fromCid)
       native "TypedData_setRange";
+
+  int get _cid native "Object_cid";
 }
 
 
 abstract class _TypedList extends _TypedListBase implements ByteBuffer {
   // Default method implementing parts of the TypedData interface.
   int get offsetInBytes {
     return 0;
   }
 
   int get lengthInBytes {
@@ skipping 170 matching lines @@
   }
 
   factory _Uint8ClampedArray.view(ByteBuffer buffer,
                                   [int offsetInBytes = 0, int length]) {
     if (length == null) {
       length = buffer.lengthInBytes - offsetInBytes;
     }
     return new _Uint8ClampedArrayView(buffer, offsetInBytes, length);
   }
 
-  bool _isClamped() { return true; }
-
   // Methods implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
@@ skipping 805 matching lines @@
 }
 
 
 class _ExternalUint8ClampedArray extends _TypedList implements Uint8ClampedList {
   // Factory constructors.
 
   factory _ExternalUint8ClampedArray(int length) {
     return _new(length);
   }
 
-  bool _isClamped() { return true; }
-
   // Method(s) implementing the List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _getUint8(index);
   }
 
   void operator[]=(int index, int value) {
@@ skipping 1014 matching lines @@
     : super(buffer, _offsetInBytes,
             _defaultIfNull(_length,
                            ((buffer.lengthInBytes - _offsetInBytes) ~/
                             Uint8List.BYTES_PER_ELEMENT))) {
     _rangeCheck(buffer.lengthInBytes,
                 offsetInBytes,
                 length * Uint8List.BYTES_PER_ELEMENT);
   }
 
 
-  bool _isClamped() { return true; }
-
   // Method(s) implementing List interface.
 
   int operator[](int index) {
     if (index < 0 || index >= length) {
       _throwRangeError(index, length);
     }
     return _typedData._getUint8(offsetInBytes +
                                 (index * Uint8List.BYTES_PER_ELEMENT));
   }
 
@@ skipping 965 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);
 }