Make Visitor use heap for the current thread

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 101 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(ThreadState* state) : m_state(state) { }
+
     // 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 82 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 ThreadState* state() const { return m_state; }
+    inline ThreadHeap& heap() const { return state()->heap(); }
+
 private:
     template<typename T>
     static void handleWeakCell(Visitor* self, void* object);
+
+    ThreadState* m_state;
 };
 
 // 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 69 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 getMarkingMode() const { return m_markingMode; }
 
-    inline ThreadHeap& heap() const { return m_state->heap(); }
-
 protected:
     Visitor(ThreadState*, MarkingMode);
 
     virtual void registerWeakCellWithCallback(void**, WeakCallback) = 0;
 
 private:
     static Visitor* fromHelper(VisitorHelper<Visitor>* helper) { return static_cast<Visitor*>(helper); }
 
     ThreadState* m_state;
     const MarkingMode m_markingMode;
 };
 
 } // namespace blink
 
 #endif // Visitor_h