1465 lines
64 KiB
C++
1465 lines
64 KiB
C++
/* -*- 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 DocGroup;
|
|
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 and GetDocGroup to make binding codegen happy
|
|
virtual nsISupports* GetParentObject();
|
|
DocGroup* GetDocGroup() const;
|
|
};
|
|
|
|
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 and GetDocGroup to make binding codegen happy
|
|
virtual nsISupports* GetParentObject();
|
|
DocGroup* GetDocGroup() const;
|
|
|
|
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);
|
|
void CeReactionsMethod();
|
|
void CeReactionsMethodOverload();
|
|
void CeReactionsMethodOverload(const nsAString&);
|
|
bool CeReactionsAttr() const;
|
|
void SetCeReactionsAttr(bool);
|
|
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);
|
|
};
|
|
|
|
class TestHTMLConstructorInterface : public nsGenericHTMLElement
|
|
{
|
|
public:
|
|
virtual nsISupports* GetParentObject();
|
|
};
|
|
|
|
class TestCEReactionsInterface : public nsISupports,
|
|
public nsWrapperCache
|
|
{
|
|
public:
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// We need a GetParentObject to make binding codegen happy
|
|
virtual nsISupports* GetParentObject();
|
|
|
|
int32_t Item(uint32_t);
|
|
uint32_t Length() const;
|
|
int32_t IndexedGetter(uint32_t, bool &);
|
|
void IndexedSetter(uint32_t, int32_t);
|
|
void NamedDeleter(const nsAString&, bool &);
|
|
void NamedGetter(const nsAString&, bool &, nsString&);
|
|
void NamedSetter(const nsAString&, const nsAString&);
|
|
void GetSupportedNames(nsTArray<nsString>&);
|
|
};
|
|
|
|
} // namespace dom
|
|
} // namespace mozilla
|
|
|
|
#endif /* TestBindingHeader_h */
|