Cleanup of HEAP and FACTORY macro usage in accessors.cc.

src/accessors.cc

 // Copyright 2006-2008 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 101 matching lines @@
   bool has_exception;
   Handle<Object> uint32_v = Execution::ToUint32(value_handle, &has_exception);
   if (has_exception) return Failure::Exception();
   Handle<Object> number_v = Execution::ToNumber(value_handle, &has_exception);
   if (has_exception) return Failure::Exception();
 
   // Restore raw pointers,
   object = *object_handle;
   value = *value_handle;
 
+  Isolate* isolate = Isolate::Current();

[Mads Ager (chromium), 2011/03/28 12:59:52]

Please get the isolate from the object parameter instead of taking it through
thread-local storage: object->GetIsolate().

Also, please extract it before creating the handle scope and pass it in as an
argument there as well. Also pass it to the handle constructor.

+
   if (uint32_v->Number() == number_v->Number()) {
     if (object->IsJSArray()) {
       return JSArray::cast(object)->SetElementsLength(*uint32_v);
     } else {
       // This means one of the object's prototypes is a JSArray and
       // the object does not have a 'length' property.
       // Calling SetProperty causes an infinite loop.
-      return object->SetLocalPropertyIgnoreAttributes(HEAP->length_symbol(),
-                                                      value, NONE);
+      return object->SetLocalPropertyIgnoreAttributes(
+              isolate->heap()->length_symbol(), value, NONE);
     }
   }
-  return Isolate::Current()->Throw(
-      *FACTORY->NewRangeError("invalid_array_length",
+  return isolate->Throw(
+      *isolate->factory()->NewRangeError("invalid_array_length",
           HandleVector<Object>(NULL, 0)));
 }
 
 
 const AccessorDescriptor Accessors::ArrayLength = {
   ArrayGetLength,
   ArraySetLength,
   0
 };
 
@@ skipping 163 matching lines @@
   0
 };
 
 
 //
 // Accessors::ScriptGetLineEnds
 //
 
 
 MaybeObject* Accessors::ScriptGetLineEnds(Object* object, void*) {
+  Isolate* isolate = Isolate::Current();

[Mads Ager (chromium), 2011/03/28 12:59:52]

Please extract the isolate from the object. The object is casted to a JSValue
which is a heap object from which you can get the isolate. Pass the isolate
pointer to the handle scope constructor and the handle constructor.

   HandleScope scope;
   Handle<Script> script(Script::cast(JSValue::cast(object)->value()));
   InitScriptLineEnds(script);
   ASSERT(script->line_ends()->IsFixedArray());
   Handle<FixedArray> line_ends(FixedArray::cast(script->line_ends()));
   // We do not want anyone to modify this array from JS.
-  ASSERT(*line_ends == HEAP->empty_fixed_array() ||
-         line_ends->map() == HEAP->fixed_cow_array_map());
-  Handle<JSArray> js_array = FACTORY->NewJSArrayWithElements(line_ends);
+  ASSERT(*line_ends == isolate->heap()->empty_fixed_array() ||
+         line_ends->map() == isolate->heap()->fixed_cow_array_map());
+  Handle<JSArray> js_array =
+      isolate->factory()->NewJSArrayWithElements(line_ends);
   return *js_array;
 }
 
 
 const AccessorDescriptor Accessors::ScriptLineEnds = {
   ScriptGetLineEnds,
   IllegalSetter,
   0
 };
 
@@ skipping 100 matching lines @@
   0
 };
 
 
 //
 // Accessors::FunctionPrototype
 //
 
 
 MaybeObject* Accessors::FunctionGetPrototype(Object* object, void*) {
+  Heap* heap = HEAP;
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
-  if (!found_it) return HEAP->undefined_value();
+  if (!found_it) return heap->undefined_value();
   while (!function->should_have_prototype()) {
     found_it = false;
     function = FindInPrototypeChain<JSFunction>(object->GetPrototype(),
                                                 &found_it);
     // There has to be one because we hit the getter.
     ASSERT(found_it);
   }
 
   if (!function->has_prototype()) {
     Object* prototype;
-    { MaybeObject* maybe_prototype = HEAP->AllocateFunctionPrototype(function);
+    { MaybeObject* maybe_prototype = heap->AllocateFunctionPrototype(function);
       if (!maybe_prototype->ToObject(&prototype)) return maybe_prototype;
     }
     Object* result;
     { MaybeObject* maybe_result = function->SetPrototype(prototype);
       if (!maybe_result->ToObject(&result)) return maybe_result;
     }
   }
   return function->prototype();
 }
 
 
 MaybeObject* Accessors::FunctionSetPrototype(JSObject* object,
                                              Object* value,
                                              void*) {
+  Heap* heap = HEAP;
   bool found_it = false;
   JSFunction* function = FindInPrototypeChain<JSFunction>(object, &found_it);
-  if (!found_it) return HEAP->undefined_value();
+  if (!found_it) return heap->undefined_value();
   if (!function->should_have_prototype()) {
     // Since we hit this accessor, object will have no prototype property.
-    return object->SetLocalPropertyIgnoreAttributes(HEAP->prototype_symbol(),
+    return object->SetLocalPropertyIgnoreAttributes(heap->prototype_symbol(),
                                                     value,
                                                     NONE);
   }
 
   if (function->has_initial_map()) {
     // If the function has allocated the initial map
     // replace it with a copy containing the new prototype.
     Object* new_map;
     { MaybeObject* maybe_new_map =
           function->initial_map()->CopyDropTransitions();
@@ skipping 424 matching lines @@
 }
 
 
 const AccessorDescriptor Accessors::ObjectPrototype = {
   ObjectGetPrototype,
   ObjectSetPrototype,
   0
 };
 
 } }  // namespace v8::internal