Oilpan: Remove most WillBe types from the code base

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

Index: third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.h
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.h b/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.h
index 36cee2705aec8cbff943c9fa4e5e17165fef8721..f0126c2b571a2ac4061e7dfbc2c7cb47487cb3be 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.h
+++ b/third_party/WebKit/Source/bindings/tests/results/core/UnionTypesCore.h
@@ -25,7 +25,7 @@ class TestInterface2;
 class TestInterfaceEmpty;
 class TestInterfaceGarbageCollected;
 class TestInterfaceImplementation;
-class TestInterfaceWillBeGarbageCollected;
+class TestInterfaceGarbageCollected;
 
 class CORE_EXPORT ArrayBufferOrArrayBufferViewOrDictionary final {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
@@ -260,14 +260,14 @@ public:
     bool isNull() const { return m_type == SpecificTypeNone; }
 
     bool isNode() const { return m_type == SpecificTypeNode; }
-    PassRefPtrWillBeRawPtr<Node> getAsNode() const;
-    void setNode(PassRefPtrWillBeRawPtr<Node>);
-    static NodeOrNodeList fromNode(PassRefPtrWillBeRawPtr<Node>);
+    RawPtr<Node> getAsNode() const;
+    void setNode(RawPtr<Node>);
+    static NodeOrNodeList fromNode(RawPtr<Node>);
 
     bool isNodeList() const { return m_type == SpecificTypeNodeList; }
-    PassRefPtrWillBeRawPtr<NodeList> getAsNodeList() const;
-    void setNodeList(PassRefPtrWillBeRawPtr<NodeList>);
-    static NodeOrNodeList fromNodeList(PassRefPtrWillBeRawPtr<NodeList>);
+    RawPtr<NodeList> getAsNodeList() const;
+    void setNodeList(RawPtr<NodeList>);
+    static NodeOrNodeList fromNodeList(RawPtr<NodeList>);
 
     NodeOrNodeList(const NodeOrNodeList&);
     ~NodeOrNodeList();
@@ -282,8 +282,8 @@ private:
     };
     SpecificTypes m_type;
 
-    RefPtrWillBeMember<Node> m_node;
-    RefPtrWillBeMember<NodeList> m_nodeList;
+    Member<Node> m_node;
+    Member<NodeList> m_nodeList;
 
     friend CORE_EXPORT v8::Local<v8::Value> toV8(const NodeOrNodeList&, v8::Local<v8::Object>, v8::Isolate*);
 };
@@ -737,57 +737,57 @@ struct NativeValueTraits<TestInterfaceOrTestInterfaceEmpty> {
     CORE_EXPORT static TestInterfaceOrTestInterfaceEmpty nativeValue(v8::Isolate*, v8::Local<v8::Value>, ExceptionState&);
 };
 
-class CORE_EXPORT TestInterfaceWillBeGarbageCollectedOrTestDictionary final {
+class CORE_EXPORT TestInterfaceGarbageCollectedOrTestDictionary final {
     DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
 public:
-    TestInterfaceWillBeGarbageCollectedOrTestDictionary();
+    TestInterfaceGarbageCollectedOrTestDictionary();
     bool isNull() const { return m_type == SpecificTypeNone; }
 
-    bool isTestInterfaceWillBeGarbageCollected() const { return m_type == SpecificTypeTestInterfaceWillBeGarbageCollected; }
-    PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> getAsTestInterfaceWillBeGarbageCollected() const;
-    void setTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected>);
-    static TestInterfaceWillBeGarbageCollectedOrTestDictionary fromTestInterfaceWillBeGarbageCollected(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected>);
+    bool isTestInterfaceGarbageCollected() const { return m_type == SpecificTypeTestInterfaceGarbageCollected; }
+    RawPtr<TestInterfaceGarbageCollected> getAsTestInterfaceGarbageCollected() const;
+    void setTestInterfaceGarbageCollected(RawPtr<TestInterfaceGarbageCollected>);
+    static TestInterfaceGarbageCollectedOrTestDictionary fromTestInterfaceGarbageCollected(RawPtr<TestInterfaceGarbageCollected>);
 
     bool isTestDictionary() const { return m_type == SpecificTypeTestDictionary; }
     TestDictionary getAsTestDictionary() const;
     void setTestDictionary(TestDictionary);
-    static TestInterfaceWillBeGarbageCollectedOrTestDictionary fromTestDictionary(TestDictionary);
+    static TestInterfaceGarbageCollectedOrTestDictionary fromTestDictionary(TestDictionary);
 
-    TestInterfaceWillBeGarbageCollectedOrTestDictionary(const TestInterfaceWillBeGarbageCollectedOrTestDictionary&);
-    ~TestInterfaceWillBeGarbageCollectedOrTestDictionary();
-    TestInterfaceWillBeGarbageCollectedOrTestDictionary& operator=(const TestInterfaceWillBeGarbageCollectedOrTestDictionary&);
+    TestInterfaceGarbageCollectedOrTestDictionary(const TestInterfaceGarbageCollectedOrTestDictionary&);
+    ~TestInterfaceGarbageCollectedOrTestDictionary();
+    TestInterfaceGarbageCollectedOrTestDictionary& operator=(const TestInterfaceGarbageCollectedOrTestDictionary&);
     DECLARE_TRACE();
 
 private:
     enum SpecificTypes {
         SpecificTypeNone,
-        SpecificTypeTestInterfaceWillBeGarbageCollected,
+        SpecificTypeTestInterfaceGarbageCollected,
         SpecificTypeTestDictionary,
     };
     SpecificTypes m_type;
 
-    RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> m_testInterfaceWillBeGarbageCollected;
+    Member<TestInterfaceGarbageCollected> m_testInterfaceGarbageCollected;
     TestDictionary m_testDictionary;
 
-    friend CORE_EXPORT v8::Local<v8::Value> toV8(const TestInterfaceWillBeGarbageCollectedOrTestDictionary&, v8::Local<v8::Object>, v8::Isolate*);
+    friend CORE_EXPORT v8::Local<v8::Value> toV8(const TestInterfaceGarbageCollectedOrTestDictionary&, v8::Local<v8::Object>, v8::Isolate*);
 };
 
-class V8TestInterfaceWillBeGarbageCollectedOrTestDictionary final {
+class V8TestInterfaceGarbageCollectedOrTestDictionary final {
 public:
-    CORE_EXPORT static void toImpl(v8::Isolate*, v8::Local<v8::Value>, TestInterfaceWillBeGarbageCollectedOrTestDictionary&, UnionTypeConversionMode, ExceptionState&);
+    CORE_EXPORT static void toImpl(v8::Isolate*, v8::Local<v8::Value>, TestInterfaceGarbageCollectedOrTestDictionary&, UnionTypeConversionMode, ExceptionState&);
 };
 
-CORE_EXPORT v8::Local<v8::Value> toV8(const TestInterfaceWillBeGarbageCollectedOrTestDictionary&, v8::Local<v8::Object>, v8::Isolate*);
+CORE_EXPORT v8::Local<v8::Value> toV8(const TestInterfaceGarbageCollectedOrTestDictionary&, v8::Local<v8::Object>, v8::Isolate*);
 
 template <class CallbackInfo>
-inline void v8SetReturnValue(const CallbackInfo& callbackInfo, TestInterfaceWillBeGarbageCollectedOrTestDictionary& impl)
+inline void v8SetReturnValue(const CallbackInfo& callbackInfo, TestInterfaceGarbageCollectedOrTestDictionary& impl)
 {
     v8SetReturnValue(callbackInfo, toV8(impl, callbackInfo.Holder(), callbackInfo.GetIsolate()));
 }
 
 template <>
-struct NativeValueTraits<TestInterfaceWillBeGarbageCollectedOrTestDictionary> {
-    CORE_EXPORT static TestInterfaceWillBeGarbageCollectedOrTestDictionary nativeValue(v8::Isolate*, v8::Local<v8::Value>, ExceptionState&);
+struct NativeValueTraits<TestInterfaceGarbageCollectedOrTestDictionary> {
+    CORE_EXPORT static TestInterfaceGarbageCollectedOrTestDictionary nativeValue(v8::Isolate*, v8::Local<v8::Value>, ExceptionState&);
 };
 
 class CORE_EXPORT UnrestrictedDoubleOrString final {
@@ -862,7 +862,7 @@ WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TestInterface2OrUint8Array);
 WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TestInterfaceGarbageCollectedOrString);
 WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TestInterfaceOrLong);
 WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TestInterfaceOrTestInterfaceEmpty);
-WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TestInterfaceWillBeGarbageCollectedOrTestDictionary);
+WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::TestInterfaceGarbageCollectedOrTestDictionary);
 WTF_ALLOW_MOVE_AND_INIT_WITH_MEM_FUNCTIONS(blink::UnrestrictedDoubleOrString);
 
 #endif // UnionTypeCore_h