1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/dom/bindings/test/TestBindingHeader.h Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1260 @@
1.4 +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
1.5 +/* This Source Code Form is subject to the terms of the Mozilla Public
1.6 + * License, v. 2.0. If a copy of the MPL was not distributed with this file,
1.7 + * You can obtain one at http://mozilla.org/MPL/2.0/.
1.8 + */
1.9 +
1.10 +#ifndef TestBindingHeader_h
1.11 +#define TestBindingHeader_h
1.12 +
1.13 +#include "mozilla/dom/BindingUtils.h"
1.14 +#include "mozilla/dom/Date.h"
1.15 +#include "mozilla/dom/MozMap.h"
1.16 +#include "mozilla/dom/TypedArray.h"
1.17 +#include "mozilla/dom/UnionTypes.h"
1.18 +#include "mozilla/ErrorResult.h"
1.19 +#include "nsCOMPtr.h"
1.20 +#include "nsGenericHTMLElement.h"
1.21 +#include "nsWrapperCache.h"
1.22 +
1.23 +// Forward declare this before we include TestCodeGenBinding.h, because that header relies on including
1.24 +// this one for it, for ParentDict. Hopefully it won't begin to rely on it in more fundamental ways.
1.25 +namespace mozilla {
1.26 +namespace dom {
1.27 +class TestExternalInterface;
1.28 +} // namespace dom
1.29 +} // namespace mozilla
1.30 +
1.31 +// We don't export TestCodeGenBinding.h, but it's right in our parent dir.
1.32 +#include "../TestCodeGenBinding.h"
1.33 +
1.34 +extern bool TestFuncControlledMember(JSContext*, JSObject*);
1.35 +
1.36 +namespace mozilla {
1.37 +namespace dom {
1.38 +
1.39 +// IID for nsRenamedInterface
1.40 +#define NS_RENAMED_INTERFACE_IID \
1.41 +{ 0xd4b19ef3, 0xe68b, 0x4e3f, \
1.42 + { 0x94, 0xbc, 0xc9, 0xde, 0x3a, 0x69, 0xb0, 0xe8 } }
1.43 +
1.44 +class nsRenamedInterface : public nsISupports,
1.45 + public nsWrapperCache
1.46 +{
1.47 +public:
1.48 + NS_DECLARE_STATIC_IID_ACCESSOR(NS_RENAMED_INTERFACE_IID)
1.49 + NS_DECL_ISUPPORTS
1.50 +
1.51 + // We need a GetParentObject to make binding codegen happy
1.52 + virtual nsISupports* GetParentObject();
1.53 +};
1.54 +
1.55 +NS_DEFINE_STATIC_IID_ACCESSOR(nsRenamedInterface, NS_RENAMED_INTERFACE_IID)
1.56 +
1.57 +// IID for the IndirectlyImplementedInterface
1.58 +#define NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID \
1.59 +{ 0xfed55b69, 0x7012, 0x4849, \
1.60 + { 0xaf, 0x56, 0x4b, 0xa9, 0xee, 0x41, 0x30, 0x89 } }
1.61 +
1.62 +class IndirectlyImplementedInterface : public nsISupports,
1.63 + public nsWrapperCache
1.64 +{
1.65 +public:
1.66 + NS_DECLARE_STATIC_IID_ACCESSOR(NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
1.67 + NS_DECL_ISUPPORTS
1.68 +
1.69 + // We need a GetParentObject to make binding codegen happy
1.70 + virtual nsISupports* GetParentObject();
1.71 +
1.72 + bool IndirectlyImplementedProperty();
1.73 + void IndirectlyImplementedProperty(bool);
1.74 + void IndirectlyImplementedMethod();
1.75 +};
1.76 +
1.77 +NS_DEFINE_STATIC_IID_ACCESSOR(IndirectlyImplementedInterface, NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
1.78 +
1.79 +// IID for the TestExternalInterface
1.80 +#define NS_TEST_EXTERNAL_INTERFACE_IID \
1.81 +{ 0xd5ba0c99, 0x9b1d, 0x4e71, \
1.82 + { 0x8a, 0x94, 0x56, 0x38, 0x6c, 0xa3, 0xda, 0x3d } }
1.83 +class TestExternalInterface : public nsISupports
1.84 +{
1.85 +public:
1.86 + NS_DECLARE_STATIC_IID_ACCESSOR(NS_TEST_EXTERNAL_INTERFACE_IID)
1.87 + NS_DECL_ISUPPORTS
1.88 +};
1.89 +
1.90 +NS_DEFINE_STATIC_IID_ACCESSOR(TestExternalInterface, NS_TEST_EXTERNAL_INTERFACE_IID)
1.91 +
1.92 +class TestNonWrapperCacheInterface : public nsISupports
1.93 +{
1.94 +public:
1.95 + NS_DECL_ISUPPORTS
1.96 +
1.97 + virtual JSObject* WrapObject(JSContext* cx);
1.98 +};
1.99 +
1.100 +class OnlyForUseInConstructor : public nsISupports,
1.101 + public nsWrapperCache
1.102 +{
1.103 +public:
1.104 + NS_DECL_ISUPPORTS
1.105 + // We need a GetParentObject to make binding codegen happy
1.106 + virtual nsISupports* GetParentObject();
1.107 +};
1.108 +
1.109 +class TestInterface : public nsISupports,
1.110 + public nsWrapperCache
1.111 +{
1.112 +public:
1.113 + NS_DECL_ISUPPORTS
1.114 +
1.115 + // We need a GetParentObject to make binding codegen happy
1.116 + virtual nsISupports* GetParentObject();
1.117 +
1.118 + // And now our actual WebIDL API
1.119 + // Constructors
1.120 + static
1.121 + already_AddRefed<TestInterface>
1.122 + Constructor(const GlobalObject&, ErrorResult&);
1.123 + static
1.124 + already_AddRefed<TestInterface>
1.125 + Constructor(const GlobalObject&, const nsAString&, ErrorResult&);
1.126 + static
1.127 + already_AddRefed<TestInterface>
1.128 + Constructor(const GlobalObject&, uint32_t, const Nullable<bool>&,
1.129 + ErrorResult&);
1.130 + static
1.131 + already_AddRefed<TestInterface>
1.132 + Constructor(const GlobalObject&, TestInterface*, ErrorResult&);
1.133 + static
1.134 + already_AddRefed<TestInterface>
1.135 + Constructor(const GlobalObject&, uint32_t, IndirectlyImplementedInterface&, ErrorResult&);
1.136 +
1.137 + static
1.138 + already_AddRefed<TestInterface>
1.139 + Constructor(const GlobalObject&, Date&, ErrorResult&);
1.140 + /* static
1.141 + already_AddRefed<TestInterface>
1.142 + Constructor(const GlobalObject&, uint32_t, uint32_t,
1.143 + const TestInterfaceOrOnlyForUseInConstructor&, ErrorResult&);
1.144 + */
1.145 +
1.146 + static
1.147 + already_AddRefed<TestInterface> Test(const GlobalObject&, ErrorResult&);
1.148 + static
1.149 + already_AddRefed<TestInterface> Test(const GlobalObject&, const nsAString&,
1.150 + ErrorResult&);
1.151 + static
1.152 + already_AddRefed<TestInterface> Test(const GlobalObject&, const nsACString&,
1.153 + ErrorResult&);
1.154 +
1.155 + static
1.156 + already_AddRefed<TestInterface> Test2(const GlobalObject&,
1.157 + JSContext*,
1.158 + const DictForConstructor&,
1.159 + JS::Handle<JS::Value>,
1.160 + JS::Handle<JSObject*>,
1.161 + JS::Handle<JSObject*>,
1.162 + const Sequence<Dict>&,
1.163 + JS::Handle<JS::Value>,
1.164 + const Optional<JS::Handle<JSObject*> >&,
1.165 + const Optional<JS::Handle<JSObject*> >&,
1.166 + ErrorResult&);
1.167 +
1.168 + // Integer types
1.169 + int8_t ReadonlyByte();
1.170 + int8_t WritableByte();
1.171 + void SetWritableByte(int8_t);
1.172 + void PassByte(int8_t);
1.173 + int8_t ReceiveByte();
1.174 + void PassOptionalByte(const Optional<int8_t>&);
1.175 + void PassOptionalByteBeforeRequired(const Optional<int8_t>&, int8_t);
1.176 + void PassOptionalByteWithDefault(int8_t);
1.177 + void PassOptionalByteWithDefaultBeforeRequired(int8_t, int8_t);
1.178 + void PassNullableByte(const Nullable<int8_t>&);
1.179 + void PassOptionalNullableByte(const Optional< Nullable<int8_t> >&);
1.180 + void PassVariadicByte(const Sequence<int8_t>&);
1.181 + int8_t CachedByte();
1.182 + int8_t CachedConstantByte();
1.183 + int8_t CachedWritableByte();
1.184 + void SetCachedWritableByte(int8_t);
1.185 +
1.186 + int16_t ReadonlyShort();
1.187 + int16_t WritableShort();
1.188 + void SetWritableShort(int16_t);
1.189 + void PassShort(int16_t);
1.190 + int16_t ReceiveShort();
1.191 + void PassOptionalShort(const Optional<int16_t>&);
1.192 + void PassOptionalShortWithDefault(int16_t);
1.193 +
1.194 + int32_t ReadonlyLong();
1.195 + int32_t WritableLong();
1.196 + void SetWritableLong(int32_t);
1.197 + void PassLong(int32_t);
1.198 + int16_t ReceiveLong();
1.199 + void PassOptionalLong(const Optional<int32_t>&);
1.200 + void PassOptionalLongWithDefault(int32_t);
1.201 +
1.202 + int64_t ReadonlyLongLong();
1.203 + int64_t WritableLongLong();
1.204 + void SetWritableLongLong(int64_t);
1.205 + void PassLongLong(int64_t);
1.206 + int64_t ReceiveLongLong();
1.207 + void PassOptionalLongLong(const Optional<int64_t>&);
1.208 + void PassOptionalLongLongWithDefault(int64_t);
1.209 +
1.210 + uint8_t ReadonlyOctet();
1.211 + uint8_t WritableOctet();
1.212 + void SetWritableOctet(uint8_t);
1.213 + void PassOctet(uint8_t);
1.214 + uint8_t ReceiveOctet();
1.215 + void PassOptionalOctet(const Optional<uint8_t>&);
1.216 + void PassOptionalOctetWithDefault(uint8_t);
1.217 +
1.218 + uint16_t ReadonlyUnsignedShort();
1.219 + uint16_t WritableUnsignedShort();
1.220 + void SetWritableUnsignedShort(uint16_t);
1.221 + void PassUnsignedShort(uint16_t);
1.222 + uint16_t ReceiveUnsignedShort();
1.223 + void PassOptionalUnsignedShort(const Optional<uint16_t>&);
1.224 + void PassOptionalUnsignedShortWithDefault(uint16_t);
1.225 +
1.226 + uint32_t ReadonlyUnsignedLong();
1.227 + uint32_t WritableUnsignedLong();
1.228 + void SetWritableUnsignedLong(uint32_t);
1.229 + void PassUnsignedLong(uint32_t);
1.230 + uint32_t ReceiveUnsignedLong();
1.231 + void PassOptionalUnsignedLong(const Optional<uint32_t>&);
1.232 + void PassOptionalUnsignedLongWithDefault(uint32_t);
1.233 +
1.234 + uint64_t ReadonlyUnsignedLongLong();
1.235 + uint64_t WritableUnsignedLongLong();
1.236 + void SetWritableUnsignedLongLong(uint64_t);
1.237 + void PassUnsignedLongLong(uint64_t);
1.238 + uint64_t ReceiveUnsignedLongLong();
1.239 + void PassOptionalUnsignedLongLong(const Optional<uint64_t>&);
1.240 + void PassOptionalUnsignedLongLongWithDefault(uint64_t);
1.241 +
1.242 + float WritableFloat() const;
1.243 + void SetWritableFloat(float);
1.244 + float WritableUnrestrictedFloat() const;
1.245 + void SetWritableUnrestrictedFloat(float);
1.246 + Nullable<float> GetWritableNullableFloat() const;
1.247 + void SetWritableNullableFloat(Nullable<float>);
1.248 + Nullable<float> GetWritableNullableUnrestrictedFloat() const;
1.249 + void SetWritableNullableUnrestrictedFloat(Nullable<float>);
1.250 + double WritableDouble() const;
1.251 + void SetWritableDouble(double);
1.252 + double WritableUnrestrictedDouble() const;
1.253 + void SetWritableUnrestrictedDouble(double);
1.254 + Nullable<double> GetWritableNullableDouble() const;
1.255 + void SetWritableNullableDouble(Nullable<double>);
1.256 + Nullable<double> GetWritableNullableUnrestrictedDouble() const;
1.257 + void SetWritableNullableUnrestrictedDouble(Nullable<double>);
1.258 + void PassFloat(float, float, Nullable<float>, Nullable<float>,
1.259 + double, double, Nullable<double>, Nullable<double>,
1.260 + const Sequence<float>&, const Sequence<float>&,
1.261 + const Sequence<Nullable<float> >&,
1.262 + const Sequence<Nullable<float> >&,
1.263 + const Sequence<double>&, const Sequence<double>&,
1.264 + const Sequence<Nullable<double> >&,
1.265 + const Sequence<Nullable<double> >&);
1.266 + void PassLenientFloat(float, float, Nullable<float>, Nullable<float>,
1.267 + double, double, Nullable<double>, Nullable<double>,
1.268 + const Sequence<float>&, const Sequence<float>&,
1.269 + const Sequence<Nullable<float> >&,
1.270 + const Sequence<Nullable<float> >&,
1.271 + const Sequence<double>&, const Sequence<double>&,
1.272 + const Sequence<Nullable<double> >&,
1.273 + const Sequence<Nullable<double> >&);
1.274 + float LenientFloatAttr() const;
1.275 + void SetLenientFloatAttr(float);
1.276 + double LenientDoubleAttr() const;
1.277 + void SetLenientDoubleAttr(double);
1.278 +
1.279 + void PassUnrestricted(float arg1,
1.280 + float arg2,
1.281 + float arg3,
1.282 + float arg4,
1.283 + double arg5,
1.284 + double arg6,
1.285 + double arg7,
1.286 + double arg8);
1.287 +
1.288 + // Interface types
1.289 + already_AddRefed<TestInterface> ReceiveSelf();
1.290 + already_AddRefed<TestInterface> ReceiveNullableSelf();
1.291 + TestInterface* ReceiveWeakSelf();
1.292 + TestInterface* ReceiveWeakNullableSelf();
1.293 + void PassSelf(TestInterface&);
1.294 + void PassNullableSelf(TestInterface*);
1.295 + already_AddRefed<TestInterface> NonNullSelf();
1.296 + void SetNonNullSelf(TestInterface&);
1.297 + already_AddRefed<TestInterface> GetNullableSelf();
1.298 + already_AddRefed<TestInterface> CachedSelf();
1.299 + void SetNullableSelf(TestInterface*);
1.300 + void PassOptionalSelf(const Optional<TestInterface*> &);
1.301 + void PassOptionalNonNullSelf(const Optional<NonNull<TestInterface> >&);
1.302 + void PassOptionalSelfWithDefault(TestInterface*);
1.303 +
1.304 + already_AddRefed<TestNonWrapperCacheInterface> ReceiveNonWrapperCacheInterface();
1.305 + already_AddRefed<TestNonWrapperCacheInterface> ReceiveNullableNonWrapperCacheInterface();
1.306 + void ReceiveNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);
1.307 + void ReceiveNullableNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);
1.308 + void ReceiveNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);
1.309 + void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);
1.310 +
1.311 + already_AddRefed<IndirectlyImplementedInterface> ReceiveOther();
1.312 + already_AddRefed<IndirectlyImplementedInterface> ReceiveNullableOther();
1.313 + IndirectlyImplementedInterface* ReceiveWeakOther();
1.314 + IndirectlyImplementedInterface* ReceiveWeakNullableOther();
1.315 + void PassOther(IndirectlyImplementedInterface&);
1.316 + void PassNullableOther(IndirectlyImplementedInterface*);
1.317 + already_AddRefed<IndirectlyImplementedInterface> NonNullOther();
1.318 + void SetNonNullOther(IndirectlyImplementedInterface&);
1.319 + already_AddRefed<IndirectlyImplementedInterface> GetNullableOther();
1.320 + void SetNullableOther(IndirectlyImplementedInterface*);
1.321 + void PassOptionalOther(const Optional<IndirectlyImplementedInterface*>&);
1.322 + void PassOptionalNonNullOther(const Optional<NonNull<IndirectlyImplementedInterface> >&);
1.323 + void PassOptionalOtherWithDefault(IndirectlyImplementedInterface*);
1.324 +
1.325 + already_AddRefed<TestExternalInterface> ReceiveExternal();
1.326 + already_AddRefed<TestExternalInterface> ReceiveNullableExternal();
1.327 + TestExternalInterface* ReceiveWeakExternal();
1.328 + TestExternalInterface* ReceiveWeakNullableExternal();
1.329 + void PassExternal(TestExternalInterface*);
1.330 + void PassNullableExternal(TestExternalInterface*);
1.331 + already_AddRefed<TestExternalInterface> NonNullExternal();
1.332 + void SetNonNullExternal(TestExternalInterface*);
1.333 + already_AddRefed<TestExternalInterface> GetNullableExternal();
1.334 + void SetNullableExternal(TestExternalInterface*);
1.335 + void PassOptionalExternal(const Optional<TestExternalInterface*>&);
1.336 + void PassOptionalNonNullExternal(const Optional<TestExternalInterface*>&);
1.337 + void PassOptionalExternalWithDefault(TestExternalInterface*);
1.338 +
1.339 + already_AddRefed<TestCallbackInterface> ReceiveCallbackInterface();
1.340 + already_AddRefed<TestCallbackInterface> ReceiveNullableCallbackInterface();
1.341 + TestCallbackInterface* ReceiveWeakCallbackInterface();
1.342 + TestCallbackInterface* ReceiveWeakNullableCallbackInterface();
1.343 + void PassCallbackInterface(TestCallbackInterface&);
1.344 + void PassNullableCallbackInterface(TestCallbackInterface*);
1.345 + already_AddRefed<TestCallbackInterface> NonNullCallbackInterface();
1.346 + void SetNonNullCallbackInterface(TestCallbackInterface&);
1.347 + already_AddRefed<TestCallbackInterface> GetNullableCallbackInterface();
1.348 + void SetNullableCallbackInterface(TestCallbackInterface*);
1.349 + void PassOptionalCallbackInterface(const Optional<nsRefPtr<TestCallbackInterface> >&);
1.350 + void PassOptionalNonNullCallbackInterface(const Optional<OwningNonNull<TestCallbackInterface> >&);
1.351 + void PassOptionalCallbackInterfaceWithDefault(TestCallbackInterface*);
1.352 +
1.353 + already_AddRefed<IndirectlyImplementedInterface> ReceiveConsequentialInterface();
1.354 + void PassConsequentialInterface(IndirectlyImplementedInterface&);
1.355 +
1.356 + // Sequence types
1.357 + void GetReadonlySequence(nsTArray<int32_t>&);
1.358 + void GetReadonlySequenceOfDictionaries(JSContext*, nsTArray<Dict>&);
1.359 + void GetReadonlyNullableSequenceOfDictionaries(JSContext*, Nullable<nsTArray<Dict> >&);
1.360 + void GetReadonlyFrozenSequence(JSContext*, nsTArray<Dict>&);
1.361 + void GetReadonlyFrozenNullableSequence(JSContext*, Nullable<nsTArray<Dict>>&);
1.362 + void ReceiveSequence(nsTArray<int32_t>&);
1.363 + void ReceiveNullableSequence(Nullable< nsTArray<int32_t> >&);
1.364 + void ReceiveSequenceOfNullableInts(nsTArray< Nullable<int32_t> >&);
1.365 + void ReceiveNullableSequenceOfNullableInts(Nullable< nsTArray< Nullable<int32_t> > >&);
1.366 + void PassSequence(const Sequence<int32_t> &);
1.367 + void PassNullableSequence(const Nullable< Sequence<int32_t> >&);
1.368 + void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t> >&);
1.369 + void PassOptionalSequenceOfNullableInts(const Optional<Sequence<Nullable<int32_t> > > &);
1.370 + void PassOptionalNullableSequenceOfNullableInts(const Optional<Nullable<Sequence<Nullable<int32_t> > > > &);
1.371 + void ReceiveCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);
1.372 + void ReceiveCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);
1.373 + void ReceiveNullableCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);
1.374 + void ReceiveNullableCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);
1.375 + void ReceiveCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);
1.376 + void ReceiveNullableCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);
1.377 + void ReceiveWeakCastableObjectSequence(nsTArray<TestInterface*> &);
1.378 + void ReceiveWeakNullableCastableObjectSequence(nsTArray<TestInterface*> &);
1.379 + void ReceiveWeakCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);
1.380 + void ReceiveWeakNullableCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);
1.381 + void PassCastableObjectSequence(const Sequence< OwningNonNull<TestInterface> >&);
1.382 + void PassNullableCastableObjectSequence(const Sequence< nsRefPtr<TestInterface> > &);
1.383 + void PassCastableObjectNullableSequence(const Nullable< Sequence< OwningNonNull<TestInterface> > >&);
1.384 + void PassNullableCastableObjectNullableSequence(const Nullable< Sequence< nsRefPtr<TestInterface> > >&);
1.385 + void PassOptionalSequence(const Optional<Sequence<int32_t> >&);
1.386 + void PassOptionalNullableSequence(const Optional<Nullable<Sequence<int32_t> > >&);
1.387 + void PassOptionalNullableSequenceWithDefaultValue(const Nullable< Sequence<int32_t> >&);
1.388 + void PassOptionalObjectSequence(const Optional<Sequence<OwningNonNull<TestInterface> > >&);
1.389 + void PassExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);
1.390 + void PassNullableExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);
1.391 +
1.392 + void ReceiveStringSequence(nsTArray<nsString>&);
1.393 + void PassStringSequence(const Sequence<nsString>&);
1.394 +
1.395 + void ReceiveByteStringSequence(nsTArray<nsCString>&);
1.396 + void PassByteStringSequence(const Sequence<nsCString>&);
1.397 +
1.398 + void ReceiveAnySequence(JSContext*, nsTArray<JS::Value>&);
1.399 + void ReceiveNullableAnySequence(JSContext*, Nullable<nsTArray<JS::Value> >&);
1.400 + void ReceiveAnySequenceSequence(JSContext*, nsTArray<nsTArray<JS::Value> >&);
1.401 +
1.402 + void ReceiveObjectSequence(JSContext*, nsTArray<JSObject*>&);
1.403 + void ReceiveNullableObjectSequence(JSContext*, nsTArray<JSObject*>&);
1.404 +
1.405 + void PassSequenceOfSequences(const Sequence< Sequence<int32_t> >&);
1.406 + void ReceiveSequenceOfSequences(nsTArray< nsTArray<int32_t> >&);
1.407 +
1.408 + // MozMap types
1.409 + void PassMozMap(const MozMap<int32_t> &);
1.410 + void PassNullableMozMap(const Nullable< MozMap<int32_t> >&);
1.411 + void PassMozMapOfNullableInts(const MozMap<Nullable<int32_t> >&);
1.412 + void PassOptionalMozMapOfNullableInts(const Optional<MozMap<Nullable<int32_t> > > &);
1.413 + void PassOptionalNullableMozMapOfNullableInts(const Optional<Nullable<MozMap<Nullable<int32_t> > > > &);
1.414 + void PassCastableObjectMozMap(const MozMap< OwningNonNull<TestInterface> >&);
1.415 + void PassNullableCastableObjectMozMap(const MozMap< nsRefPtr<TestInterface> > &);
1.416 + void PassCastableObjectNullableMozMap(const Nullable< MozMap< OwningNonNull<TestInterface> > >&);
1.417 + void PassNullableCastableObjectNullableMozMap(const Nullable< MozMap< nsRefPtr<TestInterface> > >&);
1.418 + void PassOptionalMozMap(const Optional<MozMap<int32_t> >&);
1.419 + void PassOptionalNullableMozMap(const Optional<Nullable<MozMap<int32_t> > >&);
1.420 + void PassOptionalNullableMozMapWithDefaultValue(const Nullable< MozMap<int32_t> >&);
1.421 + void PassOptionalObjectMozMap(const Optional<MozMap<OwningNonNull<TestInterface> > >&);
1.422 + void PassExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);
1.423 + void PassNullableExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);
1.424 + void PassStringMozMap(const MozMap<nsString>&);
1.425 + void PassByteStringMozMap(const MozMap<nsCString>&);
1.426 + void PassMozMapOfMozMaps(const MozMap< MozMap<int32_t> >&);
1.427 + void ReceiveMozMap(MozMap<int32_t>&);
1.428 + void ReceiveNullableMozMap(Nullable<MozMap<int32_t>>&);
1.429 + void ReceiveMozMapOfNullableInts(MozMap<Nullable<int32_t>>&);
1.430 + void ReceiveNullableMozMapOfNullableInts(Nullable<MozMap<Nullable<int32_t>>>&);
1.431 + void ReceiveMozMapOfMozMaps(MozMap<MozMap<int32_t>>&);
1.432 + void ReceiveAnyMozMap(JSContext*, MozMap<JS::Value>&);
1.433 +
1.434 + // Typed array types
1.435 + void PassArrayBuffer(const ArrayBuffer&);
1.436 + void PassNullableArrayBuffer(const Nullable<ArrayBuffer>&);
1.437 + void PassOptionalArrayBuffer(const Optional<ArrayBuffer>&);
1.438 + void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer> >&);
1.439 + void PassOptionalNullableArrayBufferWithDefaultValue(const Nullable<ArrayBuffer>&);
1.440 + void PassArrayBufferView(const ArrayBufferView&);
1.441 + void PassInt8Array(const Int8Array&);
1.442 + void PassInt16Array(const Int16Array&);
1.443 + void PassInt32Array(const Int32Array&);
1.444 + void PassUint8Array(const Uint8Array&);
1.445 + void PassUint16Array(const Uint16Array&);
1.446 + void PassUint32Array(const Uint32Array&);
1.447 + void PassUint8ClampedArray(const Uint8ClampedArray&);
1.448 + void PassFloat32Array(const Float32Array&);
1.449 + void PassFloat64Array(const Float64Array&);
1.450 + void PassSequenceOfArrayBuffers(const Sequence<ArrayBuffer>&);
1.451 + void PassSequenceOfNullableArrayBuffers(const Sequence<Nullable<ArrayBuffer> >&);
1.452 + void PassMozMapOfArrayBuffers(const MozMap<ArrayBuffer>&);
1.453 + void PassMozMapOfNullableArrayBuffers(const MozMap<Nullable<ArrayBuffer> >&);
1.454 + void PassVariadicTypedArray(const Sequence<Float32Array>&);
1.455 + void PassVariadicNullableTypedArray(const Sequence<Nullable<Float32Array> >&);
1.456 + void ReceiveUint8Array(JSContext*, JS::MutableHandle<JSObject*>);
1.457 +
1.458 + // DOMString types
1.459 + void PassString(const nsAString&);
1.460 + void PassNullableString(const nsAString&);
1.461 + void PassOptionalString(const Optional<nsAString>&);
1.462 + void PassOptionalStringWithDefaultValue(const nsAString&);
1.463 + void PassOptionalNullableString(const Optional<nsAString>&);
1.464 + void PassOptionalNullableStringWithDefaultValue(const nsAString&);
1.465 + void PassVariadicString(const Sequence<nsString>&);
1.466 +
1.467 + // ByteString types
1.468 + void PassByteString(const nsCString&);
1.469 + void PassNullableByteString(const nsCString&);
1.470 + void PassOptionalByteString(const Optional<nsCString>&);
1.471 + void PassOptionalNullableByteString(const Optional<nsCString>&);
1.472 + void PassVariadicByteString(const Sequence<nsCString>&);
1.473 +
1.474 + // Enumerated types
1.475 + void PassEnum(TestEnum);
1.476 + void PassNullableEnum(const Nullable<TestEnum>&);
1.477 + void PassOptionalEnum(const Optional<TestEnum>&);
1.478 + void PassEnumWithDefault(TestEnum);
1.479 + void PassOptionalNullableEnum(const Optional<Nullable<TestEnum> >&);
1.480 + void PassOptionalNullableEnumWithDefaultValue(const Nullable<TestEnum>&);
1.481 + void PassOptionalNullableEnumWithDefaultValue2(const Nullable<TestEnum>&);
1.482 + TestEnum ReceiveEnum();
1.483 + Nullable<TestEnum> ReceiveNullableEnum();
1.484 + TestEnum EnumAttribute();
1.485 + TestEnum ReadonlyEnumAttribute();
1.486 + void SetEnumAttribute(TestEnum);
1.487 +
1.488 + // Callback types
1.489 + void PassCallback(TestCallback&);
1.490 + void PassNullableCallback(TestCallback*);
1.491 + void PassOptionalCallback(const Optional<OwningNonNull<TestCallback> >&);
1.492 + void PassOptionalNullableCallback(const Optional<nsRefPtr<TestCallback> >&);
1.493 + void PassOptionalNullableCallbackWithDefaultValue(TestCallback*);
1.494 + already_AddRefed<TestCallback> ReceiveCallback();
1.495 + already_AddRefed<TestCallback> ReceiveNullableCallback();
1.496 + void PassNullableTreatAsNullCallback(TestTreatAsNullCallback*);
1.497 + void PassOptionalNullableTreatAsNullCallback(const Optional<nsRefPtr<TestTreatAsNullCallback> >&);
1.498 + void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(TestTreatAsNullCallback*);
1.499 + void SetTreatAsNullCallback(TestTreatAsNullCallback&);
1.500 + already_AddRefed<TestTreatAsNullCallback> TreatAsNullCallback();
1.501 + void SetNullableTreatAsNullCallback(TestTreatAsNullCallback*);
1.502 + already_AddRefed<TestTreatAsNullCallback> GetNullableTreatAsNullCallback();
1.503 +
1.504 + // Any types
1.505 + void PassAny(JSContext*, JS::Handle<JS::Value>);
1.506 + void PassVariadicAny(JSContext*, const Sequence<JS::Value>&);
1.507 + void PassOptionalAny(JSContext*, JS::Handle<JS::Value>);
1.508 + void PassAnyDefaultNull(JSContext*, JS::Handle<JS::Value>);
1.509 + void PassSequenceOfAny(JSContext*, const Sequence<JS::Value>&);
1.510 + void PassNullableSequenceOfAny(JSContext*, const Nullable<Sequence<JS::Value> >&);
1.511 + void PassOptionalSequenceOfAny(JSContext*, const Optional<Sequence<JS::Value> >&);
1.512 + void PassOptionalNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<JS::Value> > >&);
1.513 + void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, const Nullable<Sequence<JS::Value> >&);
1.514 + void PassSequenceOfSequenceOfAny(JSContext*, const Sequence<Sequence<JS::Value> >&);
1.515 + void PassSequenceOfNullableSequenceOfAny(JSContext*, const Sequence<Nullable<Sequence<JS::Value> > >&);
1.516 + void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, const Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&);
1.517 + void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&);
1.518 + void PassMozMapOfAny(JSContext*, const MozMap<JS::Value>&);
1.519 + void PassNullableMozMapOfAny(JSContext*, const Nullable<MozMap<JS::Value> >&);
1.520 + void PassOptionalMozMapOfAny(JSContext*, const Optional<MozMap<JS::Value> >&);
1.521 + void PassOptionalNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<JS::Value> > >&);
1.522 + void PassOptionalMozMapOfAnyWithDefaultValue(JSContext*, const Nullable<MozMap<JS::Value> >&);
1.523 + void PassMozMapOfMozMapOfAny(JSContext*, const MozMap<MozMap<JS::Value> >&);
1.524 + void PassMozMapOfNullableMozMapOfAny(JSContext*, const MozMap<Nullable<MozMap<JS::Value> > >&);
1.525 + void PassNullableMozMapOfNullableMozMapOfAny(JSContext*, const Nullable<MozMap<Nullable<MozMap<JS::Value> > > >&);
1.526 + void PassOptionalNullableMozMapOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<MozMap<JS::Value>>>>>&);
1.527 + void PassOptionalNullableMozMapOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<Sequence<JS::Value>>>>>&);
1.528 + void PassOptionalNullableSequenceOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<MozMap<JS::Value>>>>>&);
1.529 + void ReceiveAny(JSContext*, JS::MutableHandle<JS::Value>);
1.530 +
1.531 + // object types
1.532 + void PassObject(JSContext*, JS::Handle<JSObject*>);
1.533 + void PassVariadicObject(JSContext*, const Sequence<JSObject*>&);
1.534 + void PassNullableObject(JSContext*, JS::Handle<JSObject*>);
1.535 + void PassVariadicNullableObject(JSContext*, const Sequence<JSObject*>&);
1.536 + void PassOptionalObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
1.537 + void PassOptionalNullableObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
1.538 + void PassOptionalNullableObjectWithDefaultValue(JSContext*, JS::Handle<JSObject*>);
1.539 + void PassSequenceOfObject(JSContext*, const Sequence<JSObject*>&);
1.540 + void PassSequenceOfNullableObject(JSContext*, const Sequence<JSObject*>&);
1.541 + void PassNullableSequenceOfObject(JSContext*, const Nullable<Sequence<JSObject*> >&);
1.542 + void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
1.543 + void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
1.544 + void PassMozMapOfObject(JSContext*, const MozMap<JSObject*>&);
1.545 + void ReceiveObject(JSContext*, JS::MutableHandle<JSObject*>);
1.546 + void ReceiveNullableObject(JSContext*, JS::MutableHandle<JSObject*>);
1.547 +
1.548 + // Union types
1.549 + void PassUnion(JSContext*, const ObjectOrLong& arg);
1.550 + void PassUnionWithNullable(JSContext* cx, const ObjectOrNullOrLong& arg)
1.551 + {
1.552 + OwningObjectOrLong returnValue;
1.553 + if (arg.IsNull()) {
1.554 + } else if (arg.IsObject()) {
1.555 + JS::Rooted<JSObject*> obj(cx, arg.GetAsObject());
1.556 + JS_GetClass(obj);
1.557 + returnValue.SetAsObject() = obj;
1.558 + } else {
1.559 + int32_t i = arg.GetAsLong();
1.560 + i += 1;
1.561 + returnValue.SetAsLong() = i;
1.562 + }
1.563 + }
1.564 +#ifdef DEBUG
1.565 + void PassUnion2(const LongOrBoolean& arg);
1.566 + void PassUnion3(JSContext*, const ObjectOrLongOrBoolean& arg);
1.567 + void PassUnion4(const NodeOrLongOrBoolean& arg);
1.568 + void PassUnion5(JSContext*, const ObjectOrBoolean& arg);
1.569 + void PassUnion6(JSContext*, const ObjectOrString& arg);
1.570 + void PassUnion7(JSContext*, const ObjectOrStringOrLong& arg);
1.571 + void PassUnion8(JSContext*, const ObjectOrStringOrBoolean& arg);
1.572 + void PassUnion9(JSContext*, const ObjectOrStringOrLongOrBoolean& arg);
1.573 + void PassUnion10(const EventInitOrLong& arg);
1.574 + void PassUnion11(JSContext*, const CustomEventInitOrLong& arg);
1.575 + void PassUnion12(const EventInitOrLong& arg);
1.576 + void PassUnion13(JSContext*, const ObjectOrLongOrNull& arg);
1.577 + void PassUnion14(JSContext*, const ObjectOrLongOrNull& arg);
1.578 + void PassUnionWithCallback(const EventHandlerNonNullOrNullOrLong& arg);
1.579 +#endif
1.580 + void PassNullableUnion(JSContext*, const Nullable<ObjectOrLong>&);
1.581 + void PassOptionalUnion(JSContext*, const Optional<ObjectOrLong>&);
1.582 + void PassOptionalNullableUnion(JSContext*, const Optional<Nullable<ObjectOrLong> >&);
1.583 + void PassOptionalNullableUnionWithDefaultValue(JSContext*, const Nullable<ObjectOrLong>&);
1.584 + //void PassUnionWithInterfaces(const TestInterfaceOrTestExternalInterface& arg);
1.585 + //void PassUnionWithInterfacesAndNullable(const TestInterfaceOrNullOrTestExternalInterface& arg);
1.586 + void PassUnionWithArrayBuffer(const ArrayBufferOrLong&);
1.587 + void PassUnionWithString(JSContext*, const StringOrObject&);
1.588 + //void PassUnionWithEnum(JSContext*, const TestEnumOrObject&);
1.589 + //void PassUnionWithCallback(JSContext*, const TestCallbackOrLong&);
1.590 + void PassUnionWithObject(JSContext*, const ObjectOrLong&);
1.591 +
1.592 + void PassUnionWithDefaultValue1(const DoubleOrString& arg);
1.593 + void PassUnionWithDefaultValue2(const DoubleOrString& arg);
1.594 + void PassUnionWithDefaultValue3(const DoubleOrString& arg);
1.595 + void PassUnionWithDefaultValue4(const FloatOrString& arg);
1.596 + void PassUnionWithDefaultValue5(const FloatOrString& arg);
1.597 + void PassUnionWithDefaultValue6(const FloatOrString& arg);
1.598 + void PassUnionWithDefaultValue7(const UnrestrictedDoubleOrString& arg);
1.599 + void PassUnionWithDefaultValue8(const UnrestrictedDoubleOrString& arg);
1.600 + void PassUnionWithDefaultValue9(const UnrestrictedDoubleOrString& arg);
1.601 + void PassUnionWithDefaultValue10(const UnrestrictedDoubleOrString& arg);
1.602 + void PassUnionWithDefaultValue11(const UnrestrictedFloatOrString& arg);
1.603 + void PassUnionWithDefaultValue12(const UnrestrictedFloatOrString& arg);
1.604 + void PassUnionWithDefaultValue13(const UnrestrictedFloatOrString& arg);
1.605 + void PassUnionWithDefaultValue14(const UnrestrictedFloatOrString& arg);
1.606 +
1.607 + void PassNullableUnionWithDefaultValue1(const Nullable<DoubleOrString>& arg);
1.608 + void PassNullableUnionWithDefaultValue2(const Nullable<DoubleOrString>& arg);
1.609 + void PassNullableUnionWithDefaultValue3(const Nullable<DoubleOrString>& arg);
1.610 + void PassNullableUnionWithDefaultValue4(const Nullable<FloatOrString>& arg);
1.611 + void PassNullableUnionWithDefaultValue5(const Nullable<FloatOrString>& arg);
1.612 + void PassNullableUnionWithDefaultValue6(const Nullable<FloatOrString>& arg);
1.613 + void PassNullableUnionWithDefaultValue7(const Nullable<UnrestrictedDoubleOrString>& arg);
1.614 + void PassNullableUnionWithDefaultValue8(const Nullable<UnrestrictedDoubleOrString>& arg);
1.615 + void PassNullableUnionWithDefaultValue9(const Nullable<UnrestrictedDoubleOrString>& arg);
1.616 + void PassNullableUnionWithDefaultValue10(const Nullable<UnrestrictedFloatOrString>& arg);
1.617 + void PassNullableUnionWithDefaultValue11(const Nullable<UnrestrictedFloatOrString>& arg);
1.618 + void PassNullableUnionWithDefaultValue12(const Nullable<UnrestrictedFloatOrString>& arg);
1.619 +
1.620 + void PassSequenceOfUnions(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
1.621 + void PassSequenceOfUnions2(JSContext*, const Sequence<OwningObjectOrLong>&);
1.622 + void PassVariadicUnion(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
1.623 +
1.624 + void PassSequenceOfNullableUnions(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
1.625 + void PassVariadicNullableUnion(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
1.626 + void PassMozMapOfUnions(const MozMap<OwningCanvasPatternOrCanvasGradient>&);
1.627 + void PassMozMapOfUnions2(JSContext*, const MozMap<OwningObjectOrLong>&);
1.628 +
1.629 + void ReceiveUnion(OwningCanvasPatternOrCanvasGradient&);
1.630 + void ReceiveUnion2(JSContext*, OwningObjectOrLong&);
1.631 + void ReceiveUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
1.632 + void ReceiveNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
1.633 + void ReceiveNullableUnion2(JSContext*, Nullable<OwningObjectOrLong>&);
1.634 + void GetWritableUnion(OwningCanvasPatternOrCanvasGradient&);
1.635 + void SetWritableUnion(const CanvasPatternOrCanvasGradient&);
1.636 + void GetWritableUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
1.637 + void SetWritableUnionContainingNull(const CanvasPatternOrNullOrCanvasGradient&);
1.638 + void GetWritableNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
1.639 + void SetWritableNullableUnion(const Nullable<CanvasPatternOrCanvasGradient>&);
1.640 +
1.641 + // Date types
1.642 + void PassDate(Date);
1.643 + void PassNullableDate(const Nullable<Date>&);
1.644 + void PassOptionalDate(const Optional<Date>&);
1.645 + void PassOptionalNullableDate(const Optional<Nullable<Date> >&);
1.646 + void PassOptionalNullableDateWithDefaultValue(const Nullable<Date>&);
1.647 + void PassDateSequence(const Sequence<Date>&);
1.648 + void PassDateMozMap(const MozMap<Date>&);
1.649 + void PassNullableDateSequence(const Sequence<Nullable<Date> >&);
1.650 + Date ReceiveDate();
1.651 + Nullable<Date> ReceiveNullableDate();
1.652 +
1.653 + // binaryNames tests
1.654 + void MethodRenamedTo();
1.655 + void MethodRenamedTo(int8_t);
1.656 + int8_t AttributeGetterRenamedTo();
1.657 + int8_t AttributeRenamedTo();
1.658 + void SetAttributeRenamedTo(int8_t);
1.659 +
1.660 + // Dictionary tests
1.661 + void PassDictionary(JSContext*, const Dict&);
1.662 + void GetReadonlyDictionary(JSContext*, Dict&);
1.663 + void GetReadonlyNullableDictionary(JSContext*, Nullable<Dict>&);
1.664 + void GetWritableDictionary(JSContext*, Dict&);
1.665 + void SetWritableDictionary(JSContext*, const Dict&);
1.666 + void GetReadonlyFrozenDictionary(JSContext*, Dict&);
1.667 + void GetReadonlyFrozenNullableDictionary(JSContext*, Nullable<Dict>&);
1.668 + void GetWritableFrozenDictionary(JSContext*, Dict&);
1.669 + void SetWritableFrozenDictionary(JSContext*, const Dict&);
1.670 + void ReceiveDictionary(JSContext*, Dict&);
1.671 + void ReceiveNullableDictionary(JSContext*, Nullable<Dict>&);
1.672 + void PassOtherDictionary(const GrandparentDict&);
1.673 + void PassSequenceOfDictionaries(JSContext*, const Sequence<Dict>&);
1.674 + void PassMozMapOfDictionaries(const MozMap<GrandparentDict>&);
1.675 + void PassDictionaryOrLong(JSContext*, const Dict&);
1.676 + void PassDictionaryOrLong(int32_t);
1.677 + void PassDictContainingDict(JSContext*, const DictContainingDict&);
1.678 + void PassDictContainingSequence(JSContext*, const DictContainingSequence&);
1.679 + void ReceiveDictContainingSequence(JSContext*, DictContainingSequence&);
1.680 +
1.681 + // Typedefs
1.682 + void ExerciseTypedefInterfaces1(TestInterface&);
1.683 + already_AddRefed<TestInterface> ExerciseTypedefInterfaces2(TestInterface*);
1.684 + void ExerciseTypedefInterfaces3(TestInterface&);
1.685 +
1.686 + // Static methods and attributes
1.687 + static void StaticMethod(const GlobalObject&, bool);
1.688 + static void StaticMethodWithContext(const GlobalObject&, JSContext*,
1.689 + JS::Value);
1.690 + static bool StaticAttribute(const GlobalObject&);
1.691 + static void SetStaticAttribute(const GlobalObject&, bool);
1.692 +
1.693 + // Overload resolution tests
1.694 + bool Overload1(TestInterface&);
1.695 + TestInterface* Overload1(const nsAString&, TestInterface&);
1.696 + void Overload2(TestInterface&);
1.697 + void Overload2(JSContext*, const Dict&);
1.698 + void Overload2(bool);
1.699 + void Overload2(const nsAString&);
1.700 + void Overload2(Date);
1.701 + void Overload3(TestInterface&);
1.702 + void Overload3(const TestCallback&);
1.703 + void Overload3(bool);
1.704 + void Overload4(TestInterface&);
1.705 + void Overload4(TestCallbackInterface&);
1.706 + void Overload4(const nsAString&);
1.707 + void Overload5(int32_t);
1.708 + void Overload5(TestEnum);
1.709 + void Overload6(int32_t);
1.710 + void Overload6(bool);
1.711 + void Overload7(int32_t);
1.712 + void Overload7(bool);
1.713 + void Overload7(const nsCString&);
1.714 + void Overload8(int32_t);
1.715 + void Overload8(TestInterface&);
1.716 + void Overload9(const Nullable<int32_t>&);
1.717 + void Overload9(const nsAString&);
1.718 + void Overload10(const Nullable<int32_t>&);
1.719 + void Overload10(JSContext*, JS::Handle<JSObject*>);
1.720 + void Overload11(int32_t);
1.721 + void Overload11(const nsAString&);
1.722 + void Overload12(int32_t);
1.723 + void Overload12(const Nullable<bool>&);
1.724 + void Overload13(const Nullable<int32_t>&);
1.725 + void Overload13(bool);
1.726 + void Overload14(const Optional<int32_t>&);
1.727 + void Overload14(TestInterface&);
1.728 + void Overload15(int32_t);
1.729 + void Overload15(const Optional<NonNull<TestInterface> >&);
1.730 + void Overload16(int32_t);
1.731 + void Overload16(const Optional<TestInterface*>&);
1.732 +
1.733 + // Variadic handling
1.734 + void PassVariadicThirdArg(const nsAString&, int32_t,
1.735 + const Sequence<OwningNonNull<TestInterface> >&);
1.736 +
1.737 + // Conditionally exposed methods/attributes
1.738 + bool Prefable1();
1.739 + bool Prefable2();
1.740 + bool Prefable3();
1.741 + bool Prefable4();
1.742 + bool Prefable5();
1.743 + bool Prefable6();
1.744 + bool Prefable7();
1.745 + bool Prefable8();
1.746 + bool Prefable9();
1.747 + void Prefable10();
1.748 + void Prefable11();
1.749 + bool Prefable12();
1.750 + void Prefable13();
1.751 + bool Prefable14();
1.752 + bool Prefable15();
1.753 + bool Prefable16();
1.754 + void Prefable17();
1.755 + void Prefable18();
1.756 + void Prefable19();
1.757 + void Prefable20();
1.758 + void Prefable21();
1.759 + void Prefable22();
1.760 + void Prefable23();
1.761 + void Prefable24();
1.762 +
1.763 + // Miscellania
1.764 + int32_t AttrWithLenientThis();
1.765 + void SetAttrWithLenientThis(int32_t);
1.766 + uint32_t UnforgeableAttr();
1.767 + uint32_t UnforgeableAttr2();
1.768 + void Stringify(nsString&);
1.769 + void PassRenamedInterface(nsRenamedInterface&);
1.770 + TestInterface* PutForwardsAttr();
1.771 + TestInterface* PutForwardsAttr2();
1.772 + TestInterface* PutForwardsAttr3();
1.773 + void GetJsonifierShouldSkipThis(JSContext*, JS::MutableHandle<JS::Value>);
1.774 + void SetJsonifierShouldSkipThis(JSContext*, JS::Rooted<JS::Value>&);
1.775 + TestParentInterface* JsonifierShouldSkipThis2();
1.776 + void SetJsonifierShouldSkipThis2(TestParentInterface&);
1.777 + TestCallbackInterface* JsonifierShouldSkipThis3();
1.778 + void SetJsonifierShouldSkipThis3(TestCallbackInterface&);
1.779 + void ThrowingMethod(ErrorResult& aRv);
1.780 + bool GetThrowingAttr(ErrorResult& aRv) const;
1.781 + void SetThrowingAttr(bool arg, ErrorResult& aRv);
1.782 + bool GetThrowingGetterAttr(ErrorResult& aRv) const;
1.783 + void SetThrowingGetterAttr(bool arg);
1.784 + bool ThrowingSetterAttr() const;
1.785 + void SetThrowingSetterAttr(bool arg, ErrorResult& aRv);
1.786 + int16_t LegacyCall(JS::Value, uint32_t, TestInterface&);
1.787 + void PassArgsWithDefaults(JSContext*, const Optional<int32_t>&,
1.788 + TestInterface*, const Dict&, double,
1.789 + const Optional<float>&);
1.790 +
1.791 + // Methods and properties imported via "implements"
1.792 + bool ImplementedProperty();
1.793 + void SetImplementedProperty(bool);
1.794 + void ImplementedMethod();
1.795 + bool ImplementedParentProperty();
1.796 + void SetImplementedParentProperty(bool);
1.797 + void ImplementedParentMethod();
1.798 + bool IndirectlyImplementedProperty();
1.799 + void SetIndirectlyImplementedProperty(bool);
1.800 + void IndirectlyImplementedMethod();
1.801 + uint32_t DiamondImplementedProperty();
1.802 +
1.803 + // Test EnforceRange/Clamp
1.804 + void DontEnforceRangeOrClamp(int8_t);
1.805 + void DoEnforceRange(int8_t);
1.806 + void DoClamp(int8_t);
1.807 + void SetEnforcedByte(int8_t);
1.808 + int8_t EnforcedByte();
1.809 + void SetClampedByte(int8_t);
1.810 + int8_t ClampedByte();
1.811 +
1.812 +private:
1.813 + // We add signatures here that _could_ start matching if the codegen
1.814 + // got data types wrong. That way if it ever does we'll have a call
1.815 + // to these private deleted methods and compilation will fail.
1.816 + void SetReadonlyByte(int8_t) MOZ_DELETE;
1.817 + template<typename T>
1.818 + void SetWritableByte(T) MOZ_DELETE;
1.819 + template<typename T>
1.820 + void PassByte(T) MOZ_DELETE;
1.821 + void PassNullableByte(Nullable<int8_t>&) MOZ_DELETE;
1.822 + template<typename T>
1.823 + void PassOptionalByte(const Optional<T>&) MOZ_DELETE;
1.824 + template<typename T>
1.825 + void PassOptionalByteWithDefault(T) MOZ_DELETE;
1.826 + void PassVariadicByte(Sequence<int8_t>&) MOZ_DELETE;
1.827 +
1.828 + void SetReadonlyShort(int16_t) MOZ_DELETE;
1.829 + template<typename T>
1.830 + void SetWritableShort(T) MOZ_DELETE;
1.831 + template<typename T>
1.832 + void PassShort(T) MOZ_DELETE;
1.833 + template<typename T>
1.834 + void PassOptionalShort(const Optional<T>&) MOZ_DELETE;
1.835 + template<typename T>
1.836 + void PassOptionalShortWithDefault(T) MOZ_DELETE;
1.837 +
1.838 + void SetReadonlyLong(int32_t) MOZ_DELETE;
1.839 + template<typename T>
1.840 + void SetWritableLong(T) MOZ_DELETE;
1.841 + template<typename T>
1.842 + void PassLong(T) MOZ_DELETE;
1.843 + template<typename T>
1.844 + void PassOptionalLong(const Optional<T>&) MOZ_DELETE;
1.845 + template<typename T>
1.846 + void PassOptionalLongWithDefault(T) MOZ_DELETE;
1.847 +
1.848 + void SetReadonlyLongLong(int64_t) MOZ_DELETE;
1.849 + template<typename T>
1.850 + void SetWritableLongLong(T) MOZ_DELETE;
1.851 + template<typename T>
1.852 + void PassLongLong(T) MOZ_DELETE;
1.853 + template<typename T>
1.854 + void PassOptionalLongLong(const Optional<T>&) MOZ_DELETE;
1.855 + template<typename T>
1.856 + void PassOptionalLongLongWithDefault(T) MOZ_DELETE;
1.857 +
1.858 + void SetReadonlyOctet(uint8_t) MOZ_DELETE;
1.859 + template<typename T>
1.860 + void SetWritableOctet(T) MOZ_DELETE;
1.861 + template<typename T>
1.862 + void PassOctet(T) MOZ_DELETE;
1.863 + template<typename T>
1.864 + void PassOptionalOctet(const Optional<T>&) MOZ_DELETE;
1.865 + template<typename T>
1.866 + void PassOptionalOctetWithDefault(T) MOZ_DELETE;
1.867 +
1.868 + void SetReadonlyUnsignedShort(uint16_t) MOZ_DELETE;
1.869 + template<typename T>
1.870 + void SetWritableUnsignedShort(T) MOZ_DELETE;
1.871 + template<typename T>
1.872 + void PassUnsignedShort(T) MOZ_DELETE;
1.873 + template<typename T>
1.874 + void PassOptionalUnsignedShort(const Optional<T>&) MOZ_DELETE;
1.875 + template<typename T>
1.876 + void PassOptionalUnsignedShortWithDefault(T) MOZ_DELETE;
1.877 +
1.878 + void SetReadonlyUnsignedLong(uint32_t) MOZ_DELETE;
1.879 + template<typename T>
1.880 + void SetWritableUnsignedLong(T) MOZ_DELETE;
1.881 + template<typename T>
1.882 + void PassUnsignedLong(T) MOZ_DELETE;
1.883 + template<typename T>
1.884 + void PassOptionalUnsignedLong(const Optional<T>&) MOZ_DELETE;
1.885 + template<typename T>
1.886 + void PassOptionalUnsignedLongWithDefault(T) MOZ_DELETE;
1.887 +
1.888 + void SetReadonlyUnsignedLongLong(uint64_t) MOZ_DELETE;
1.889 + template<typename T>
1.890 + void SetWritableUnsignedLongLong(T) MOZ_DELETE;
1.891 + template<typename T>
1.892 + void PassUnsignedLongLong(T) MOZ_DELETE;
1.893 + template<typename T>
1.894 + void PassOptionalUnsignedLongLong(const Optional<T>&) MOZ_DELETE;
1.895 + template<typename T>
1.896 + void PassOptionalUnsignedLongLongWithDefault(T) MOZ_DELETE;
1.897 +
1.898 + // Enforce that only const things are passed for sequences
1.899 + void PassSequence(Sequence<int32_t> &) MOZ_DELETE;
1.900 + void PassNullableSequence(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
1.901 + void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
1.902 + void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
1.903 + void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
1.904 + void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) MOZ_DELETE;
1.905 + void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
1.906 + void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
1.907 + void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) MOZ_DELETE;
1.908 + void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
1.909 + void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) MOZ_DELETE;
1.910 + void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) MOZ_DELETE;
1.911 + void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
1.912 + void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
1.913 + void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
1.914 + void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
1.915 +
1.916 + // Enforce that only const things are passed for optional
1.917 + void PassOptionalByte(Optional<int8_t>&) MOZ_DELETE;
1.918 + void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) MOZ_DELETE;
1.919 + void PassOptionalShort(Optional<int16_t>&) MOZ_DELETE;
1.920 + void PassOptionalLong(Optional<int32_t>&) MOZ_DELETE;
1.921 + void PassOptionalLongLong(Optional<int64_t>&) MOZ_DELETE;
1.922 + void PassOptionalOctet(Optional<uint8_t>&) MOZ_DELETE;
1.923 + void PassOptionalUnsignedShort(Optional<uint16_t>&) MOZ_DELETE;
1.924 + void PassOptionalUnsignedLong(Optional<uint32_t>&) MOZ_DELETE;
1.925 + void PassOptionalUnsignedLongLong(Optional<uint64_t>&) MOZ_DELETE;
1.926 + void PassOptionalSelf(Optional<TestInterface*> &) MOZ_DELETE;
1.927 + void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) MOZ_DELETE;
1.928 + void PassOptionalOther(Optional<IndirectlyImplementedInterface*>&);
1.929 + void PassOptionalNonNullOther(Optional<NonNull<IndirectlyImplementedInterface> >&);
1.930 + void PassOptionalExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
1.931 + void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
1.932 + void PassOptionalSequence(Optional<Sequence<int32_t> >&) MOZ_DELETE;
1.933 + void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) MOZ_DELETE;
1.934 + void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) MOZ_DELETE;
1.935 + void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) MOZ_DELETE;
1.936 + void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) MOZ_DELETE;
1.937 + void PassOptionalEnum(Optional<TestEnum>&) MOZ_DELETE;
1.938 + void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) MOZ_DELETE;
1.939 + void PassOptionalNullableCallback(JSContext*, Optional<nsRefPtr<TestCallback> >&) MOZ_DELETE;
1.940 + void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) MOZ_DELETE;
1.941 +
1.942 + // And test that string stuff is always const
1.943 + void PassString(nsAString&) MOZ_DELETE;
1.944 + void PassNullableString(nsAString&) MOZ_DELETE;
1.945 + void PassOptionalString(Optional<nsAString>&) MOZ_DELETE;
1.946 + void PassOptionalStringWithDefaultValue(nsAString&) MOZ_DELETE;
1.947 + void PassOptionalNullableString(Optional<nsAString>&) MOZ_DELETE;
1.948 + void PassOptionalNullableStringWithDefaultValue(nsAString&) MOZ_DELETE;
1.949 + void PassVariadicString(Sequence<nsString>&) MOZ_DELETE;
1.950 +
1.951 + // cstrings should be const as well
1.952 + void PassByteString(nsCString&) MOZ_DELETE;
1.953 + void PassNullableByteString(nsCString&) MOZ_DELETE;
1.954 + void PassOptionalByteString(Optional<nsCString>&) MOZ_DELETE;
1.955 + void PassOptionalNullableByteString(Optional<nsCString>&) MOZ_DELETE;
1.956 + void PassVariadicByteString(Sequence<nsCString>&) MOZ_DELETE;
1.957 +
1.958 + // Make sure dictionary arguments are always const
1.959 + void PassDictionary(JSContext*, Dict&) MOZ_DELETE;
1.960 + void PassOtherDictionary(GrandparentDict&) MOZ_DELETE;
1.961 + void PassSequenceOfDictionaries(JSContext*, Sequence<Dict>&) MOZ_DELETE;
1.962 + void PassDictionaryOrLong(JSContext*, Dict&) MOZ_DELETE;
1.963 + void PassDictContainingDict(JSContext*, DictContainingDict&) MOZ_DELETE;
1.964 + void PassDictContainingSequence(DictContainingSequence&) MOZ_DELETE;
1.965 +
1.966 + // Make sure various nullable things are always const
1.967 + void PassNullableEnum(Nullable<TestEnum>&) MOZ_DELETE;
1.968 +
1.969 + // Make sure unions are always const
1.970 + void PassUnion(JSContext*, ObjectOrLong& arg) MOZ_DELETE;
1.971 + void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) MOZ_DELETE;
1.972 + void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
1.973 + void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) MOZ_DELETE;
1.974 + void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) MOZ_DELETE;
1.975 + void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
1.976 +
1.977 + // Make sure various date stuff is const as needed
1.978 + void PassNullableDate(Nullable<Date>&) MOZ_DELETE;
1.979 + void PassOptionalDate(Optional<Date>&) MOZ_DELETE;
1.980 + void PassOptionalNullableDate(Optional<Nullable<Date> >&) MOZ_DELETE;
1.981 + void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) MOZ_DELETE;
1.982 + void PassDateSequence(Sequence<Date>&) MOZ_DELETE;
1.983 + void PassNullableDateSequence(Sequence<Nullable<Date> >&) MOZ_DELETE;
1.984 +
1.985 + // Make sure variadics are const as needed
1.986 + void PassVariadicAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
1.987 + void PassVariadicObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
1.988 + void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
1.989 +
1.990 + // Ensure NonNull does not leak in
1.991 + void PassSelf(NonNull<TestInterface>&) MOZ_DELETE;
1.992 + void PassSelf(OwningNonNull<TestInterface>&) MOZ_DELETE;
1.993 + void PassSelf(const NonNull<TestInterface>&) MOZ_DELETE;
1.994 + void PassSelf(const OwningNonNull<TestInterface>&) MOZ_DELETE;
1.995 + void PassOther(NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
1.996 + void PassOther(const NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
1.997 + void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
1.998 + void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
1.999 + void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
1.1000 + void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
1.1001 + void PassCallbackInterface(NonNull<TestCallbackInterface>&) MOZ_DELETE;
1.1002 + void PassCallbackInterface(const NonNull<TestCallbackInterface>&) MOZ_DELETE;
1.1003 + void PassCallback(OwningNonNull<TestCallback>&) MOZ_DELETE;
1.1004 + void PassCallback(const OwningNonNull<TestCallback>&) MOZ_DELETE;
1.1005 + void PassCallback(NonNull<TestCallback>&) MOZ_DELETE;
1.1006 + void PassCallback(const NonNull<TestCallback>&) MOZ_DELETE;
1.1007 + void PassString(const NonNull<nsAString>&) MOZ_DELETE;
1.1008 + void PassString(NonNull<nsAString>&) MOZ_DELETE;
1.1009 + void PassString(const OwningNonNull<nsAString>&) MOZ_DELETE;
1.1010 + void PassString(OwningNonNull<nsAString>&) MOZ_DELETE;
1.1011 +};
1.1012 +
1.1013 +class TestIndexedGetterInterface : public nsISupports,
1.1014 + public nsWrapperCache
1.1015 +{
1.1016 +public:
1.1017 + NS_DECL_ISUPPORTS
1.1018 +
1.1019 + // We need a GetParentObject to make binding codegen happy
1.1020 + virtual nsISupports* GetParentObject();
1.1021 +
1.1022 + uint32_t IndexedGetter(uint32_t, bool&);
1.1023 + uint32_t IndexedGetter(uint32_t&) MOZ_DELETE;
1.1024 + uint32_t Item(uint32_t&);
1.1025 + uint32_t Item(uint32_t, bool&) MOZ_DELETE;
1.1026 + uint32_t Length();
1.1027 + void LegacyCall(JS::Handle<JS::Value>);
1.1028 +};
1.1029 +
1.1030 +class TestNamedGetterInterface : public nsISupports,
1.1031 + public nsWrapperCache
1.1032 +{
1.1033 +public:
1.1034 + NS_DECL_ISUPPORTS
1.1035 +
1.1036 + // We need a GetParentObject to make binding codegen happy
1.1037 + virtual nsISupports* GetParentObject();
1.1038 +
1.1039 + void NamedGetter(const nsAString&, bool&, nsAString&);
1.1040 + bool NameIsEnumerable(const nsAString&);
1.1041 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1042 +};
1.1043 +
1.1044 +class TestIndexedGetterAndSetterAndNamedGetterInterface : public nsISupports,
1.1045 + public nsWrapperCache
1.1046 +{
1.1047 +public:
1.1048 + NS_DECL_ISUPPORTS
1.1049 +
1.1050 + // We need a GetParentObject to make binding codegen happy
1.1051 + virtual nsISupports* GetParentObject();
1.1052 +
1.1053 + void NamedGetter(const nsAString&, bool&, nsAString&);
1.1054 + bool NameIsEnumerable(const nsAString&);
1.1055 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1056 + int32_t IndexedGetter(uint32_t, bool&);
1.1057 + void IndexedSetter(uint32_t, int32_t);
1.1058 + uint32_t Length();
1.1059 +};
1.1060 +
1.1061 +class TestIndexedAndNamedGetterInterface : public nsISupports,
1.1062 + public nsWrapperCache
1.1063 +{
1.1064 +public:
1.1065 + NS_DECL_ISUPPORTS
1.1066 +
1.1067 + // We need a GetParentObject to make binding codegen happy
1.1068 + virtual nsISupports* GetParentObject();
1.1069 +
1.1070 + uint32_t IndexedGetter(uint32_t, bool&);
1.1071 + void NamedGetter(const nsAString&, bool&, nsAString&);
1.1072 + bool NameIsEnumerable(const nsAString&);
1.1073 + void NamedItem(const nsAString&, nsAString&);
1.1074 + uint32_t Length();
1.1075 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1076 +};
1.1077 +
1.1078 +class TestIndexedSetterInterface : public nsISupports,
1.1079 + public nsWrapperCache
1.1080 +{
1.1081 +public:
1.1082 + NS_DECL_ISUPPORTS
1.1083 +
1.1084 + // We need a GetParentObject to make binding codegen happy
1.1085 + virtual nsISupports* GetParentObject();
1.1086 +
1.1087 + void IndexedSetter(uint32_t, const nsAString&);
1.1088 + void IndexedGetter(uint32_t, bool&, nsString&);
1.1089 + uint32_t Length();
1.1090 + void SetItem(uint32_t, const nsAString&);
1.1091 +};
1.1092 +
1.1093 +class TestNamedSetterInterface : public nsISupports,
1.1094 + public nsWrapperCache
1.1095 +{
1.1096 +public:
1.1097 + NS_DECL_ISUPPORTS
1.1098 +
1.1099 + // We need a GetParentObject to make binding codegen happy
1.1100 + virtual nsISupports* GetParentObject();
1.1101 +
1.1102 + void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
1.1103 + TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
1.1104 + bool NameIsEnumerable(const nsAString&);
1.1105 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1106 +};
1.1107 +
1.1108 +class TestIndexedAndNamedSetterInterface : public nsISupports,
1.1109 + public nsWrapperCache
1.1110 +{
1.1111 +public:
1.1112 + NS_DECL_ISUPPORTS
1.1113 +
1.1114 + // We need a GetParentObject to make binding codegen happy
1.1115 + virtual nsISupports* GetParentObject();
1.1116 +
1.1117 + void IndexedSetter(uint32_t, TestIndexedSetterInterface&);
1.1118 + TestIndexedSetterInterface* IndexedGetter(uint32_t, bool&);
1.1119 + uint32_t Length();
1.1120 + void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
1.1121 + TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
1.1122 + bool NameIsEnumerable(const nsAString&);
1.1123 + void SetNamedItem(const nsAString&, TestIndexedSetterInterface&);
1.1124 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1125 +};
1.1126 +
1.1127 +class TestIndexedAndNamedGetterAndSetterInterface : public TestIndexedSetterInterface
1.1128 +{
1.1129 +public:
1.1130 + uint32_t IndexedGetter(uint32_t, bool&);
1.1131 + uint32_t Item(uint32_t);
1.1132 + void NamedGetter(const nsAString&, bool&, nsAString&);
1.1133 + bool NameIsEnumerable(const nsAString&);
1.1134 + void NamedItem(const nsAString&, nsAString&);
1.1135 + void IndexedSetter(uint32_t, int32_t&);
1.1136 + void IndexedSetter(uint32_t, const nsAString&) MOZ_DELETE;
1.1137 + void NamedSetter(const nsAString&, const nsAString&);
1.1138 + void Stringify(nsAString&);
1.1139 + uint32_t Length();
1.1140 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1141 +};
1.1142 +
1.1143 +class TestCppKeywordNamedMethodsInterface : public nsISupports,
1.1144 + public nsWrapperCache
1.1145 +{
1.1146 +public:
1.1147 + NS_DECL_ISUPPORTS
1.1148 +
1.1149 + // We need a GetParentObject to make binding codegen happy
1.1150 + virtual nsISupports* GetParentObject();
1.1151 +
1.1152 + bool Continue();
1.1153 + bool Delete();
1.1154 + int32_t Volatile();
1.1155 +};
1.1156 +
1.1157 +class TestIndexedDeleterInterface : public nsISupports,
1.1158 + public nsWrapperCache
1.1159 +{
1.1160 +public:
1.1161 + NS_DECL_ISUPPORTS
1.1162 +
1.1163 + // We need a GetParentObject to make binding codegen happy
1.1164 + virtual nsISupports* GetParentObject();
1.1165 +
1.1166 + void IndexedDeleter(uint32_t, bool&);
1.1167 + void IndexedDeleter(uint32_t) MOZ_DELETE;
1.1168 + long IndexedGetter(uint32_t, bool&);
1.1169 + uint32_t Length();
1.1170 + void DelItem(uint32_t);
1.1171 + void DelItem(uint32_t, bool&) MOZ_DELETE;
1.1172 +};
1.1173 +
1.1174 +class TestIndexedDeleterWithRetvalInterface : public nsISupports,
1.1175 + public nsWrapperCache
1.1176 +{
1.1177 +public:
1.1178 + NS_DECL_ISUPPORTS
1.1179 +
1.1180 + // We need a GetParentObject to make binding codegen happy
1.1181 + virtual nsISupports* GetParentObject();
1.1182 +
1.1183 + bool IndexedDeleter(uint32_t, bool&);
1.1184 + bool IndexedDeleter(uint32_t) MOZ_DELETE;
1.1185 + long IndexedGetter(uint32_t, bool&);
1.1186 + uint32_t Length();
1.1187 + bool DelItem(uint32_t);
1.1188 + bool DelItem(uint32_t, bool&) MOZ_DELETE;
1.1189 +};
1.1190 +
1.1191 +class TestNamedDeleterInterface : public nsISupports,
1.1192 + public nsWrapperCache
1.1193 +{
1.1194 +public:
1.1195 + NS_DECL_ISUPPORTS
1.1196 +
1.1197 + // We need a GetParentObject to make binding codegen happy
1.1198 + virtual nsISupports* GetParentObject();
1.1199 +
1.1200 + void NamedDeleter(const nsAString&, bool&);
1.1201 + long NamedGetter(const nsAString&, bool&);
1.1202 + bool NameIsEnumerable(const nsAString&);
1.1203 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1204 +};
1.1205 +
1.1206 +class TestNamedDeleterWithRetvalInterface : public nsISupports,
1.1207 + public nsWrapperCache
1.1208 +{
1.1209 +public:
1.1210 + NS_DECL_ISUPPORTS
1.1211 +
1.1212 + // We need a GetParentObject to make binding codegen happy
1.1213 + virtual nsISupports* GetParentObject();
1.1214 +
1.1215 + bool NamedDeleter(const nsAString&, bool&);
1.1216 + bool NamedDeleter(const nsAString&) MOZ_DELETE;
1.1217 + long NamedGetter(const nsAString&, bool&);
1.1218 + bool NameIsEnumerable(const nsAString&);
1.1219 + bool DelNamedItem(const nsAString&);
1.1220 + bool DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
1.1221 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1222 +};
1.1223 +
1.1224 +class TestIndexedAndNamedDeleterInterface : public nsISupports,
1.1225 + public nsWrapperCache
1.1226 +{
1.1227 +public:
1.1228 + NS_DECL_ISUPPORTS
1.1229 +
1.1230 + // We need a GetParentObject to make binding codegen happy
1.1231 + virtual nsISupports* GetParentObject();
1.1232 +
1.1233 + void IndexedDeleter(uint32_t, bool&);
1.1234 + long IndexedGetter(uint32_t, bool&);
1.1235 + uint32_t Length();
1.1236 +
1.1237 + void NamedDeleter(const nsAString&, bool&);
1.1238 + void NamedDeleter(const nsAString&) MOZ_DELETE;
1.1239 + long NamedGetter(const nsAString&, bool&);
1.1240 + bool NameIsEnumerable(const nsAString&);
1.1241 + void DelNamedItem(const nsAString&);
1.1242 + void DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
1.1243 + void GetSupportedNames(unsigned, nsTArray<nsString>&);
1.1244 +};
1.1245 +
1.1246 +class TestParentInterface : public nsISupports,
1.1247 + public nsWrapperCache
1.1248 +{
1.1249 +public:
1.1250 + NS_DECL_ISUPPORTS
1.1251 +
1.1252 + // We need a GetParentObject to make binding codegen happy
1.1253 + virtual nsISupports* GetParentObject();
1.1254 +};
1.1255 +
1.1256 +class TestChildInterface : public TestParentInterface
1.1257 +{
1.1258 +};
1.1259 +
1.1260 +} // namespace dom
1.1261 +} // namespace mozilla
1.1262 +
1.1263 +#endif /* TestBindingHeader_h */
