Attachment 9272951 Details for Bug 1577383

TestInterfaceJSMaplikeSetlikeIterableBinding.h

TestInterfaceJSMaplikeSetlikeIterableBinding.h (text/plain), 41.63 KB, created by Shelly Lin [:shelly]

(hide)

Description:

Filename:

MIME Type:

Creator: Shelly Lin [:shelly]

Size: 41.63 KB

patch

obsolete

>/* THIS FILE IS AUTOGENERATED FROM TestInterfaceJSMaplikeSetlikeIterable.webidl BY Codegen.py - DO NOT EDIT */
>
>#ifndef mozilla_dom_TestInterfaceJSMaplikeSetlikeIterableBinding_h
>#define mozilla_dom_TestInterfaceJSMaplikeSetlikeIterableBinding_h
>
>#include "js/CallAndConstruct.h"
>#include "js/RootingAPI.h"
>#include "js/TypeDecls.h"
>#include "mozilla/dom/BindingDeclarations.h"
>#include "mozilla/dom/FakeString.h"
>#include "mozilla/dom/IterableIterator.h"
>#include "mozilla/dom/Nullable.h"
>#include "mozilla/dom/PrototypeList.h"
>#include "mozilla/dom/UnionMember.h"
>
>class nsINode;
>
>namespace mozilla {
>namespace dom {
>
>struct NativePropertyHooks;
>class OwningStringOrLong;
>class ProtoAndIfaceCache;
>class StringOrLong;
>class TestInterfaceAsyncIterableDouble;
>struct TestInterfaceAsyncIterableDoubleAtoms;
>class TestInterfaceAsyncIterableDoubleUnion;
>struct TestInterfaceAsyncIterableDoubleUnionAtoms;
>class TestInterfaceAsyncIterableSingle;
>struct TestInterfaceAsyncIterableSingleAtoms;
>class TestInterfaceIterableDouble;
>struct TestInterfaceIterableDoubleAtoms;
>class TestInterfaceIterableDoubleUnion;
>struct TestInterfaceIterableDoubleUnionAtoms;
>class TestInterfaceIterableSingle;
>struct TestInterfaceIterableSingleAtoms;
>class TestInterfaceMaplike;
>struct TestInterfaceMaplikeAtoms;
>class TestInterfaceMaplikeJSObject;
>struct TestInterfaceMaplikeJSObjectAtoms;
>class TestInterfaceMaplikeObject;
>struct TestInterfaceMaplikeObjectAtoms;
>class TestInterfaceSetlike;
>struct TestInterfaceSetlikeAtoms;
>class TestInterfaceSetlikeNode;
>struct TestInterfaceSetlikeNodeAtoms;
>
>} // namespace dom
>} // namespace mozilla
>
>namespace mozilla::dom {
>
>class StringOrLong
>{
>  friend class StringOrLongArgument;
>  enum Type
>  {
>    eUninitialized,
>    eString,
>    eLong
>  };
>
>  union Value
>  {
>    UnionMember<binding_detail::FakeString<char16_t> > mString;
>    UnionMember<int32_t > mLong;
>
>  };
>
>  Type mType;
>  Value mValue;
>
>  StringOrLong(const StringOrLong&) = delete;
>  StringOrLong& operator=(const StringOrLong&) = delete;
>public:
>  explicit inline StringOrLong()
>    : mType(eUninitialized)
>  {
>  }
>
>  inline ~StringOrLong()
>  {
>    Uninit();
>  }
>
>  inline binding_detail::FakeString<char16_t>&
>  RawSetAsString()
>  {
>    if (mType == eString) {
>      return mValue.mString.Value();
>    }
>    MOZ_ASSERT(mType == eUninitialized);
>    mType = eString;
>    return mValue.mString.SetValue();
>  }
>
>  inline binding_detail::FakeString<char16_t>&
>  SetAsString()
>  {
>    if (mType == eString) {
>      return mValue.mString.Value();
>    }
>    Uninit();
>    mType = eString;
>    return mValue.mString.SetValue();
>  }
>
>  inline bool
>  IsString() const
>  {
>    return mType == eString;
>  }
>
>  inline binding_detail::FakeString<char16_t>&
>  GetAsString()
>  {
>    MOZ_RELEASE_ASSERT(IsString(), "Wrong type!");
>    return mValue.mString.Value();
>  }
>
>  inline const nsAString&
>  GetAsString() const
>  {
>    MOZ_RELEASE_ASSERT(IsString(), "Wrong type!");
>    return mValue.mString.Value();
>  }
>
>  inline int32_t&
>  RawSetAsLong()
>  {
>    if (mType == eLong) {
>      return mValue.mLong.Value();
>    }
>    MOZ_ASSERT(mType == eUninitialized);
>    mType = eLong;
>    return mValue.mLong.SetValue();
>  }
>
>  inline int32_t&
>  SetAsLong()
>  {
>    if (mType == eLong) {
>      return mValue.mLong.Value();
>    }
>    Uninit();
>    mType = eLong;
>    return mValue.mLong.SetValue();
>  }
>
>  inline bool
>  IsLong() const
>  {
>    return mType == eLong;
>  }
>
>  inline int32_t&
>  GetAsLong()
>  {
>    MOZ_RELEASE_ASSERT(IsLong(), "Wrong type!");
>    return mValue.mLong.Value();
>  }
>
>  inline int32_t
>  GetAsLong() const
>  {
>    MOZ_RELEASE_ASSERT(IsLong(), "Wrong type!");
>    return mValue.mLong.Value();
>  }
>
>  inline void
>  Uninit()
>  {
>    switch (mType) {
>      case eUninitialized: {
>        break;
>      }
>      case eString: {
>        DestroyString();
>        break;
>      }
>      case eLong: {
>        DestroyLong();
>        break;
>      }
>    }
>  }
>
>  bool
>  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
>
>private:
>  inline void
>  DestroyString()
>  {
>    MOZ_RELEASE_ASSERT(IsString(), "Wrong type!");
>    mValue.mString.Destroy();
>    mType = eUninitialized;
>  }
>
>  inline void
>  DestroyLong()
>  {
>    MOZ_RELEASE_ASSERT(IsLong(), "Wrong type!");
>    mValue.mLong.Destroy();
>    mType = eUninitialized;
>  }
>};
>
>
>class OwningStringOrLong : public AllOwningUnionBase
>{
>  friend void ImplCycleCollectionUnlink(OwningStringOrLong& aUnion);
>  enum Type
>  {
>    eUninitialized,
>    eString,
>    eLong
>  };
>
>  union Value
>  {
>    UnionMember<nsString > mString;
>    UnionMember<int32_t > mLong;
>
>  };
>
>  Type mType;
>  Value mValue;
>
>public:
>  explicit inline OwningStringOrLong()
>    : mType(eUninitialized)
>  {
>  }
>
>  explicit inline OwningStringOrLong(const OwningStringOrLong& aOther)
>    : mType(eUninitialized)
>  {
>    *this = aOther;
>  }
>
>  inline ~OwningStringOrLong()
>  {
>    Uninit();
>  }
>
>  nsString&
>  RawSetAsString();
>
>  nsString&
>  SetAsString();
>
>  bool
>  TrySetToString(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
>
>  template <int N>
>  inline void
>  SetStringLiteral(const nsString::char_type (&aData)[N])
>  {
>    RawSetAsString().AssignLiteral(aData);
>  }
>
>  inline bool
>  IsString() const
>  {
>    return mType == eString;
>  }
>
>  inline nsString&
>  GetAsString()
>  {
>    MOZ_RELEASE_ASSERT(IsString(), "Wrong type!");
>    return mValue.mString.Value();
>  }
>
>  inline nsString const &
>  GetAsString() const
>  {
>    MOZ_RELEASE_ASSERT(IsString(), "Wrong type!");
>    return mValue.mString.Value();
>  }
>
>  int32_t&
>  RawSetAsLong();
>
>  int32_t&
>  SetAsLong();
>
>  bool
>  TrySetToLong(JSContext* cx, JS::Handle<JS::Value> value, bool& tryNext, bool passedToJSImpl = false);
>
>  inline bool
>  IsLong() const
>  {
>    return mType == eLong;
>  }
>
>  inline int32_t&
>  GetAsLong()
>  {
>    MOZ_RELEASE_ASSERT(IsLong(), "Wrong type!");
>    return mValue.mLong.Value();
>  }
>
>  inline int32_t const &
>  GetAsLong() const
>  {
>    MOZ_RELEASE_ASSERT(IsLong(), "Wrong type!");
>    return mValue.mLong.Value();
>  }
>
>  void
>  Uninit();
>
>  bool
>  ToJSVal(JSContext* cx, JS::Handle<JSObject*> scopeObj, JS::MutableHandle<JS::Value> rval) const;
>
>  void
>  TraceUnion(JSTracer* trc);
>
>  OwningStringOrLong&
>  operator=(const OwningStringOrLong& aOther);
>
>private:
>  void
>  DestroyString();
>
>  void
>  DestroyLong();
>};
>
>
>namespace TestInterfaceAsyncIterableDouble_Binding {
>
>  typedef mozilla::dom::TestInterfaceAsyncIterableDouble NativeType;
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceAsyncIterableDouble* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceAsyncIterableDouble,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceAsyncIterableDouble,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceAsyncIterableDouble_Binding
>
>
>
>namespace TestInterfaceAsyncIterableDoubleAsyncIterator_Binding {
>
>  typedef mozilla::dom::AsyncIterableIterator<mozilla::dom::TestInterfaceAsyncIterableDouble> NativeType;
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::AsyncIterableIterator<mozilla::dom::TestInterfaceAsyncIterableDouble>* aObject, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceAsyncIterableDoubleAsyncIterator,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>} // namespace TestInterfaceAsyncIterableDoubleAsyncIterator_Binding
>
>
>
>namespace TestInterfaceAsyncIterableDoubleUnion_Binding {
>
>  typedef mozilla::dom::TestInterfaceAsyncIterableDoubleUnion NativeType;
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceAsyncIterableDoubleUnion* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceAsyncIterableDoubleUnion,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceAsyncIterableDoubleUnion,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceAsyncIterableDoubleUnion_Binding
>
>
>
>namespace TestInterfaceAsyncIterableDoubleUnionAsyncIterator_Binding {
>
>  typedef mozilla::dom::AsyncIterableIterator<mozilla::dom::TestInterfaceAsyncIterableDoubleUnion> NativeType;
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::AsyncIterableIterator<mozilla::dom::TestInterfaceAsyncIterableDoubleUnion>* aObject, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceAsyncIterableDoubleUnionAsyncIterator,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>} // namespace TestInterfaceAsyncIterableDoubleUnionAsyncIterator_Binding
>
>
>
>namespace TestInterfaceAsyncIterableSingle_Binding {
>
>  typedef mozilla::dom::TestInterfaceAsyncIterableSingle NativeType;
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceAsyncIterableSingle* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceAsyncIterableSingle,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceAsyncIterableSingle,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceAsyncIterableSingle_Binding
>
>
>
>namespace TestInterfaceAsyncIterableSingleAsyncIterator_Binding {
>
>  typedef mozilla::dom::AsyncIterableIterator<mozilla::dom::TestInterfaceAsyncIterableSingle> NativeType;
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::AsyncIterableIterator<mozilla::dom::TestInterfaceAsyncIterableSingle>* aObject, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceAsyncIterableSingleAsyncIterator,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>} // namespace TestInterfaceAsyncIterableSingleAsyncIterator_Binding
>
>
>
>namespace TestInterfaceIterableDouble_Binding {
>
>  typedef mozilla::dom::TestInterfaceIterableDouble NativeType;
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceIterableDouble* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceIterableDouble,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceIterableDouble,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceIterableDouble_Binding
>
>
>
>namespace TestInterfaceIterableDoubleIterator_Binding {
>
>  typedef mozilla::dom::IterableIterator<mozilla::dom::TestInterfaceIterableDouble> NativeType;
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::IterableIterator<mozilla::dom::TestInterfaceIterableDouble>* aObject, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceIterableDoubleIterator,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>} // namespace TestInterfaceIterableDoubleIterator_Binding
>
>
>
>namespace TestInterfaceIterableDoubleUnion_Binding {
>
>  typedef mozilla::dom::TestInterfaceIterableDoubleUnion NativeType;
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceIterableDoubleUnion* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceIterableDoubleUnion,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceIterableDoubleUnion,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceIterableDoubleUnion_Binding
>
>
>
>namespace TestInterfaceIterableDoubleUnionIterator_Binding {
>
>  typedef mozilla::dom::IterableIterator<mozilla::dom::TestInterfaceIterableDoubleUnion> NativeType;
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::IterableIterator<mozilla::dom::TestInterfaceIterableDoubleUnion>* aObject, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceIterableDoubleUnionIterator,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>} // namespace TestInterfaceIterableDoubleUnionIterator_Binding
>
>
>
>namespace TestInterfaceIterableSingle_Binding {
>
>  typedef mozilla::dom::TestInterfaceIterableSingle NativeType;
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceIterableSingle* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceIterableSingle,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceIterableSingle,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceIterableSingle_Binding
>
>
>
>namespace TestInterfaceMaplike_Binding {
>
>  typedef mozilla::dom::TestInterfaceMaplike NativeType;
>
>  namespace MaplikeHelpers {
>  void
>  Clear(mozilla::dom::TestInterfaceMaplike* self, ErrorResult& aRv);
>  bool
>  Delete(mozilla::dom::TestInterfaceMaplike* self, const nsAString& aKey, ErrorResult& aRv);
>  bool
>  Has(mozilla::dom::TestInterfaceMaplike* self, const nsAString& aKey, ErrorResult& aRv);
>  void
>  Set(mozilla::dom::TestInterfaceMaplike* self, const nsAString& aKey, int32_t aValue, ErrorResult& aRv);
>  int32_t
>  Get(mozilla::dom::TestInterfaceMaplike* self, const nsAString& aKey, ErrorResult& aRv);
>  } // namespace MaplikeHelpers
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceMaplike* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceMaplike,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceMaplike,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceMaplike_Binding
>
>
>
>namespace TestInterfaceMaplikeJSObject_Binding {
>
>  typedef mozilla::dom::TestInterfaceMaplikeJSObject NativeType;
>
>  namespace MaplikeHelpers {
>  void
>  Clear(mozilla::dom::TestInterfaceMaplikeJSObject* self, ErrorResult& aRv);
>  bool
>  Delete(mozilla::dom::TestInterfaceMaplikeJSObject* self, const nsAString& aKey, ErrorResult& aRv);
>  bool
>  Has(mozilla::dom::TestInterfaceMaplikeJSObject* self, const nsAString& aKey, ErrorResult& aRv);
>  void
>  Set(mozilla::dom::TestInterfaceMaplikeJSObject* self, const nsAString& aKey, JS::Handle<JSObject*> aValue, ErrorResult& aRv);
>  void
>  Get(mozilla::dom::TestInterfaceMaplikeJSObject* self, JSContext* cx, const nsAString& aKey, JS::MutableHandle<JSObject*> aRetVal, ErrorResult& aRv);
>  } // namespace MaplikeHelpers
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceMaplikeJSObject* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceMaplikeJSObject,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceMaplikeJSObject,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceMaplikeJSObject_Binding
>
>
>
>namespace TestInterfaceMaplikeObject_Binding {
>
>  typedef mozilla::dom::TestInterfaceMaplikeObject NativeType;
>
>  namespace MaplikeHelpers {
>  void
>  Clear(mozilla::dom::TestInterfaceMaplikeObject* self, ErrorResult& aRv);
>  bool
>  Delete(mozilla::dom::TestInterfaceMaplikeObject* self, const nsAString& aKey, ErrorResult& aRv);
>  bool
>  Has(mozilla::dom::TestInterfaceMaplikeObject* self, const nsAString& aKey, ErrorResult& aRv);
>  void
>  Set(mozilla::dom::TestInterfaceMaplikeObject* self, const nsAString& aKey, TestInterfaceMaplike& aValue, ErrorResult& aRv);
>  already_AddRefed<TestInterfaceMaplike>
>  Get(mozilla::dom::TestInterfaceMaplikeObject* self, const nsAString& aKey, ErrorResult& aRv);
>  } // namespace MaplikeHelpers
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceMaplikeObject* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceMaplikeObject,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceMaplikeObject,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceMaplikeObject_Binding
>
>
>
>namespace TestInterfaceSetlike_Binding {
>
>  typedef mozilla::dom::TestInterfaceSetlike NativeType;
>
>  namespace SetlikeHelpers {
>  void
>  Clear(mozilla::dom::TestInterfaceSetlike* self, ErrorResult& aRv);
>  bool
>  Delete(mozilla::dom::TestInterfaceSetlike* self, const nsAString& aKey, ErrorResult& aRv);
>  bool
>  Has(mozilla::dom::TestInterfaceSetlike* self, const nsAString& aKey, ErrorResult& aRv);
>  void
>  Add(mozilla::dom::TestInterfaceSetlike* self, const nsAString& aKey, ErrorResult& aRv);
>  } // namespace SetlikeHelpers
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceSetlike* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceSetlike,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceSetlike,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceSetlike_Binding
>
>
>
>namespace TestInterfaceSetlikeNode_Binding {
>
>  typedef mozilla::dom::TestInterfaceSetlikeNode NativeType;
>
>  namespace SetlikeHelpers {
>  void
>  Clear(mozilla::dom::TestInterfaceSetlikeNode* self, ErrorResult& aRv);
>  bool
>  Delete(mozilla::dom::TestInterfaceSetlikeNode* self, nsINode& aKey, ErrorResult& aRv);
>  bool
>  Has(mozilla::dom::TestInterfaceSetlikeNode* self, nsINode& aKey, ErrorResult& aRv);
>  void
>  Add(mozilla::dom::TestInterfaceSetlikeNode* self, nsINode& aKey, ErrorResult& aRv);
>  } // namespace SetlikeHelpers
>
>  bool
>  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);
>
>  const JSClass*
>  GetJSClass();
>
>  bool
>  Wrap(JSContext* aCx, mozilla::dom::TestInterfaceSetlikeNode* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);
>
>  template <class T>
>  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)
>  {
>    JS::Rooted<JSObject*> reflector(aCx);
>    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;
>  }
>
>  // We declare this as an array so that retrieving a pointer to this
>  // binding's property hooks only requires compile/link-time resolvable
>  // address arithmetic.  Declaring it as a pointer instead would require
>  // doing a run-time load to fetch a pointer to this binding's property
>  // hooks.  And then structures which embedded a pointer to this structure
>  // would require a run-time load for proper initialization, which would
>  // then induce static constructors.  Lots of static constructors.
>  extern const NativePropertyHooks sNativePropertyHooks[];
>
>  void
>  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);
>
>  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)
>  {
>    /* Get the interface prototype object for this class.  This will create the
>       object as needed. */
>    return GetPerInterfaceObjectHandle(aCx, prototypes::id::TestInterfaceSetlikeNode,
>                                       &CreateInterfaceObjects,
>                                       /* aDefineOnGlobal = */ true);
>
>  }
>
>  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)
>  {
>    /* Get the interface object for this class.  This will create the object as
>       needed. */
>
>    return GetPerInterfaceObjectHandle(aCx, constructors::id::TestInterfaceSetlikeNode,
>                                       &CreateInterfaceObjects,
>                                       aDefineOnGlobal);
>  }
>
>  JSObject*
>  GetConstructorObject(JSContext* aCx);
>
>} // namespace TestInterfaceSetlikeNode_Binding
>
>
>
>} // namespace mozilla::dom
>
>#endif // mozilla_dom_TestInterfaceJSMaplikeSetlikeIterableBinding_h

Actions: View

Attachments on bug 1577383: 9191830 | 9270183 | 9272951 | 9272952 | 9278910