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]) {

[cshapiro, 2012/12/05 23:01:49]

Is this indented correctly?  I would assume the opening square bracket should
line up with the opening parenthesis.

[srdjan, 2012/12/06 19:23:14]

Done.

+    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 391 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 47 matching lines @@
     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";
 }
 
 
+

[cshapiro, 2012/12/05 23:01:49]

extra vertical space?

[srdjan, 2012/12/06 19:23:14]

Done.

+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) {
+    if (value < 0) {
+      value = 0;
+    } else if (value > 0xFF) {
+      value = 0xFF;
+    }
+    _setIndexed(index, _toUint8(value));

[cshapiro, 2012/12/05 23:01:49]

Why not replace lines 562-566 with a new function called "_toClampedUint8". 
This function would be used in place of the _toUint8 call which is mostly made
redundant by the range narrowing above.

Here is the clamp specification

http://dev.w3.org/2006/webapi/WebIDL/#Clamp

[srdjan, 2012/12/06 19:23:14]

Done.

+  }
+
+  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 _Uint8ClampedArray || from is _ExternalUint8ClampedArray) {

[cshapiro, 2012/12/05 23:01:49]

I think _Uint8Array and _ExternalUint8Array are valid here.  By extension, the
setRange for _Uint8Array should accept the clamped arrays.

(The right thing to do might be to have this keyed off of the _BYTES_PER_ELEMENT
value of the from array rather than the type name.)

[srdjan, 2012/12/06 19:23:14]

We need to talk more about that.

+      _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 "Uint8ClampedArray_getIndexed";
+  int _setIndexed(int index, int value) native "Uint8ClampedArray_setIndexed";
+}
+
+
 class _Int16Array extends _ByteArrayBase implements Int16List {
   factory _Int16Array(int length) {
     return _new(length);
   }
 
   factory _Int16Array.transferable(int length) {
     return _newTransferable(length);
   }
 
   factory _Int16Array.view(ByteArray array, [int start = 0, int length]) {
@@ skipping 181 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 1785 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;
 }