[wrapper-tracing] Support for incrementally tracing ScopedPersistent

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

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef WrapperVisitor_h
 #define WrapperVisitor_h
 
 #include "platform/PlatformExport.h"
 #include "wtf/Allocator.h"
 
 namespace v8 {
 class Value;
 class Object;
 template <class T>
 class PersistentBase;
 }
 
 namespace blink {
 
 template <typename T>
 class TraceTrait;
 template <typename T>
 class Member;
 class ScriptWrappable;
 template <typename T>
-class ScopedPersistent;
+class TraceWrapperV8Reference;
 class TraceWrapperBase;
 template <typename T>
 class TraceWrapperMember;
 
 // Only add a special class here if the class cannot derive from
 // TraceWrapperBase.
 #define WRAPPER_VISITOR_SPECIAL_CLASSES(V) \
   V(ElementRareData)                       \
   V(NodeListsNodeData)                     \
   V(NodeMutationObserverData)              \
@@ skipping 48 matching lines @@
 #define DEFINE_INLINE_TRACE_WRAPPERS() DECLARE_TRACE_WRAPPERS()
 #define DEFINE_INLINE_VIRTUAL_TRACE_WRAPPERS() DECLARE_VIRTUAL_TRACE_WRAPPERS()
 
 // ###########################################################################
 // TODO(hlopko): Get rid of virtual calls using CRTP
 class PLATFORM_EXPORT WrapperVisitor {
   USING_FAST_MALLOC(WrapperVisitor);
 
  public:
   template <typename T>
   void traceWrappers(const T* traceable) const {

[haraken, 2016/11/03 14:25:04]

Would you help me understand who uses this method? I'm afraid that this method
can be used for 'catch-all' of traceWrappers().

[Michael Lippautz, 2016/11/03 14:53:41]

Yes, one has to be careful with traceWrappers overloads. It's used for anything
that inherits from TraceWrapperBase. Once we are in the same component we can
improve this signature. 

     static_assert(sizeof(T), "T must be fully defined");
+    // Ideally, we'd assert that we can cast to TraceWrapperBase here.
+    static_assert(IsGarbageCollectedType<T>::value,
+                  "only garbage collected objects can be");

[haraken, 2016/11/03 14:25:04]

Only garbage collected objects can be used in traceWrappers().

[Michael Lippautz, 2016/11/03 14:53:41]

Done.

 
     if (!traceable) {
       return;
     }
 
     if (TraceTrait<T>::heapObjectHeader(traceable)->isWrapperHeaderMarked()) {
       return;
     }
 
     pushToMarkingDeque(TraceTrait<T>::markWrapper,
@@ skipping 22 matching lines @@
   template <typename T>
   void traceWrappersWithManualWriteBarrier(const Member<T>& t) const {
     traceWrappers(t.get());
   }
   template <typename T>
   void traceWrappersWithManualWriteBarrier(const WeakMember<T>& t) const {
     traceWrappers(t.get());
   }
 
   virtual void traceWrappers(
-      const ScopedPersistent<v8::Value>* persistent) const = 0;
-  virtual void traceWrappers(
-      const ScopedPersistent<v8::Object>* persistent) const = 0;
-  virtual void markWrapper(
-      const v8::PersistentBase<v8::Object>* persistent) const = 0;
+      const TraceWrapperV8Reference<v8::Value>*) const = 0;

[haraken, 2016/11/03 14:25:04]

It's inconsistent that traceWrappers(const TraceWrapperMember<T>& t) takes a
reference but traceWrappers(const TraceWrapperV8Reference<v8::Value>*) takes a
pointer.

[Michael Lippautz, 2016/11/03 14:53:41]

Done.

+  virtual void markWrapper(const v8::PersistentBase<v8::Value>*) const = 0;
 
   virtual void dispatchTraceWrappers(const TraceWrapperBase*) const = 0;
 #define DECLARE_DISPATCH_TRACE_WRAPPERS(ClassName) \
   virtual void dispatchTraceWrappers(const ClassName*) const = 0;
 
   WRAPPER_VISITOR_SPECIAL_CLASSES(DECLARE_DISPATCH_TRACE_WRAPPERS);
 
 #undef DECLARE_DISPATCH_TRACE_WRAPPERS
   virtual void dispatchTraceWrappers(const void*) const = 0;
 
   virtual bool markWrapperHeader(HeapObjectHeader*) const = 0;
   virtual void markWrappersInAllWorlds(const ScriptWrappable*) const = 0;
   virtual void markWrappersInAllWorlds(const void*) const = 0;
   virtual void pushToMarkingDeque(
       void (*traceWrappersCallback)(const WrapperVisitor*, const void*),
       HeapObjectHeader* (*heapObjectHeaderCallback)(const void*),
       const void*) const = 0;
 };
 
 }  // namespace blink
 
 #endif  // WrapperVisitor_h