Added Uint8ClampedList. COmpielr optimziations to follow in next CL.

runtime/lib/byte_array.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.
 
 patch class Int8List {
   /* patch */ factory Int8List(int length) {
     return new _Int8Array(length);
   }
 
   /* patch */ factory Int8List.transferable(int length) {
@@ skipping 16 matching lines @@
     return new _Uint8Array.transferable(length);
   }
 
   /* patch */ factory Uint8List.view(ByteArray array,
                                      [int start = 0, int length]) {
     return new _Uint8ArrayView(array, start, length);
   }
 }
 
 
+patch class Uint8ClampedList {
+  /* patch */ factory Uint8ClampedList(int length) {
+    return new _Uint8ClampedArray(length);
+  }
+
+  /* patch */ factory Uint8ClampedList.transferable(int length) {
+    return new _Uint8ClampedArray.transferable(length);
+  }
+
+  /* patch */ factory Uint8ClampedList.view(ByteArray array,
+                                            [int start = 0, int length]) {
+    return new _Uint8ClampedArrayView(array, start, length);
+  }
+}
+
+
 patch class Int16List {
   /* patch */ factory Int16List(int length) {
     return new _Int16Array(length);
   }
 
   /* patch */ factory Int16List.transferable(int length) {
     return new _Int16Array.transferable(length);
   }
 
   /* patch */ factory Int16List.view(ByteArray array, [int start = 0, int length]) {
@@ skipping 271 matching lines @@
   if (value > (mask >> 1)) value -= mask + 1;
   return value;
 }
 
 int _toInt8(int value) {
   return _toInt(value, 0xFF);
 }
 int _toUint8(int value) {
   return value & 0xFF;
 }
+int _toClampedUint8(int value) {
+  if (value < 0) return 0;
+  if (value > 0xFF) return 0xFF;
+  return value;
+}
 
 
 int _toInt16(int value) {
   return _toInt(value, 0xFFFF);
 }
 int _toUint16(int value) {
   return value & 0xFFFF;
 }
 
 
@@ skipping 101 matching lines @@
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 1;
 
   static _Int8Array _new(int length) native "Int8Array_new";
   static _Int8Array _newTransferable(int length)
       native "Int8Array_newTransferable";
-      
 
   int _getIndexed(int index) native "Int8Array_getIndexed";
   int _setIndexed(int index, int value) native "Int8Array_setIndexed";
 }
 
 
 class _Uint8Array extends _ByteArrayBase implements Uint8List {
   factory _Uint8Array(int length) {
     return _new(length);
   }
@@ skipping 22 matching lines @@
   }
 
   List<int> getRange(int start, int length) {
     _rangeCheck(this.length, start, length);
     List<int> result = _new(length);
     result.setRange(0, length, this, start);
     return result;
   }
 
   void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
-    if (from is _Uint8Array || from is _ExternalUint8Array) {
+    if (from is _Uint8Array || from is _ExternalUint8Array ||
+        from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {
       _setRange(start * _BYTES_PER_ELEMENT,
                 length * _BYTES_PER_ELEMENT,
                 from,
                 startFrom * _BYTES_PER_ELEMENT);
     } else {
       Arrays.copy(from, startFrom, this, start, length);
     }
   }
 
   String toString() {
     return Collections.collectionToString(this);
   }
 
   int bytesPerElement() {
     return _BYTES_PER_ELEMENT;
   }
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 1;
 
   static _Uint8Array _new(int length) native "Uint8Array_new";
-  static _Uint8Array _newTransferable(int length) 
+  static _Uint8Array _newTransferable(int length)
       native "Uint8Array_newTransferable";
-      
+
+  int _getIndexed(int index) native "Uint8Array_getIndexed";
+  int _setIndexed(int index, int value) native "Uint8Array_setIndexed";
+}
+
+
+class _Uint8ClampedArray extends _ByteArrayBase implements Uint8ClampedList {
+  factory _Uint8ClampedArray(int length) {
+    return _new(length);
+  }
+
+  factory _Uint8ClampedArray.transferable(int length) {
+    return _newTransferable(length);
+  }
+
+  factory _Uint8ClampedArray.view(ByteArray array,
+                                 [int start = 0, int length]) {
+    if (length == null) {
+      length = array.lengthInBytes();
+    }
+    return new _Uint8ClampedArrayView(array, start, length);
+  }
+
+  int operator[](int index) {
+    return _getIndexed(index);
+  }
+
+  int operator[]=(int index, int value) {
+    _setIndexed(index, _toClampedUint8(value));
+  }
+
+  Iterator<int> iterator() {
+    return new _ByteArrayIterator<int>(this);
+  }
+
+  List<int> getRange(int start, int length) {
+    _rangeCheck(this.length, start, length);
+    List<int> result = _new(length);
+    result.setRange(0, length, this, start);
+    return result;
+  }
+
+  void setRange(int start, int length, List<int> from, [int startFrom = 0]) {
+    if (from is _Uint8Array || from is _ExternalUint8Array ||
+        from is _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {
+      _setRange(start * _BYTES_PER_ELEMENT,
+                length * _BYTES_PER_ELEMENT,
+                from,
+                startFrom * _BYTES_PER_ELEMENT);
+    } else {
+      Arrays.copy(from, startFrom, this, start, length);
+    }
+  }
+
+  String toString() {
+    return Collections.collectionToString(this);
+  }
+
+  int bytesPerElement() {
+    return _BYTES_PER_ELEMENT;
+  }
+
+  int lengthInBytes() {
+    return _length() * _BYTES_PER_ELEMENT;
+  }
+
+  static const int _BYTES_PER_ELEMENT = 1;
+
+  static _Uint8ClampedArray _new(int length) native "Uint8ClampedArray_new";
+  static _Uint8ClampedArray _newTransferable(int length)
+      native "Uint8ClampedArray_newTransferable";
+
   int _getIndexed(int index) native "Uint8Array_getIndexed";
   int _setIndexed(int index, int value) native "Uint8Array_setIndexed";
 }
 
 
 class _Int16Array extends _ByteArrayBase implements Int16List {
   factory _Int16Array(int length) {
     return _new(length);
   }
 
@@ skipping 186 matching lines @@
 
   int lengthInBytes() {
     return _length() * _BYTES_PER_ELEMENT;
   }
 
   static const int _BYTES_PER_ELEMENT = 4;
 
   static _Int32Array _new(int length) native "Int32Array_new";
   static _Int32Array _newTransferable(int length)
       native "Int32Array_newTransferable";
-      
+
 
   int _getIndexed(int index) native "Int32Array_getIndexed";
   int _setIndexed(int index, int value) native "Int32Array_setIndexed";
 }
 
 
 class _Uint32Array extends _ByteArrayBase implements Uint32List {
   factory _Uint32Array(int length) {
     return _new(length);
   }
@@ skipping 1786 matching lines @@
     }
     _rangeCheck(this.length, start, length);
     return _array.subByteArray(_offset + start, length);
   }
 
   static const int _BYTES_PER_ELEMENT = 8;
   final ByteArray _array;
   final int _offset;
   final int _length;
 }