Have bindings layer assume and insist that all interface types are GCed.

third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.cpp

 // Copyright 2014 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.
 
 // This file has been auto-generated by code_generator_v8.py. DO NOT MODIFY!
 
 #include "bindings/core/v8/UnionTypesCore.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/UnionTypesCore.h"
@@ skipping 95 matching lines @@
 
 void V8ArrayBufferOrArrayBufferViewOrDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, ArrayBufferOrArrayBufferViewOrDictionary& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8ArrayBuffer::hasInstance(v8Value, isolate)) {
-        RawPtr<TestArrayBuffer> cppValue = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestArrayBuffer* cppValue = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setArrayBuffer(cppValue);
         return;
     }
 
     if (V8ArrayBufferView::hasInstance(v8Value, isolate)) {
-        RawPtr<TestArrayBufferView> cppValue = V8ArrayBufferView::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestArrayBufferView* cppValue = V8ArrayBufferView::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setArrayBufferView(cppValue);
         return;
     }
 
     if (isUndefinedOrNull(v8Value) || v8Value->IsObject()) {
         Dictionary cppValue = Dictionary(v8Value, isolate, exceptionState);
         if (exceptionState.hadException())
             return;
         impl.setDictionary(cppValue);
         return;
@@ skipping 423 matching lines @@
 
 void V8NodeOrNodeList::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, NodeOrNodeList& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8Node::hasInstance(v8Value, isolate)) {
-        RawPtr<Node> cppValue = V8Node::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        Node* cppValue = V8Node::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setNode(cppValue);
         return;
     }
 
     if (V8NodeList::hasInstance(v8Value, isolate)) {
-        RawPtr<NodeList> cppValue = V8NodeList::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        NodeList* cppValue = V8NodeList::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setNodeList(cppValue);
         return;
     }
 
     exceptionState.throwTypeError("The provided value is not of type '(Node or NodeList)'");
 }
 
 v8::Local<v8::Value> toV8(const NodeOrNodeList& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     switch (impl.m_type) {
@@ skipping 93 matching lines @@
 
 void V8StringOrArrayBufferOrArrayBufferView::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, StringOrArrayBufferOrArrayBufferView& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8ArrayBuffer::hasInstance(v8Value, isolate)) {
-        RawPtr<TestArrayBuffer> cppValue = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestArrayBuffer* cppValue = V8ArrayBuffer::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setArrayBuffer(cppValue);
         return;
     }
 
     if (V8ArrayBufferView::hasInstance(v8Value, isolate)) {
-        RawPtr<TestArrayBufferView> cppValue = V8ArrayBufferView::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestArrayBufferView* cppValue = V8ArrayBufferView::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setArrayBufferView(cppValue);
         return;
     }
 
     {
         V8StringResource<> cppValue = v8Value;
         if (!cppValue.prepare(exceptionState))
             return;
         impl.setString(cppValue);
         return;
@@ skipping 345 matching lines @@
     TestEnumOrDouble impl;
     V8TestEnumOrDouble::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
     return impl;
 }
 
 TestInterface2OrUint8Array::TestInterface2OrUint8Array()
     : m_type(SpecificTypeNone)
 {
 }
 
-PassRefPtr<TestInterface2> TestInterface2OrUint8Array::getAsTestInterface2() const
+TestInterface2* TestInterface2OrUint8Array::getAsTestInterface2() const
 {
     ASSERT(isTestInterface2());
     return m_testInterface2;
 }
 
-void TestInterface2OrUint8Array::setTestInterface2(PassRefPtr<TestInterface2> value)
+void TestInterface2OrUint8Array::setTestInterface2(TestInterface2* value)
 {
     ASSERT(isNull());
     m_testInterface2 = value;
     m_type = SpecificTypeTestInterface2;
 }
 
-TestInterface2OrUint8Array TestInterface2OrUint8Array::fromTestInterface2(PassRefPtr<TestInterface2> value)
+TestInterface2OrUint8Array TestInterface2OrUint8Array::fromTestInterface2(TestInterface2* value)
 {
     TestInterface2OrUint8Array container;
     container.setTestInterface2(value);
     return container;
 }
 
 DOMUint8Array* TestInterface2OrUint8Array::getAsUint8Array() const
 {
     ASSERT(isUint8Array());
     return m_uint8Array;
@@ skipping 12 matching lines @@
     container.setUint8Array(value);
     return container;
 }
 
 TestInterface2OrUint8Array::TestInterface2OrUint8Array(const TestInterface2OrUint8Array&) = default;
 TestInterface2OrUint8Array::~TestInterface2OrUint8Array() = default;
 TestInterface2OrUint8Array& TestInterface2OrUint8Array::operator=(const TestInterface2OrUint8Array&) = default;
 
 DEFINE_TRACE(TestInterface2OrUint8Array)
 {
+    visitor->trace(m_testInterface2);
     visitor->trace(m_uint8Array);
 }
 
 void V8TestInterface2OrUint8Array::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterface2OrUint8Array& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8TestInterface2::hasInstance(v8Value, isolate)) {
-        RefPtr<TestInterface2> cppValue = V8TestInterface2::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestInterface2* cppValue = V8TestInterface2::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterface2(cppValue);
         return;
     }
 
     if (V8Uint8Array::hasInstance(v8Value, isolate)) {
-        RawPtr<DOMUint8Array> cppValue = V8Uint8Array::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        DOMUint8Array* cppValue = V8Uint8Array::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setUint8Array(cppValue);
         return;
     }
 
     exceptionState.throwTypeError("The provided value is not of type '(TestInterface2 or Uint8Array)'");
 }
 
 v8::Local<v8::Value> toV8(const TestInterface2OrUint8Array& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     switch (impl.m_type) {
@@ skipping 72 matching lines @@
 
 void V8TestInterfaceGarbageCollectedOrString::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceGarbageCollectedOrString& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8TestInterfaceGarbageCollected::hasInstance(v8Value, isolate)) {
-        RawPtr<TestInterfaceGarbageCollected> cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestInterfaceGarbageCollected* cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterfaceGarbageCollected(cppValue);
         return;
     }
 
     {
         V8StringResource<> cppValue = v8Value;
         if (!cppValue.prepare(exceptionState))
             return;
         impl.setString(cppValue);
         return;
@@ skipping 21 matching lines @@
     TestInterfaceGarbageCollectedOrString impl;
     V8TestInterfaceGarbageCollectedOrString::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
     return impl;
 }
 
 TestInterfaceOrLong::TestInterfaceOrLong()
     : m_type(SpecificTypeNone)
 {
 }
 
-PassRefPtr<TestInterfaceImplementation> TestInterfaceOrLong::getAsTestInterface() const
+TestInterfaceImplementation* TestInterfaceOrLong::getAsTestInterface() const
 {
     ASSERT(isTestInterface());
     return m_testInterface;
 }
 
-void TestInterfaceOrLong::setTestInterface(PassRefPtr<TestInterfaceImplementation> value)
+void TestInterfaceOrLong::setTestInterface(TestInterfaceImplementation* value)
 {
     ASSERT(isNull());
     m_testInterface = value;
     m_type = SpecificTypeTestInterface;
 }
 
-TestInterfaceOrLong TestInterfaceOrLong::fromTestInterface(PassRefPtr<TestInterfaceImplementation> value)
+TestInterfaceOrLong TestInterfaceOrLong::fromTestInterface(TestInterfaceImplementation* value)
 {
     TestInterfaceOrLong container;
     container.setTestInterface(value);
     return container;
 }
 
 int TestInterfaceOrLong::getAsLong() const
 {
     ASSERT(isLong());
     return m_long;
@@ skipping 12 matching lines @@
     container.setLong(value);
     return container;
 }
 
 TestInterfaceOrLong::TestInterfaceOrLong(const TestInterfaceOrLong&) = default;
 TestInterfaceOrLong::~TestInterfaceOrLong() = default;
 TestInterfaceOrLong& TestInterfaceOrLong::operator=(const TestInterfaceOrLong&) = default;
 
 DEFINE_TRACE(TestInterfaceOrLong)
 {
+    visitor->trace(m_testInterface);
 }
 
 void V8TestInterfaceOrLong::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceOrLong& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8TestInterface::hasInstance(v8Value, isolate)) {
-        RefPtr<TestInterfaceImplementation> cppValue = V8TestInterface::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterface(cppValue);
         return;
     }
 
     if (v8Value->IsNumber()) {
         int cppValue = toInt32(isolate, v8Value, NormalConversion, exceptionState);
         if (exceptionState.hadException())
             return;
         impl.setLong(cppValue);
         return;
@@ skipping 29 matching lines @@
     TestInterfaceOrLong impl;
     V8TestInterfaceOrLong::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
     return impl;
 }
 
 TestInterfaceOrTestInterfaceEmpty::TestInterfaceOrTestInterfaceEmpty()
     : m_type(SpecificTypeNone)
 {
 }
 
-PassRefPtr<TestInterfaceImplementation> TestInterfaceOrTestInterfaceEmpty::getAsTestInterface() const
+TestInterfaceImplementation* TestInterfaceOrTestInterfaceEmpty::getAsTestInterface() const
 {
     ASSERT(isTestInterface());
     return m_testInterface;
 }
 
-void TestInterfaceOrTestInterfaceEmpty::setTestInterface(PassRefPtr<TestInterfaceImplementation> value)
+void TestInterfaceOrTestInterfaceEmpty::setTestInterface(TestInterfaceImplementation* value)
 {
     ASSERT(isNull());
     m_testInterface = value;
     m_type = SpecificTypeTestInterface;
 }
 
-TestInterfaceOrTestInterfaceEmpty TestInterfaceOrTestInterfaceEmpty::fromTestInterface(PassRefPtr<TestInterfaceImplementation> value)
+TestInterfaceOrTestInterfaceEmpty TestInterfaceOrTestInterfaceEmpty::fromTestInterface(TestInterfaceImplementation* value)
 {
     TestInterfaceOrTestInterfaceEmpty container;
     container.setTestInterface(value);
     return container;
 }
 
-PassRefPtr<TestInterfaceEmpty> TestInterfaceOrTestInterfaceEmpty::getAsTestInterfaceEmpty() const
+TestInterfaceEmpty* TestInterfaceOrTestInterfaceEmpty::getAsTestInterfaceEmpty() const
 {
     ASSERT(isTestInterfaceEmpty());
     return m_testInterfaceEmpty;
 }
 
-void TestInterfaceOrTestInterfaceEmpty::setTestInterfaceEmpty(PassRefPtr<TestInterfaceEmpty> value)
+void TestInterfaceOrTestInterfaceEmpty::setTestInterfaceEmpty(TestInterfaceEmpty* value)
 {
     ASSERT(isNull());
     m_testInterfaceEmpty = value;
     m_type = SpecificTypeTestInterfaceEmpty;
 }
 
-TestInterfaceOrTestInterfaceEmpty TestInterfaceOrTestInterfaceEmpty::fromTestInterfaceEmpty(PassRefPtr<TestInterfaceEmpty> value)
+TestInterfaceOrTestInterfaceEmpty TestInterfaceOrTestInterfaceEmpty::fromTestInterfaceEmpty(TestInterfaceEmpty* value)
 {
     TestInterfaceOrTestInterfaceEmpty container;
     container.setTestInterfaceEmpty(value);
     return container;
 }
 
 TestInterfaceOrTestInterfaceEmpty::TestInterfaceOrTestInterfaceEmpty(const TestInterfaceOrTestInterfaceEmpty&) = default;
 TestInterfaceOrTestInterfaceEmpty::~TestInterfaceOrTestInterfaceEmpty() = default;
 TestInterfaceOrTestInterfaceEmpty& TestInterfaceOrTestInterfaceEmpty::operator=(const TestInterfaceOrTestInterfaceEmpty&) = default;
 
 DEFINE_TRACE(TestInterfaceOrTestInterfaceEmpty)
 {
+    visitor->trace(m_testInterface);
+    visitor->trace(m_testInterfaceEmpty);
 }
 
 void V8TestInterfaceOrTestInterfaceEmpty::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceOrTestInterfaceEmpty& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
 
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
     if (V8TestInterface::hasInstance(v8Value, isolate)) {
-        RefPtr<TestInterfaceImplementation> cppValue = V8TestInterface::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestInterfaceImplementation* cppValue = V8TestInterface::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterface(cppValue);
         return;
     }
 
     if (V8TestInterfaceEmpty::hasInstance(v8Value, isolate)) {
-        RefPtr<TestInterfaceEmpty> cppValue = V8TestInterfaceEmpty::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        TestInterfaceEmpty* cppValue = V8TestInterfaceEmpty::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setTestInterfaceEmpty(cppValue);
         return;
     }
 
     exceptionState.throwTypeError("The provided value is not of type '(TestInterface or TestInterfaceEmpty)'");
 }
 
 v8::Local<v8::Value> toV8(const TestInterfaceOrTestInterfaceEmpty& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     switch (impl.m_type) {
@@ skipping 111 matching lines @@
 }
 
 UnrestrictedDoubleOrString NativeValueTraits<UnrestrictedDoubleOrString>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
     UnrestrictedDoubleOrString impl;
     V8UnrestrictedDoubleOrString::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
     return impl;
 }
 
 } // namespace blink