[Isolates] Clean up some usages of the heap macro.

src/runtime.cc

 // Copyright 2006-2009 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 1446 matching lines @@
   JSArray* result = JSArray::cast(args[0]);
   // Arguments to RegExpCloneResult should always be fresh RegExp exec call
   // results (either a fresh JSRegExpResult or null).
   // If the argument is not a JSRegExpResult, or isn't unmodified, just return
   // the argument uncloned.
   if (result->map() != regexp_result_map) return result;
 
   // Having the original JSRegExpResult map guarantees that we have
   // fast elements and no properties except the two in-object properties.
   ASSERT(result->HasFastElements());
-  ASSERT(result->properties() == HEAP->empty_fixed_array());
+  ASSERT(result->properties() == isolate->heap()->empty_fixed_array());
   ASSERT_EQ(2, regexp_result_map->inobject_properties());
 
-  Object* new_array_alloc = HEAP->AllocateRaw(JSRegExpResult::kSize,
-                                              NEW_SPACE,
-                                              OLD_POINTER_SPACE);
+  Object* new_array_alloc = isolate->heap()->AllocateRaw(JSRegExpResult::kSize,
+                                                         NEW_SPACE,
+                                                         OLD_POINTER_SPACE);
   if (new_array_alloc->IsFailure()) return new_array_alloc;
 
   // Set HeapObject map to JSRegExpResult map.
   reinterpret_cast<HeapObject*>(new_array_alloc)->set_map(regexp_result_map);
 
   JSArray* new_array = JSArray::cast(new_array_alloc);
 
   // Copy JSObject properties.
   new_array->set_properties(result->properties());  // Empty FixedArray.
 
   // Copy JSObject elements as copy-on-write.
   FixedArray* elements = FixedArray::cast(result->elements());
-  if (elements != HEAP->empty_fixed_array()) {
-    elements->set_map(HEAP->fixed_cow_array_map());
+  if (elements != isolate->heap()->empty_fixed_array()) {
+    elements->set_map(isolate->heap()->fixed_cow_array_map());
   }
   new_array->set_elements(elements);
 
   // Copy JSArray length.
   new_array->set_length(result->length());
 
   // Copy JSRegExpResult in-object property fields input and index.
   new_array->FastPropertyAtPut(JSRegExpResult::kIndexIndex,
                                result->FastPropertyAt(
                                    JSRegExpResult::kIndexIndex));
@@ skipping 4925 matching lines @@
   RUNTIME_GET_ISOLATE;
   NoHandleAllocation ha;
   ASSERT(args.length() == 2);
 
   CONVERT_DOUBLE_CHECKED(t, args[0]);
   CONVERT_CHECKED(JSArray, res_array, args[1]);
 
   int year, month, day;
   DateYMDFromTime(static_cast<int>(floor(t / 86400000)), year, month, day);
 
-  RUNTIME_ASSERT(res_array->elements()->map() == HEAP->fixed_array_map());
+  RUNTIME_ASSERT(res_array->elements()->map() ==
+                 isolate->heap()->fixed_array_map());
   FixedArray* elms = FixedArray::cast(res_array->elements());
   RUNTIME_ASSERT(elms->length() == 3);
 
   elms->set(0, Smi::FromInt(year));
   elms->set(1, Smi::FromInt(month));
   elms->set(2, Smi::FromInt(day));
 
   return isolate->heap()->undefined_value();
 }
 
@@ skipping 1427 matching lines @@
 
 
 // Move contents of argument 0 (an array) to argument 1 (an array)
 static Object* Runtime_MoveArrayContents(RUNTIME_CALLING_CONVENTION) {
   RUNTIME_GET_ISOLATE;
   ASSERT(args.length() == 2);
   CONVERT_CHECKED(JSArray, from, args[0]);
   CONVERT_CHECKED(JSArray, to, args[1]);
   HeapObject* new_elements = from->elements();
   Object* new_map;
-  if (new_elements->map() == HEAP->fixed_array_map() ||
-      new_elements->map() == HEAP->fixed_cow_array_map()) {
+  if (new_elements->map() == isolate->heap()->fixed_array_map() ||
+      new_elements->map() == isolate->heap()->fixed_cow_array_map()) {
     new_map = to->map()->GetFastElementsMap();
   } else {
     new_map = to->map()->GetSlowElementsMap();
   }
   if (new_map->IsFailure()) return new_map;
   to->set_map(Map::cast(new_map));
   to->set_elements(new_elements);
   to->set_length(from->length());
   Object* obj = from->ResetElements();
   if (obj->IsFailure()) return obj;
@@ skipping 2733 matching lines @@
 #define SETUP_RUNTIME_ENTRIES(Name, argc, resize)                              \
   entries_[lut_index].method = &CodeGenerator::Generate##Name;                 \
   entries_[lut_index].name = "_" #Name;                                        \
   entries_[lut_index++].nargs = argc;
   INLINE_RUNTIME_FUNCTION_LIST(SETUP_RUNTIME_ENTRIES);
 #undef SETUP_RUNTIME_ENTRIES
 }
 
 
 } }  // namespace v8::internal