Fix TypedDataBuffer.insertAll() with an Iterable.

lib/typed_buffers.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.
 
 /// Growable typed-data lists.
 ///
 /// These lists works just as a typed-data list, except that they are growable.
 /// They use an underlying buffer, and when that buffer becomes too small, it
 /// is replaced by a new buffer.
 ///
@@ skipping 41 matching lines @@
       } else {
         newBuffer = _createBiggerBuffer(newLength);
       }
       newBuffer.setRange(0, _length, _buffer);
       _buffer = newBuffer;
     }
     _length = newLength;
   }
 
   void _add(E value) {
-    if (_length == _buffer.length) _grow();
+    if (_length == _buffer.length) _grow(_length);
     _buffer[_length++] = value;
   }
 
   // We override the default implementation of `add` because it grows the list
   // by setting the length in increments of one. We want to grow by doubling
   // capacity in most cases.
   void add(E value) { _add(value); }
 
   /// Appends all objects of [values] to the end of this buffer.
   ///
@@ skipping 45 matching lines @@
     if (end == null && values is List) {
       end = values.length;
     }
     if (end != null) {
       _insertKnownLength(index, values, start, end);
       return;
     }
 
     // Add elements at end, growing as appropriate, then put them back at
     // position [index] using flip-by-double-reverse.
-    if (end != null) values = values.take(end);
-    int writeIndex = _length;
-    int skipCount = start;
+    var writeIndex = _length;
+    var skipCount = start;
     for (var value in values) {
       if (skipCount > 0) {
         skipCount--;
         continue;
       }
       if (writeIndex == _buffer.length) {
-        _grow();
+        _grow(writeIndex);
       }
       _buffer[writeIndex++] = value;
     }
+
     if (skipCount > 0) {
       throw new StateError("Too few elements");
     }
     if (end != null && writeIndex < end) {
       throw new RangeError.range(end, start, writeIndex, "end");
     }
+
     // Swap [index.._length) and [_length..writeIndex) by double-reversing.
     _reverse(_buffer, index, _length);
     _reverse(_buffer, _length, writeIndex);
     _reverse(_buffer, index, writeIndex);
     _length = writeIndex;
     return;
   }
 
   // Reverses the range [start..end) of buffer.
   static void _reverse(List<int> buffer, int start, int end) {
@@ skipping 91 matching lines @@
   List<E> _createBiggerBuffer(int requiredCapacity) {
     int newLength = _buffer.length * 2;
     if (requiredCapacity != null && newLength < requiredCapacity) {
       newLength = requiredCapacity;
     } else if (newLength < INITIAL_LENGTH) {
       newLength = INITIAL_LENGTH;
     }
     return _createBuffer(newLength);
   }
 
-  void _grow() {
-    _buffer = _createBiggerBuffer(null)..setRange(0, _length, _buffer);
+  /// Grows the buffer.
+  ///
+  /// This copies the first [length] elements into the new buffer.
+  void _grow(int length) {
+    _buffer = _createBiggerBuffer(null)..setRange(0, length, _buffer);
   }
 
   void setRange(int start, int end, Iterable<E> source, [int skipCount = 0]) {
     if (end > _length) throw new RangeError.range(end, 0, _length);
     _setRange(start, end, source, skipCount);
   }
 
   /// Like [setRange], but with no bounds checking.
   void _setRange(int start, int end, Iterable<E> source, int skipCount) {
     if (source is _TypedDataBuffer<E>) {
@@ skipping 104 matching lines @@
   Int32x4 get _defaultValue => _zero;
   Int32x4List _createBuffer(int size) => new Int32x4List(size);
 }
 
 class Float32x4Buffer extends _TypedDataBuffer<Float32x4> {
   Float32x4Buffer([int initialLength = 0])
       : super(new Float32x4List(initialLength));
   Float32x4 get _defaultValue => new Float32x4.zero();
   Float32x4List _createBuffer(int size) => new Float32x4List(size);
 }