FastElementsAccessor::SetLengthWithoutNormalize() handlified.

src/elements.cc

Index: src/elements.cc
diff --git a/src/elements.cc b/src/elements.cc
index 527df6e3d753cf9386839413d78dc5f9a610447b..5a6f91b4816f9bf5dbcac569b42114d577dac700 100644
--- a/src/elements.cc
+++ b/src/elements.cc
@@ -784,6 +784,16 @@ class ElementsAccessorBase : public ElementsAccessor {
     return obj;
   }
 
+  // TODO(ishell): Temporary wrapper until handlified.
+  MUST_USE_RESULT static Handle<FixedArray> SetFastElementsCapacityAndLength(
+      Handle<JSObject> obj,
+      int capacity,
+      int length) {
+    CALL_HEAP_FUNCTION(obj->GetIsolate(),
+                       SetFastElementsCapacityAndLength(*obj, capacity, length),
+                       FixedArray);
+  }
+
   MUST_USE_RESULT virtual Handle<Object> Delete(
       Handle<JSObject> obj,
       uint32_t key,
@@ -978,28 +988,28 @@ class FastElementsAccessor
 
   // Adjusts the length of the fast backing store or returns the new length or
   // undefined in case conversion to a slow backing store should be performed.
-  static MaybeObject* SetLengthWithoutNormalize(FixedArrayBase* backing_store,
-                                                JSArray* array,
-                                                Object* length_object,
-                                                uint32_t length) {
+  static Handle<Object> SetLengthWithoutNormalize(
+      Handle<FixedArrayBase> backing_store,
+      Handle<JSArray> array,
+      Handle<Object> length_object,
+      uint32_t length) {
+    Isolate* isolate = array->GetIsolate();
     uint32_t old_capacity = backing_store->length();
-    Object* old_length = array->length();
+    Handle<Object> old_length(array->length(), isolate);
     bool same_or_smaller_size = old_length->IsSmi() &&
-        static_cast<uint32_t>(Smi::cast(old_length)->value()) >= length;
+        static_cast<uint32_t>(Handle<Smi>::cast(old_length)->value()) >= length;
     ElementsKind kind = array->GetElementsKind();
 
     if (!same_or_smaller_size && IsFastElementsKind(kind) &&
         !IsFastHoleyElementsKind(kind)) {
       kind = GetHoleyElementsKind(kind);
-      MaybeObject* maybe_obj = array->TransitionElementsKind(kind);
-      if (maybe_obj->IsFailure()) return maybe_obj;
+      JSObject::TransitionElementsKind(array, kind);
     }
 
     // Check whether the backing store should be shrunk.
     if (length <= old_capacity) {
       if (array->HasFastSmiOrObjectElements()) {
-        MaybeObject* maybe_obj = array->EnsureWritableFastElements();
-        if (!maybe_obj->To(&backing_store)) return maybe_obj;
+        backing_store = JSObject::EnsureWritableFastElements(array);
       }
       if (2 * length <= old_capacity) {
         // If more than half the elements won't be used, trim the array.
@@ -1016,7 +1026,7 @@ class FastElementsAccessor
         // Otherwise, fill the unused tail with holes.
         int old_length = FastD2IChecked(array->length()->Number());
         for (int i = length; i < old_length; i++) {
-          BackingStore::cast(backing_store)->set_the_hole(i);
+          Handle<BackingStore>::cast(backing_store)->set_the_hole(i);
         }
       }
       return length_object;
@@ -1026,27 +1036,14 @@ class FastElementsAccessor
     uint32_t min = JSObject::NewElementsCapacity(old_capacity);
     uint32_t new_capacity = length > min ? length : min;
     if (!array->ShouldConvertToSlowElements(new_capacity)) {
-      MaybeObject* result = FastElementsAccessorSubclass::
+      FastElementsAccessorSubclass::
           SetFastElementsCapacityAndLength(array, new_capacity, length);
-      if (result->IsFailure()) return result;
       array->ValidateElements();
       return length_object;
     }
 
     // Request conversion to slow elements.
-    return array->GetHeap()->undefined_value();
-  }
-
-  // TODO(ishell): Temporary wrapper until handlified.
-  static Handle<Object> SetLengthWithoutNormalize(
-      Handle<FixedArrayBase> backing_store,
-      Handle<JSArray> array,
-      Handle<Object> length_object,
-      uint32_t length) {
-    CALL_HEAP_FUNCTION(array->GetIsolate(),
-                       SetLengthWithoutNormalize(
-                           *backing_store, *array, *length_object, length),
-                       Object);
+    return isolate->factory()->undefined_value();
   }
 
   static Handle<Object> DeleteCommon(Handle<JSObject> obj,
@@ -1244,6 +1241,16 @@ class FastSmiOrObjectElementsAccessor
                                                  length,
                                                  set_capacity_mode);
   }
+
+  // TODO(ishell): Temporary wrapper until handlified.
+  static Handle<FixedArray> SetFastElementsCapacityAndLength(
+      Handle<JSObject> obj,
+      int capacity,
+      int length) {
+    CALL_HEAP_FUNCTION(obj->GetIsolate(),
+                       SetFastElementsCapacityAndLength(*obj, capacity, length),
+                       FixedArray);
+  }
 };
 
 
@@ -1314,6 +1321,16 @@ class FastDoubleElementsAccessor
                                                        length);
   }
 
+  // TODO(ishell): Temporary wrapper until handlified.
+  static Handle<FixedArray> SetFastElementsCapacityAndLength(
+      Handle<JSObject> obj,
+      int capacity,
+      int length) {
+    CALL_HEAP_FUNCTION(obj->GetIsolate(),
+                       SetFastElementsCapacityAndLength(*obj, capacity, length),
+                       FixedArray);
+  }
+
  protected:
   static MaybeObject* CopyElementsImpl(FixedArrayBase* from,
                                        uint32_t from_start,