[wrapper-tracing] Support for incrementally tracing ScopedPersistent

third_party/WebKit/Source/bindings/core/v8/ScopedPersistent.h

 /*
  * Copyright (C) 2009 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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ScopedPersistent_h
 #define ScopedPersistent_h
 
+#include "bindings/core/v8/ScriptWrappableVisitor.h"
 #include "wtf/Allocator.h"
 #include "wtf/Noncopyable.h"
 #include <memory>
 #include <v8.h>
 
 namespace blink {
 
 template <typename T>
 class ScopedPersistent {
   USING_FAST_MALLOC(ScopedPersistent);
   WTF_MAKE_NONCOPYABLE(ScopedPersistent);
 
  public:
   ScopedPersistent() {}
 
   ScopedPersistent(v8::Isolate* isolate, v8::Local<T> handle)
       : m_handle(isolate, handle) {}
 
   ScopedPersistent(v8::Isolate* isolate, v8::MaybeLocal<T> maybe) {
     v8::Local<T> local;
     if (maybe.ToLocal(&local))
       m_handle.Reset(isolate, local);
   }
 
-  ~ScopedPersistent() { clear(); }
+  virtual ~ScopedPersistent() { clear(); }
 
   ALWAYS_INLINE v8::Local<T> newLocal(v8::Isolate* isolate) const {
     return v8::Local<T>::New(isolate, m_handle);
   }
 
   // If you don't need to get weak callback, use setPhantom instead.
   // setPhantom is faster than setWeak.
   template <typename P>
   void setWeak(P* parameters,
                void (*callback)(const v8::WeakCallbackInfo<P>&),
                v8::WeakCallbackType type = v8::WeakCallbackType::kParameter) {
     m_handle.SetWeak(parameters, callback, type);
   }
 
   // Turns this handle into a weak phantom handle without
   // finalization callback.
   void setPhantom() { m_handle.SetWeak(); }
 
   void clearWeak() { m_handle.template ClearWeak<void>(); }
 
   bool isEmpty() const { return m_handle.IsEmpty(); }
   bool isWeak() const { return m_handle.IsWeak(); }
 
-  void set(v8::Isolate* isolate, v8::Local<T> handle) {
+  virtual void set(v8::Isolate* isolate, v8::Local<T> handle) {
     m_handle.Reset(isolate, handle);
   }
 
   // Note: This is clear in the std::unique_ptr sense, not the v8::Handle sense.
   void clear() { m_handle.Reset(); }
 
   void setReference(const v8::Persistent<v8::Object>& parent,
                     v8::Isolate* isolate) {
     isolate->SetReference(parent, m_handle);
   }
@@ skipping 12 matching lines @@
   template <typename S>
   const ScopedPersistent<S>& cast() const {
     return reinterpret_cast<const ScopedPersistent<v8::Object>&>(
         const_cast<const ScopedPersistent<T>&>(*this));
   }
 
  private:
   v8::Persistent<T> m_handle;
 };
 
+/**
+ * TraceWrapperScopedPersistent is used to trace from Blink to V8.
+ *
+ * TODO(mlippautz): Once shipped, create a separate type with a more
+ * appropriate handle type than v8::Persistent. The handle should have regular

[haraken, 2016/11/03 05:55:25]

I'm just curious but how hard would it be to implement TraceWrapperV8Reference
correctly? It's nasty that we use v8::Persistent, make it weak, but trace it to
keep it alive... It will work, but we're doing a very strange thing.

[Michael Lippautz, 2016/11/03 08:59:53]

What I have in mind is a new handle type on the V8 side that can be used by
TraceWrapperV8Reference or maybe even directly. Briefly discussed with jochen@
and he also agrees on adding a new handle type.

In essence, this is already on the radar and will be done in near future.

+ * tracing semantics, i.e., only hold strongly on to an object if reached
+ * trough tracing.
+ */
+template <typename T>
+class TraceWrapperScopedPersistent : public ScopedPersistent<T> {

[Michael Lippautz, 2016/11/02 16:00:03]

The name doesn't really fit. I am all open for any other suggestions.

[Marcel Hlopko, 2016/11/02 16:44:51]

TracedV8Reference? It's neither scoped nor persistent, so I'd at least get rid
of those words :)

[Michael Lippautz, 2016/11/02 17:07:55]

+1 for TracedV8Reference. haraken?

[haraken, 2016/11/03 05:55:25]

I want to keep a "TraceWrapper" prefix at least. TraceWrapperV8Reference?

[Michael Lippautz, 2016/11/03 08:59:53]

Done.

+ public:
+  TraceWrapperScopedPersistent(void* parent)
+      : ScopedPersistent<T>(), m_parent(parent) {}
+
+  TraceWrapperScopedPersistent(void* parent,
+                               v8::Isolate* isolate,
+                               v8::Local<T> handle)
+      : ScopedPersistent<T>(isolate, handle), m_parent(parent) {}
+
+  TraceWrapperScopedPersistent(void* parent,
+                               v8::Isolate* isolate,
+                               v8::MaybeLocal<T> maybe)
+      : ScopedPersistent<T>(isolate, maybe), m_parent(parent) {}
+
+  void set(v8::Isolate* isolate, v8::Local<T> handle) override {
+    ScriptWrappableVisitor::writeBarrier(m_parent, this);
+    ScopedPersistent<T>::set(isolate, handle);
+  }
+
+  template <typename S>
+  const TraceWrapperScopedPersistent<S>& cast() const {
+    return reinterpret_cast<const TraceWrapperScopedPersistent<S>&>(
+        const_cast<const TraceWrapperScopedPersistent<T>&>(*this));
+  }
+
+ private:
+  void* m_parent;
+};
+
 }  // namespace blink
 
 #endif  // ScopedPersistent_h