michael@0: /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0: /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0:  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
michael@0:  * You can obtain one at http://mozilla.org/MPL/2.0/.
michael@0:  */
michael@0: 
michael@0: #ifndef TestBindingHeader_h
michael@0: #define TestBindingHeader_h
michael@0: 
michael@0: #include "mozilla/dom/BindingUtils.h"
michael@0: #include "mozilla/dom/Date.h"
michael@0: #include "mozilla/dom/MozMap.h"
michael@0: #include "mozilla/dom/TypedArray.h"
michael@0: #include "mozilla/dom/UnionTypes.h"
michael@0: #include "mozilla/ErrorResult.h"
michael@0: #include "nsCOMPtr.h"
michael@0: #include "nsGenericHTMLElement.h"
michael@0: #include "nsWrapperCache.h"
michael@0: 
michael@0: // Forward declare this before we include TestCodeGenBinding.h, because that header relies on including
michael@0: // this one for it, for ParentDict. Hopefully it won't begin to rely on it in more fundamental ways.
michael@0: namespace mozilla {
michael@0: namespace dom {
michael@0: class TestExternalInterface;
michael@0: } // namespace dom
michael@0: } // namespace mozilla
michael@0: 
michael@0: // We don't export TestCodeGenBinding.h, but it's right in our parent dir.
michael@0: #include "../TestCodeGenBinding.h"
michael@0: 
michael@0: extern bool TestFuncControlledMember(JSContext*, JSObject*);
michael@0: 
michael@0: namespace mozilla {
michael@0: namespace dom {
michael@0: 
michael@0: // IID for nsRenamedInterface
michael@0: #define NS_RENAMED_INTERFACE_IID \
michael@0: { 0xd4b19ef3, 0xe68b, 0x4e3f, \
michael@0:  { 0x94, 0xbc, 0xc9, 0xde, 0x3a, 0x69, 0xb0, 0xe8 } }
michael@0: 
michael@0: class nsRenamedInterface : public nsISupports,
michael@0:                            public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECLARE_STATIC_IID_ACCESSOR(NS_RENAMED_INTERFACE_IID)
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: };
michael@0: 
michael@0: NS_DEFINE_STATIC_IID_ACCESSOR(nsRenamedInterface, NS_RENAMED_INTERFACE_IID)
michael@0: 
michael@0: // IID for the IndirectlyImplementedInterface
michael@0: #define NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID \
michael@0: { 0xfed55b69, 0x7012, 0x4849, \
michael@0:  { 0xaf, 0x56, 0x4b, 0xa9, 0xee, 0x41, 0x30, 0x89 } }
michael@0: 
michael@0: class IndirectlyImplementedInterface : public nsISupports,
michael@0:                                        public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECLARE_STATIC_IID_ACCESSOR(NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   bool IndirectlyImplementedProperty();
michael@0:   void IndirectlyImplementedProperty(bool);
michael@0:   void IndirectlyImplementedMethod();
michael@0: };
michael@0: 
michael@0: NS_DEFINE_STATIC_IID_ACCESSOR(IndirectlyImplementedInterface, NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
michael@0: 
michael@0: // IID for the TestExternalInterface
michael@0: #define NS_TEST_EXTERNAL_INTERFACE_IID \
michael@0: { 0xd5ba0c99, 0x9b1d, 0x4e71, \
michael@0:  { 0x8a, 0x94, 0x56, 0x38, 0x6c, 0xa3, 0xda, 0x3d } }
michael@0: class TestExternalInterface : public nsISupports
michael@0: {
michael@0: public:
michael@0:   NS_DECLARE_STATIC_IID_ACCESSOR(NS_TEST_EXTERNAL_INTERFACE_IID)
michael@0:   NS_DECL_ISUPPORTS
michael@0: };
michael@0: 
michael@0: NS_DEFINE_STATIC_IID_ACCESSOR(TestExternalInterface, NS_TEST_EXTERNAL_INTERFACE_IID)
michael@0: 
michael@0: class TestNonWrapperCacheInterface : public nsISupports
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   virtual JSObject* WrapObject(JSContext* cx);
michael@0: };
michael@0: 
michael@0: class OnlyForUseInConstructor : public nsISupports,
michael@0:                                 public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: };
michael@0: 
michael@0: class TestInterface : public nsISupports,
michael@0:                       public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   // And now our actual WebIDL API
michael@0:   // Constructors
michael@0:   static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, ErrorResult&);
michael@0:   static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, const nsAString&, ErrorResult&);
michael@0:   static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, uint32_t, const Nullable<bool>&,
michael@0:                 ErrorResult&);
michael@0:   static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, TestInterface*, ErrorResult&);
michael@0:   static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, uint32_t, IndirectlyImplementedInterface&, ErrorResult&);
michael@0: 
michael@0:   static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, Date&, ErrorResult&);
michael@0:   /*  static
michael@0:   already_AddRefed<TestInterface>
michael@0:     Constructor(const GlobalObject&, uint32_t, uint32_t,
michael@0:                 const TestInterfaceOrOnlyForUseInConstructor&, ErrorResult&);
michael@0:   */
michael@0: 
michael@0:   static
michael@0:   already_AddRefed<TestInterface> Test(const GlobalObject&, ErrorResult&);
michael@0:   static
michael@0:   already_AddRefed<TestInterface> Test(const GlobalObject&, const nsAString&,
michael@0:                                        ErrorResult&);
michael@0:   static
michael@0:   already_AddRefed<TestInterface> Test(const GlobalObject&, const nsACString&,
michael@0:                                        ErrorResult&);
michael@0: 
michael@0:   static
michael@0:   already_AddRefed<TestInterface> Test2(const GlobalObject&,
michael@0:                                         JSContext*,
michael@0:                                         const DictForConstructor&,
michael@0:                                         JS::Handle<JS::Value>,
michael@0:                                         JS::Handle<JSObject*>,
michael@0:                                         JS::Handle<JSObject*>,
michael@0:                                         const Sequence<Dict>&,
michael@0:                                         JS::Handle<JS::Value>,
michael@0:                                         const Optional<JS::Handle<JSObject*> >&,
michael@0:                                         const Optional<JS::Handle<JSObject*> >&,
michael@0:                                         ErrorResult&);
michael@0: 
michael@0:   // Integer types
michael@0:   int8_t ReadonlyByte();
michael@0:   int8_t WritableByte();
michael@0:   void SetWritableByte(int8_t);
michael@0:   void PassByte(int8_t);
michael@0:   int8_t ReceiveByte();
michael@0:   void PassOptionalByte(const Optional<int8_t>&);
michael@0:   void PassOptionalByteBeforeRequired(const Optional<int8_t>&, int8_t);
michael@0:   void PassOptionalByteWithDefault(int8_t);
michael@0:   void PassOptionalByteWithDefaultBeforeRequired(int8_t, int8_t);
michael@0:   void PassNullableByte(const Nullable<int8_t>&);
michael@0:   void PassOptionalNullableByte(const Optional< Nullable<int8_t> >&);
michael@0:   void PassVariadicByte(const Sequence<int8_t>&);
michael@0:   int8_t CachedByte();
michael@0:   int8_t CachedConstantByte();
michael@0:   int8_t CachedWritableByte();
michael@0:   void SetCachedWritableByte(int8_t);
michael@0: 
michael@0:   int16_t ReadonlyShort();
michael@0:   int16_t WritableShort();
michael@0:   void SetWritableShort(int16_t);
michael@0:   void PassShort(int16_t);
michael@0:   int16_t ReceiveShort();
michael@0:   void PassOptionalShort(const Optional<int16_t>&);
michael@0:   void PassOptionalShortWithDefault(int16_t);
michael@0: 
michael@0:   int32_t ReadonlyLong();
michael@0:   int32_t WritableLong();
michael@0:   void SetWritableLong(int32_t);
michael@0:   void PassLong(int32_t);
michael@0:   int16_t ReceiveLong();
michael@0:   void PassOptionalLong(const Optional<int32_t>&);
michael@0:   void PassOptionalLongWithDefault(int32_t);
michael@0: 
michael@0:   int64_t ReadonlyLongLong();
michael@0:   int64_t WritableLongLong();
michael@0:   void SetWritableLongLong(int64_t);
michael@0:   void PassLongLong(int64_t);
michael@0:   int64_t ReceiveLongLong();
michael@0:   void PassOptionalLongLong(const Optional<int64_t>&);
michael@0:   void PassOptionalLongLongWithDefault(int64_t);
michael@0: 
michael@0:   uint8_t ReadonlyOctet();
michael@0:   uint8_t WritableOctet();
michael@0:   void SetWritableOctet(uint8_t);
michael@0:   void PassOctet(uint8_t);
michael@0:   uint8_t ReceiveOctet();
michael@0:   void PassOptionalOctet(const Optional<uint8_t>&);
michael@0:   void PassOptionalOctetWithDefault(uint8_t);
michael@0: 
michael@0:   uint16_t ReadonlyUnsignedShort();
michael@0:   uint16_t WritableUnsignedShort();
michael@0:   void SetWritableUnsignedShort(uint16_t);
michael@0:   void PassUnsignedShort(uint16_t);
michael@0:   uint16_t ReceiveUnsignedShort();
michael@0:   void PassOptionalUnsignedShort(const Optional<uint16_t>&);
michael@0:   void PassOptionalUnsignedShortWithDefault(uint16_t);
michael@0: 
michael@0:   uint32_t ReadonlyUnsignedLong();
michael@0:   uint32_t WritableUnsignedLong();
michael@0:   void SetWritableUnsignedLong(uint32_t);
michael@0:   void PassUnsignedLong(uint32_t);
michael@0:   uint32_t ReceiveUnsignedLong();
michael@0:   void PassOptionalUnsignedLong(const Optional<uint32_t>&);
michael@0:   void PassOptionalUnsignedLongWithDefault(uint32_t);
michael@0: 
michael@0:   uint64_t ReadonlyUnsignedLongLong();
michael@0:   uint64_t WritableUnsignedLongLong();
michael@0:   void SetWritableUnsignedLongLong(uint64_t);
michael@0:   void PassUnsignedLongLong(uint64_t);
michael@0:   uint64_t ReceiveUnsignedLongLong();
michael@0:   void PassOptionalUnsignedLongLong(const Optional<uint64_t>&);
michael@0:   void PassOptionalUnsignedLongLongWithDefault(uint64_t);
michael@0: 
michael@0:   float WritableFloat() const;
michael@0:   void SetWritableFloat(float);
michael@0:   float WritableUnrestrictedFloat() const;
michael@0:   void SetWritableUnrestrictedFloat(float);
michael@0:   Nullable<float> GetWritableNullableFloat() const;
michael@0:   void SetWritableNullableFloat(Nullable<float>);
michael@0:   Nullable<float> GetWritableNullableUnrestrictedFloat() const;
michael@0:   void SetWritableNullableUnrestrictedFloat(Nullable<float>);
michael@0:   double WritableDouble() const;
michael@0:   void SetWritableDouble(double);
michael@0:   double WritableUnrestrictedDouble() const;
michael@0:   void SetWritableUnrestrictedDouble(double);
michael@0:   Nullable<double> GetWritableNullableDouble() const;
michael@0:   void SetWritableNullableDouble(Nullable<double>);
michael@0:   Nullable<double> GetWritableNullableUnrestrictedDouble() const;
michael@0:   void SetWritableNullableUnrestrictedDouble(Nullable<double>);
michael@0:   void PassFloat(float, float, Nullable<float>, Nullable<float>,
michael@0:                  double, double, Nullable<double>, Nullable<double>,
michael@0:                  const Sequence<float>&, const Sequence<float>&,
michael@0:                  const Sequence<Nullable<float> >&,
michael@0:                  const Sequence<Nullable<float> >&,
michael@0:                  const Sequence<double>&, const Sequence<double>&,
michael@0:                  const Sequence<Nullable<double> >&,
michael@0:                  const Sequence<Nullable<double> >&);
michael@0:   void PassLenientFloat(float, float, Nullable<float>, Nullable<float>,
michael@0:                         double, double, Nullable<double>, Nullable<double>,
michael@0:                         const Sequence<float>&, const Sequence<float>&,
michael@0:                         const Sequence<Nullable<float> >&,
michael@0:                         const Sequence<Nullable<float> >&,
michael@0:                         const Sequence<double>&, const Sequence<double>&,
michael@0:                         const Sequence<Nullable<double> >&,
michael@0:                         const Sequence<Nullable<double> >&);
michael@0:   float LenientFloatAttr() const;
michael@0:   void SetLenientFloatAttr(float);
michael@0:   double LenientDoubleAttr() const;
michael@0:   void SetLenientDoubleAttr(double);
michael@0: 
michael@0:   void PassUnrestricted(float arg1,
michael@0:                         float arg2,
michael@0:                         float arg3,
michael@0:                         float arg4,
michael@0:                         double arg5,
michael@0:                         double arg6,
michael@0:                         double arg7,
michael@0:                         double arg8);
michael@0: 
michael@0:   // Interface types
michael@0:   already_AddRefed<TestInterface> ReceiveSelf();
michael@0:   already_AddRefed<TestInterface> ReceiveNullableSelf();
michael@0:   TestInterface* ReceiveWeakSelf();
michael@0:   TestInterface* ReceiveWeakNullableSelf();
michael@0:   void PassSelf(TestInterface&);
michael@0:   void PassNullableSelf(TestInterface*);
michael@0:   already_AddRefed<TestInterface> NonNullSelf();
michael@0:   void SetNonNullSelf(TestInterface&);
michael@0:   already_AddRefed<TestInterface> GetNullableSelf();
michael@0:   already_AddRefed<TestInterface> CachedSelf();
michael@0:   void SetNullableSelf(TestInterface*);
michael@0:   void PassOptionalSelf(const Optional<TestInterface*> &);
michael@0:   void PassOptionalNonNullSelf(const Optional<NonNull<TestInterface> >&);
michael@0:   void PassOptionalSelfWithDefault(TestInterface*);
michael@0: 
michael@0:   already_AddRefed<TestNonWrapperCacheInterface> ReceiveNonWrapperCacheInterface();
michael@0:   already_AddRefed<TestNonWrapperCacheInterface> ReceiveNullableNonWrapperCacheInterface();
michael@0:   void ReceiveNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);
michael@0:   void ReceiveNullableNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);
michael@0:   void ReceiveNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);
michael@0:   void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);
michael@0: 
michael@0:   already_AddRefed<IndirectlyImplementedInterface> ReceiveOther();
michael@0:   already_AddRefed<IndirectlyImplementedInterface> ReceiveNullableOther();
michael@0:   IndirectlyImplementedInterface* ReceiveWeakOther();
michael@0:   IndirectlyImplementedInterface* ReceiveWeakNullableOther();
michael@0:   void PassOther(IndirectlyImplementedInterface&);
michael@0:   void PassNullableOther(IndirectlyImplementedInterface*);
michael@0:   already_AddRefed<IndirectlyImplementedInterface> NonNullOther();
michael@0:   void SetNonNullOther(IndirectlyImplementedInterface&);
michael@0:   already_AddRefed<IndirectlyImplementedInterface> GetNullableOther();
michael@0:   void SetNullableOther(IndirectlyImplementedInterface*);
michael@0:   void PassOptionalOther(const Optional<IndirectlyImplementedInterface*>&);
michael@0:   void PassOptionalNonNullOther(const Optional<NonNull<IndirectlyImplementedInterface> >&);
michael@0:   void PassOptionalOtherWithDefault(IndirectlyImplementedInterface*);
michael@0: 
michael@0:   already_AddRefed<TestExternalInterface> ReceiveExternal();
michael@0:   already_AddRefed<TestExternalInterface> ReceiveNullableExternal();
michael@0:   TestExternalInterface* ReceiveWeakExternal();
michael@0:   TestExternalInterface* ReceiveWeakNullableExternal();
michael@0:   void PassExternal(TestExternalInterface*);
michael@0:   void PassNullableExternal(TestExternalInterface*);
michael@0:   already_AddRefed<TestExternalInterface> NonNullExternal();
michael@0:   void SetNonNullExternal(TestExternalInterface*);
michael@0:   already_AddRefed<TestExternalInterface> GetNullableExternal();
michael@0:   void SetNullableExternal(TestExternalInterface*);
michael@0:   void PassOptionalExternal(const Optional<TestExternalInterface*>&);
michael@0:   void PassOptionalNonNullExternal(const Optional<TestExternalInterface*>&);
michael@0:   void PassOptionalExternalWithDefault(TestExternalInterface*);
michael@0: 
michael@0:   already_AddRefed<TestCallbackInterface> ReceiveCallbackInterface();
michael@0:   already_AddRefed<TestCallbackInterface> ReceiveNullableCallbackInterface();
michael@0:   TestCallbackInterface* ReceiveWeakCallbackInterface();
michael@0:   TestCallbackInterface* ReceiveWeakNullableCallbackInterface();
michael@0:   void PassCallbackInterface(TestCallbackInterface&);
michael@0:   void PassNullableCallbackInterface(TestCallbackInterface*);
michael@0:   already_AddRefed<TestCallbackInterface> NonNullCallbackInterface();
michael@0:   void SetNonNullCallbackInterface(TestCallbackInterface&);
michael@0:   already_AddRefed<TestCallbackInterface> GetNullableCallbackInterface();
michael@0:   void SetNullableCallbackInterface(TestCallbackInterface*);
michael@0:   void PassOptionalCallbackInterface(const Optional<nsRefPtr<TestCallbackInterface> >&);
michael@0:   void PassOptionalNonNullCallbackInterface(const Optional<OwningNonNull<TestCallbackInterface> >&);
michael@0:   void PassOptionalCallbackInterfaceWithDefault(TestCallbackInterface*);
michael@0: 
michael@0:   already_AddRefed<IndirectlyImplementedInterface> ReceiveConsequentialInterface();
michael@0:   void PassConsequentialInterface(IndirectlyImplementedInterface&);
michael@0: 
michael@0:   // Sequence types
michael@0:   void GetReadonlySequence(nsTArray<int32_t>&);
michael@0:   void GetReadonlySequenceOfDictionaries(JSContext*, nsTArray<Dict>&);
michael@0:   void GetReadonlyNullableSequenceOfDictionaries(JSContext*, Nullable<nsTArray<Dict> >&);
michael@0:   void GetReadonlyFrozenSequence(JSContext*, nsTArray<Dict>&);
michael@0:   void GetReadonlyFrozenNullableSequence(JSContext*, Nullable<nsTArray<Dict>>&);
michael@0:   void ReceiveSequence(nsTArray<int32_t>&);
michael@0:   void ReceiveNullableSequence(Nullable< nsTArray<int32_t> >&);
michael@0:   void ReceiveSequenceOfNullableInts(nsTArray< Nullable<int32_t> >&);
michael@0:   void ReceiveNullableSequenceOfNullableInts(Nullable< nsTArray< Nullable<int32_t> > >&);
michael@0:   void PassSequence(const Sequence<int32_t> &);
michael@0:   void PassNullableSequence(const Nullable< Sequence<int32_t> >&);
michael@0:   void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t> >&);
michael@0:   void PassOptionalSequenceOfNullableInts(const Optional<Sequence<Nullable<int32_t> > > &);
michael@0:   void PassOptionalNullableSequenceOfNullableInts(const Optional<Nullable<Sequence<Nullable<int32_t> > > > &);
michael@0:   void ReceiveCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);
michael@0:   void ReceiveCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);
michael@0:   void ReceiveNullableCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);
michael@0:   void ReceiveNullableCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);
michael@0:   void ReceiveCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);
michael@0:   void ReceiveNullableCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);
michael@0:   void ReceiveWeakCastableObjectSequence(nsTArray<TestInterface*> &);
michael@0:   void ReceiveWeakNullableCastableObjectSequence(nsTArray<TestInterface*> &);
michael@0:   void ReceiveWeakCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);
michael@0:   void ReceiveWeakNullableCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);
michael@0:   void PassCastableObjectSequence(const Sequence< OwningNonNull<TestInterface> >&);
michael@0:   void PassNullableCastableObjectSequence(const Sequence< nsRefPtr<TestInterface> > &);
michael@0:   void PassCastableObjectNullableSequence(const Nullable< Sequence< OwningNonNull<TestInterface> > >&);
michael@0:   void PassNullableCastableObjectNullableSequence(const Nullable< Sequence< nsRefPtr<TestInterface> > >&);
michael@0:   void PassOptionalSequence(const Optional<Sequence<int32_t> >&);
michael@0:   void PassOptionalNullableSequence(const Optional<Nullable<Sequence<int32_t> > >&);
michael@0:   void PassOptionalNullableSequenceWithDefaultValue(const Nullable< Sequence<int32_t> >&);
michael@0:   void PassOptionalObjectSequence(const Optional<Sequence<OwningNonNull<TestInterface> > >&);
michael@0:   void PassExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);
michael@0:   void PassNullableExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);
michael@0: 
michael@0:   void ReceiveStringSequence(nsTArray<nsString>&);
michael@0:   void PassStringSequence(const Sequence<nsString>&);
michael@0: 
michael@0:   void ReceiveByteStringSequence(nsTArray<nsCString>&);
michael@0:   void PassByteStringSequence(const Sequence<nsCString>&);
michael@0: 
michael@0:   void ReceiveAnySequence(JSContext*, nsTArray<JS::Value>&);
michael@0:   void ReceiveNullableAnySequence(JSContext*, Nullable<nsTArray<JS::Value> >&);
michael@0:   void ReceiveAnySequenceSequence(JSContext*, nsTArray<nsTArray<JS::Value> >&);
michael@0: 
michael@0:   void ReceiveObjectSequence(JSContext*, nsTArray<JSObject*>&);
michael@0:   void ReceiveNullableObjectSequence(JSContext*, nsTArray<JSObject*>&);
michael@0: 
michael@0:   void PassSequenceOfSequences(const Sequence< Sequence<int32_t> >&);
michael@0:   void ReceiveSequenceOfSequences(nsTArray< nsTArray<int32_t> >&);
michael@0: 
michael@0:   // MozMap types
michael@0:   void PassMozMap(const MozMap<int32_t> &);
michael@0:   void PassNullableMozMap(const Nullable< MozMap<int32_t> >&);
michael@0:   void PassMozMapOfNullableInts(const MozMap<Nullable<int32_t> >&);
michael@0:   void PassOptionalMozMapOfNullableInts(const Optional<MozMap<Nullable<int32_t> > > &);
michael@0:   void PassOptionalNullableMozMapOfNullableInts(const Optional<Nullable<MozMap<Nullable<int32_t> > > > &);
michael@0:   void PassCastableObjectMozMap(const MozMap< OwningNonNull<TestInterface> >&);
michael@0:   void PassNullableCastableObjectMozMap(const MozMap< nsRefPtr<TestInterface> > &);
michael@0:   void PassCastableObjectNullableMozMap(const Nullable< MozMap< OwningNonNull<TestInterface> > >&);
michael@0:   void PassNullableCastableObjectNullableMozMap(const Nullable< MozMap< nsRefPtr<TestInterface> > >&);
michael@0:   void PassOptionalMozMap(const Optional<MozMap<int32_t> >&);
michael@0:   void PassOptionalNullableMozMap(const Optional<Nullable<MozMap<int32_t> > >&);
michael@0:   void PassOptionalNullableMozMapWithDefaultValue(const Nullable< MozMap<int32_t> >&);
michael@0:   void PassOptionalObjectMozMap(const Optional<MozMap<OwningNonNull<TestInterface> > >&);
michael@0:   void PassExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);
michael@0:   void PassNullableExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);
michael@0:   void PassStringMozMap(const MozMap<nsString>&);
michael@0:   void PassByteStringMozMap(const MozMap<nsCString>&);
michael@0:   void PassMozMapOfMozMaps(const MozMap< MozMap<int32_t> >&);
michael@0:   void ReceiveMozMap(MozMap<int32_t>&);
michael@0:   void ReceiveNullableMozMap(Nullable<MozMap<int32_t>>&);
michael@0:   void ReceiveMozMapOfNullableInts(MozMap<Nullable<int32_t>>&);
michael@0:   void ReceiveNullableMozMapOfNullableInts(Nullable<MozMap<Nullable<int32_t>>>&);
michael@0:   void ReceiveMozMapOfMozMaps(MozMap<MozMap<int32_t>>&);
michael@0:   void ReceiveAnyMozMap(JSContext*, MozMap<JS::Value>&);
michael@0: 
michael@0:   // Typed array types
michael@0:   void PassArrayBuffer(const ArrayBuffer&);
michael@0:   void PassNullableArrayBuffer(const Nullable<ArrayBuffer>&);
michael@0:   void PassOptionalArrayBuffer(const Optional<ArrayBuffer>&);
michael@0:   void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer> >&);
michael@0:   void PassOptionalNullableArrayBufferWithDefaultValue(const Nullable<ArrayBuffer>&);
michael@0:   void PassArrayBufferView(const ArrayBufferView&);
michael@0:   void PassInt8Array(const Int8Array&);
michael@0:   void PassInt16Array(const Int16Array&);
michael@0:   void PassInt32Array(const Int32Array&);
michael@0:   void PassUint8Array(const Uint8Array&);
michael@0:   void PassUint16Array(const Uint16Array&);
michael@0:   void PassUint32Array(const Uint32Array&);
michael@0:   void PassUint8ClampedArray(const Uint8ClampedArray&);
michael@0:   void PassFloat32Array(const Float32Array&);
michael@0:   void PassFloat64Array(const Float64Array&);
michael@0:   void PassSequenceOfArrayBuffers(const Sequence<ArrayBuffer>&);
michael@0:   void PassSequenceOfNullableArrayBuffers(const Sequence<Nullable<ArrayBuffer> >&);
michael@0:   void PassMozMapOfArrayBuffers(const MozMap<ArrayBuffer>&);
michael@0:   void PassMozMapOfNullableArrayBuffers(const MozMap<Nullable<ArrayBuffer> >&);
michael@0:   void PassVariadicTypedArray(const Sequence<Float32Array>&);
michael@0:   void PassVariadicNullableTypedArray(const Sequence<Nullable<Float32Array> >&);
michael@0:   void ReceiveUint8Array(JSContext*, JS::MutableHandle<JSObject*>);
michael@0: 
michael@0:   // DOMString types
michael@0:   void PassString(const nsAString&);
michael@0:   void PassNullableString(const nsAString&);
michael@0:   void PassOptionalString(const Optional<nsAString>&);
michael@0:   void PassOptionalStringWithDefaultValue(const nsAString&);
michael@0:   void PassOptionalNullableString(const Optional<nsAString>&);
michael@0:   void PassOptionalNullableStringWithDefaultValue(const nsAString&);
michael@0:   void PassVariadicString(const Sequence<nsString>&);
michael@0: 
michael@0:   // ByteString types
michael@0:   void PassByteString(const nsCString&);
michael@0:   void PassNullableByteString(const nsCString&);
michael@0:   void PassOptionalByteString(const Optional<nsCString>&);
michael@0:   void PassOptionalNullableByteString(const Optional<nsCString>&);
michael@0:   void PassVariadicByteString(const Sequence<nsCString>&);
michael@0: 
michael@0:   // Enumerated types
michael@0:   void PassEnum(TestEnum);
michael@0:   void PassNullableEnum(const Nullable<TestEnum>&);
michael@0:   void PassOptionalEnum(const Optional<TestEnum>&);
michael@0:   void PassEnumWithDefault(TestEnum);
michael@0:   void PassOptionalNullableEnum(const Optional<Nullable<TestEnum> >&);
michael@0:   void PassOptionalNullableEnumWithDefaultValue(const Nullable<TestEnum>&);
michael@0:   void PassOptionalNullableEnumWithDefaultValue2(const Nullable<TestEnum>&);
michael@0:   TestEnum ReceiveEnum();
michael@0:   Nullable<TestEnum> ReceiveNullableEnum();
michael@0:   TestEnum EnumAttribute();
michael@0:   TestEnum ReadonlyEnumAttribute();
michael@0:   void SetEnumAttribute(TestEnum);
michael@0: 
michael@0:   // Callback types
michael@0:   void PassCallback(TestCallback&);
michael@0:   void PassNullableCallback(TestCallback*);
michael@0:   void PassOptionalCallback(const Optional<OwningNonNull<TestCallback> >&);
michael@0:   void PassOptionalNullableCallback(const Optional<nsRefPtr<TestCallback> >&);
michael@0:   void PassOptionalNullableCallbackWithDefaultValue(TestCallback*);
michael@0:   already_AddRefed<TestCallback> ReceiveCallback();
michael@0:   already_AddRefed<TestCallback> ReceiveNullableCallback();
michael@0:   void PassNullableTreatAsNullCallback(TestTreatAsNullCallback*);
michael@0:   void PassOptionalNullableTreatAsNullCallback(const Optional<nsRefPtr<TestTreatAsNullCallback> >&);
michael@0:   void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(TestTreatAsNullCallback*);
michael@0:   void SetTreatAsNullCallback(TestTreatAsNullCallback&);
michael@0:   already_AddRefed<TestTreatAsNullCallback> TreatAsNullCallback();
michael@0:   void SetNullableTreatAsNullCallback(TestTreatAsNullCallback*);
michael@0:   already_AddRefed<TestTreatAsNullCallback> GetNullableTreatAsNullCallback();
michael@0: 
michael@0:   // Any types
michael@0:   void PassAny(JSContext*, JS::Handle<JS::Value>);
michael@0:   void PassVariadicAny(JSContext*, const Sequence<JS::Value>&);
michael@0:   void PassOptionalAny(JSContext*, JS::Handle<JS::Value>);
michael@0:   void PassAnyDefaultNull(JSContext*, JS::Handle<JS::Value>);
michael@0:   void PassSequenceOfAny(JSContext*, const Sequence<JS::Value>&);
michael@0:   void PassNullableSequenceOfAny(JSContext*, const Nullable<Sequence<JS::Value> >&);
michael@0:   void PassOptionalSequenceOfAny(JSContext*, const Optional<Sequence<JS::Value> >&);
michael@0:   void PassOptionalNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<JS::Value> > >&);
michael@0:   void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, const Nullable<Sequence<JS::Value> >&);
michael@0:   void PassSequenceOfSequenceOfAny(JSContext*, const Sequence<Sequence<JS::Value> >&);
michael@0:   void PassSequenceOfNullableSequenceOfAny(JSContext*, const Sequence<Nullable<Sequence<JS::Value> > >&);
michael@0:   void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, const Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&);
michael@0:   void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&);
michael@0:   void PassMozMapOfAny(JSContext*, const MozMap<JS::Value>&);
michael@0:   void PassNullableMozMapOfAny(JSContext*, const Nullable<MozMap<JS::Value> >&);
michael@0:   void PassOptionalMozMapOfAny(JSContext*, const Optional<MozMap<JS::Value> >&);
michael@0:   void PassOptionalNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<JS::Value> > >&);
michael@0:   void PassOptionalMozMapOfAnyWithDefaultValue(JSContext*, const Nullable<MozMap<JS::Value> >&);
michael@0:   void PassMozMapOfMozMapOfAny(JSContext*, const MozMap<MozMap<JS::Value> >&);
michael@0:   void PassMozMapOfNullableMozMapOfAny(JSContext*, const MozMap<Nullable<MozMap<JS::Value> > >&);
michael@0:   void PassNullableMozMapOfNullableMozMapOfAny(JSContext*, const Nullable<MozMap<Nullable<MozMap<JS::Value> > > >&);
michael@0:   void PassOptionalNullableMozMapOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<MozMap<JS::Value>>>>>&);
michael@0:   void PassOptionalNullableMozMapOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<Sequence<JS::Value>>>>>&);
michael@0:   void PassOptionalNullableSequenceOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<MozMap<JS::Value>>>>>&);
michael@0:   void ReceiveAny(JSContext*, JS::MutableHandle<JS::Value>);
michael@0: 
michael@0:   // object types
michael@0:   void PassObject(JSContext*, JS::Handle<JSObject*>);
michael@0:   void PassVariadicObject(JSContext*, const Sequence<JSObject*>&);
michael@0:   void PassNullableObject(JSContext*, JS::Handle<JSObject*>);
michael@0:   void PassVariadicNullableObject(JSContext*, const Sequence<JSObject*>&);
michael@0:   void PassOptionalObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
michael@0:   void PassOptionalNullableObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
michael@0:   void PassOptionalNullableObjectWithDefaultValue(JSContext*, JS::Handle<JSObject*>);
michael@0:   void PassSequenceOfObject(JSContext*, const Sequence<JSObject*>&);
michael@0:   void PassSequenceOfNullableObject(JSContext*, const Sequence<JSObject*>&);
michael@0:   void PassNullableSequenceOfObject(JSContext*, const Nullable<Sequence<JSObject*> >&);
michael@0:   void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
michael@0:   void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
michael@0:   void PassMozMapOfObject(JSContext*, const MozMap<JSObject*>&);
michael@0:   void ReceiveObject(JSContext*, JS::MutableHandle<JSObject*>);
michael@0:   void ReceiveNullableObject(JSContext*, JS::MutableHandle<JSObject*>);
michael@0: 
michael@0:   // Union types
michael@0:   void PassUnion(JSContext*, const ObjectOrLong& arg);
michael@0:   void PassUnionWithNullable(JSContext* cx, const ObjectOrNullOrLong& arg)
michael@0:   {
michael@0:     OwningObjectOrLong returnValue;
michael@0:     if (arg.IsNull()) {
michael@0:     } else if (arg.IsObject()) {
michael@0:       JS::Rooted<JSObject*> obj(cx, arg.GetAsObject());
michael@0:       JS_GetClass(obj);
michael@0:       returnValue.SetAsObject() = obj;
michael@0:     } else {
michael@0:       int32_t i = arg.GetAsLong();
michael@0:       i += 1;
michael@0:       returnValue.SetAsLong() = i;
michael@0:     }
michael@0:   }
michael@0: #ifdef DEBUG
michael@0:   void PassUnion2(const LongOrBoolean& arg);
michael@0:   void PassUnion3(JSContext*, const ObjectOrLongOrBoolean& arg);
michael@0:   void PassUnion4(const NodeOrLongOrBoolean& arg);
michael@0:   void PassUnion5(JSContext*, const ObjectOrBoolean& arg);
michael@0:   void PassUnion6(JSContext*, const ObjectOrString& arg);
michael@0:   void PassUnion7(JSContext*, const ObjectOrStringOrLong& arg);
michael@0:   void PassUnion8(JSContext*, const ObjectOrStringOrBoolean& arg);
michael@0:   void PassUnion9(JSContext*, const ObjectOrStringOrLongOrBoolean& arg);
michael@0:   void PassUnion10(const EventInitOrLong& arg);
michael@0:   void PassUnion11(JSContext*, const CustomEventInitOrLong& arg);
michael@0:   void PassUnion12(const EventInitOrLong& arg);
michael@0:   void PassUnion13(JSContext*, const ObjectOrLongOrNull& arg);
michael@0:   void PassUnion14(JSContext*, const ObjectOrLongOrNull& arg);
michael@0:   void PassUnionWithCallback(const EventHandlerNonNullOrNullOrLong& arg);
michael@0: #endif
michael@0:   void PassNullableUnion(JSContext*, const Nullable<ObjectOrLong>&);
michael@0:   void PassOptionalUnion(JSContext*, const Optional<ObjectOrLong>&);
michael@0:   void PassOptionalNullableUnion(JSContext*, const Optional<Nullable<ObjectOrLong> >&);
michael@0:   void PassOptionalNullableUnionWithDefaultValue(JSContext*, const Nullable<ObjectOrLong>&);
michael@0:   //void PassUnionWithInterfaces(const TestInterfaceOrTestExternalInterface& arg);
michael@0:   //void PassUnionWithInterfacesAndNullable(const TestInterfaceOrNullOrTestExternalInterface& arg);
michael@0:   void PassUnionWithArrayBuffer(const ArrayBufferOrLong&);
michael@0:   void PassUnionWithString(JSContext*, const StringOrObject&);
michael@0:   //void PassUnionWithEnum(JSContext*, const TestEnumOrObject&);
michael@0:   //void PassUnionWithCallback(JSContext*, const TestCallbackOrLong&);
michael@0:   void PassUnionWithObject(JSContext*, const ObjectOrLong&);
michael@0: 
michael@0:   void PassUnionWithDefaultValue1(const DoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue2(const DoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue3(const DoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue4(const FloatOrString& arg);
michael@0:   void PassUnionWithDefaultValue5(const FloatOrString& arg);
michael@0:   void PassUnionWithDefaultValue6(const FloatOrString& arg);
michael@0:   void PassUnionWithDefaultValue7(const UnrestrictedDoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue8(const UnrestrictedDoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue9(const UnrestrictedDoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue10(const UnrestrictedDoubleOrString& arg);
michael@0:   void PassUnionWithDefaultValue11(const UnrestrictedFloatOrString& arg);
michael@0:   void PassUnionWithDefaultValue12(const UnrestrictedFloatOrString& arg);
michael@0:   void PassUnionWithDefaultValue13(const UnrestrictedFloatOrString& arg);
michael@0:   void PassUnionWithDefaultValue14(const UnrestrictedFloatOrString& arg);
michael@0: 
michael@0:   void PassNullableUnionWithDefaultValue1(const Nullable<DoubleOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue2(const Nullable<DoubleOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue3(const Nullable<DoubleOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue4(const Nullable<FloatOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue5(const Nullable<FloatOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue6(const Nullable<FloatOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue7(const Nullable<UnrestrictedDoubleOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue8(const Nullable<UnrestrictedDoubleOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue9(const Nullable<UnrestrictedDoubleOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue10(const Nullable<UnrestrictedFloatOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue11(const Nullable<UnrestrictedFloatOrString>& arg);
michael@0:   void PassNullableUnionWithDefaultValue12(const Nullable<UnrestrictedFloatOrString>& arg);
michael@0: 
michael@0:   void PassSequenceOfUnions(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
michael@0:   void PassSequenceOfUnions2(JSContext*, const Sequence<OwningObjectOrLong>&);
michael@0:   void PassVariadicUnion(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
michael@0: 
michael@0:   void PassSequenceOfNullableUnions(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
michael@0:   void PassVariadicNullableUnion(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
michael@0:   void PassMozMapOfUnions(const MozMap<OwningCanvasPatternOrCanvasGradient>&);
michael@0:   void PassMozMapOfUnions2(JSContext*, const MozMap<OwningObjectOrLong>&);
michael@0: 
michael@0:   void ReceiveUnion(OwningCanvasPatternOrCanvasGradient&);
michael@0:   void ReceiveUnion2(JSContext*, OwningObjectOrLong&);
michael@0:   void ReceiveUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
michael@0:   void ReceiveNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
michael@0:   void ReceiveNullableUnion2(JSContext*, Nullable<OwningObjectOrLong>&);
michael@0:   void GetWritableUnion(OwningCanvasPatternOrCanvasGradient&);
michael@0:   void SetWritableUnion(const CanvasPatternOrCanvasGradient&);
michael@0:   void GetWritableUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
michael@0:   void SetWritableUnionContainingNull(const CanvasPatternOrNullOrCanvasGradient&);
michael@0:   void GetWritableNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
michael@0:   void SetWritableNullableUnion(const Nullable<CanvasPatternOrCanvasGradient>&);
michael@0: 
michael@0:   // Date types
michael@0:   void PassDate(Date);
michael@0:   void PassNullableDate(const Nullable<Date>&);
michael@0:   void PassOptionalDate(const Optional<Date>&);
michael@0:   void PassOptionalNullableDate(const Optional<Nullable<Date> >&);
michael@0:   void PassOptionalNullableDateWithDefaultValue(const Nullable<Date>&);
michael@0:   void PassDateSequence(const Sequence<Date>&);
michael@0:   void PassDateMozMap(const MozMap<Date>&);
michael@0:   void PassNullableDateSequence(const Sequence<Nullable<Date> >&);
michael@0:   Date ReceiveDate();
michael@0:   Nullable<Date> ReceiveNullableDate();
michael@0: 
michael@0:   // binaryNames tests
michael@0:   void MethodRenamedTo();
michael@0:   void MethodRenamedTo(int8_t);
michael@0:   int8_t AttributeGetterRenamedTo();
michael@0:   int8_t AttributeRenamedTo();
michael@0:   void SetAttributeRenamedTo(int8_t);
michael@0: 
michael@0:   // Dictionary tests
michael@0:   void PassDictionary(JSContext*, const Dict&);
michael@0:   void GetReadonlyDictionary(JSContext*, Dict&);
michael@0:   void GetReadonlyNullableDictionary(JSContext*, Nullable<Dict>&);
michael@0:   void GetWritableDictionary(JSContext*, Dict&);
michael@0:   void SetWritableDictionary(JSContext*, const Dict&);
michael@0:   void GetReadonlyFrozenDictionary(JSContext*, Dict&);
michael@0:   void GetReadonlyFrozenNullableDictionary(JSContext*, Nullable<Dict>&);
michael@0:   void GetWritableFrozenDictionary(JSContext*, Dict&);
michael@0:   void SetWritableFrozenDictionary(JSContext*, const Dict&);
michael@0:   void ReceiveDictionary(JSContext*, Dict&);
michael@0:   void ReceiveNullableDictionary(JSContext*, Nullable<Dict>&);
michael@0:   void PassOtherDictionary(const GrandparentDict&);
michael@0:   void PassSequenceOfDictionaries(JSContext*, const Sequence<Dict>&);
michael@0:   void PassMozMapOfDictionaries(const MozMap<GrandparentDict>&);
michael@0:   void PassDictionaryOrLong(JSContext*, const Dict&);
michael@0:   void PassDictionaryOrLong(int32_t);
michael@0:   void PassDictContainingDict(JSContext*, const DictContainingDict&);
michael@0:   void PassDictContainingSequence(JSContext*, const DictContainingSequence&);
michael@0:   void ReceiveDictContainingSequence(JSContext*, DictContainingSequence&);
michael@0: 
michael@0:   // Typedefs
michael@0:   void ExerciseTypedefInterfaces1(TestInterface&);
michael@0:   already_AddRefed<TestInterface> ExerciseTypedefInterfaces2(TestInterface*);
michael@0:   void ExerciseTypedefInterfaces3(TestInterface&);
michael@0: 
michael@0:   // Static methods and attributes
michael@0:   static void StaticMethod(const GlobalObject&, bool);
michael@0:   static void StaticMethodWithContext(const GlobalObject&, JSContext*,
michael@0:                                       JS::Value);
michael@0:   static bool StaticAttribute(const GlobalObject&);
michael@0:   static void SetStaticAttribute(const GlobalObject&, bool);
michael@0: 
michael@0:   // Overload resolution tests
michael@0:   bool Overload1(TestInterface&);
michael@0:   TestInterface* Overload1(const nsAString&, TestInterface&);
michael@0:   void Overload2(TestInterface&);
michael@0:   void Overload2(JSContext*, const Dict&);
michael@0:   void Overload2(bool);
michael@0:   void Overload2(const nsAString&);
michael@0:   void Overload2(Date);
michael@0:   void Overload3(TestInterface&);
michael@0:   void Overload3(const TestCallback&);
michael@0:   void Overload3(bool);
michael@0:   void Overload4(TestInterface&);
michael@0:   void Overload4(TestCallbackInterface&);
michael@0:   void Overload4(const nsAString&);
michael@0:   void Overload5(int32_t);
michael@0:   void Overload5(TestEnum);
michael@0:   void Overload6(int32_t);
michael@0:   void Overload6(bool);
michael@0:   void Overload7(int32_t);
michael@0:   void Overload7(bool);
michael@0:   void Overload7(const nsCString&);
michael@0:   void Overload8(int32_t);
michael@0:   void Overload8(TestInterface&);
michael@0:   void Overload9(const Nullable<int32_t>&);
michael@0:   void Overload9(const nsAString&);
michael@0:   void Overload10(const Nullable<int32_t>&);
michael@0:   void Overload10(JSContext*, JS::Handle<JSObject*>);
michael@0:   void Overload11(int32_t);
michael@0:   void Overload11(const nsAString&);
michael@0:   void Overload12(int32_t);
michael@0:   void Overload12(const Nullable<bool>&);
michael@0:   void Overload13(const Nullable<int32_t>&);
michael@0:   void Overload13(bool);
michael@0:   void Overload14(const Optional<int32_t>&);
michael@0:   void Overload14(TestInterface&);
michael@0:   void Overload15(int32_t);
michael@0:   void Overload15(const Optional<NonNull<TestInterface> >&);
michael@0:   void Overload16(int32_t);
michael@0:   void Overload16(const Optional<TestInterface*>&);
michael@0: 
michael@0:   // Variadic handling
michael@0:   void PassVariadicThirdArg(const nsAString&, int32_t,
michael@0:                             const Sequence<OwningNonNull<TestInterface> >&);
michael@0: 
michael@0:   // Conditionally exposed methods/attributes
michael@0:   bool Prefable1();
michael@0:   bool Prefable2();
michael@0:   bool Prefable3();
michael@0:   bool Prefable4();
michael@0:   bool Prefable5();
michael@0:   bool Prefable6();
michael@0:   bool Prefable7();
michael@0:   bool Prefable8();
michael@0:   bool Prefable9();
michael@0:   void Prefable10();
michael@0:   void Prefable11();
michael@0:   bool Prefable12();
michael@0:   void Prefable13();
michael@0:   bool Prefable14();
michael@0:   bool Prefable15();
michael@0:   bool Prefable16();
michael@0:   void Prefable17();
michael@0:   void Prefable18();
michael@0:   void Prefable19();
michael@0:   void Prefable20();
michael@0:   void Prefable21();
michael@0:   void Prefable22();
michael@0:   void Prefable23();
michael@0:   void Prefable24();
michael@0: 
michael@0:   // Miscellania
michael@0:   int32_t AttrWithLenientThis();
michael@0:   void SetAttrWithLenientThis(int32_t);
michael@0:   uint32_t UnforgeableAttr();
michael@0:   uint32_t UnforgeableAttr2();
michael@0:   void Stringify(nsString&);
michael@0:   void PassRenamedInterface(nsRenamedInterface&);
michael@0:   TestInterface* PutForwardsAttr();
michael@0:   TestInterface* PutForwardsAttr2();
michael@0:   TestInterface* PutForwardsAttr3();
michael@0:   void GetJsonifierShouldSkipThis(JSContext*, JS::MutableHandle<JS::Value>);
michael@0:   void SetJsonifierShouldSkipThis(JSContext*, JS::Rooted<JS::Value>&);
michael@0:   TestParentInterface* JsonifierShouldSkipThis2();
michael@0:   void SetJsonifierShouldSkipThis2(TestParentInterface&);
michael@0:   TestCallbackInterface* JsonifierShouldSkipThis3();
michael@0:   void SetJsonifierShouldSkipThis3(TestCallbackInterface&);
michael@0:   void ThrowingMethod(ErrorResult& aRv);
michael@0:   bool GetThrowingAttr(ErrorResult& aRv) const;
michael@0:   void SetThrowingAttr(bool arg, ErrorResult& aRv);
michael@0:   bool GetThrowingGetterAttr(ErrorResult& aRv) const;
michael@0:   void SetThrowingGetterAttr(bool arg);
michael@0:   bool ThrowingSetterAttr() const;
michael@0:   void SetThrowingSetterAttr(bool arg, ErrorResult& aRv);
michael@0:   int16_t LegacyCall(JS::Value, uint32_t, TestInterface&);
michael@0:   void PassArgsWithDefaults(JSContext*, const Optional<int32_t>&,
michael@0:                             TestInterface*, const Dict&, double,
michael@0:                             const Optional<float>&);
michael@0: 
michael@0:   // Methods and properties imported via "implements"
michael@0:   bool ImplementedProperty();
michael@0:   void SetImplementedProperty(bool);
michael@0:   void ImplementedMethod();
michael@0:   bool ImplementedParentProperty();
michael@0:   void SetImplementedParentProperty(bool);
michael@0:   void ImplementedParentMethod();
michael@0:   bool IndirectlyImplementedProperty();
michael@0:   void SetIndirectlyImplementedProperty(bool);
michael@0:   void IndirectlyImplementedMethod();
michael@0:   uint32_t DiamondImplementedProperty();
michael@0: 
michael@0:   // Test EnforceRange/Clamp
michael@0:   void DontEnforceRangeOrClamp(int8_t);
michael@0:   void DoEnforceRange(int8_t);
michael@0:   void DoClamp(int8_t);
michael@0:   void SetEnforcedByte(int8_t);
michael@0:   int8_t EnforcedByte();
michael@0:   void SetClampedByte(int8_t);
michael@0:   int8_t ClampedByte();
michael@0: 
michael@0: private:
michael@0:   // We add signatures here that _could_ start matching if the codegen
michael@0:   // got data types wrong.  That way if it ever does we'll have a call
michael@0:   // to these private deleted methods and compilation will fail.
michael@0:   void SetReadonlyByte(int8_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableByte(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassByte(T) MOZ_DELETE;
michael@0:   void PassNullableByte(Nullable<int8_t>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalByte(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalByteWithDefault(T) MOZ_DELETE;
michael@0:   void PassVariadicByte(Sequence<int8_t>&) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyShort(int16_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableShort(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassShort(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalShort(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalShortWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyLong(int32_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalLong(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalLongWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyLongLong(int64_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableLongLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassLongLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalLongLong(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalLongLongWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyOctet(uint8_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableOctet(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOctet(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalOctet(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalOctetWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyUnsignedShort(uint16_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableUnsignedShort(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassUnsignedShort(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalUnsignedShort(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalUnsignedShortWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyUnsignedLong(uint32_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableUnsignedLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassUnsignedLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalUnsignedLong(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalUnsignedLongWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   void SetReadonlyUnsignedLongLong(uint64_t) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void SetWritableUnsignedLongLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassUnsignedLongLong(T) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalUnsignedLongLong(const Optional<T>&) MOZ_DELETE;
michael@0:   template<typename T>
michael@0:   void PassOptionalUnsignedLongLongWithDefault(T) MOZ_DELETE;
michael@0: 
michael@0:   // Enforce that only const things are passed for sequences
michael@0:   void PassSequence(Sequence<int32_t> &) MOZ_DELETE;
michael@0:   void PassNullableSequence(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
michael@0:   void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
michael@0:   void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0:   void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
michael@0:   void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0:   void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0:   void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
michael@0:   void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) MOZ_DELETE;
michael@0:   void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0:   void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
michael@0: 
michael@0:   // Enforce that only const things are passed for optional
michael@0:   void PassOptionalByte(Optional<int8_t>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) MOZ_DELETE;
michael@0:   void PassOptionalShort(Optional<int16_t>&) MOZ_DELETE;
michael@0:   void PassOptionalLong(Optional<int32_t>&) MOZ_DELETE;
michael@0:   void PassOptionalLongLong(Optional<int64_t>&) MOZ_DELETE;
michael@0:   void PassOptionalOctet(Optional<uint8_t>&) MOZ_DELETE;
michael@0:   void PassOptionalUnsignedShort(Optional<uint16_t>&) MOZ_DELETE;
michael@0:   void PassOptionalUnsignedLong(Optional<uint32_t>&) MOZ_DELETE;
michael@0:   void PassOptionalUnsignedLongLong(Optional<uint64_t>&) MOZ_DELETE;
michael@0:   void PassOptionalSelf(Optional<TestInterface*> &) MOZ_DELETE;
michael@0:   void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) MOZ_DELETE;
michael@0:   void PassOptionalOther(Optional<IndirectlyImplementedInterface*>&);
michael@0:   void PassOptionalNonNullOther(Optional<NonNull<IndirectlyImplementedInterface> >&);
michael@0:   void PassOptionalExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
michael@0:   void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
michael@0:   void PassOptionalSequence(Optional<Sequence<int32_t> >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) MOZ_DELETE;
michael@0:   void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) MOZ_DELETE;
michael@0:   void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) MOZ_DELETE;
michael@0:   void PassOptionalEnum(Optional<TestEnum>&) MOZ_DELETE;
michael@0:   void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableCallback(JSContext*, Optional<nsRefPtr<TestCallback> >&) MOZ_DELETE;
michael@0:   void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) MOZ_DELETE;
michael@0: 
michael@0:   // And test that string stuff is always const
michael@0:   void PassString(nsAString&) MOZ_DELETE;
michael@0:   void PassNullableString(nsAString&) MOZ_DELETE;
michael@0:   void PassOptionalString(Optional<nsAString>&) MOZ_DELETE;
michael@0:   void PassOptionalStringWithDefaultValue(nsAString&) MOZ_DELETE;
michael@0:   void PassOptionalNullableString(Optional<nsAString>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableStringWithDefaultValue(nsAString&) MOZ_DELETE;
michael@0:   void PassVariadicString(Sequence<nsString>&) MOZ_DELETE;
michael@0: 
michael@0:   // cstrings should be const as well
michael@0:   void PassByteString(nsCString&) MOZ_DELETE;
michael@0:   void PassNullableByteString(nsCString&) MOZ_DELETE;
michael@0:   void PassOptionalByteString(Optional<nsCString>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableByteString(Optional<nsCString>&) MOZ_DELETE;
michael@0:   void PassVariadicByteString(Sequence<nsCString>&) MOZ_DELETE;
michael@0: 
michael@0:   // Make sure dictionary arguments are always const
michael@0:   void PassDictionary(JSContext*, Dict&) MOZ_DELETE;
michael@0:   void PassOtherDictionary(GrandparentDict&) MOZ_DELETE;
michael@0:   void PassSequenceOfDictionaries(JSContext*, Sequence<Dict>&) MOZ_DELETE;
michael@0:   void PassDictionaryOrLong(JSContext*, Dict&) MOZ_DELETE;
michael@0:   void PassDictContainingDict(JSContext*, DictContainingDict&) MOZ_DELETE;
michael@0:   void PassDictContainingSequence(DictContainingSequence&) MOZ_DELETE;
michael@0: 
michael@0:   // Make sure various nullable things are always const
michael@0:   void PassNullableEnum(Nullable<TestEnum>&) MOZ_DELETE;
michael@0: 
michael@0:   // Make sure unions are always const
michael@0:   void PassUnion(JSContext*, ObjectOrLong& arg) MOZ_DELETE;
michael@0:   void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) MOZ_DELETE;
michael@0:   void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
michael@0:   void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
michael@0: 
michael@0:   // Make sure various date stuff is const as needed
michael@0:   void PassNullableDate(Nullable<Date>&) MOZ_DELETE;
michael@0:   void PassOptionalDate(Optional<Date>&) MOZ_DELETE;
michael@0:   void PassOptionalNullableDate(Optional<Nullable<Date> >&) MOZ_DELETE;
michael@0:   void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) MOZ_DELETE;
michael@0:   void PassDateSequence(Sequence<Date>&) MOZ_DELETE;
michael@0:   void PassNullableDateSequence(Sequence<Nullable<Date> >&) MOZ_DELETE;
michael@0: 
michael@0:   // Make sure variadics are const as needed
michael@0:   void PassVariadicAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
michael@0:   void PassVariadicObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0:   void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0: 
michael@0:   // Ensure NonNull does not leak in
michael@0:   void PassSelf(NonNull<TestInterface>&) MOZ_DELETE;
michael@0:   void PassSelf(OwningNonNull<TestInterface>&) MOZ_DELETE;
michael@0:   void PassSelf(const NonNull<TestInterface>&) MOZ_DELETE;
michael@0:   void PassSelf(const OwningNonNull<TestInterface>&) MOZ_DELETE;
michael@0:   void PassOther(NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0:   void PassOther(const NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0:   void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0:   void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0:   void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0:   void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0:   void PassCallbackInterface(NonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0:   void PassCallbackInterface(const NonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0:   void PassCallback(OwningNonNull<TestCallback>&) MOZ_DELETE;
michael@0:   void PassCallback(const OwningNonNull<TestCallback>&) MOZ_DELETE;
michael@0:   void PassCallback(NonNull<TestCallback>&) MOZ_DELETE;
michael@0:   void PassCallback(const NonNull<TestCallback>&) MOZ_DELETE;
michael@0:   void PassString(const NonNull<nsAString>&) MOZ_DELETE;
michael@0:   void PassString(NonNull<nsAString>&) MOZ_DELETE;
michael@0:   void PassString(const OwningNonNull<nsAString>&) MOZ_DELETE;
michael@0:   void PassString(OwningNonNull<nsAString>&) MOZ_DELETE;
michael@0: };
michael@0: 
michael@0: class TestIndexedGetterInterface : public nsISupports,
michael@0:                                    public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   uint32_t IndexedGetter(uint32_t, bool&);
michael@0:   uint32_t IndexedGetter(uint32_t&) MOZ_DELETE;
michael@0:   uint32_t Item(uint32_t&);
michael@0:   uint32_t Item(uint32_t, bool&) MOZ_DELETE;
michael@0:   uint32_t Length();
michael@0:   void LegacyCall(JS::Handle<JS::Value>);
michael@0: };
michael@0: 
michael@0: class TestNamedGetterInterface : public nsISupports,
michael@0:                                  public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestIndexedGetterAndSetterAndNamedGetterInterface : public nsISupports,
michael@0:                                                           public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0:   int32_t IndexedGetter(uint32_t, bool&);
michael@0:   void IndexedSetter(uint32_t, int32_t);
michael@0:   uint32_t Length();
michael@0: };
michael@0: 
michael@0: class TestIndexedAndNamedGetterInterface : public nsISupports,
michael@0:                                            public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   uint32_t IndexedGetter(uint32_t, bool&);
michael@0:   void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void NamedItem(const nsAString&, nsAString&);
michael@0:   uint32_t Length();
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestIndexedSetterInterface : public nsISupports,
michael@0:                                    public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void IndexedSetter(uint32_t, const nsAString&);
michael@0:   void IndexedGetter(uint32_t, bool&, nsString&);
michael@0:   uint32_t Length();
michael@0:   void SetItem(uint32_t, const nsAString&);
michael@0: };
michael@0: 
michael@0: class TestNamedSetterInterface : public nsISupports,
michael@0:                                  public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
michael@0:   TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestIndexedAndNamedSetterInterface : public nsISupports,
michael@0:                                            public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void IndexedSetter(uint32_t, TestIndexedSetterInterface&);
michael@0:   TestIndexedSetterInterface* IndexedGetter(uint32_t, bool&);
michael@0:   uint32_t Length();
michael@0:   void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
michael@0:   TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void SetNamedItem(const nsAString&, TestIndexedSetterInterface&);
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestIndexedAndNamedGetterAndSetterInterface : public TestIndexedSetterInterface
michael@0: {
michael@0: public:
michael@0:   uint32_t IndexedGetter(uint32_t, bool&);
michael@0:   uint32_t Item(uint32_t);
michael@0:   void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void NamedItem(const nsAString&, nsAString&);
michael@0:   void IndexedSetter(uint32_t, int32_t&);
michael@0:   void IndexedSetter(uint32_t, const nsAString&) MOZ_DELETE;
michael@0:   void NamedSetter(const nsAString&, const nsAString&);
michael@0:   void Stringify(nsAString&);
michael@0:   uint32_t Length();
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestCppKeywordNamedMethodsInterface : public nsISupports,
michael@0:                                             public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   bool Continue();
michael@0:   bool Delete();
michael@0:   int32_t Volatile();
michael@0: };
michael@0: 
michael@0: class TestIndexedDeleterInterface : public nsISupports,
michael@0:                                     public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void IndexedDeleter(uint32_t, bool&);
michael@0:   void IndexedDeleter(uint32_t) MOZ_DELETE;
michael@0:   long IndexedGetter(uint32_t, bool&);
michael@0:   uint32_t Length();
michael@0:   void DelItem(uint32_t);
michael@0:   void DelItem(uint32_t, bool&) MOZ_DELETE;
michael@0: };
michael@0: 
michael@0: class TestIndexedDeleterWithRetvalInterface : public nsISupports,
michael@0:                                               public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   bool IndexedDeleter(uint32_t, bool&);
michael@0:   bool IndexedDeleter(uint32_t) MOZ_DELETE;
michael@0:   long IndexedGetter(uint32_t, bool&);
michael@0:   uint32_t Length();
michael@0:   bool DelItem(uint32_t);
michael@0:   bool DelItem(uint32_t, bool&) MOZ_DELETE;
michael@0: };
michael@0: 
michael@0: class TestNamedDeleterInterface : public nsISupports,
michael@0:                                   public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void NamedDeleter(const nsAString&, bool&);
michael@0:   long NamedGetter(const nsAString&, bool&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestNamedDeleterWithRetvalInterface : public nsISupports,
michael@0:                                             public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   bool NamedDeleter(const nsAString&, bool&);
michael@0:   bool NamedDeleter(const nsAString&) MOZ_DELETE;
michael@0:   long NamedGetter(const nsAString&, bool&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   bool DelNamedItem(const nsAString&);
michael@0:   bool DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestIndexedAndNamedDeleterInterface : public nsISupports,
michael@0:                                             public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: 
michael@0:   void IndexedDeleter(uint32_t, bool&);
michael@0:   long IndexedGetter(uint32_t, bool&);
michael@0:   uint32_t Length();
michael@0: 
michael@0:   void NamedDeleter(const nsAString&, bool&);
michael@0:   void NamedDeleter(const nsAString&) MOZ_DELETE;
michael@0:   long NamedGetter(const nsAString&, bool&);
michael@0:   bool NameIsEnumerable(const nsAString&);
michael@0:   void DelNamedItem(const nsAString&);
michael@0:   void DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
michael@0:   void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0: };
michael@0: 
michael@0: class TestParentInterface : public nsISupports,
michael@0:                             public nsWrapperCache
michael@0: {
michael@0: public:
michael@0:   NS_DECL_ISUPPORTS
michael@0: 
michael@0:   // We need a GetParentObject to make binding codegen happy
michael@0:   virtual nsISupports* GetParentObject();
michael@0: };
michael@0: 
michael@0: class TestChildInterface : public TestParentInterface
michael@0: {
michael@0: };
michael@0: 
michael@0: } // namespace dom
michael@0: } // namespace mozilla
michael@0: 
michael@0: #endif /* TestBindingHeader_h */