JSArray::SetContent() handlified.

src/runtime.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 3271 matching lines @@
 
   int length() {
     return length_;
   }
 
   int capacity() {
     return array_->length();
   }
 
   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;
   }
 
 
  private:
   Handle<FixedArray> array_;
   int length_;
   bool has_non_smi_elements_;
 };
@@ skipping 1255 matching lines @@
   if (subject_length > kMinLengthToCache) {
     Handle<Object> cached_answer(RegExpResultsCache::Lookup(
         isolate->heap(),
         *subject,
         regexp->data(),
         RegExpResultsCache::REGEXP_MULTIPLE_INDICES), isolate);
     if (*cached_answer != Smi::FromInt(0)) {
       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 =
           cached_fixed_array->get(cached_fixed_array->length() - 1);
       Smi* js_array_length = Smi::cast(cached_fixed_array_last_element);
       result_array->set_length(js_array_length);
       RegExpImpl::SetLastMatchInfo(
           last_match_array, subject, capture_count, NULL);
       return *result_array;
     }
@@ skipping 5097 matching lines @@
     date_cache_version->set(0, Smi::FromInt(0));
     isolate->eternal_handles()->CreateSingleton(
         isolate, *date_cache_version, EternalHandles::DATE_CACHE_VERSION);
   }
   Handle<FixedArray> date_cache_version =
       Handle<FixedArray>::cast(isolate->eternal_handles()->GetSingleton(
           EternalHandles::DATE_CACHE_VERSION));
   // 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;
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_GlobalReceiver) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
   Object* global = args[0];
   if (!global->IsJSGlobalObject()) return isolate->heap()->null_value();
   return JSGlobalObject::cast(global)->global_receiver();
@@ skipping 3255 matching lines @@
     //   instances->set(i, *GetScriptWrapper(script))
     // is unsafe as GetScriptWrapper might call GC and the C++ compiler might
     // already have dereferenced the instances handle.
     Handle<JSValue> wrapper = GetScriptWrapper(script);
     instances->set(i, *wrapper);
   }
 
   // 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;
 }
 
 
 // Helper function used by Runtime_DebugReferencedBy below.
 static int DebugReferencedBy(HeapIterator* iterator,
                              JSObject* target,
                              Object* instance_filter, int max_references,
                              FixedArray* instances, int instances_size,
                              JSFunction* arguments_function) {
@@ skipping 109 matching lines @@
   HeapIterator heap_iterator2(heap);
   count = DebugReferencedBy(&heap_iterator2,
                             *target, *instance_filter, max_references,
                             *instances, count, *arguments_function);
 
   // Return result as JS array.
   Handle<JSFunction> constructor(
       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;
 }
 
 
 // Helper function used by Runtime_DebugConstructedBy below.
 static int DebugConstructedBy(HeapIterator* iterator,
                               JSFunction* constructor,
                               int max_references,
                               FixedArray* instances,
                               int instances_size) {
@@ skipping 57 matching lines @@
   count = DebugConstructedBy(&heap_iterator2,
                              *constructor,
                              max_references,
                              *instances,
                              count);
 
   // Return result as JS array.
   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;
 }
 
 
 // Find the effective prototype object as returned by __proto__.
 // args[0]: the object to find the prototype for.
 RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugGetPrototype) {
   SealHandleScope shs(isolate);
   ASSERT(args.length() == 1);
   CONVERT_ARG_CHECKED(JSObject, obj, 0);
@@ skipping 1844 matching lines @@
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "Runtime::PerformGC");
   }
 }
 
 
 } }  // namespace v8::internal