[heap] Decouple SpaceIterator from ObjectIterator.

src/heap/heap.h

 // Copyright 2012 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_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 2114 matching lines @@
   // and after context disposal.
   int number_of_disposed_maps_;
 
   int global_ic_age_;
 
   NewSpace* new_space_;
   OldSpace* old_space_;
   OldSpace* code_space_;
   MapSpace* map_space_;
   LargeObjectSpace* lo_space_;
+  // Map from the space id to the space.
+  Space* space_[LAST_SPACE + 1];
   HeapState gc_state_;
   int gc_post_processing_depth_;
   Address new_space_top_after_last_gc_;
 
   // Returns the amount of external memory registered since last global gc.
   int64_t PromotedExternalMemorySize();
 
   // How many "runtime allocations" happened.
   uint32_t allocations_count_;
 
@@ skipping 304 matching lines @@
   explicit PagedSpaces(Heap* heap) : heap_(heap), counter_(OLD_SPACE) {}
   PagedSpace* next();
 
  private:
   Heap* heap_;
   int counter_;
 };
 
 
 // Space iterator for iterating over all spaces of the heap.
 // For each space an object iterator is provided. The deallocation of the

[Michael Lippautz, 2016/09/27 13:53:05]

nit: Outdated comment.

[ulan, 2016/09/27 14:10:53]

Done.

 // returned object iterators is handled by the space iterator.
 class SpaceIterator : public Malloced {
  public:
   explicit SpaceIterator(Heap* heap);
   virtual ~SpaceIterator();
 
   bool has_next();
-  ObjectIterator* next();
+  Space* next();
 
  private:
-  ObjectIterator* CreateIterator();
-
   Heap* heap_;
   int current_space_;         // from enum AllocationSpace.
-  ObjectIterator* iterator_;  // object iterator for the current space.
 };
 
 
 // A HeapIterator provides iteration over the whole heap. It
 // aggregates the specific iterators for the different spaces as
 // these can only iterate over one space only.
 //
 // HeapIterator ensures there is no allocation during its lifetime
 // (using an embedded DisallowHeapAllocation instance).
 //
@@ skipping 25 matching lines @@
   // allocations.
   MakeHeapIterableHelper make_heap_iterable_helper_;
   DisallowHeapAllocation no_heap_allocation_;
 
   Heap* heap_;
   HeapObjectsFiltering filtering_;
   HeapObjectsFilter* filter_;
   // Space iterator for iterating all the spaces.
   SpaceIterator* space_iterator_;
   // Object iterator for the space currently being iterated.
-  ObjectIterator* object_iterator_;
+  std::unique_ptr<ObjectIterator> object_iterator_;
 };
 
 // Abstract base class for checking whether a weak object should be retained.
 class WeakObjectRetainer {
  public:
   virtual ~WeakObjectRetainer() {}
 
   // Return whether this object should be retained. If NULL is returned the
   // object has no references. Otherwise the address of the retained object
   // should be returned as in some GC situations the object has been moved.
@@ skipping 110 matching lines @@
   friend class LargeObjectSpace;
   friend class NewSpace;
   friend class PagedSpace;
   DISALLOW_COPY_AND_ASSIGN(AllocationObserver);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_H_