[v8-dev] JSArray::SetContent() handlified. (issue 206223003)

Thu, 20 Mar 2014 07:14:44 -0700 

Reviewers: Yang,

Message:
PTAL

Description:
JSArray::SetContent() handlified.

Please review this at https://codereview.chromium.org/206223003/

SVN Base: https://v8.googlecode.com/svn/branches/bleeding_edge

Affected files (+42, -35 lines):
  M src/elements.cc
  M src/factory.h
  M src/factory.cc
  M src/objects-inl.h
  M src/objects.h
  M src/runtime.cc


Index: src/elements.cc
diff --git a/src/elements.cc b/src/elements.cc
index 5d3ef1308615ee8bc19e8a1879c2330ce5c0ec26..7730ce5ff7517f0b2405ea8089a1f227a5270d8e 100644 
--- a/src/elements.cc
+++ b/src/elements.cc
@@ -1975,12 +1975,11 @@ MUST_USE_RESULT Handle<Object> ElementsAccessorBase<ElementsAccessorSubclass, 
     }
   }

-  Factory* factory = isolate->factory();
   // Fall-back case: The new length is not a number so make the array
   // size one and set only element to length.
-  Handle<FixedArray> new_backing_store = factory->NewFixedArray(1);
+ Handle<FixedArray> new_backing_store = isolate->factory()->NewFixedArray(1); 
   new_backing_store->set(0, *length);
-  factory->SetContent(array, new_backing_store);
+  JSArray::SetContent(array, new_backing_store);
   return array;
 }

Index: src/factory.cc
diff --git a/src/factory.cc b/src/factory.cc
index 557760714cc0d2d143851f21b27340c6699045a5..00f0584413f24c3e0e54691d8595a0abaec4739d 100644 
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -1493,14 +1493,6 @@ void Factory::SetElementsCapacityAndLength(Handle<JSArray> array, 
 }


-void Factory::SetContent(Handle<JSArray> array,
-                         Handle<FixedArrayBase> elements) {
-  CALL_HEAP_FUNCTION_VOID(
-      isolate(),
-      array->SetContent(*elements));
-}
-
-
 Handle<JSGeneratorObject> Factory::NewJSGeneratorObject(
     Handle<JSFunction> function) {
   ASSERT(function->shared()->is_generator());
Index: src/factory.h
diff --git a/src/factory.h b/src/factory.h
index 22ec4d395ce628b04b9fc7e6e5dcb863f275c8a0..daece18b7f700590e6f27875c0ce0b41ced281bc 100644 
--- a/src/factory.h
+++ b/src/factory.h
@@ -374,8 +374,6 @@ class Factory {
                                     int capacity,
                                     int length);

-  void SetContent(Handle<JSArray> array, Handle<FixedArrayBase> elements);
-
Handle<JSGeneratorObject> NewJSGeneratorObject(Handle<JSFunction> function); 

   Handle<JSArrayBuffer> NewJSArrayBuffer();
Index: src/objects-inl.h
diff --git a/src/objects-inl.h b/src/objects-inl.h
index 811b2f9c8776de4613a1ece5b2f62deef2415204..03ca6697dc99a5f8c19697ad7629c281a8ad8a3b 100644 
--- a/src/objects-inl.h
+++ b/src/objects-inl.h
@@ -1662,6 +1662,19 @@ MaybeObject* JSObject::EnsureCanContainElements(Object** objects, 
 }


+// TODO(ishell): Temporary wrapper until handlified.
+// static
+void JSObject::EnsureCanContainElements(Handle<JSObject> object,
+                                        Handle<FixedArrayBase> elements,
+                                        uint32_t length,
+                                        EnsureElementsMode mode) {
+  CALL_HEAP_FUNCTION_VOID(object->GetIsolate(),
+                          object->EnsureCanContainElements(*elements,
+                                                           length,
+                                                           mode));
+}
+
+
 MaybeObject* JSObject::EnsureCanContainElements(FixedArrayBase* elements,
                                                 uint32_t length,
                                                 EnsureElementsMode mode) {
@@ -6568,19 +6581,20 @@ bool JSArray::AllowsSetElementsLength() {
 }


-MaybeObject* JSArray::SetContent(FixedArrayBase* storage) {
-  MaybeObject* maybe_result = EnsureCanContainElements(
-      storage, storage->length(), ALLOW_COPIED_DOUBLE_ELEMENTS);
-  if (maybe_result->IsFailure()) return maybe_result;
-  ASSERT((storage->map() == GetHeap()->fixed_double_array_map() &&
-          IsFastDoubleElementsKind(GetElementsKind())) ||
-         ((storage->map() != GetHeap()->fixed_double_array_map()) &&
-          (IsFastObjectElementsKind(GetElementsKind()) ||
-           (IsFastSmiElementsKind(GetElementsKind()) &&
-            FixedArray::cast(storage)->ContainsOnlySmisOrHoles()))));
-  set_elements(storage);
-  set_length(Smi::FromInt(storage->length()));
-  return this;
+// static
+void JSArray::SetContent(Handle<JSArray> array,
+                         Handle<FixedArrayBase> storage) {
+  EnsureCanContainElements(array, storage, storage->length(),
+                           ALLOW_COPIED_DOUBLE_ELEMENTS);
+
+  ASSERT((storage->map() == array->GetHeap()->fixed_double_array_map() &&
+          IsFastDoubleElementsKind(array->GetElementsKind())) ||
+         ((storage->map() != array->GetHeap()->fixed_double_array_map()) &&
+          (IsFastObjectElementsKind(array->GetElementsKind()) ||
+           (IsFastSmiElementsKind(array->GetElementsKind()) &&
+ Handle<FixedArray>::cast(storage)->ContainsOnlySmisOrHoles())))); 
+  array->set_elements(*storage);
+  array->set_length(Smi::FromInt(storage->length()));
 }


Index: src/objects.h
diff --git a/src/objects.h b/src/objects.h
index 25dbcbbfdb9299d344b7dfa0ecc444d7d5fd920c..7c8715234c8f8c0784deb497d5c63cd20503d92e 100644 
--- a/src/objects.h
+++ b/src/objects.h
@@ -2424,6 +2424,11 @@ class JSObject: public JSReceiver {
       Object** elements,
       uint32_t count,
       EnsureElementsMode mode);
+  static inline void EnsureCanContainElements(
+      Handle<JSObject> object,
+      Handle<FixedArrayBase> elements,
+      uint32_t length,
+      EnsureElementsMode mode);
   MUST_USE_RESULT inline MaybeObject* EnsureCanContainElements(
       FixedArrayBase* elements,
       uint32_t length,
@@ -10032,7 +10037,8 @@ class JSArray: public JSObject {
                                           Handle<Object> length);

   // Set the content of the array to the content of storage.
-  MUST_USE_RESULT inline MaybeObject* SetContent(FixedArrayBase* storage);
+  static inline void SetContent(Handle<JSArray> array,
+                                Handle<FixedArrayBase> storage);

   // Casting.
   static inline JSArray* cast(Object* obj);
Index: src/runtime.cc
diff --git a/src/runtime.cc b/src/runtime.cc
index cc7942f0b427b70f0e413b188c16f6739a14d80e..f84f3d825c54b59e968e8681d81e1ec7b2a07db9 100644 
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -3289,8 +3289,7 @@ class FixedArrayBuilder {
   }

   Handle<JSArray> ToJSArray(Handle<JSArray> target_array) {
-    Factory* factory = target_array->GetIsolate()->factory();
-    factory->SetContent(target_array, array_);
+    JSArray::SetContent(target_array, array_);
     target_array->set_length(Smi::FromInt(length_));
     return target_array;
   }
@@ -4566,7 +4565,7 @@ static MaybeObject* SearchRegExpMultiple(
       Handle<FixedArray> cached_fixed_array =
           Handle<FixedArray>(FixedArray::cast(*cached_answer));
       // The cache FixedArray is a COW-array and can therefore be reused.
-      isolate->factory()->SetContent(result_array, cached_fixed_array);
+      JSArray::SetContent(result_array, cached_fixed_array);
// The actual length of the result array is stored in the last element of // the backing store (the backing FixedArray may have a larger capacity). 
       Object* cached_fixed_array_last_element =
@@ -9684,8 +9683,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DateCacheVersion) { 
   // Return result as a JS array.
   Handle<JSObject> result =
       isolate->factory()->NewJSObject(isolate->array_function());
-  isolate->factory()->SetContent(Handle<JSArray>::cast(result),
-                                 date_cache_version);
+  JSArray::SetContent(Handle<JSArray>::cast(result), date_cache_version);
   return *result;
 }
@@ -12961,7 +12959,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugGetLoadedScripts) { 
   // Return result as a JS array.
   Handle<JSObject> result =
       isolate->factory()->NewJSObject(isolate->array_function());
-  isolate->factory()->SetContent(Handle<JSArray>::cast(result), instances);
+  JSArray::SetContent(Handle<JSArray>::cast(result), instances);
   return *result;
 }
@@ -13091,7 +13089,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugReferencedBy) { 
       isolate->context()->native_context()->array_function());

   Handle<JSObject> result = isolate->factory()->NewJSObject(constructor);
-  isolate->factory()->SetContent(Handle<JSArray>::cast(result), instances);
+  JSArray::SetContent(Handle<JSArray>::cast(result), instances);
   return *result;
 }
@@ -13169,7 +13167,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugConstructedBy) { 
   Handle<JSFunction> array_function(
       isolate->context()->native_context()->array_function());
Handle<JSObject> result = isolate->factory()->NewJSObject(array_function); 
-  isolate->factory()->SetContent(Handle<JSArray>::cast(result), instances);
+  JSArray::SetContent(Handle<JSArray>::cast(result), instances);
   return *result;
 }



--
--
v8-dev mailing list
v8-dev@googlegroups.com
http://groups.google.com/group/v8-dev
--- You received this message because you are subscribed to the Google Groups "v8-dev" group. 
To unsubscribe from this group and stop receiving emails from it, send an email 
to v8-dev+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to