Added Uint8ClampedList. COmpielr optimziations to follow in next CL.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 4647 matching lines @@
     ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
     return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
   }
 
   HEAP_OBJECT_IMPLEMENTATION(Uint8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
 };
 
 
+class Uint8ClampedArray : public ByteArray {

[siva, 2012/12/06 01:31:13]

If we make RawUint8ClampedArray extend RawUint8Array
then we could also have
Uint8ClampedArray extend Uint8Array
(it would be very similar to the ImmutableArray model)
Only the New methods would be special cased.

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

Done.

+ public:
+  intptr_t ByteLength() const {
+    return Length();
+  }
+
+  uint8_t At(intptr_t index) const {
+    ASSERT((index >= 0) && (index < Length()));
+    return raw_ptr()->data_[index];
+  }
+
+  void SetAt(intptr_t index, uint8_t value) const {
+    ASSERT((index >= 0) && (index < Length()));
+    raw_ptr()->data_[index] = value;
+  }
+
+  static const intptr_t kBytesPerElement = 1;
+  static const intptr_t kMaxElements = kSmiMax / kBytesPerElement;
+
+  static intptr_t data_offset() {
+    return OFFSET_OF(RawUint8ClampedArray, data_);
+  }
+
+  static intptr_t InstanceSize() {
+    ASSERT(sizeof(RawUint8ClampedArray) ==
+           OFFSET_OF(RawUint8ClampedArray, data_));
+    return 0;
+  }
+
+  static intptr_t InstanceSize(intptr_t len) {
+    ASSERT(0 <= len && len <= kMaxElements);
+    return RoundedAllocationSize(
+        sizeof(RawUint8ClampedArray) + (len * kBytesPerElement));
+  }
+
+  static RawUint8ClampedArray* New(intptr_t len,
+                                   Heap::Space space = Heap::kNew);
+  static RawUint8ClampedArray* New(const uint8_t* data,
+                                   intptr_t len,
+                                   Heap::Space space = Heap::kNew);
+
+ private:
+  uint8_t* ByteAddr(intptr_t byte_offset) const {
+    ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
+    return reinterpret_cast<uint8_t*>(&raw_ptr()->data_) + byte_offset;
+  }
+
+  HEAP_OBJECT_IMPLEMENTATION(Uint8ClampedArray, ByteArray);
+  friend class ByteArray;
+  friend class Class;
+};
+
+
 class Int16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int16_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
     return raw_ptr()->data_[index];
   }
@@ skipping 517 matching lines @@
     raw_ptr()->external_data_ = data;
   }
 
   HEAP_OBJECT_IMPLEMENTATION(ExternalUint8Array, ByteArray);
   friend class ByteArray;
   friend class Class;
   friend class TokenStream;
 };
 
 
+class ExternalUint8ClampedArray : public ByteArray {
+ public:
+  intptr_t ByteLength() const {
+    return Length() * kBytesPerElement;
+  }
+
+  uint8_t At(intptr_t index) const {
+    ASSERT((index >= 0) && (index < Length()));
+    return raw_ptr()->external_data_->data()[index];
+  }
+
+  void SetAt(intptr_t index, uint8_t value) const {
+    ASSERT((index >= 0) && (index < Length()));
+    raw_ptr()->external_data_->data()[index] = value;
+  }
+
+  void* GetData() const {
+    return raw_ptr()->external_data_->data();
+  }
+
+  void* GetPeer() const {
+    return raw_ptr()->external_data_->peer();
+  }
+
+  static const intptr_t kBytesPerElement = 1;
+
+  // Since external arrays may be serialized to non-external ones,
+  // enforce the same maximum element count.
+  static const intptr_t kMaxElements = Uint8ClampedArray::kMaxElements;
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawExternalUint8ClampedArray));
+  }
+
+  static intptr_t external_data_offset() {
+    return OFFSET_OF(RawExternalUint8ClampedArray, external_data_);
+  }
+
+  static RawExternalUint8ClampedArray* New(uint8_t* data,
+                                           intptr_t len,
+                                           void* peer,
+                                           Dart_PeerFinalizer callback,
+                                           Heap::Space space = Heap::kNew);
+
+ private:
+  uint8_t* ByteAddr(intptr_t byte_offset) const {
+    ASSERT((byte_offset >= 0) && (byte_offset < ByteLength()));
+    uint8_t* data =
+        reinterpret_cast<uint8_t*>(raw_ptr()->external_data_->data());
+    return data + byte_offset;
+  }
+
+  void SetExternalData(ExternalByteArrayData<uint8_t>* data) {
+    raw_ptr()->external_data_ = data;
+  }
+
+  HEAP_OBJECT_IMPLEMENTATION(ExternalUint8ClampedArray, ByteArray);
+  friend class ByteArray;
+  friend class Class;
+  friend class TokenStream;
+};
+
+
 class ExternalInt16Array : public ByteArray {
  public:
   intptr_t ByteLength() const {
     return Length() * kBytesPerElement;
   }
 
   int16_t At(intptr_t index) const {
     ASSERT((index >= 0) && (index < Length()));
     return raw_ptr()->external_data_->data()[index];
   }
@@ skipping 778 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_