Refactor the Heap into ThreadHeap to prepare for per thread heaps

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

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 34 matching lines @@
 #include "wtf/TypeTraits.h"
 
 namespace blink {
 
 template<typename T> class GarbageCollected;
 class HeapObjectHeader;
 class InlinedGlobalMarkingVisitor;
 template<typename T> class TraceTrait;
 template<typename T> class TraceEagerlyTrait;
 class Visitor;
+class GCData;
 
 // The TraceMethodDelegate is used to convert a trace method for type T to a TraceCallback.
 // This allows us to pass a type's trace method as a parameter to the PersistentNode
 // constructor. The PersistentNode constructor needs the specific trace method due an issue
 // with the Windows compiler which instantiates even unused variables. This causes problems
 // in header files where we have only forward declarations of classes.
 template<typename T, void (T::*method)(Visitor*)>
 struct TraceMethodDelegate {
     static void trampoline(Visitor* visitor, void* self)
     {
@@ skipping 49 matching lines @@
 #define DEFINE_INLINE_TRACE() DEFINE_INLINE_TRACE_IMPL(EMPTY_MACRO_ARGUMENT)
 #define DEFINE_INLINE_VIRTUAL_TRACE() DEFINE_INLINE_TRACE_IMPL(virtual)
 
 // VisitorHelper contains common implementation of Visitor helper methods.
 //
 // VisitorHelper avoids virtual methods by using CRTP.
 // c.f. http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern
 template<typename Derived>
 class VisitorHelper {
 public:
+    VisitorHelper(GCData* gcData) : m_gcData(gcData) {}

[haraken, 2016/01/28 15:52:50]

Add explicit.

+
     // One-argument templated mark method. This uses the static type of
     // the argument to get the TraceTrait. By default, the mark method
     // of the TraceTrait just calls the virtual two-argument mark method on this
     // visitor, where the second argument is the static trace method of the trait.
     template<typename T>
     void mark(T* t)
     {
         static_assert(sizeof(T), "T must be fully defined");
         static_assert(IsGarbageCollectedType<T>::value, "T needs to be a garbage collected object");
         if (!t)
@@ skipping 140 matching lines @@
     template<typename T, void (T::*method)(Visitor*)>
     void registerWeakMembers(const T* obj)
     {
         registerWeakMembers(obj, &TraceMethodDelegate<T, method>::trampoline);
     }
     void registerWeakMembers(const void* object, WeakCallback callback)
     {
         Derived::fromHelper(this)->registerWeakMembers(object, object, callback);
     }
 
+    inline GCData* gcData() const { return m_gcData; }
+
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* object);
+
+    GCData* m_gcData;
 };
 
 // Visitor is used to traverse the Blink object graph. Used for the
 // marking phase of the mark-sweep garbage collector.
 //
 // Pointers are marked and pushed on the marking stack by calling the
 // |mark| method with the pointer as an argument.
 //
 // Pointers within objects are traced by calling the |trace| methods
 // with the object as an argument. Tracing objects will mark all of the
@@ skipping 68 matching lines @@
     virtual void registerWeakTable(const void*, EphemeronCallback, EphemeronCallback) = 0;
 #if ENABLE(ASSERT)
     virtual bool weakTableRegistered(const void*) = 0;
 #endif
 
     virtual bool ensureMarked(const void*) = 0;
 
     inline MarkingMode markingMode() const { return m_markingMode; }
 
 protected:
-    explicit Visitor(MarkingMode markingMode)
-        : m_markingMode(markingMode)
+    explicit Visitor(MarkingMode markingMode, GCData* gcData)
+        : VisitorHelper(gcData)
+        , m_markingMode(markingMode)
     { }
 
     virtual void registerWeakCellWithCallback(void**, WeakCallback) = 0;
 
 private:
     static Visitor* fromHelper(VisitorHelper<Visitor>* helper) { return static_cast<Visitor*>(helper); }
 
     const MarkingMode m_markingMode;
     bool m_isGlobalMarkingVisitor;
 };
 
 #if ENABLE(DETAILED_MEMORY_INFRA)
 template<typename T>
 struct TypenameStringTrait {
     static const String get()
     {
         return WTF::extractTypeNameFromFunctionName(WTF::extractNameFunction<T>());
     }
 };
 #endif
 
 } // namespace blink
 
 #endif // Visitor_h