[wrapper-tracing] Fix dispatching of TraceWrapperv8Reference

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

Index: third_party/WebKit/Source/bindings/core/v8/TraceWrapperV8Reference.h
diff --git a/third_party/WebKit/Source/bindings/core/v8/TraceWrapperV8Reference.h b/third_party/WebKit/Source/bindings/core/v8/TraceWrapperV8Reference.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ba5a94dd90f51cb06b5ecd1bbf8cc70fd9113f6
--- /dev/null
+++ b/third_party/WebKit/Source/bindings/core/v8/TraceWrapperV8Reference.h
@@ -0,0 +1,81 @@
+// 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 TraceWrapperV8Reference_h
+#define TraceWrapperV8Reference_h
+
+#include "bindings/core/v8/ScriptWrappableVisitor.h"
+
+namespace blink {
+
+/**
+ * TraceWrapperV8Reference is used to trace from Blink to V8. If wrapper
+ * tracing is disabled, the reference is a weak v8::Persistent. Otherwise,
+ * the reference is (strongly) traced by wrapper tracing.
+ *
+ * TODO(mlippautz): Use a better handle type than v8::Persistent.
+ */
+template <typename T>
+class TraceWrapperV8Reference {
+ public:
+  explicit TraceWrapperV8Reference(void* parent) : m_parent(parent) {}
+
+  TraceWrapperV8Reference(v8::Isolate* isolate,
+                          void* parent,
+                          v8::Local<T> handle)
+      : m_parent(parent) {
+    internalSet(isolate, handle);
+    m_handle.SetWeak();
+  }
+
+  ~TraceWrapperV8Reference() { clear(); }
+
+  void set(v8::Isolate* isolate, v8::Local<T> handle) {
+    internalSet(isolate, handle);
+    m_handle.SetWeak();
+  }
+
+  template <typename P>
+  void set(v8::Isolate* isolate,
+           v8::Local<T> handle,
+           P* parameters,
+           void (*callback)(const v8::WeakCallbackInfo<P>&),
+           v8::WeakCallbackType type = v8::WeakCallbackType::kParameter) {
+    internalSet(isolate, handle);
+    m_handle.SetWeak(parameters, callback, type);
+  }
+
+  ALWAYS_INLINE v8::Local<T> newLocal(v8::Isolate* isolate) const {
+    return v8::Local<T>::New(isolate, m_handle);
+  }
+
+  bool isEmpty() const { return m_handle.IsEmpty(); }
+  void clear() { m_handle.Reset(); }
+  ALWAYS_INLINE v8::Persistent<T>& get() { return m_handle; }
+
+  void setReference(const v8::Persistent<v8::Object>& parent,
+                    v8::Isolate* isolate) {
+    DCHECK(!RuntimeEnabledFeatures::traceWrappablesEnabled());
+    isolate->SetReference(parent, m_handle);
+  }
+
+  template <typename S>
+  const TraceWrapperV8Reference<S>& cast() const {
+    return reinterpret_cast<const TraceWrapperV8Reference<S>&>(
+        const_cast<const TraceWrapperV8Reference<T>&>(*this));
+  }
+
+ private:
+  inline void internalSet(v8::Isolate* isolate, v8::Local<T> handle) {
+    m_handle.Reset(isolate, handle);
+    ScriptWrappableVisitor::writeBarrier(m_parent, &cast<v8::Value>());
+  }
+
+  v8::Persistent<T> m_handle;
+  void* m_parent;
+};
+
+}  // namespace blink
+
+#endif  // TraceWrapperV8Reference_h