[Isolates] ScavengeVisitor gets member Heap*.

src/spaces-inl.h

 // 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 39 matching lines @@
                ? space_->first_page_
                : prev_page_->next_page();
   return prev_page_;
 }
 
 
 // -----------------------------------------------------------------------------
 // Page
 
 Page* Page::next_page() {
-  return Isolate::Current()->memory_allocator()->GetNextPage(this);
+  return heap_->isolate()->memory_allocator()->GetNextPage(this);
 }
 
 
 Address Page::AllocationTop() {
-  PagedSpace* owner = Isolate::Current()->memory_allocator()->PageOwner(this);
+  PagedSpace* owner = heap_->isolate()->memory_allocator()->PageOwner(this);
   return owner->PageAllocationTop(this);
 }
 
 
 Address Page::AllocationWatermark() {
-  PagedSpace* owner = Isolate::Current()->memory_allocator()->PageOwner(this);
+  PagedSpace* owner = heap_->isolate()->memory_allocator()->PageOwner(this);
   if (this == owner->AllocationTopPage()) {
     return owner->top();
   }
   return address() + AllocationWatermarkOffset();
 }
 
 
 uint32_t Page::AllocationWatermarkOffset() {
   return static_cast<uint32_t>((flags_ & kAllocationWatermarkOffsetMask) >>
                                kAllocationWatermarkOffsetShift);
 }
 
 
 void Page::SetAllocationWatermark(Address allocation_watermark) {
-  if ((HEAP->gc_state() == Heap::SCAVENGE) && IsWatermarkValid()) {
+  if ((heap_->gc_state() == Heap::SCAVENGE) && IsWatermarkValid()) {
     // When iterating intergenerational references during scavenge
     // we might decide to promote an encountered young object.
     // We will allocate a space for such an object and put it
     // into the promotion queue to process it later.
     // If space for object was allocated somewhere beyond allocation
     // watermark this might cause garbage pointers to appear under allocation
     // watermark. To avoid visiting them during dirty regions iteration
     // which might be still in progress we store a valid allocation watermark
     // value and mark this page as having an invalid watermark.
     SetCachedAllocationWatermark(AllocationWatermark());
@@ skipping 116 matching lines @@
   while (++rstart < rend) {
     bitmask |= 1 << rstart;
   }
 
   if (bitmask) {
     SetRegionMarks(GetRegionMarks() & ~bitmask);
   }
 }
 
 
-void Page::FlipMeaningOfInvalidatedWatermarkFlag() {
-  HEAP->page_watermark_invalidated_mark_ ^= 1 << WATERMARK_INVALIDATED;
+void Page::FlipMeaningOfInvalidatedWatermarkFlag(Heap* heap) {
+  heap->page_watermark_invalidated_mark_ ^= 1 << WATERMARK_INVALIDATED;
 }
 
 
 bool Page::IsWatermarkValid() {
   return (flags_ & (1 << WATERMARK_INVALIDATED)) !=
-      HEAP->page_watermark_invalidated_mark_;
+      heap_->page_watermark_invalidated_mark_;
 }
 
 
 void Page::InvalidateWatermark(bool value) {
   if (value) {
     flags_ = (flags_ & ~(1 << WATERMARK_INVALIDATED)) |
-             HEAP->page_watermark_invalidated_mark_;
+             heap_->page_watermark_invalidated_mark_;
   } else {
     flags_ =
         (flags_ & ~(1 << WATERMARK_INVALIDATED)) |
-        (HEAP->page_watermark_invalidated_mark_ ^ (1 << WATERMARK_INVALIDATED));
+        (heap_->page_watermark_invalidated_mark_ ^ (1 << WATERMARK_INVALIDATED));
   }
 
   ASSERT(IsWatermarkValid() == !value);
 }
 
 
 bool Page::GetPageFlag(PageFlag flag) {
   return (flags_ & static_cast<intptr_t>(1 << flag)) != 0;
 }
 
 
 void Page::SetPageFlag(PageFlag flag, bool value) {
   if (value) {
     flags_ |= static_cast<intptr_t>(1 << flag);
   } else {
     flags_ &= ~static_cast<intptr_t>(1 << flag);
   }
 }
 
 
 void Page::ClearPageFlags() {
   flags_ = 0;
 }
 
 
 void Page::ClearGCFields() {
   InvalidateWatermark(true);
   SetAllocationWatermark(ObjectAreaStart());
-  if (HEAP->gc_state() == Heap::SCAVENGE) {
+  if (heap_->gc_state() == Heap::SCAVENGE) {
     SetCachedAllocationWatermark(ObjectAreaStart());
   }
   SetRegionMarks(kAllRegionsCleanMarks);
 }
 
 
 bool Page::WasInUseBeforeMC() {
   return GetPageFlag(WAS_IN_USE_BEFORE_MC);
 }
 
@@ skipping 124 matching lines @@
 #endif
 
 
 // --------------------------------------------------------------------------
 // PagedSpace
 
 bool PagedSpace::Contains(Address addr) {
   Page* p = Page::FromAddress(addr);
   ASSERT(p->is_valid());
 
-  return Isolate::Current()->memory_allocator()->IsPageInSpace(p, this);
+  return heap()->isolate()->memory_allocator()->IsPageInSpace(p, this);
 }
 
 
 // Try linear allocation in the page of alloc_info's allocation top.  Does
 // not contain slow case logic (eg, move to the next page or try free list
 // allocation) so it can be used by all the allocation functions and for all
 // the paged spaces.
 HeapObject* PagedSpace::AllocateLinearly(AllocationInfo* alloc_info,
                                          int size_in_bytes) {
   Address current_top = alloc_info->top;
@@ skipping 62 matching lines @@
   ASSERT(space->low() <= alloc_info->top
          && alloc_info->top <= space->high()
          && alloc_info->limit == space->high());
 #endif
   return obj;
 }
 
 
 int LargeObjectSpace::Available() {
   return LargeObjectChunk::ObjectSizeFor(
-      Isolate::Current()->memory_allocator()->Available());
+      heap()->isolate()->memory_allocator()->Available());
 }
 
 
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   return object->map() == HEAP->raw_unchecked_byte_array_map()
       || object->map() == HEAP->raw_unchecked_one_pointer_filler_map()
       || object->map() == HEAP->raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_