bindings: Use forward declarations for wrapper types in dictionary_impl

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

Index: third_party/WebKit/Source/bindings/tests/results/core/TestDictionary.cpp
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/TestDictionary.cpp b/third_party/WebKit/Source/bindings/tests/results/core/TestDictionary.cpp
index cfe7c01ef7b347b332791a1e98dd1e7d8fcd7382..ce7dc36e09456dc962914f6c936a09ee34031c68 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/TestDictionary.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/TestDictionary.cpp
@@ -9,7 +9,14 @@
 #include "TestDictionary.h"
 
 #include "bindings/core/v8/DoubleOrString.h"
+#include "bindings/core/v8/Nullable.h"
 #include "bindings/core/v8/TestInterface2OrUint8Array.h"
+#include "bindings/tests/idls/core/TestInterfaceGarbageCollected.h"
+#include "bindings/tests/idls/core/TestInterfaceImplementation.h"
+#include "bindings/tests/idls/core/TestObject.h"
+#include "core/dom/Element.h"
+#include "core/events/EventTarget.h"
+#include "wtf/Vector.h"
 
 namespace blink {
 
@@ -42,8 +49,417 @@ DEFINE_TRACE(TestDictionary) {
   visitor->trace(m_testInterfaceMember);
   visitor->trace(m_testInterfaceOrNullMember);
   visitor->trace(m_testInterfaceSequenceMember);
+  visitor->trace(m_testObjectSequenceMember);
   visitor->trace(m_uint8ArrayMember);
   IDLDictionaryBase::trace(visitor);
 }
 
+bool TestDictionary::hasAnyMember() const {
+  return !(m_anyMember.isEmpty() || m_anyMember.isNull() || m_anyMember.isUndefined());
+}
+
+ScriptValue TestDictionary::anyMember() const {
+  return m_anyMember;
+}
+
+void TestDictionary::setAnyMember(ScriptValue value) {
+  m_anyMember = value;
+}
+
+bool TestDictionary::hasBooleanMember() const {
+  return !m_booleanMember.isNull();
+}
+
+bool TestDictionary::booleanMember() const {
+  return m_booleanMember.get();
+}
+
+void TestDictionary::setBooleanMember(bool value) {
+  m_booleanMember = value;
+}
+
+bool TestDictionary::hasCreateMember() const {
+  return !m_createMember.isNull();
+}
+
+bool TestDictionary::createMember() const {
+  return m_createMember.get();
+}
+
+void TestDictionary::setCreateMember(bool value) {
+  m_createMember = value;
+}
+
+bool TestDictionary::hasDictionaryMember() const {
+  return !m_dictionaryMember.isUndefinedOrNull();
+}
+
+Dictionary TestDictionary::dictionaryMember() const {
+  return m_dictionaryMember;
+}
+
+void TestDictionary::setDictionaryMember(Dictionary value) {
+  m_dictionaryMember = value;
+}
+
+bool TestDictionary::hasDoubleOrNullMember() const {
+  return !m_doubleOrNullMember.isNull();
+}
+
+double TestDictionary::doubleOrNullMember() const {
+  return m_doubleOrNullMember.get();
+}
+
+void TestDictionary::setDoubleOrNullMember(double value) {
+  m_doubleOrNullMember = value;
+}
+
+void TestDictionary::setDoubleOrNullMemberToNull() {
+  m_doubleOrNullMember = Nullable<double>();
+}
+
+bool TestDictionary::hasDoubleOrStringMember() const {
+  return !m_doubleOrStringMember.isNull();
+}
+
+const DoubleOrString& TestDictionary::doubleOrStringMember() const {
+  return m_doubleOrStringMember;
+}
+
+void TestDictionary::setDoubleOrStringMember(const DoubleOrString& value) {
+  m_doubleOrStringMember = value;
+}
+
+bool TestDictionary::hasDoubleOrStringSequenceMember() const {
+  return !m_doubleOrStringSequenceMember.isNull();
+}
+
+const HeapVector<DoubleOrString>& TestDictionary::doubleOrStringSequenceMember() const {
+  return m_doubleOrStringSequenceMember.get();
+}
+
+void TestDictionary::setDoubleOrStringSequenceMember(const HeapVector<DoubleOrString>& value) {
+  m_doubleOrStringSequenceMember = value;
+}
+
+bool TestDictionary::hasElementOrNullMember() const {
+  return m_elementOrNullMember;
+}
+
+Element* TestDictionary::elementOrNullMember() const {
+  return m_elementOrNullMember;
+}
+
+void TestDictionary::setElementOrNullMember(Element* value) {
+  m_elementOrNullMember = value;
+}
+
+void TestDictionary::setElementOrNullMemberToNull() {
+  m_elementOrNullMember = Member<Element>();
+}
+
+bool TestDictionary::hasEnumMember() const {
+  return !m_enumMember.isNull();
+}
+
+String TestDictionary::enumMember() const {
+  return m_enumMember;
+}
+
+void TestDictionary::setEnumMember(String value) {
+  m_enumMember = value;
+}
+
+bool TestDictionary::hasEnumSequenceMember() const {
+  return !m_enumSequenceMember.isNull();
+}
+
+const Vector<String>& TestDictionary::enumSequenceMember() const {
+  return m_enumSequenceMember.get();
+}
+
+void TestDictionary::setEnumSequenceMember(const Vector<String>& value) {
+  m_enumSequenceMember = value;
+}
+
+bool TestDictionary::hasEventTargetMember() const {
+  return m_eventTargetMember;
+}
+
+EventTarget* TestDictionary::eventTargetMember() const {
+  return m_eventTargetMember;
+}
+
+void TestDictionary::setEventTargetMember(EventTarget* value) {
+  m_eventTargetMember = value;
+}
+
+bool TestDictionary::hasInternalDictionarySequenceMember() const {
+  return !m_internalDictionarySequenceMember.isNull();
+}
+
+const HeapVector<InternalDictionary>& TestDictionary::internalDictionarySequenceMember() const {
+  return m_internalDictionarySequenceMember.get();
+}
+
+void TestDictionary::setInternalDictionarySequenceMember(const HeapVector<InternalDictionary>& value) {
+  m_internalDictionarySequenceMember = value;
+}
+
+bool TestDictionary::hasLongMember() const {
+  return !m_longMember.isNull();
+}
+
+int TestDictionary::longMember() const {
+  return m_longMember.get();
+}
+
+void TestDictionary::setLongMember(int value) {
+  m_longMember = value;
+}
+
+bool TestDictionary::hasObjectMember() const {
+  return !(m_objectMember.isEmpty() || m_objectMember.isNull() || m_objectMember.isUndefined());
+}
+
+ScriptValue TestDictionary::objectMember() const {
+  return m_objectMember;
+}
+
+void TestDictionary::setObjectMember(ScriptValue value) {
+  m_objectMember = value;
+}
+
+bool TestDictionary::hasObjectOrNullMember() const {
+  return !(m_objectOrNullMember.isEmpty() || m_objectOrNullMember.isNull() || m_objectOrNullMember.isUndefined());
+}
+
+ScriptValue TestDictionary::objectOrNullMember() const {
+  return m_objectOrNullMember;
+}
+
+void TestDictionary::setObjectOrNullMember(ScriptValue value) {
+  m_objectOrNullMember = value;
+}
+
+void TestDictionary::setObjectOrNullMemberToNull() {
+  m_objectOrNullMember = ScriptValue();
+}
+
+bool TestDictionary::hasOtherDoubleOrStringMember() const {
+  return !m_otherDoubleOrStringMember.isNull();
+}
+
+const DoubleOrString& TestDictionary::otherDoubleOrStringMember() const {
+  return m_otherDoubleOrStringMember;
+}
+
+void TestDictionary::setOtherDoubleOrStringMember(const DoubleOrString& value) {
+  m_otherDoubleOrStringMember = value;
+}
+
+bool TestDictionary::hasRestrictedDoubleMember() const {
+  return !m_restrictedDoubleMember.isNull();
+}
+
+double TestDictionary::restrictedDoubleMember() const {
+  return m_restrictedDoubleMember.get();
+}
+
+void TestDictionary::setRestrictedDoubleMember(double value) {
+  m_restrictedDoubleMember = value;
+}
+
+bool TestDictionary::hasRuntimeMember() const {
+  return !m_runtimeMember.isNull();
+}
+
+bool TestDictionary::runtimeMember() const {
+  return m_runtimeMember.get();
+}
+
+void TestDictionary::setRuntimeMember(bool value) {
+  m_runtimeMember = value;
+}
+
+bool TestDictionary::hasStringArrayMember() const {
+  return !m_stringArrayMember.isNull();
+}
+
+const Vector<String>& TestDictionary::stringArrayMember() const {
+  return m_stringArrayMember.get();
+}
+
+void TestDictionary::setStringArrayMember(const Vector<String>& value) {
+  m_stringArrayMember = value;
+}
+
+bool TestDictionary::hasStringMember() const {
+  return !m_stringMember.isNull();
+}
+
+String TestDictionary::stringMember() const {
+  return m_stringMember;
+}
+
+void TestDictionary::setStringMember(String value) {
+  m_stringMember = value;
+}
+
+bool TestDictionary::hasStringOrNullMember() const {
+  return !m_stringOrNullMember.isNull();
+}
+
+String TestDictionary::stringOrNullMember() const {
+  return m_stringOrNullMember;
+}
+
+void TestDictionary::setStringOrNullMember(String value) {
+  m_stringOrNullMember = value;
+}
+
+void TestDictionary::setStringOrNullMemberToNull() {
+  m_stringOrNullMember = String();
+}
+
+bool TestDictionary::hasStringSequenceMember() const {
+  return !m_stringSequenceMember.isNull();
+}
+
+const Vector<String>& TestDictionary::stringSequenceMember() const {
+  return m_stringSequenceMember.get();
+}
+
+void TestDictionary::setStringSequenceMember(const Vector<String>& value) {
+  m_stringSequenceMember = value;
+}
+
+bool TestDictionary::hasTestInterface2OrUint8ArrayMember() const {
+  return !m_testInterface2OrUint8ArrayMember.isNull();
+}
+
+const TestInterface2OrUint8Array& TestDictionary::testInterface2OrUint8ArrayMember() const {
+  return m_testInterface2OrUint8ArrayMember;
+}
+
+void TestDictionary::setTestInterface2OrUint8ArrayMember(const TestInterface2OrUint8Array& value) {
+  m_testInterface2OrUint8ArrayMember = value;
+}
+
+bool TestDictionary::hasTestInterfaceGarbageCollectedMember() const {
+  return m_testInterfaceGarbageCollectedMember;
+}
+
+TestInterfaceGarbageCollected* TestDictionary::testInterfaceGarbageCollectedMember() const {
+  return m_testInterfaceGarbageCollectedMember;
+}
+
+void TestDictionary::setTestInterfaceGarbageCollectedMember(TestInterfaceGarbageCollected* value) {
+  m_testInterfaceGarbageCollectedMember = value;
+}
+
+bool TestDictionary::hasTestInterfaceGarbageCollectedOrNullMember() const {
+  return m_testInterfaceGarbageCollectedOrNullMember;
+}
+
+TestInterfaceGarbageCollected* TestDictionary::testInterfaceGarbageCollectedOrNullMember() const {
+  return m_testInterfaceGarbageCollectedOrNullMember;
+}
+
+void TestDictionary::setTestInterfaceGarbageCollectedOrNullMember(TestInterfaceGarbageCollected* value) {
+  m_testInterfaceGarbageCollectedOrNullMember = value;
+}
+
+void TestDictionary::setTestInterfaceGarbageCollectedOrNullMemberToNull() {
+  m_testInterfaceGarbageCollectedOrNullMember = Member<TestInterfaceGarbageCollected>();
+}
+
+bool TestDictionary::hasTestInterfaceGarbageCollectedSequenceMember() const {
+  return !m_testInterfaceGarbageCollectedSequenceMember.isNull();
+}
+
+const HeapVector<Member<TestInterfaceGarbageCollected>>& TestDictionary::testInterfaceGarbageCollectedSequenceMember() const {
+  return m_testInterfaceGarbageCollectedSequenceMember.get();
+}
+
+void TestDictionary::setTestInterfaceGarbageCollectedSequenceMember(const HeapVector<Member<TestInterfaceGarbageCollected>>& value) {
+  m_testInterfaceGarbageCollectedSequenceMember = value;
+}
+
+bool TestDictionary::hasTestInterfaceMember() const {
+  return m_testInterfaceMember;
+}
+
+TestInterfaceImplementation* TestDictionary::testInterfaceMember() const {
+  return m_testInterfaceMember;
+}
+
+void TestDictionary::setTestInterfaceMember(TestInterfaceImplementation* value) {
+  m_testInterfaceMember = value;
+}
+
+bool TestDictionary::hasTestInterfaceOrNullMember() const {
+  return m_testInterfaceOrNullMember;
+}
+
+TestInterfaceImplementation* TestDictionary::testInterfaceOrNullMember() const {
+  return m_testInterfaceOrNullMember;
+}
+
+void TestDictionary::setTestInterfaceOrNullMember(TestInterfaceImplementation* value) {
+  m_testInterfaceOrNullMember = value;
+}
+
+void TestDictionary::setTestInterfaceOrNullMemberToNull() {
+  m_testInterfaceOrNullMember = Member<TestInterfaceImplementation>();
+}
+
+bool TestDictionary::hasTestInterfaceSequenceMember() const {
+  return !m_testInterfaceSequenceMember.isNull();
+}
+
+const HeapVector<Member<TestInterfaceImplementation>>& TestDictionary::testInterfaceSequenceMember() const {
+  return m_testInterfaceSequenceMember.get();
+}
+
+void TestDictionary::setTestInterfaceSequenceMember(const HeapVector<Member<TestInterfaceImplementation>>& value) {
+  m_testInterfaceSequenceMember = value;
+}
+
+bool TestDictionary::hasTestObjectSequenceMember() const {
+  return !m_testObjectSequenceMember.isNull();
+}
+
+const HeapVector<Member<TestObject>>& TestDictionary::testObjectSequenceMember() const {
+  return m_testObjectSequenceMember.get();
+}
+
+void TestDictionary::setTestObjectSequenceMember(const HeapVector<Member<TestObject>>& value) {
+  m_testObjectSequenceMember = value;
+}
+
+bool TestDictionary::hasUint8ArrayMember() const {
+  return m_uint8ArrayMember;
+}
+
+DOMUint8Array* TestDictionary::uint8ArrayMember() const {
+  return m_uint8ArrayMember;
+}
+
+void TestDictionary::setUint8ArrayMember(DOMUint8Array* value) {
+  m_uint8ArrayMember = value;
+}
+
+bool TestDictionary::hasUnrestrictedDoubleMember() const {
+  return !m_unrestrictedDoubleMember.isNull();
+}
+
+double TestDictionary::unrestrictedDoubleMember() const {
+  return m_unrestrictedDoubleMember.get();
+}
+
+void TestDictionary::setUnrestrictedDoubleMember(double value) {
+  m_unrestrictedDoubleMember = value;
+}
+
 }  // namespace blink