Handlification of ArrayConstructorCommon().

src/objects.cc

Index: src/objects.cc
diff --git a/src/objects.cc b/src/objects.cc
index 787b6d82b47145688e92447ff2e57f24473ff5d7..3f6304a2bc0908f549ea9b6723a51ddc21f90192 100644
--- a/src/objects.cc
+++ b/src/objects.cc
@@ -11348,6 +11348,15 @@ MaybeObject* JSObject::SetFastDoubleElementsCapacityAndLength(
 }
 
 
+// TODO(ishell): temporary wrapper until handlified.
+// static
+void JSArray::Initialize(Handle<JSArray> array, int capacity, int length) {

[Yang, 2014/03/18 09:52:17]

Why is this still a "temporary wrapper"? Afaict the MaybeObject version of this
method is only used in test-heap.cc from within handlified code, why not replace
that last use and remove the MaybeObject version?

[Igor Sheludko, 2014/03/18 11:25:10]

Actually I did this in a next CL, but you are right. Done.

+  ASSERT(capacity >= 0);
+  array->GetIsolate()->factory()->NewJSArrayStorage(
+      array, length, capacity, INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
+}
+
+
 MaybeObject* JSArray::Initialize(int capacity, int length) {
   ASSERT(capacity >= 0);
   return GetHeap()->AllocateJSArrayStorage(this, length, capacity,
@@ -11430,6 +11439,16 @@ static void EndPerformSplice(Handle<JSArray> object) {
 }
 
 
+// TODO(ishell): Temporary wrapper until handlified.
+// static
+Handle<Object> JSArray::SetElementsLength(Handle<JSArray> array,
+                                          Handle<Object> length) {
+  CALL_HEAP_FUNCTION(array->GetIsolate(),
+                     array->SetElementsLength(*length),
+                     Object);
+}
+
+
 MaybeObject* JSArray::SetElementsLength(Object* len) {
   // We should never end in here with a pixel or external array.
   ASSERT(AllowsSetElementsLength());
@@ -11893,6 +11912,21 @@ Handle<Object> JSObject::SetPrototype(Handle<JSObject> object,
 }
 
 
+// TODO(ishell): temporary wrapper until handilfied.
+// static
+void JSObject::EnsureCanContainElements(Handle<JSObject> object,
+                                        Arguments* args,
+                                        uint32_t first_arg,
+                                        uint32_t arg_count,
+                                        EnsureElementsMode mode) {
+  CALL_HEAP_FUNCTION_VOID(object->GetIsolate(),
+                          object->EnsureCanContainElements(args,
+                                                           first_arg,
+                                                           arg_count,
+                                                           mode));
+}
+
+
 MaybeObject* JSObject::EnsureCanContainElements(Arguments* args,
                                                 uint32_t first_arg,
                                                 uint32_t arg_count,