Revert of Replace slots buffer with remembered set.

src/heap/spaces-inl.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_SPACES_INL_H_
 #define V8_HEAP_SPACES_INL_H_
 
 #include "src/heap/incremental-marking.h"
 #include "src/heap/spaces.h"
 #include "src/isolate.h"
@@ skipping 129 matching lines @@
         DCHECK_CODEOBJECT_SIZE(obj_size, space_);
       } else {
         DCHECK_OBJECT_SIZE(obj_size);
       }
       return obj;
     }
   }
   return NULL;
 }
 
-// -----------------------------------------------------------------------------
-// LargePageIterator
-
-LargePageIterator::LargePageIterator(LargeObjectSpace* space)
-    : next_page_(space->first_page()) {}
-
-LargePage* LargePageIterator::next() {
-  LargePage* result = next_page_;
-  if (next_page_ != nullptr) {
-    next_page_ = next_page_->next_page();
-  }
-  return result;
-}
 
 // -----------------------------------------------------------------------------
 // MemoryAllocator
 
 #ifdef ENABLE_HEAP_PROTECTION
 
 void MemoryAllocator::Protect(Address start, size_t size) {
   base::OS::Protect(start, size);
 }
 
@@ skipping 141 matching lines @@
   if (offset < MemoryChunk::kHeaderSize || !chunk->HasPageHeader()) {
     chunk = heap->lo_space()->FindPage(addr);
   }
   return chunk;
 }
 
 Page* Page::FromAnyPointerAddress(Heap* heap, Address addr) {
   return static_cast<Page*>(MemoryChunk::FromAnyPointerAddress(heap, addr));
 }
 
-MemoryChunkIterator::MemoryChunkIterator(Heap* heap, Mode mode)
+
+PointerChunkIterator::PointerChunkIterator(Heap* heap)
     : state_(kOldSpaceState),
-      mode_(mode),
       old_iterator_(heap->old_space()),
-      code_iterator_(heap->code_space()),
       map_iterator_(heap->map_space()),
       lo_iterator_(heap->lo_space()) {}
 
-MemoryChunk* MemoryChunkIterator::next() {
+
+MemoryChunk* PointerChunkIterator::next() {
   switch (state_) {
     case kOldSpaceState: {
       if (old_iterator_.has_next()) {
         return old_iterator_.next();
       }
       state_ = kMapState;
       // Fall through.
     }
     case kMapState: {
-      if (mode_ != ALL_BUT_MAP_SPACE && map_iterator_.has_next()) {
+      if (map_iterator_.has_next()) {
         return map_iterator_.next();
       }
-      state_ = kCodeState;
-      // Fall through.
-    }
-    case kCodeState: {
-      if (mode_ != ALL_BUT_CODE_SPACE && code_iterator_.has_next()) {
-        return code_iterator_.next();
-      }
       state_ = kLargeObjectState;
       // Fall through.
     }
     case kLargeObjectState: {
-      MemoryChunk* answer = lo_iterator_.next();
-      if (answer != nullptr) {
-        return answer;
-      }
-      state_ = kFinishedState;
-      // Fall through;
+      HeapObject* heap_object;
+      do {
+        heap_object = lo_iterator_.Next();
+        if (heap_object == NULL) {
+          state_ = kFinishedState;
+          return NULL;
+        }
+        // Fixed arrays are the only pointer-containing objects in large
+        // object space.
+      } while (!heap_object->IsFixedArray());
+      MemoryChunk* answer = MemoryChunk::FromAddress(heap_object->address());
+      return answer;
     }
     case kFinishedState:
-      return nullptr;
+      return NULL;
     default:
       break;
   }
   UNREACHABLE();
-  return nullptr;
+  return NULL;
 }
 
 
 void Page::set_next_page(Page* page) {
   DCHECK(page->owner() == owner());
   set_next_chunk(page);
 }
 
 
 void Page::set_prev_page(Page* page) {
@@ skipping 245 matching lines @@
     other->allocation_info_.Reset(nullptr, nullptr);
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_SPACES_INL_H_