IDL: DOM impl class code generation for IDL dictionaries

Source/bindings/tests/results/TestDictionary.h

Index: Source/bindings/tests/results/TestDictionary.h
diff --git a/Source/bindings/tests/results/TestDictionary.h b/Source/bindings/tests/results/TestDictionary.h
new file mode 100644
index 0000000000000000000000000000000000000000..bd716a11118e23a2f7fad7a8a80aa20e4df85b2e
--- /dev/null
+++ b/Source/bindings/tests/results/TestDictionary.h
@@ -0,0 +1,91 @@
+// 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!
+
+#ifndef TestDictionary_h
+#define TestDictionary_h
+
+#include "bindings/core/v8/Nullable.h"
+#include "bindings/tests/idls/TestInterfaceGarbageCollected.h"
+#include "bindings/tests/idls/TestInterfaceImplementation.h"
+#include "bindings/tests/idls/TestInterfaceWillBeGarbageCollected.h"
+#include "platform/heap/Handle.h"
+#include "wtf/Vector.h"
+#include "wtf/text/WTFString.h"
+
+namespace blink {
+
+class TestDictionary FINAL : public GarbageCollectedFinalized<TestDictionary> {
+public:
+    static TestDictionary* create()
+    {
+        return new TestDictionary;
+    }
+
+    bool hasBooleanMember() const { return !m_booleanMember.isNull(); }
+    bool booleanMember() const { return m_booleanMember.get(); }
+    void setBooleanMember(bool) { m_booleanMember = value;}
+    bool hasLongMember() const { return !m_longMember.isNull(); }
+    int longMember() const { return m_longMember.get(); }
+    void setLongMember(int) { m_longMember = value;}
+    bool hasStringMember() const { return !m_stringMember.isNull(); }
+    const String& stringMember() const { return m_stringMember; }
+    void setStringMember(const String&) { m_stringMember = value;}
+    bool hasTestInterfaceMember() const { return m_testInterfaceMember; }
+    PassRefPtr<TestInterfaceImplementation> testInterfaceMember() const { return m_testInterfaceMember; }
+    void setTestInterfaceMember(PassRefPtr<TestInterfaceImplementation>) { m_testInterfaceMember = value;}
+    bool hasDoubleOrNullMember() const { return !m_doubleOrNullMember.isNull(); }
+    double doubleOrNullMember() const { return m_doubleOrNullMember.get(); }
+    void setDoubleOrNullMember(double) { m_doubleOrNullMember = value;}
+    bool hasStringOrNullMember() const { return !m_stringOrNullMember.isNull(); }
+    const String& stringOrNullMember() const { return m_stringOrNullMember; }
+    void setStringOrNullMember(const String&) { m_stringOrNullMember = value;}
+    bool hasTestInterfaceOrNullMember() const { return m_testInterfaceOrNullMember; }
+    PassRefPtr<TestInterfaceImplementation> testInterfaceOrNullMember() const { return m_testInterfaceOrNullMember; }
+    void setTestInterfaceOrNullMember(PassRefPtr<TestInterfaceImplementation>) { m_testInterfaceOrNullMember = value;}
+    bool hasTestInterfaceGarbageCollectedMember() const { return m_testInterfaceGarbageCollectedMember; }
+    RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedMember() const { return m_testInterfaceGarbageCollectedMember; }
+    void setTestInterfaceGarbageCollectedMember(RawPtr<TestInterfaceGarbageCollected>) { m_testInterfaceGarbageCollectedMember = value;}
+    bool hasTestInterfaceGarbageCollectedOrNullMember() const { return m_testInterfaceGarbageCollectedOrNullMember; }
+    RawPtr<TestInterfaceGarbageCollected> testInterfaceGarbageCollectedOrNullMember() const { return m_testInterfaceGarbageCollectedOrNullMember; }
+    void setTestInterfaceGarbageCollectedOrNullMember(RawPtr<TestInterfaceGarbageCollected>) { m_testInterfaceGarbageCollectedOrNullMember = value;}
+    bool hasTestInterfaceWillBeGarbageCollectedMember() const { return m_testInterfaceWillBeGarbageCollectedMember; }
+    PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedMember() const { return m_testInterfaceWillBeGarbageCollectedMember; }
+    void setTestInterfaceWillBeGarbageCollectedMember(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected>) { m_testInterfaceWillBeGarbageCollectedMember = value;}
+    bool hasTestInterfaceWillBeGarbageCollectedOrNullMember() const { return m_testInterfaceWillBeGarbageCollectedOrNullMember; }
+    PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected> testInterfaceWillBeGarbageCollectedOrNullMember() const { return m_testInterfaceWillBeGarbageCollectedOrNullMember; }
+    void setTestInterfaceWillBeGarbageCollectedOrNullMember(PassRefPtrWillBeRawPtr<TestInterfaceWillBeGarbageCollected>) { m_testInterfaceWillBeGarbageCollectedOrNullMember = value;}
+    bool hasStringArrayMember() const { return !m_stringArrayMember.isNull(); }
+    const Vector<String>& stringArrayMember() const { return m_stringArrayMember.get(); }
+    void setStringArrayMember(const Vector<String>&) { m_stringArrayMember = value;}
+    bool hasStringSequenceMember() const { return !m_stringSequenceMember.isNull(); }
+    const Vector<String>& stringSequenceMember() const { return m_stringSequenceMember.get(); }
+    void setStringSequenceMember(const Vector<String>&) { m_stringSequenceMember = value;}
+
+    void trace(Visitor*);
+
+private:
+    TestDictionary();
+
+    Nullable<bool> m_booleanMember;
+    Nullable<int> m_longMember;

[haraken, 2014/07/29 11:09:19]

Just help me understand: Where does the difference appear between a 'long'
member and a 'long?' member? (I understand we're using Nullable<> to represent
IDL's nullable or a missing value. Then it seems to me that there is no
difference in implementation between nullable types and not-nullable types.)

[bashi, 2014/07/29 11:51:21]

From the spec's viewpoint or the implementation's viewpoint?

Speaking of the spec, I can't figure out why nullable is needed, given that 'not
specified' and 'null' would mean the same thing in dictionaries, IIUC.

In the terms of our implementation, there should be no difference, as you
described. Nullable is supported because the spec says it is allowed (and easy
to implement).

[haraken, 2014/07/29 12:25:48]

Makes sense, thanks for the clarification!

+    String m_stringMember;
+    RefPtr<TestInterfaceImplementation> m_testInterfaceMember;
+    Nullable<double> m_doubleOrNullMember;
+    String m_stringOrNullMember;
+    RefPtr<TestInterfaceImplementation> m_testInterfaceOrNullMember;
+    Member<TestInterfaceGarbageCollected> m_testInterfaceGarbageCollectedMember;
+    Member<TestInterfaceGarbageCollected> m_testInterfaceGarbageCollectedOrNullMember;
+    RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> m_testInterfaceWillBeGarbageCollectedMember;
+    RefPtrWillBeMember<TestInterfaceWillBeGarbageCollected> m_testInterfaceWillBeGarbageCollectedOrNullMember;
+    Nullable<Vector<String> > m_stringArrayMember;
+    Nullable<Vector<String> > m_stringSequenceMember;
+
+    friend class V8TestDictionary;
+};
+
+} // namespace blink
+
+#endif // TestDictionary_h