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 35 matching lines @@
 
 namespace blink {
 
 template<typename T> class GarbageCollected;
 class HeapObjectHeader;
 class InlinedGlobalMarkingVisitor;
 template<typename T> class TraceTrait;
 template<typename T> class TraceEagerlyTrait;
 class ThreadState;
 class Visitor;
+class VisitorScope;
 
 // 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_ONLY(TraceMethodDelegate);
     static void trampoline(Visitor* visitor, void* self)
@@ skipping 50 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(VisitorScope* visitorScope) : m_visitorScope(visitorScope) {}
+
     // 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 VisitorScope* visitorScope() const { return m_visitorScope; }
+
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* object);
+
+    VisitorScope* m_visitorScope;
 };
 
 // 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, VisitorScope* visitorScope)
+        : VisitorHelper(visitorScope)
+        , 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;
 };
 
-class VisitorScope final {
+class PLATFORM_EXPORT VisitorScope final {

[haraken, 2016/02/29 11:17:45]

Can we unify the VisitorScope and the Visitor into one class (before landing
this CL)? Then you don't need to look up the VisitorScope from the Visitor.
Conceptually, the VisitorScope and the Visitor should be the same thing.

class Visitor {
  STACK_ALLOCATED();
  ...;
  ThreadState* m_state;
};

[keishi, 2016/03/02 06:01:03]

Created https://codereview.chromium.org/1753623002/

     STACK_ALLOCATED();
 public:
     VisitorScope(ThreadState*, BlinkGC::GCType);
     ~VisitorScope();
     Visitor* visitor() const { return m_visitor.get(); }
+    Heap& heap() const { return m_state->heap(); }
 
 private:
     ThreadState* m_state;
     OwnPtr<Visitor> m_visitor;
 };
 
 } // namespace blink
 
 #endif // Visitor_h