Oilpan: Remove most WillBe types from the code base

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

Index: third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.cpp
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.cpp b/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.cpp
index 3a4495fe0517ae3c4017a56de62848b2c54ad6cb..0cc7db9c16117b46b4cf2fda04ba2d92f100b93b 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.cpp
@@ -16,7 +16,7 @@
 #include "bindings/core/v8/V8TestInterface2.h"
 #include "bindings/core/v8/V8TestInterfaceEmpty.h"
 #include "bindings/core/v8/V8TestInterfaceGarbageCollected.h"
-#include "bindings/core/v8/V8TestInterfaceWillBeGarbageCollected.h"
+#include "bindings/core/v8/V8TestInterfaceGarbageCollected.h"
 #include "bindings/core/v8/V8Uint8Array.h"
 #include "bindings/tests/idls/core/TestImplements2.h"
 #include "bindings/tests/idls/core/TestImplements3Implementation.h"
@@ -503,40 +503,40 @@ NodeOrNodeList::NodeOrNodeList()
 {
 }
 
-PassRefPtrWillBeRawPtr<Node> NodeOrNodeList::getAsNode() const
+RawPtr<Node> NodeOrNodeList::getAsNode() const
 {
     ASSERT(isNode());
     return m_node;
 }
 
-void NodeOrNodeList::setNode(PassRefPtrWillBeRawPtr<Node> value)
+void NodeOrNodeList::setNode(RawPtr<Node> value)
 {
     ASSERT(isNull());
     m_node = value;
     m_type = SpecificTypeNode;
 }
 
-NodeOrNodeList NodeOrNodeList::fromNode(PassRefPtrWillBeRawPtr<Node> value)
+NodeOrNodeList NodeOrNodeList::fromNode(RawPtr<Node> value)
 {
     NodeOrNodeList container;
     container.setNode(value);
     return container;
 }
 
-PassRefPtrWillBeRawPtr<NodeList> NodeOrNodeList::getAsNodeList() const
+RawPtr<NodeList> NodeOrNodeList::getAsNodeList() const
 {
     ASSERT(isNodeList());
     return m_nodeList;
 }
 
-void NodeOrNodeList::setNodeList(PassRefPtrWillBeRawPtr<NodeList> value)
+void NodeOrNodeList::setNodeList(RawPtr<NodeList> value)
 {
     ASSERT(isNull());
     m_nodeList = value;
     m_type = SpecificTypeNodeList;
 }
 
-NodeOrNodeList NodeOrNodeList::fromNodeList(PassRefPtrWillBeRawPtr<NodeList> value)
+NodeOrNodeList NodeOrNodeList::fromNodeList(RawPtr<NodeList> value)
 {
     NodeOrNodeList container;
     container.setNodeList(value);
@@ -562,13 +562,13 @@ void V8NodeOrNodeList::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value
         return;
 
     if (V8Node::hasInstance(v8Value, isolate)) {
-        RefPtrWillBeRawPtr<Node> cppValue = V8Node::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        RawPtr<Node> cppValue = V8Node::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setNode(cppValue);
         return;
     }
 
     if (V8NodeList::hasInstance(v8Value, isolate)) {
-        RefPtrWillBeRawPtr<NodeList> cppValue = V8NodeList::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        RawPtr<NodeList> cppValue = V8NodeList::toImpl(v8::Local<v8::Object>::Cast(v8Value));
         impl.setNodeList(cppValue);
         return;
     }
@@ -1450,62 +1450,62 @@ TestInterfaceOrTestInterfaceEmpty NativeValueTraits<TestInterfaceOrTestInterface
     return impl;
 }
 
-TestInterfaceWillBeGarbageCollectedOrTestDictionary::TestInterfaceWillBeGarbageCollectedOrTestDictionary()
+TestInterfaceGarbageCollectedOrTestDictionary::TestInterfaceGarbageCollectedOrTestDictionary()
     : m_type(SpecificTypeNone)
 {
 }
 
-PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> TestInterfaceWillBeGarbageCollectedOrTestDictionary::getAsTestInterfaceWillBeGarbageCollected() const
+RawPtr<TestInterfaceGarbageCollected> TestInterfaceGarbageCollectedOrTestDictionary::getAsTestInterfaceGarbageCollected() const
 {
-    ASSERT(isTestInterfaceWillBeGarbageCollected());
-    return m_testInterfaceWillBeGarbageCollected;
+    ASSERT(isTestInterfaceGarbageCollected());
+    return m_testInterfaceGarbageCollected;
 }
 
-void TestInterfaceWillBeGarbageCollectedOrTestDictionary::setTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value)
+void TestInterfaceGarbageCollectedOrTestDictionary::setTestInterfaceGarbageCollected(RawPtr<TestInterfaceGarbageCollected> value)
 {
     ASSERT(isNull());
-    m_testInterfaceWillBeGarbageCollected = value;
-    m_type = SpecificTypeTestInterfaceWillBeGarbageCollected;
+    m_testInterfaceGarbageCollected = value;
+    m_type = SpecificTypeTestInterfaceGarbageCollected;
 }
 
-TestInterfaceWillBeGarbageCollectedOrTestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::fromTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> value)
+TestInterfaceGarbageCollectedOrTestDictionary TestInterfaceGarbageCollectedOrTestDictionary::fromTestInterfaceGarbageCollected(RawPtr<TestInterfaceGarbageCollected> value)
 {
-    TestInterfaceWillBeGarbageCollectedOrTestDictionary container;
-    container.setTestInterfaceWillBeGarbageCollected(value);
+    TestInterfaceGarbageCollectedOrTestDictionary container;
+    container.setTestInterfaceGarbageCollected(value);
     return container;
 }
 
-TestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::getAsTestDictionary() const
+TestDictionary TestInterfaceGarbageCollectedOrTestDictionary::getAsTestDictionary() const
 {
     ASSERT(isTestDictionary());
     return m_testDictionary;
 }
 
-void TestInterfaceWillBeGarbageCollectedOrTestDictionary::setTestDictionary(TestDictionary value)
+void TestInterfaceGarbageCollectedOrTestDictionary::setTestDictionary(TestDictionary value)
 {
     ASSERT(isNull());
     m_testDictionary = value;
     m_type = SpecificTypeTestDictionary;
 }
 
-TestInterfaceWillBeGarbageCollectedOrTestDictionary TestInterfaceWillBeGarbageCollectedOrTestDictionary::fromTestDictionary(TestDictionary value)
+TestInterfaceGarbageCollectedOrTestDictionary TestInterfaceGarbageCollectedOrTestDictionary::fromTestDictionary(TestDictionary value)
 {
-    TestInterfaceWillBeGarbageCollectedOrTestDictionary container;
+    TestInterfaceGarbageCollectedOrTestDictionary container;
     container.setTestDictionary(value);
     return container;
 }
 
-TestInterfaceWillBeGarbageCollectedOrTestDictionary::TestInterfaceWillBeGarbageCollectedOrTestDictionary(const TestInterfaceWillBeGarbageCollectedOrTestDictionary&) = default;
-TestInterfaceWillBeGarbageCollectedOrTestDictionary::~TestInterfaceWillBeGarbageCollectedOrTestDictionary() = default;
-TestInterfaceWillBeGarbageCollectedOrTestDictionary& TestInterfaceWillBeGarbageCollectedOrTestDictionary::operator=(const TestInterfaceWillBeGarbageCollectedOrTestDictionary&) = default;
+TestInterfaceGarbageCollectedOrTestDictionary::TestInterfaceGarbageCollectedOrTestDictionary(const TestInterfaceGarbageCollectedOrTestDictionary&) = default;
+TestInterfaceGarbageCollectedOrTestDictionary::~TestInterfaceGarbageCollectedOrTestDictionary() = default;
+TestInterfaceGarbageCollectedOrTestDictionary& TestInterfaceGarbageCollectedOrTestDictionary::operator=(const TestInterfaceGarbageCollectedOrTestDictionary&) = default;
 
-DEFINE_TRACE(TestInterfaceWillBeGarbageCollectedOrTestDictionary)
+DEFINE_TRACE(TestInterfaceGarbageCollectedOrTestDictionary)
 {
-    visitor->trace(m_testInterfaceWillBeGarbageCollected);
+    visitor->trace(m_testInterfaceGarbageCollected);
     visitor->trace(m_testDictionary);
 }
 
-void V8TestInterfaceWillBeGarbageCollectedOrTestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceWillBeGarbageCollectedOrTestDictionary& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
+void V8TestInterfaceGarbageCollectedOrTestDictionary::toImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8Value, TestInterfaceGarbageCollectedOrTestDictionary& impl, UnionTypeConversionMode conversionMode, ExceptionState& exceptionState)
 {
     if (v8Value.IsEmpty())
         return;
@@ -1513,9 +1513,9 @@ void V8TestInterfaceWillBeGarbageCollectedOrTestDictionary::toImpl(v8::Isolate*
     if (conversionMode == UnionTypeConversionMode::Nullable && isUndefinedOrNull(v8Value))
         return;
 
-    if (V8TestInterfaceWillBeGarbageCollected::hasInstance(v8Value, isolate)) {
-        RefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> cppValue = V8TestInterfaceWillBeGarbageCollected::toImpl(v8::Local<v8::Object>::Cast(v8Value));
-        impl.setTestInterfaceWillBeGarbageCollected(cppValue);
+    if (V8TestInterfaceGarbageCollected::hasInstance(v8Value, isolate)) {
+        RawPtr<TestInterfaceGarbageCollected> cppValue = V8TestInterfaceGarbageCollected::toImpl(v8::Local<v8::Object>::Cast(v8Value));
+        impl.setTestInterfaceGarbageCollected(cppValue);
         return;
     }
 
@@ -1528,17 +1528,17 @@ void V8TestInterfaceWillBeGarbageCollectedOrTestDictionary::toImpl(v8::Isolate*
         return;
     }
 
-    exceptionState.throwTypeError("The provided value is not of type '(TestInterfaceWillBeGarbageCollected or TestDictionary)'");
+    exceptionState.throwTypeError("The provided value is not of type '(TestInterfaceGarbageCollected or TestDictionary)'");
 }
 
-v8::Local<v8::Value> toV8(const TestInterfaceWillBeGarbageCollectedOrTestDictionary& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
+v8::Local<v8::Value> toV8(const TestInterfaceGarbageCollectedOrTestDictionary& impl, v8::Local<v8::Object> creationContext, v8::Isolate* isolate)
 {
     switch (impl.m_type) {
-    case TestInterfaceWillBeGarbageCollectedOrTestDictionary::SpecificTypeNone:
+    case TestInterfaceGarbageCollectedOrTestDictionary::SpecificTypeNone:
         return v8::Null(isolate);
-    case TestInterfaceWillBeGarbageCollectedOrTestDictionary::SpecificTypeTestInterfaceWillBeGarbageCollected:
-        return toV8(impl.getAsTestInterfaceWillBeGarbageCollected(), creationContext, isolate);
-    case TestInterfaceWillBeGarbageCollectedOrTestDictionary::SpecificTypeTestDictionary:
+    case TestInterfaceGarbageCollectedOrTestDictionary::SpecificTypeTestInterfaceGarbageCollected:
+        return toV8(impl.getAsTestInterfaceGarbageCollected(), creationContext, isolate);
+    case TestInterfaceGarbageCollectedOrTestDictionary::SpecificTypeTestDictionary:
         return toV8(impl.getAsTestDictionary(), creationContext, isolate);
     default:
         ASSERT_NOT_REACHED();
@@ -1546,10 +1546,10 @@ v8::Local<v8::Value> toV8(const TestInterfaceWillBeGarbageCollectedOrTestDiction
     return v8::Local<v8::Value>();
 }
 
-TestInterfaceWillBeGarbageCollectedOrTestDictionary NativeValueTraits<TestInterfaceWillBeGarbageCollectedOrTestDictionary>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
+TestInterfaceGarbageCollectedOrTestDictionary NativeValueTraits<TestInterfaceGarbageCollectedOrTestDictionary>::nativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exceptionState)
 {
-    TestInterfaceWillBeGarbageCollectedOrTestDictionary impl;
-    V8TestInterfaceWillBeGarbageCollectedOrTestDictionary::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
+    TestInterfaceGarbageCollectedOrTestDictionary impl;
+    V8TestInterfaceGarbageCollectedOrTestDictionary::toImpl(isolate, value, impl, UnionTypeConversionMode::NotNullable, exceptionState);
     return impl;
 }