Added Uint8ClampedList. COmpielr optimziations to follow in next CL.

runtime/vm/object.cc

 // 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.
 
 #include "vm/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 728 matching lines @@
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
   name = Symbols::_Int8Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
   name = Symbols::_Uint8Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
+  cls = Class::New<Uint8ClampedArray>();
+  object_store->set_uint8_clamped_array_class(cls);
+  name = Symbols::_Uint8ClampedArray();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
   cls = Class::New<Int16Array>();
   object_store->set_int16_array_class(cls);
   name = Symbols::_Int16Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
   cls = Class::New<Uint16Array>();
   object_store->set_uint16_array_class(cls);
   name = Symbols::_Uint16Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
@@ skipping 30 matching lines @@
   cls = Class::New<ExternalInt8Array>();
   object_store->set_external_int8_array_class(cls);
   name = Symbols::_ExternalInt8Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
   cls = Class::New<ExternalUint8Array>();
   object_store->set_external_uint8_array_class(cls);
   name = Symbols::_ExternalUint8Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
+  cls = Class::New<ExternalUint8ClampedArray>();
+  object_store->set_external_uint8_clamped_array_class(cls);
+  name = Symbols::_ExternalUint8ClampedArray();
+  RegisterPrivateClass(cls, name, scalarlist_lib);
+
   cls = Class::New<ExternalInt16Array>();
   object_store->set_external_int16_array_class(cls);
   name = Symbols::_ExternalInt16Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
   cls = Class::New<ExternalUint16Array>();
   object_store->set_external_uint16_array_class(cls);
   name = Symbols::_ExternalUint16Array();
   RegisterPrivateClass(cls, name, scalarlist_lib);
 
@@ skipping 230 matching lines @@
 
   cls = Class::New<GrowableObjectArray>();
   object_store->set_growable_object_array_class(cls);
 
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
 
+  cls = Class::New<Uint8ClampedArray>();
+  object_store->set_uint8_clamped_array_class(cls);
+
   cls = Class::New<Int16Array>();
   object_store->set_int16_array_class(cls);
 
   cls = Class::New<Uint16Array>();
   object_store->set_uint16_array_class(cls);
 
   cls = Class::New<Int32Array>();
   object_store->set_int32_array_class(cls);
 
   cls = Class::New<Uint32Array>();
@@ skipping 10 matching lines @@
 
   cls = Class::New<Float64Array>();
   object_store->set_float64_array_class(cls);
 
   cls = Class::New<ExternalInt8Array>();
   object_store->set_external_int8_array_class(cls);
 
   cls = Class::New<ExternalUint8Array>();
   object_store->set_external_uint8_array_class(cls);
 
+  cls = Class::New<ExternalUint8ClampedArray>();
+  object_store->set_external_uint8_clamped_array_class(cls);
+
   cls = Class::New<ExternalInt16Array>();
   object_store->set_external_int16_array_class(cls);
 
   cls = Class::New<ExternalUint16Array>();
   object_store->set_external_uint16_array_class(cls);
 
   cls = Class::New<ExternalInt32Array>();
   object_store->set_external_int32_array_class(cls);
 
   cls = Class::New<ExternalUint32Array>();
@@ skipping 176 matching lines @@
     case kArrayCid:
     case kImmutableArrayCid:
     case kGrowableObjectArrayCid:
       return Symbols::New("List");
     case kInt8ArrayCid:
     case kExternalInt8ArrayCid:
       return Symbols::New("Int8List");
     case kUint8ArrayCid:
     case kExternalUint8ArrayCid:
       return Symbols::New("Uint8List");
+    case kUint8ClampedArrayCid:
+    case kExternalUint8ClampedArrayCid:
+      return Symbols::New("Uint8ClampedList");
     case kInt16ArrayCid:
     case kExternalInt16ArrayCid:
       return Symbols::New("Int16List");
     case kUint16ArrayCid:
     case kExternalUint16ArrayCid:
       return Symbols::New("Uint16List");
     case kInt32ArrayCid:
     case kExternalInt32ArrayCid:
       return Symbols::New("Int32List");
     case kUint32ArrayCid:
@@ skipping 10188 matching lines @@
          Class::null());
   return NewImpl<Uint8Array, RawUint8Array>(kClassId, data, len, space);
 }
 
 
 const char* Uint8Array::ToCString() const {
   return "_Uint8Array";
 }
 
 
+RawUint8ClampedArray* Uint8ClampedArray::New(intptr_t len, Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->uint8_clamped_array_class() !=
+         Class::null());
+  return NewImpl<Uint8ClampedArray, RawUint8ClampedArray>(kClassId, len, space);
+}
+
+
+RawUint8ClampedArray* Uint8ClampedArray::New(const uint8_t* data,
+                                             intptr_t len,
+                                             Heap::Space space) {
+  ASSERT(Isolate::Current()->object_store()->uint8_clamped_array_class() !=
+         Class::null());
+  return NewImpl<Uint8ClampedArray,
+      RawUint8ClampedArray>(kClassId, data, len, space);
+}
+
+
+const char* Uint8ClampedArray::ToCString() const {
+  return "_Uint8ClampedArray";
+}
+
+
 RawInt16Array* Int16Array::New(intptr_t len, Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->int16_array_class() !=
          Class::null());
   return NewImpl<Int16Array, RawInt16Array>(kClassId, len, space);
 }
 
 
 RawInt16Array* Int16Array::New(const int16_t* data,
                                intptr_t len,
                                Heap::Space space) {
@@ skipping 182 matching lines @@
   return NewExternalImpl<ExternalUint8Array, RawExternalUint8Array>(
       kClassId, data, len, peer, callback, space);
 }
 
 
 const char* ExternalUint8Array::ToCString() const {
   return "_ExternalUint8Array";
 }
 
 
+RawExternalUint8ClampedArray* ExternalUint8ClampedArray::New(
+    uint8_t* data,
+    intptr_t len,
+    void* peer,
+    Dart_PeerFinalizer callback,
+    Heap::Space space) {
+  ASSERT(Isolate::Current()->
+             object_store()->external_uint8_clamped_array_class() !=
+         Class::null());
+  return NewExternalImpl<ExternalUint8ClampedArray,
+      RawExternalUint8ClampedArray>(kClassId, data, len, peer, callback, space);
+}
+
+
+const char* ExternalUint8ClampedArray::ToCString() const {
+  return "_ExternalUint8ClampedArray";
+}
+
+
 RawExternalInt16Array* ExternalInt16Array::New(int16_t* data,
                                                intptr_t len,
                                                void* peer,
                                                Dart_PeerFinalizer callback,
                                                Heap::Space space) {
   ASSERT(Isolate::Current()->object_store()->external_int16_array_class() !=
          Class::null());
   return NewExternalImpl<ExternalInt16Array, RawExternalInt16Array>(
       kClassId, data, len, peer, callback, space);
 }
@@ skipping 424 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart