ASSERT that Visitor::mark is only called when inGC()

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 325 matching lines @@
     // 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)
     {
         if (!t)
             return;
 #if ENABLE(ASSERT)
         TraceTrait<T>::checkGCInfo(t);
+        Derived::fromHelper(this)->checkIsMarkingAllowed();
 #endif
         TraceTrait<T>::mark(Derived::fromHelper(this), t);
 
         STATIC_ASSERT_IS_GARBAGE_COLLECTED(T, "attempted to mark non garbage collected object");
     }
 
     // Member version of the one-argument templated trace method.
     template<typename T>
     void trace(const Member<T>& t)
     {
@@ skipping 268 matching lines @@
         m_hostName = name;
     }
 #endif
 
     inline bool canTraceEagerly() const { return m_traceDepth < kMaxEagerTraceDepth; }
     inline void incrementTraceDepth() { m_traceDepth++; }
     inline void decrementTraceDepth() { ASSERT(m_traceDepth > 0); m_traceDepth--; }
 
     inline bool isGlobalMarkingVisitor() const { return m_isGlobalMarkingVisitor; }
 
+#if ENABLE(ASSERT)
+    virtual void setAllowTraceForHashTableWeakProcessing(bool) { }
+#endif
+
 protected:
     explicit Visitor(VisitorType type)
         : m_isGlobalMarkingVisitor(type == GlobalMarkingVisitorType)
     {
         m_traceDepth = 0;
     }
 
     virtual void registerWeakCellWithCallback(void**, WeakPointerCallback) = 0;
 #if ENABLE(GC_PROFILE_MARKING)
     virtual void recordObjectGraphEdge(const void*)
     {
         ASSERT_NOT_REACHED();
     }
 
     void* m_hostObject;
     String m_hostName;
 #endif
 
+#if ENABLE(ASSERT)
+    virtual void checkIsMarkingAllowed() { }
+#endif
+
 private:
     static Visitor* fromHelper(VisitorHelper<Visitor>* helper) { return static_cast<Visitor*>(helper); }
 
     // The maximum depth of eager, unrolled trace() calls that is
     // considered safe and allowed.
     const int kMaxEagerTraceDepth = 100;
 
     static int m_traceDepth;
     bool m_isGlobalMarkingVisitor;
 };
@@ skipping 258 matching lines @@
 struct GCInfoTrait {
     static size_t index()
     {
         return GCInfoAtBase<typename GetGarbageCollectedBase<T>::type>::index();
     }
 };
 
 }
 
 #endif