Use EmbedderHeapTracer instead of object grouping when trace_embedder_heap flag is set

src/heap/mark-compact.cc

 // 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.
 
 #include "src/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 1898 matching lines @@
     Map* map = object->map();
     if (map == filler_map) continue;
 
     DCHECK(object->IsHeapObject());
     DCHECK(heap()->Contains(object));
     DCHECK(!Marking::IsWhite(Marking::MarkBitFrom(object)));
 
     MarkBit map_mark = Marking::MarkBitFrom(map);
     MarkObject(map, map_mark);
 
+    if (UsingEmbedderHeapTracer() && object->IsJSObject()) {
+      JSObject* js_object = JSObject::cast(object);
+
+      if (js_object->GetInternalFieldCount() >= 2 &&
+          js_object->WasConstructedFromApiFunction()) {

[jochen (gone - plz use gerrit), 2016/04/01 08:49:12]

eventually, we should add a flag to the FunctionTemplateInfo used to create the
constructor function that says "this type participates in tracing", and only
record those

[Marcel Hlopko, 2016/04/01 09:24:31]

Noted.

+        wrappers_to_trace().push_back(std::pair<void*, void*>(
+            reinterpret_cast<void*>(js_object->GetInternalField(0)),

[jochen (gone - plz use gerrit), 2016/04/01 08:49:12]

these can be potentially "undefined_value()", right?

[Marcel Hlopko, 2016/04/01 09:24:32]

Yes, I guarded against that in blink side, here it makes more sense. Done.

+            reinterpret_cast<void*>(js_object->GetInternalField(1))));
+      }
+    }
+
     MarkCompactMarkingVisitor::IterateBody(map, object);
   }
 }
 
 
 // Sweep the heap for overflowed objects, clear their overflow bits, and
 // push them on the marking stack.  Stop early if the marking stack fills
 // before sweeping completes.  If sweeping completes, there are no remaining
 // overflowed objects in the heap so the overflow flag on the markings stack
 // is cleared.
@@ skipping 26 matching lines @@
 // pointers.  After: the marking stack is empty and there are no overflowed
 // objects in the heap.
 void MarkCompactCollector::ProcessMarkingDeque() {
   EmptyMarkingDeque();
   while (marking_deque_.overflowed()) {
     RefillMarkingDeque();
     EmptyMarkingDeque();
   }
 }
 
+bool MarkCompactCollector::UsingEmbedderHeapTracer() const {
+  return FLAG_trace_embedder_heap && heap_->embedder_heap_tracer();
+}
 
 // Mark all objects reachable (transitively) from objects on the marking
 // stack including references only considered in the atomic marking pause.
 void MarkCompactCollector::ProcessEphemeralMarking(
     ObjectVisitor* visitor, bool only_process_harmony_weak_collections) {
   bool work_to_do = true;
   DCHECK(marking_deque_.IsEmpty() && !marking_deque_.overflowed());
+  v8::Isolate* api_isolate = reinterpret_cast<v8::Isolate*>(isolate());
+  if (!only_process_harmony_weak_collections && UsingEmbedderHeapTracer()) {
+    heap()->embedder_heap_tracer()->TraceRoots(api_isolate);
+  }
   while (work_to_do) {
     if (!only_process_harmony_weak_collections) {
-      isolate()->global_handles()->IterateObjectGroups(
-          visitor, &IsUnmarkedHeapObjectWithHeap);
-      MarkImplicitRefGroups(&MarkCompactMarkingVisitor::MarkObject);
+      if (UsingEmbedderHeapTracer()) {
+        heap_->embedder_heap_tracer()->TraceWrappableFrom(api_isolate,
+                                                          wrappers_to_trace_);
+        wrappers_to_trace_.clear();
+      } else {
+        isolate()->global_handles()->IterateObjectGroups(
+            visitor, &IsUnmarkedHeapObjectWithHeap);
+        MarkImplicitRefGroups(&MarkCompactMarkingVisitor::MarkObject);
+      }
     }
     ProcessWeakCollections();
     work_to_do = !marking_deque_.IsEmpty();
     ProcessMarkingDeque();
   }
+  if (!only_process_harmony_weak_collections && UsingEmbedderHeapTracer()) {
+    heap()->embedder_heap_tracer()->ClearTracingMarks(api_isolate);
+  }
 }
 
 
 void MarkCompactCollector::ProcessTopOptimizedFrame(ObjectVisitor* visitor) {
   for (StackFrameIterator it(isolate(), isolate()->thread_local_top());
        !it.done(); it.Advance()) {
     if (it.frame()->type() == StackFrame::JAVA_SCRIPT) {
       return;
     }
     if (it.frame()->type() == StackFrame::OPTIMIZED) {
@@ skipping 1831 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(isolate(), pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8