Master merge

This merges master into release to replace Redwood.

# Conflicts:
#	CLOBBER
#	build/moz.configure/old.configure
#	config/milestone.txt
#	config/moz.build
#	config/system-headers
#	dom/abort/AbortController.cpp
#	dom/abort/AbortController.h
#	dom/abort/AbortSignal.cpp
#	dom/abort/AbortSignal.h
#	dom/abort/moz.build
#	dom/abort/tests/moz.build
#	dom/animation/KeyframeEffect.cpp
#	dom/base/CustomElementRegistry.cpp
#	dom/base/DocGroup.cpp
#	dom/base/ResizeObserverController.cpp
#	dom/base/ResizeObserverController.h
#	dom/base/nsContentUtils.cpp
#	dom/base/nsContentUtils.h
#	dom/base/nsDocument.cpp
#	dom/base/nsIDocument.h
#	dom/fetch/FetchObserver.cpp
#	dom/fetch/FetchObserver.h
#	dom/heapsnapshot/AutoMemMap.cpp
#	dom/heapsnapshot/AutoMemMap.h
#	dom/heapsnapshot/CoreDump.proto
#	dom/heapsnapshot/HeapSnapshot.cpp
#	dom/heapsnapshot/HeapSnapshotTempFileHelperChild.h
#	dom/heapsnapshot/HeapSnapshotTempFileHelperParent.cpp
#	dom/heapsnapshot/HeapSnapshotTempFileHelperParent.h
#	dom/heapsnapshot/PHeapSnapshotTempFileHelper.ipdl
#	dom/heapsnapshot/moz.build
#	dom/heapsnapshot/tests/gtest/moz.build
#	dom/html/nsGenericHTMLElement.h
#	dom/media/platforms/PlatformDecoderModule.h
#	dom/media/platforms/moz.build
#	dom/script/ModuleLoadRequest.cpp
#	dom/script/ModuleLoadRequest.h
#	dom/script/ModuleScript.cpp
#	dom/script/ModuleScript.h
#	dom/script/ScriptElement.cpp
#	dom/script/ScriptElement.h
#	dom/script/ScriptLoadHandler.cpp
#	dom/script/ScriptLoadHandler.h
#	dom/script/ScriptLoader.cpp
#	dom/script/ScriptLoader.h
#	dom/script/ScriptSettings.cpp
#	dom/script/ScriptSettings.h
#	dom/script/nsIScriptElement.h
#	dom/script/nsIScriptLoaderObserver.idl
#	dom/webidl/HTMLLinkElement.webidl
#	gfx/gl/moz.build
#	gfx/graphite2/src/moz.build
#	gfx/layers/moz.build
#	js/ductwork/inspector/moz.build
#	js/ductwork/moz.build
#	js/src/gc/Heap.h
#	js/src/moz.build
#	js/src/vm/UnboxedObject-inl.h
#	js/src/vm/UnboxedObject.cpp
#	js/src/vm/UnboxedObject.h
#	layout/base/crashtests/crashtests.list
#	layout/build/moz.build
#	layout/generic/AspectRatio.h
#	layout/generic/crashtests/crashtests.list
#	layout/reftests/bidi/reftest-stylo.list
#	layout/reftests/reftest-stylo.list
#	layout/reftests/table-bordercollapse/reftest.list
#	layout/reftests/writing-mode/reftest-stylo.list
#	layout/style/StyleSheet.cpp
#	layout/style/nsRuleNode.cpp
#	layout/style/nsStyleStruct.cpp
#	layout/style/nsStyleStruct.h
#	modules/libpref/init/all.js
#	nsprpub/pr/src/linking/prlink.c
#	parser/html/java/htmlparser/src/nu/validator/htmlparser/impl/AttributeName.java
#	parser/html/java/htmlparser/src/nu/validator/htmlparser/impl/ElementName.java
#	parser/html/nsHtml5AtomList.h
#	parser/html/nsHtml5AttributeName.cpp
#	parser/html/nsHtml5AttributeName.h
#	parser/html/nsHtml5ElementName.cpp
#	parser/html/nsHtml5ElementName.h
#	parser/html/nsHtml5TreeBuilderCppSupplement.h
#	parser/htmlparser/nsElementTable.cpp
#	parser/htmlparser/nsHTMLTagList.h
#	security/nss/lib/nss/nss.h
#	security/nss/lib/softoken/pkcs11.c
#	security/nss/lib/softoken/softkver.h
#	security/nss/lib/util/nssutil.h
#	testing/web-platform/tests/tools/html5lib/html5lib/html5parser.py
#	testing/web-platform/tests/tools/html5lib/html5lib/treebuilders/_base.py
#	toolkit/modules/AppConstants.jsm

1 files changed, 0 insertions, 1431 deletions

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