[heap] Use shared markbits in the concurrent marker.

src/heap/objects-visiting.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_OBJECTS_VISITING_H_
 #define V8_OBJECTS_VISITING_H_
 
 #include "src/allocation.h"
 #include "src/heap/embedder-tracing.h"
 #include "src/heap/heap.h"
@@ skipping 377 matching lines @@
 //
 //   class SomeVisitor : public HeapVisitor<ResultType, SomeVisitor> {
 //     ...
 //   }
 //
 // This is an example of Curiously recurring template pattern.
 // TODO(ulan): replace static visitors with the HeapVisitor.
 template <typename ResultType, typename ConcreteVisitor>
 class HeapVisitor : public ObjectVisitor {
  public:
-  ResultType IterateBody(HeapObject* object);
+  ResultType Visit(HeapObject* object);
 
  protected:
+  // A guard predicate for visiting the object.
+  // If it returns false then the default implementations of the Visit*
+  // functions bailout from iterating the object pointers.
+  virtual bool ShouldVisit(HeapObject* object);
+  // A callback for visiting the map pointer in the object header.
+  virtual void VisitMapPointer(HeapObject* host, HeapObject** map);
+
 #define VISIT(type) virtual ResultType Visit##type(Map* map, type* object);
   TYPED_VISITOR_ID_LIST(VISIT)
 #undef VISIT
   virtual ResultType VisitShortcutCandidate(Map* map, ConsString* object);
   virtual ResultType VisitNativeContext(Map* map, Context* object);
   virtual ResultType VisitDataObject(Map* map, HeapObject* object);
   virtual ResultType VisitJSObjectFast(Map* map, JSObject* object);
   virtual ResultType VisitJSApiObject(Map* map, JSObject* object);
   virtual ResultType VisitStruct(Map* map, HeapObject* object);
   virtual ResultType VisitFreeSpace(Map* map, FreeSpace* object);
 };
 
 class WeakObjectRetainer;
 
 // A weak list is single linked list where each element has a weak pointer to
 // the next element. Given the head of the list, this function removes dead
 // elements from the list and if requested records slots for next-element
 // pointers. The template parameter T is a WeakListVisitor that defines how to
 // access the next-element pointers.
 template <class T>
 Object* VisitWeakList(Heap* heap, Object* list, WeakObjectRetainer* retainer);
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_OBJECTS_VISITING_H_