[wrapper-tracing] Reduce marking overhead: Tri-color marking without 3 colors

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

Index: third_party/WebKit/Source/platform/heap/GarbageCollected.h
diff --git a/third_party/WebKit/Source/platform/heap/GarbageCollected.h b/third_party/WebKit/Source/platform/heap/GarbageCollected.h
index 42f78a3770679e3f841a1983978cd158895070e0..3c630c96f5aa07cdf3ed8c53327fe55e66a4fb89 100644
--- a/third_party/WebKit/Source/platform/heap/GarbageCollected.h
+++ b/third_party/WebKit/Source/platform/heap/GarbageCollected.h
@@ -77,7 +77,11 @@ class PLATFORM_EXPORT GarbageCollectedMixin {
   virtual void trace(Visitor*) {}
   virtual void adjustAndMark(InlinedGlobalMarkingVisitor) const = 0;
   virtual void trace(InlinedGlobalMarkingVisitor);
-  virtual void adjustAndMarkWrapper(const WrapperVisitor*) const = 0;
+  virtual void adjustAndFullyMarkAndTraceWrapper(
+      const WrapperVisitor*) const = 0;
+  virtual void adjustAndMarkWrapperHeaderOnly(const WrapperVisitor*) const = 0;
+  virtual void adjustAndFinishMarkAndTraceMarkedWrapper(
+      const WrapperVisitor*) const = 0;
   virtual bool isHeapObjectAlive() const = 0;
   virtual HeapObjectHeader* adjustAndGetHeapObjectHeader() const = 0;
 };
@@ -102,29 +106,45 @@ class PLATFORM_EXPORT GarbageCollectedMixin {
                                                                               \
  private:
 
-#define DEFINE_GARBAGE_COLLECTED_MIXIN_WRAPPER_METHODS(TYPE)                  \
- public:                                                                      \
-  void adjustAndMarkWrapper(const WrapperVisitor* visitor) const override {   \
-    typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, \
-                                      blink::GarbageCollected>                \
-        IsSubclassOfGarbageCollected;                                         \
-    static_assert(                                                            \
-        IsSubclassOfGarbageCollected::value,                                  \
-        "only garbage collected objects can have garbage collected mixins");  \
-    AdjustAndMarkTrait<TYPE>::markWrapper(visitor,                            \
-                                          static_cast<const TYPE*>(this));    \
-  }                                                                           \
-  HeapObjectHeader* adjustAndGetHeapObjectHeader() const override {           \
-    typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type, \
-                                      blink::GarbageCollected>                \
-        IsSubclassOfGarbageCollected;                                         \
-    static_assert(                                                            \
-        IsSubclassOfGarbageCollected::value,                                  \
-        "only garbage collected objects can have garbage collected mixins");  \
-    return AdjustAndMarkTrait<TYPE>::heapObjectHeader(                        \
-        static_cast<const TYPE*>(this));                                      \
-  }                                                                           \
-                                                                              \
+#define DEFINE_GARBAGE_COLLECTED_MIXIN_WRAPPER_METHODS(TYPE)                   \
+ private:                                                                      \
+  typedef WTF::IsSubclassOfTemplate<typename std::remove_const<TYPE>::type,    \
+                                    blink::GarbageCollected>                   \
+      IsSubclassOfGarbageCollected;                                            \
+                                                                               \
+ public:                                                                       \
+  void adjustAndFullyMarkAndTraceWrapper(const WrapperVisitor* visitor)        \

[Michael Lippautz, 2016/12/20 15:10:30]

Ideally we could use covariant return types here. E.g. have something like
  TYPE* castToBase() override;
which would be the only method needed here.

Since we don't have a common supertype though (GarbageCollected<A> !=
GarbageCollected<B>) I do not (yet) see how to do it.

+      const override {                                                         \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    return AdjustAndMarkTrait<TYPE>::fullyMarkAndTraceWrapper(                 \
+        visitor, static_cast<const TYPE*>(this));                              \
+  }                                                                            \
+  void adjustAndMarkWrapperHeaderOnly(const WrapperVisitor* visitor)           \
+      const override {                                                         \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    return AdjustAndMarkTrait<TYPE>::markWrapperHeaderOnly(                    \
+        visitor, static_cast<const TYPE*>(this));                              \
+  }                                                                            \
+  void adjustAndFinishMarkAndTraceMarkedWrapper(const WrapperVisitor* visitor) \
+      const override {                                                         \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    AdjustAndMarkTrait<TYPE>::finishMarkAndTraceMarkedWrapper(                 \
+        visitor, static_cast<const TYPE*>(this));                              \
+  }                                                                            \
+  HeapObjectHeader* adjustAndGetHeapObjectHeader() const override {            \
+    static_assert(                                                             \
+        IsSubclassOfGarbageCollected::value,                                   \
+        "only garbage collected objects can have garbage collected mixins");   \
+    return AdjustAndMarkTrait<TYPE>::heapObjectHeader(                         \
+        static_cast<const TYPE*>(this));                                       \
+  }                                                                            \
+                                                                               \
  private:
 
 // A C++ object's vptr will be initialized to its leftmost base's vtable after