Fix FixedUint8ClampedArray::SetValue.

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 15596 matching lines @@
 
 static void CheckElementValue(i::Isolate* isolate,
                               int expected,
                               i::Handle<i::Object> obj,
                               int offset) {
   i::Object* element = *i::Object::GetElement(isolate, obj, offset);
   CHECK_EQ(expected, i::Smi::cast(element)->value());
 }
 
 
-THREADED_TEST(PixelArray) {
+template <class ArrayType, int kElementCount>
+void DoTestUint8ClampedArray(
+    i::Handle<ArrayType> pixels, v8::Handle<v8::Object> obj,
+    uint8_t* pixel_data) {
   LocalContext context;
   i::Isolate* isolate = CcTest::i_isolate();
-  i::Factory* factory = isolate->factory();
   v8::HandleScope scope(context->GetIsolate());
-  const int kElementCount = 260;
-  uint8_t* pixel_data = reinterpret_cast<uint8_t*>(malloc(kElementCount));
-  i::Handle<i::ExternalUint8ClampedArray> pixels =
-      i::Handle<i::ExternalUint8ClampedArray>::cast(
-          factory->NewExternalArray(kElementCount,
-                                    v8::kExternalUint8ClampedArray,
-                                    pixel_data));
-  // Force GC to trigger verification.
-  CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
   for (int i = 0; i < kElementCount; i++) {
     pixels->set(i, i % 256);
   }
   // Force GC to trigger verification.
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
   for (int i = 0; i < kElementCount; i++) {
     CHECK_EQ(i % 256, pixels->get_scalar(i));
-    CHECK_EQ(i % 256, pixel_data[i]);
+    if (pixel_data != NULL) {
+      CHECK_EQ(i % 256, pixel_data[i]);
+    }
   }
 
-  v8::Handle<v8::Object> obj = v8::Object::New(context->GetIsolate());
   i::Handle<i::JSObject> jsobj = v8::Utils::OpenHandle(*obj);
-  // Set the elements to be the pixels.
-  // jsobj->set_elements(*pixels);
-  obj->SetIndexedPropertiesToPixelData(pixel_data, kElementCount);
   CheckElementValue(isolate, 1, jsobj, 1);
   obj->Set(v8_str("field"), v8::Int32::New(CcTest::isolate(), 1503));
   context->Global()->Set(v8_str("pixels"), obj);
   v8::Handle<v8::Value> result = CompileRun("pixels.field");
   CHECK_EQ(1503, result->Int32Value());
   result = CompileRun("pixels[1]");
   CHECK_EQ(1, result->Int32Value());
 
+  ArrayType::SetValue(pixels, 0, i::handle(i::Smi::FromInt(256), isolate));
+  CHECK_EQ(255, pixels->get_scalar(0));
+  ArrayType::SetValue(pixels, 0, i::handle(i::Smi::FromInt(-1), isolate));
+  CHECK_EQ(0, pixels->get_scalar(0));
+  ArrayType::SetValue(pixels, 0, isolate->factory()->NewNumber(1025.73));
+  CHECK_EQ(255, pixels->get_scalar(0));
+  ArrayType::SetValue(pixels, 0, isolate->factory()->NewNumber(-1025.73));
+  CHECK_EQ(0, pixels->get_scalar(0));
+
+  pixels->set(0, 0);
+
   result = CompileRun("var sum = 0;"
                       "for (var i = 0; i < 8; i++) {"
                       "  sum += pixels[i] = pixels[i] = -i;"
                       "}"
                       "sum;");
   CHECK_EQ(-28, result->Int32Value());
 
   result = CompileRun("var sum = 0;"
                       "for (var i = 0; i < 8; i++) {"
                       "  sum += pixels[i] = pixels[i] = 0;"
@@ skipping 139 matching lines @@
                       "js_array.concat(pixels);");
   CHECK_EQ(77, v8::Object::Cast(*result)->Get(v8_str("0"))->Int32Value());
   CHECK_EQ(23, v8::Object::Cast(*result)->Get(v8_str("1"))->Int32Value());
 
   result = CompileRun("pixels[1] = 23;");
   CHECK_EQ(23, result->Int32Value());
 
   // Test for index greater than 255.  Regression test for:
   // http://code.google.com/p/chromium/issues/detail?id=26337.
   result = CompileRun("pixels[256] = 255;");
-  CHECK_EQ(255, result->Int32Value());
-  result = CompileRun("var i = 0;"
-                      "for (var j = 0; j < 8; j++) { i = pixels[256]; }"
-                      "i");
-  CHECK_EQ(255, result->Int32Value());
+  if (pixel_data != NULL) {
+    v8::Handle<v8::Object> obj = v8::Object::New(context->GetIsolate());
+    // Set the elements to be the pixels.
+    // jsobj->set_elements(*pixels);
+    obj->SetIndexedPropertiesToPixelData(pixel_data, kElementCount);
+    CHECK_EQ(255, result->Int32Value());
+    result = CompileRun("var i = 0;"
+                        "for (var j = 0; j < 8; j++) { i = pixels[256]; }"
+                        "i");
+    CHECK_EQ(255, result->Int32Value());
+  }
 
   // Make sure that pixel array ICs recognize when a non-pixel array
   // is passed to it.
   result = CompileRun("function pa_load(p) {"
                       "  var sum = 0;"
                       "  for (var j = 0; j < 256; j++) { sum += p[j]; }"
                       "  return sum;"
                       "}"
                       "for (var i = 0; i < 256; ++i) { pixels[i] = i; }"
                       "for (var i = 0; i < 10; ++i) { pa_load(pixels); }"
@@ skipping 155 matching lines @@
                       "    sum += p[i];"
                       "  }"
                       "  return sum; "
                       "}"
                       "for (var i = 0; i < 5000; ++i) {"
                       "  pa_init(pixels);"
                       "}"
                       "result = pa_load(pixels);"
                       "result");
   CHECK_EQ(32640, result->Int32Value());
+}
 
+
+THREADED_TEST(PixelArray) {
+  LocalContext context;
+  i::Isolate* isolate = CcTest::i_isolate();
+  i::Factory* factory = isolate->factory();
+  v8::HandleScope scope(context->GetIsolate());
+  const int kElementCount = 260;
+  uint8_t* pixel_data = reinterpret_cast<uint8_t*>(malloc(kElementCount));
+  i::Handle<i::ExternalUint8ClampedArray> pixels =
+      i::Handle<i::ExternalUint8ClampedArray>::cast(
+          factory->NewExternalArray(kElementCount,
+                                    v8::kExternalUint8ClampedArray,
+                                    pixel_data));
+  // Force GC to trigger verification.
+  CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+  v8::Handle<v8::Object> obj = v8::Object::New(context->GetIsolate());
+  obj->SetIndexedPropertiesToPixelData(pixel_data, kElementCount);
+  DoTestUint8ClampedArray<i::ExternalUint8ClampedArray, kElementCount>(
+      pixels, obj, pixel_data);
   free(pixel_data);
 }
 
 
+THREADED_TEST(FixedPixelArray) {
+  LocalContext context;
+  i::Isolate* isolate = CcTest::i_isolate();
+  i::Factory* factory = isolate->factory();
+  v8::HandleScope scope(context->GetIsolate());
+  const int kElementCount = 260;
+  i::Handle<i::FixedUint8ClampedArray> pixels =
+      i::Handle<i::FixedUint8ClampedArray>::cast(
+          factory->NewFixedTypedArray(kElementCount,
+                                    v8::kExternalUint8ClampedArray));
+  // Force GC to trigger verification.
+  CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+  v8::Handle<v8::Object> obj = v8::Object::New(context->GetIsolate());
+  i::Handle<i::JSObject> jsobj = v8::Utils::OpenHandle(*obj);
+  // Set the elements to be the pixels.
+  i::Handle<i::Map> fixed_array_map =
+      i::JSObject::GetElementsTransitionMap(jsobj, i::UINT8_CLAMPED_ELEMENTS);
+  jsobj->set_map(*fixed_array_map);
+  jsobj->set_elements(*pixels);
+  DoTestUint8ClampedArray<i::FixedUint8ClampedArray, kElementCount>(
+      pixels, obj, NULL);
+}
+
+
 THREADED_TEST(PixelArrayInfo) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   for (int size = 0; size < 100; size += 10) {
     uint8_t* pixel_data = reinterpret_cast<uint8_t*>(malloc(size));
     v8::Handle<v8::Object> obj = v8::Object::New(context->GetIsolate());
     obj->SetIndexedPropertiesToPixelData(pixel_data, size);
     CHECK(obj->HasIndexedPropertiesInPixelData());
     CHECK_EQ(pixel_data, obj->GetIndexedPropertiesPixelData());
     CHECK_EQ(size, obj->GetIndexedPropertiesPixelDataLength());
@@ skipping 397 matching lines @@
   i::Factory* factory = isolate->factory();
   v8::HandleScope scope(context->GetIsolate());
   const int kElementCount = 260;
   i::Handle<FixedTypedArrayClass> fixed_array =
     i::Handle<FixedTypedArrayClass>::cast(
         factory->NewFixedTypedArray(kElementCount, array_type));
   CHECK_EQ(FixedTypedArrayClass::kInstanceType,
            fixed_array->map()->instance_type());
   CHECK_EQ(kElementCount, fixed_array->length());
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
+
   for (int i = 0; i < kElementCount; i++) {
     fixed_array->set(i, static_cast<ElementType>(i));
   }
   // Force GC to trigger verification.
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
   for (int i = 0; i < kElementCount; i++) {
     CHECK_EQ(static_cast<int64_t>(static_cast<ElementType>(i)),
              static_cast<int64_t>(fixed_array->get_scalar(i)));
   }
   v8::Handle<v8::Object> obj = v8::Object::New(CcTest::isolate());
@@ skipping 5933 matching lines @@
              "f.call(friend);");
   CHECK_EQ(2, named_access_count);
 
   // Test access using Object.setPrototypeOf reflective method.
   named_access_count = 0;
   CompileRun("Object.setPrototypeOf(friend, {});");
   CHECK_EQ(1, named_access_count);
   CompileRun("Object.getPrototypeOf(friend);");
   CHECK_EQ(2, named_access_count);
 }