Simple BlinkGC heap compaction.

third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h

Index: third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h
diff --git a/third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h b/third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h
index 5d63592e92ef1e2454323576fc57533e3e97831d..7a8b37fb8e16ac1c10a563751b8b1d0461a9b78e 100644
--- a/third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h
+++ b/third_party/WebKit/Source/platform/heap/MarkingVisitorImpl.h
@@ -57,10 +57,10 @@ class MarkingVisitorImpl {
     markHeader(header, header->payload(), callback);
   }
 
-  inline void registerDelayedMarkNoTracing(const void* objectPointer) {
+  inline void registerDelayedMarkNoTracing(void** objectPointer) {
     ASSERT(toDerived()->getMarkingMode() != Visitor::WeakProcessing);
     toDerived()->heap().pushPostMarkingCallback(
-        const_cast<void*>(objectPointer), &markNoTracingCallback);
+        reinterpret_cast<void*>(objectPointer), &markNoTracingCallback);
   }
 
   inline void registerWeakMembers(const void* closure,
@@ -88,6 +88,21 @@ class MarkingVisitorImpl {
   }
 #endif
 
+  inline void registerMovingObjectReference(MovableReference* slot) {
+    if (toDerived()->getMarkingMode() != Visitor::GlobalMarkCompacting)
+      return;
+    toDerived()->heap().registerMovingObjectReference(slot);
+  }
+
+  inline void registerMovingObjectCallback(MovableReference reference,
+                                           MovingObjectCallback callback,
+                                           void* callbackData) {
+    if (toDerived()->getMarkingMode() != Visitor::GlobalMarkCompacting)
+      return;
+    toDerived()->heap().registerMovingObjectCallback(reference, callback,
+                                                     callbackData);
+  }
+
   inline bool ensureMarked(const void* objectPointer) {
     if (!objectPointer)
       return false;
@@ -121,7 +136,11 @@ class MarkingVisitorImpl {
 
  private:
   static void markNoTracingCallback(Visitor* visitor, void* object) {
-    visitor->markNoTracing(object);
+    // |object| is really the hash table's slot pointing
+    // to the backing store table. Adjust types accordingly..
+    void** reference = reinterpret_cast<void**>(object);
+    visitor->markNoTracing(*reference);
+    visitor->registerBackingStoreReference(reference);

[haraken, 2016/12/09 07:25:56]

How about simply calling registerBackingStoreReference when HashTable calls
registerDelayedMarkNoTracing? We need to delay calling markNoTracing but won't
need to delay calling registerBackingStoreReference. Then we won't need this
hack.

[sof, 2016/12/09 21:44:04]

It would reduce the footprint of this change, but separate marking from
registration of backing stores. I think they better belong together.

I've uncoupled them now though, so as to address this.

   }
 };