The Tor Browser / annotate

dom/bindings/test/TestBindingHeader.h@6474c204b198 (annotated)

dom/bindings/test/TestBindingHeader.h

Wed, 31 Dec 2014 06:09:35 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 06:09:35 +0100
changeset 0
6474c204b198
permissions
-rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

michael@0 1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
michael@0 2 /* This Source Code Form is subject to the terms of the Mozilla Public
michael@0 3 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
michael@0 4 * You can obtain one at http://mozilla.org/MPL/2.0/.
michael@0 5 */
michael@0 6
michael@0 7 #ifndef TestBindingHeader_h
michael@0 8 #define TestBindingHeader_h
michael@0 9
michael@0 10 #include "mozilla/dom/BindingUtils.h"
michael@0 11 #include "mozilla/dom/Date.h"
michael@0 12 #include "mozilla/dom/MozMap.h"
michael@0 13 #include "mozilla/dom/TypedArray.h"
michael@0 14 #include "mozilla/dom/UnionTypes.h"
michael@0 15 #include "mozilla/ErrorResult.h"
michael@0 16 #include "nsCOMPtr.h"
michael@0 17 #include "nsGenericHTMLElement.h"
michael@0 18 #include "nsWrapperCache.h"
michael@0 19
michael@0 20 // Forward declare this before we include TestCodeGenBinding.h, because that header relies on including
michael@0 21 // this one for it, for ParentDict. Hopefully it won't begin to rely on it in more fundamental ways.
michael@0 22 namespace mozilla {
michael@0 23 namespace dom {
michael@0 24 class TestExternalInterface;
michael@0 25 } // namespace dom
michael@0 26 } // namespace mozilla
michael@0 27
michael@0 28 // We don't export TestCodeGenBinding.h, but it's right in our parent dir.
michael@0 29 #include "../TestCodeGenBinding.h"
michael@0 30
michael@0 31 extern bool TestFuncControlledMember(JSContext*, JSObject*);
michael@0 32
michael@0 33 namespace mozilla {
michael@0 34 namespace dom {
michael@0 35
michael@0 36 // IID for nsRenamedInterface
michael@0 37 #define NS_RENAMED_INTERFACE_IID \
michael@0 38 { 0xd4b19ef3, 0xe68b, 0x4e3f, \
michael@0 39 { 0x94, 0xbc, 0xc9, 0xde, 0x3a, 0x69, 0xb0, 0xe8 } }
michael@0 40
michael@0 41 class nsRenamedInterface : public nsISupports,
michael@0 42 public nsWrapperCache
michael@0 43 {
michael@0 44 public:
michael@0 45 NS_DECLARE_STATIC_IID_ACCESSOR(NS_RENAMED_INTERFACE_IID)
michael@0 46 NS_DECL_ISUPPORTS
michael@0 47
michael@0 48 // We need a GetParentObject to make binding codegen happy
michael@0 49 virtual nsISupports* GetParentObject();
michael@0 50 };
michael@0 51
michael@0 52 NS_DEFINE_STATIC_IID_ACCESSOR(nsRenamedInterface, NS_RENAMED_INTERFACE_IID)
michael@0 53
michael@0 54 // IID for the IndirectlyImplementedInterface
michael@0 55 #define NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID \
michael@0 56 { 0xfed55b69, 0x7012, 0x4849, \
michael@0 57 { 0xaf, 0x56, 0x4b, 0xa9, 0xee, 0x41, 0x30, 0x89 } }
michael@0 58
michael@0 59 class IndirectlyImplementedInterface : public nsISupports,
michael@0 60 public nsWrapperCache
michael@0 61 {
michael@0 62 public:
michael@0 63 NS_DECLARE_STATIC_IID_ACCESSOR(NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
michael@0 64 NS_DECL_ISUPPORTS
michael@0 65
michael@0 66 // We need a GetParentObject to make binding codegen happy
michael@0 67 virtual nsISupports* GetParentObject();
michael@0 68
michael@0 69 bool IndirectlyImplementedProperty();
michael@0 70 void IndirectlyImplementedProperty(bool);
michael@0 71 void IndirectlyImplementedMethod();
michael@0 72 };
michael@0 73
michael@0 74 NS_DEFINE_STATIC_IID_ACCESSOR(IndirectlyImplementedInterface, NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)
michael@0 75
michael@0 76 // IID for the TestExternalInterface
michael@0 77 #define NS_TEST_EXTERNAL_INTERFACE_IID \
michael@0 78 { 0xd5ba0c99, 0x9b1d, 0x4e71, \
michael@0 79 { 0x8a, 0x94, 0x56, 0x38, 0x6c, 0xa3, 0xda, 0x3d } }
michael@0 80 class TestExternalInterface : public nsISupports
michael@0 81 {
michael@0 82 public:
michael@0 83 NS_DECLARE_STATIC_IID_ACCESSOR(NS_TEST_EXTERNAL_INTERFACE_IID)
michael@0 84 NS_DECL_ISUPPORTS
michael@0 85 };
michael@0 86
michael@0 87 NS_DEFINE_STATIC_IID_ACCESSOR(TestExternalInterface, NS_TEST_EXTERNAL_INTERFACE_IID)
michael@0 88
michael@0 89 class TestNonWrapperCacheInterface : public nsISupports
michael@0 90 {
michael@0 91 public:
michael@0 92 NS_DECL_ISUPPORTS
michael@0 93
michael@0 94 virtual JSObject* WrapObject(JSContext* cx);
michael@0 95 };
michael@0 96
michael@0 97 class OnlyForUseInConstructor : public nsISupports,
michael@0 98 public nsWrapperCache
michael@0 99 {
michael@0 100 public:
michael@0 101 NS_DECL_ISUPPORTS
michael@0 102 // We need a GetParentObject to make binding codegen happy
michael@0 103 virtual nsISupports* GetParentObject();
michael@0 104 };
michael@0 105
michael@0 106 class TestInterface : public nsISupports,
michael@0 107 public nsWrapperCache
michael@0 108 {
michael@0 109 public:
michael@0 110 NS_DECL_ISUPPORTS
michael@0 111
michael@0 112 // We need a GetParentObject to make binding codegen happy
michael@0 113 virtual nsISupports* GetParentObject();
michael@0 114
michael@0 115 // And now our actual WebIDL API
michael@0 116 // Constructors
michael@0 117 static
michael@0 118 already_AddRefed<TestInterface>
michael@0 119 Constructor(const GlobalObject&, ErrorResult&);
michael@0 120 static
michael@0 121 already_AddRefed<TestInterface>
michael@0 122 Constructor(const GlobalObject&, const nsAString&, ErrorResult&);
michael@0 123 static
michael@0 124 already_AddRefed<TestInterface>
michael@0 125 Constructor(const GlobalObject&, uint32_t, const Nullable<bool>&,
michael@0 126 ErrorResult&);
michael@0 127 static
michael@0 128 already_AddRefed<TestInterface>
michael@0 129 Constructor(const GlobalObject&, TestInterface*, ErrorResult&);
michael@0 130 static
michael@0 131 already_AddRefed<TestInterface>
michael@0 132 Constructor(const GlobalObject&, uint32_t, IndirectlyImplementedInterface&, ErrorResult&);
michael@0 133
michael@0 134 static
michael@0 135 already_AddRefed<TestInterface>
michael@0 136 Constructor(const GlobalObject&, Date&, ErrorResult&);
michael@0 137 /* static
michael@0 138 already_AddRefed<TestInterface>
michael@0 139 Constructor(const GlobalObject&, uint32_t, uint32_t,
michael@0 140 const TestInterfaceOrOnlyForUseInConstructor&, ErrorResult&);
michael@0 141 */
michael@0 142
michael@0 143 static
michael@0 144 already_AddRefed<TestInterface> Test(const GlobalObject&, ErrorResult&);
michael@0 145 static
michael@0 146 already_AddRefed<TestInterface> Test(const GlobalObject&, const nsAString&,
michael@0 147 ErrorResult&);
michael@0 148 static
michael@0 149 already_AddRefed<TestInterface> Test(const GlobalObject&, const nsACString&,
michael@0 150 ErrorResult&);
michael@0 151
michael@0 152 static
michael@0 153 already_AddRefed<TestInterface> Test2(const GlobalObject&,
michael@0 154 JSContext*,
michael@0 155 const DictForConstructor&,
michael@0 156 JS::Handle<JS::Value>,
michael@0 157 JS::Handle<JSObject*>,
michael@0 158 JS::Handle<JSObject*>,
michael@0 159 const Sequence<Dict>&,
michael@0 160 JS::Handle<JS::Value>,
michael@0 161 const Optional<JS::Handle<JSObject*> >&,
michael@0 162 const Optional<JS::Handle<JSObject*> >&,
michael@0 163 ErrorResult&);
michael@0 164
michael@0 165 // Integer types
michael@0 166 int8_t ReadonlyByte();
michael@0 167 int8_t WritableByte();
michael@0 168 void SetWritableByte(int8_t);
michael@0 169 void PassByte(int8_t);
michael@0 170 int8_t ReceiveByte();
michael@0 171 void PassOptionalByte(const Optional<int8_t>&);
michael@0 172 void PassOptionalByteBeforeRequired(const Optional<int8_t>&, int8_t);
michael@0 173 void PassOptionalByteWithDefault(int8_t);
michael@0 174 void PassOptionalByteWithDefaultBeforeRequired(int8_t, int8_t);
michael@0 175 void PassNullableByte(const Nullable<int8_t>&);
michael@0 176 void PassOptionalNullableByte(const Optional< Nullable<int8_t> >&);
michael@0 177 void PassVariadicByte(const Sequence<int8_t>&);
michael@0 178 int8_t CachedByte();
michael@0 179 int8_t CachedConstantByte();
michael@0 180 int8_t CachedWritableByte();
michael@0 181 void SetCachedWritableByte(int8_t);
michael@0 182
michael@0 183 int16_t ReadonlyShort();
michael@0 184 int16_t WritableShort();
michael@0 185 void SetWritableShort(int16_t);
michael@0 186 void PassShort(int16_t);
michael@0 187 int16_t ReceiveShort();
michael@0 188 void PassOptionalShort(const Optional<int16_t>&);
michael@0 189 void PassOptionalShortWithDefault(int16_t);
michael@0 190
michael@0 191 int32_t ReadonlyLong();
michael@0 192 int32_t WritableLong();
michael@0 193 void SetWritableLong(int32_t);
michael@0 194 void PassLong(int32_t);
michael@0 195 int16_t ReceiveLong();
michael@0 196 void PassOptionalLong(const Optional<int32_t>&);
michael@0 197 void PassOptionalLongWithDefault(int32_t);
michael@0 198
michael@0 199 int64_t ReadonlyLongLong();
michael@0 200 int64_t WritableLongLong();
michael@0 201 void SetWritableLongLong(int64_t);
michael@0 202 void PassLongLong(int64_t);
michael@0 203 int64_t ReceiveLongLong();
michael@0 204 void PassOptionalLongLong(const Optional<int64_t>&);
michael@0 205 void PassOptionalLongLongWithDefault(int64_t);
michael@0 206
michael@0 207 uint8_t ReadonlyOctet();
michael@0 208 uint8_t WritableOctet();
michael@0 209 void SetWritableOctet(uint8_t);
michael@0 210 void PassOctet(uint8_t);
michael@0 211 uint8_t ReceiveOctet();
michael@0 212 void PassOptionalOctet(const Optional<uint8_t>&);
michael@0 213 void PassOptionalOctetWithDefault(uint8_t);
michael@0 214
michael@0 215 uint16_t ReadonlyUnsignedShort();
michael@0 216 uint16_t WritableUnsignedShort();
michael@0 217 void SetWritableUnsignedShort(uint16_t);
michael@0 218 void PassUnsignedShort(uint16_t);
michael@0 219 uint16_t ReceiveUnsignedShort();
michael@0 220 void PassOptionalUnsignedShort(const Optional<uint16_t>&);
michael@0 221 void PassOptionalUnsignedShortWithDefault(uint16_t);
michael@0 222
michael@0 223 uint32_t ReadonlyUnsignedLong();
michael@0 224 uint32_t WritableUnsignedLong();
michael@0 225 void SetWritableUnsignedLong(uint32_t);
michael@0 226 void PassUnsignedLong(uint32_t);
michael@0 227 uint32_t ReceiveUnsignedLong();
michael@0 228 void PassOptionalUnsignedLong(const Optional<uint32_t>&);
michael@0 229 void PassOptionalUnsignedLongWithDefault(uint32_t);
michael@0 230
michael@0 231 uint64_t ReadonlyUnsignedLongLong();
michael@0 232 uint64_t WritableUnsignedLongLong();
michael@0 233 void SetWritableUnsignedLongLong(uint64_t);
michael@0 234 void PassUnsignedLongLong(uint64_t);
michael@0 235 uint64_t ReceiveUnsignedLongLong();
michael@0 236 void PassOptionalUnsignedLongLong(const Optional<uint64_t>&);
michael@0 237 void PassOptionalUnsignedLongLongWithDefault(uint64_t);
michael@0 238
michael@0 239 float WritableFloat() const;
michael@0 240 void SetWritableFloat(float);
michael@0 241 float WritableUnrestrictedFloat() const;
michael@0 242 void SetWritableUnrestrictedFloat(float);
michael@0 243 Nullable<float> GetWritableNullableFloat() const;
michael@0 244 void SetWritableNullableFloat(Nullable<float>);
michael@0 245 Nullable<float> GetWritableNullableUnrestrictedFloat() const;
michael@0 246 void SetWritableNullableUnrestrictedFloat(Nullable<float>);
michael@0 247 double WritableDouble() const;
michael@0 248 void SetWritableDouble(double);
michael@0 249 double WritableUnrestrictedDouble() const;
michael@0 250 void SetWritableUnrestrictedDouble(double);
michael@0 251 Nullable<double> GetWritableNullableDouble() const;
michael@0 252 void SetWritableNullableDouble(Nullable<double>);
michael@0 253 Nullable<double> GetWritableNullableUnrestrictedDouble() const;
michael@0 254 void SetWritableNullableUnrestrictedDouble(Nullable<double>);
michael@0 255 void PassFloat(float, float, Nullable<float>, Nullable<float>,
michael@0 256 double, double, Nullable<double>, Nullable<double>,
michael@0 257 const Sequence<float>&, const Sequence<float>&,
michael@0 258 const Sequence<Nullable<float> >&,
michael@0 259 const Sequence<Nullable<float> >&,
michael@0 260 const Sequence<double>&, const Sequence<double>&,
michael@0 261 const Sequence<Nullable<double> >&,
michael@0 262 const Sequence<Nullable<double> >&);
michael@0 263 void PassLenientFloat(float, float, Nullable<float>, Nullable<float>,
michael@0 264 double, double, Nullable<double>, Nullable<double>,
michael@0 265 const Sequence<float>&, const Sequence<float>&,
michael@0 266 const Sequence<Nullable<float> >&,
michael@0 267 const Sequence<Nullable<float> >&,
michael@0 268 const Sequence<double>&, const Sequence<double>&,
michael@0 269 const Sequence<Nullable<double> >&,
michael@0 270 const Sequence<Nullable<double> >&);
michael@0 271 float LenientFloatAttr() const;
michael@0 272 void SetLenientFloatAttr(float);
michael@0 273 double LenientDoubleAttr() const;
michael@0 274 void SetLenientDoubleAttr(double);
michael@0 275
michael@0 276 void PassUnrestricted(float arg1,
michael@0 277 float arg2,
michael@0 278 float arg3,
michael@0 279 float arg4,
michael@0 280 double arg5,
michael@0 281 double arg6,
michael@0 282 double arg7,
michael@0 283 double arg8);
michael@0 284
michael@0 285 // Interface types
michael@0 286 already_AddRefed<TestInterface> ReceiveSelf();
michael@0 287 already_AddRefed<TestInterface> ReceiveNullableSelf();
michael@0 288 TestInterface* ReceiveWeakSelf();
michael@0 289 TestInterface* ReceiveWeakNullableSelf();
michael@0 290 void PassSelf(TestInterface&);
michael@0 291 void PassNullableSelf(TestInterface*);
michael@0 292 already_AddRefed<TestInterface> NonNullSelf();
michael@0 293 void SetNonNullSelf(TestInterface&);
michael@0 294 already_AddRefed<TestInterface> GetNullableSelf();
michael@0 295 already_AddRefed<TestInterface> CachedSelf();
michael@0 296 void SetNullableSelf(TestInterface*);
michael@0 297 void PassOptionalSelf(const Optional<TestInterface*> &);
michael@0 298 void PassOptionalNonNullSelf(const Optional<NonNull<TestInterface> >&);
michael@0 299 void PassOptionalSelfWithDefault(TestInterface*);
michael@0 300
michael@0 301 already_AddRefed<TestNonWrapperCacheInterface> ReceiveNonWrapperCacheInterface();
michael@0 302 already_AddRefed<TestNonWrapperCacheInterface> ReceiveNullableNonWrapperCacheInterface();
michael@0 303 void ReceiveNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);
michael@0 304 void ReceiveNullableNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);
michael@0 305 void ReceiveNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);
michael@0 306 void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);
michael@0 307
michael@0 308 already_AddRefed<IndirectlyImplementedInterface> ReceiveOther();
michael@0 309 already_AddRefed<IndirectlyImplementedInterface> ReceiveNullableOther();
michael@0 310 IndirectlyImplementedInterface* ReceiveWeakOther();
michael@0 311 IndirectlyImplementedInterface* ReceiveWeakNullableOther();
michael@0 312 void PassOther(IndirectlyImplementedInterface&);
michael@0 313 void PassNullableOther(IndirectlyImplementedInterface*);
michael@0 314 already_AddRefed<IndirectlyImplementedInterface> NonNullOther();
michael@0 315 void SetNonNullOther(IndirectlyImplementedInterface&);
michael@0 316 already_AddRefed<IndirectlyImplementedInterface> GetNullableOther();
michael@0 317 void SetNullableOther(IndirectlyImplementedInterface*);
michael@0 318 void PassOptionalOther(const Optional<IndirectlyImplementedInterface*>&);
michael@0 319 void PassOptionalNonNullOther(const Optional<NonNull<IndirectlyImplementedInterface> >&);
michael@0 320 void PassOptionalOtherWithDefault(IndirectlyImplementedInterface*);
michael@0 321
michael@0 322 already_AddRefed<TestExternalInterface> ReceiveExternal();
michael@0 323 already_AddRefed<TestExternalInterface> ReceiveNullableExternal();
michael@0 324 TestExternalInterface* ReceiveWeakExternal();
michael@0 325 TestExternalInterface* ReceiveWeakNullableExternal();
michael@0 326 void PassExternal(TestExternalInterface*);
michael@0 327 void PassNullableExternal(TestExternalInterface*);
michael@0 328 already_AddRefed<TestExternalInterface> NonNullExternal();
michael@0 329 void SetNonNullExternal(TestExternalInterface*);
michael@0 330 already_AddRefed<TestExternalInterface> GetNullableExternal();
michael@0 331 void SetNullableExternal(TestExternalInterface*);
michael@0 332 void PassOptionalExternal(const Optional<TestExternalInterface*>&);
michael@0 333 void PassOptionalNonNullExternal(const Optional<TestExternalInterface*>&);
michael@0 334 void PassOptionalExternalWithDefault(TestExternalInterface*);
michael@0 335
michael@0 336 already_AddRefed<TestCallbackInterface> ReceiveCallbackInterface();
michael@0 337 already_AddRefed<TestCallbackInterface> ReceiveNullableCallbackInterface();
michael@0 338 TestCallbackInterface* ReceiveWeakCallbackInterface();
michael@0 339 TestCallbackInterface* ReceiveWeakNullableCallbackInterface();
michael@0 340 void PassCallbackInterface(TestCallbackInterface&);
michael@0 341 void PassNullableCallbackInterface(TestCallbackInterface*);
michael@0 342 already_AddRefed<TestCallbackInterface> NonNullCallbackInterface();
michael@0 343 void SetNonNullCallbackInterface(TestCallbackInterface&);
michael@0 344 already_AddRefed<TestCallbackInterface> GetNullableCallbackInterface();
michael@0 345 void SetNullableCallbackInterface(TestCallbackInterface*);
michael@0 346 void PassOptionalCallbackInterface(const Optional<nsRefPtr<TestCallbackInterface> >&);
michael@0 347 void PassOptionalNonNullCallbackInterface(const Optional<OwningNonNull<TestCallbackInterface> >&);
michael@0 348 void PassOptionalCallbackInterfaceWithDefault(TestCallbackInterface*);
michael@0 349
michael@0 350 already_AddRefed<IndirectlyImplementedInterface> ReceiveConsequentialInterface();
michael@0 351 void PassConsequentialInterface(IndirectlyImplementedInterface&);
michael@0 352
michael@0 353 // Sequence types
michael@0 354 void GetReadonlySequence(nsTArray<int32_t>&);
michael@0 355 void GetReadonlySequenceOfDictionaries(JSContext*, nsTArray<Dict>&);
michael@0 356 void GetReadonlyNullableSequenceOfDictionaries(JSContext*, Nullable<nsTArray<Dict> >&);
michael@0 357 void GetReadonlyFrozenSequence(JSContext*, nsTArray<Dict>&);
michael@0 358 void GetReadonlyFrozenNullableSequence(JSContext*, Nullable<nsTArray<Dict>>&);
michael@0 359 void ReceiveSequence(nsTArray<int32_t>&);
michael@0 360 void ReceiveNullableSequence(Nullable< nsTArray<int32_t> >&);
michael@0 361 void ReceiveSequenceOfNullableInts(nsTArray< Nullable<int32_t> >&);
michael@0 362 void ReceiveNullableSequenceOfNullableInts(Nullable< nsTArray< Nullable<int32_t> > >&);
michael@0 363 void PassSequence(const Sequence<int32_t> &);
michael@0 364 void PassNullableSequence(const Nullable< Sequence<int32_t> >&);
michael@0 365 void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t> >&);
michael@0 366 void PassOptionalSequenceOfNullableInts(const Optional<Sequence<Nullable<int32_t> > > &);
michael@0 367 void PassOptionalNullableSequenceOfNullableInts(const Optional<Nullable<Sequence<Nullable<int32_t> > > > &);
michael@0 368 void ReceiveCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);
michael@0 369 void ReceiveCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);
michael@0 370 void ReceiveNullableCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);
michael@0 371 void ReceiveNullableCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);
michael@0 372 void ReceiveCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);
michael@0 373 void ReceiveNullableCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);
michael@0 374 void ReceiveWeakCastableObjectSequence(nsTArray<TestInterface*> &);
michael@0 375 void ReceiveWeakNullableCastableObjectSequence(nsTArray<TestInterface*> &);
michael@0 376 void ReceiveWeakCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);
michael@0 377 void ReceiveWeakNullableCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);
michael@0 378 void PassCastableObjectSequence(const Sequence< OwningNonNull<TestInterface> >&);
michael@0 379 void PassNullableCastableObjectSequence(const Sequence< nsRefPtr<TestInterface> > &);
michael@0 380 void PassCastableObjectNullableSequence(const Nullable< Sequence< OwningNonNull<TestInterface> > >&);
michael@0 381 void PassNullableCastableObjectNullableSequence(const Nullable< Sequence< nsRefPtr<TestInterface> > >&);
michael@0 382 void PassOptionalSequence(const Optional<Sequence<int32_t> >&);
michael@0 383 void PassOptionalNullableSequence(const Optional<Nullable<Sequence<int32_t> > >&);
michael@0 384 void PassOptionalNullableSequenceWithDefaultValue(const Nullable< Sequence<int32_t> >&);
michael@0 385 void PassOptionalObjectSequence(const Optional<Sequence<OwningNonNull<TestInterface> > >&);
michael@0 386 void PassExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);
michael@0 387 void PassNullableExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);
michael@0 388
michael@0 389 void ReceiveStringSequence(nsTArray<nsString>&);
michael@0 390 void PassStringSequence(const Sequence<nsString>&);
michael@0 391
michael@0 392 void ReceiveByteStringSequence(nsTArray<nsCString>&);
michael@0 393 void PassByteStringSequence(const Sequence<nsCString>&);
michael@0 394
michael@0 395 void ReceiveAnySequence(JSContext*, nsTArray<JS::Value>&);
michael@0 396 void ReceiveNullableAnySequence(JSContext*, Nullable<nsTArray<JS::Value> >&);
michael@0 397 void ReceiveAnySequenceSequence(JSContext*, nsTArray<nsTArray<JS::Value> >&);
michael@0 398
michael@0 399 void ReceiveObjectSequence(JSContext*, nsTArray<JSObject*>&);
michael@0 400 void ReceiveNullableObjectSequence(JSContext*, nsTArray<JSObject*>&);
michael@0 401
michael@0 402 void PassSequenceOfSequences(const Sequence< Sequence<int32_t> >&);
michael@0 403 void ReceiveSequenceOfSequences(nsTArray< nsTArray<int32_t> >&);
michael@0 404
michael@0 405 // MozMap types
michael@0 406 void PassMozMap(const MozMap<int32_t> &);
michael@0 407 void PassNullableMozMap(const Nullable< MozMap<int32_t> >&);
michael@0 408 void PassMozMapOfNullableInts(const MozMap<Nullable<int32_t> >&);
michael@0 409 void PassOptionalMozMapOfNullableInts(const Optional<MozMap<Nullable<int32_t> > > &);
michael@0 410 void PassOptionalNullableMozMapOfNullableInts(const Optional<Nullable<MozMap<Nullable<int32_t> > > > &);
michael@0 411 void PassCastableObjectMozMap(const MozMap< OwningNonNull<TestInterface> >&);
michael@0 412 void PassNullableCastableObjectMozMap(const MozMap< nsRefPtr<TestInterface> > &);
michael@0 413 void PassCastableObjectNullableMozMap(const Nullable< MozMap< OwningNonNull<TestInterface> > >&);
michael@0 414 void PassNullableCastableObjectNullableMozMap(const Nullable< MozMap< nsRefPtr<TestInterface> > >&);
michael@0 415 void PassOptionalMozMap(const Optional<MozMap<int32_t> >&);
michael@0 416 void PassOptionalNullableMozMap(const Optional<Nullable<MozMap<int32_t> > >&);
michael@0 417 void PassOptionalNullableMozMapWithDefaultValue(const Nullable< MozMap<int32_t> >&);
michael@0 418 void PassOptionalObjectMozMap(const Optional<MozMap<OwningNonNull<TestInterface> > >&);
michael@0 419 void PassExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);
michael@0 420 void PassNullableExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);
michael@0 421 void PassStringMozMap(const MozMap<nsString>&);
michael@0 422 void PassByteStringMozMap(const MozMap<nsCString>&);
michael@0 423 void PassMozMapOfMozMaps(const MozMap< MozMap<int32_t> >&);
michael@0 424 void ReceiveMozMap(MozMap<int32_t>&);
michael@0 425 void ReceiveNullableMozMap(Nullable<MozMap<int32_t>>&);
michael@0 426 void ReceiveMozMapOfNullableInts(MozMap<Nullable<int32_t>>&);
michael@0 427 void ReceiveNullableMozMapOfNullableInts(Nullable<MozMap<Nullable<int32_t>>>&);
michael@0 428 void ReceiveMozMapOfMozMaps(MozMap<MozMap<int32_t>>&);
michael@0 429 void ReceiveAnyMozMap(JSContext*, MozMap<JS::Value>&);
michael@0 430
michael@0 431 // Typed array types
michael@0 432 void PassArrayBuffer(const ArrayBuffer&);
michael@0 433 void PassNullableArrayBuffer(const Nullable<ArrayBuffer>&);
michael@0 434 void PassOptionalArrayBuffer(const Optional<ArrayBuffer>&);
michael@0 435 void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer> >&);
michael@0 436 void PassOptionalNullableArrayBufferWithDefaultValue(const Nullable<ArrayBuffer>&);
michael@0 437 void PassArrayBufferView(const ArrayBufferView&);
michael@0 438 void PassInt8Array(const Int8Array&);
michael@0 439 void PassInt16Array(const Int16Array&);
michael@0 440 void PassInt32Array(const Int32Array&);
michael@0 441 void PassUint8Array(const Uint8Array&);
michael@0 442 void PassUint16Array(const Uint16Array&);
michael@0 443 void PassUint32Array(const Uint32Array&);
michael@0 444 void PassUint8ClampedArray(const Uint8ClampedArray&);
michael@0 445 void PassFloat32Array(const Float32Array&);
michael@0 446 void PassFloat64Array(const Float64Array&);
michael@0 447 void PassSequenceOfArrayBuffers(const Sequence<ArrayBuffer>&);
michael@0 448 void PassSequenceOfNullableArrayBuffers(const Sequence<Nullable<ArrayBuffer> >&);
michael@0 449 void PassMozMapOfArrayBuffers(const MozMap<ArrayBuffer>&);
michael@0 450 void PassMozMapOfNullableArrayBuffers(const MozMap<Nullable<ArrayBuffer> >&);
michael@0 451 void PassVariadicTypedArray(const Sequence<Float32Array>&);
michael@0 452 void PassVariadicNullableTypedArray(const Sequence<Nullable<Float32Array> >&);
michael@0 453 void ReceiveUint8Array(JSContext*, JS::MutableHandle<JSObject*>);
michael@0 454
michael@0 455 // DOMString types
michael@0 456 void PassString(const nsAString&);
michael@0 457 void PassNullableString(const nsAString&);
michael@0 458 void PassOptionalString(const Optional<nsAString>&);
michael@0 459 void PassOptionalStringWithDefaultValue(const nsAString&);
michael@0 460 void PassOptionalNullableString(const Optional<nsAString>&);
michael@0 461 void PassOptionalNullableStringWithDefaultValue(const nsAString&);
michael@0 462 void PassVariadicString(const Sequence<nsString>&);
michael@0 463
michael@0 464 // ByteString types
michael@0 465 void PassByteString(const nsCString&);
michael@0 466 void PassNullableByteString(const nsCString&);
michael@0 467 void PassOptionalByteString(const Optional<nsCString>&);
michael@0 468 void PassOptionalNullableByteString(const Optional<nsCString>&);
michael@0 469 void PassVariadicByteString(const Sequence<nsCString>&);
michael@0 470
michael@0 471 // Enumerated types
michael@0 472 void PassEnum(TestEnum);
michael@0 473 void PassNullableEnum(const Nullable<TestEnum>&);
michael@0 474 void PassOptionalEnum(const Optional<TestEnum>&);
michael@0 475 void PassEnumWithDefault(TestEnum);
michael@0 476 void PassOptionalNullableEnum(const Optional<Nullable<TestEnum> >&);
michael@0 477 void PassOptionalNullableEnumWithDefaultValue(const Nullable<TestEnum>&);
michael@0 478 void PassOptionalNullableEnumWithDefaultValue2(const Nullable<TestEnum>&);
michael@0 479 TestEnum ReceiveEnum();
michael@0 480 Nullable<TestEnum> ReceiveNullableEnum();
michael@0 481 TestEnum EnumAttribute();
michael@0 482 TestEnum ReadonlyEnumAttribute();
michael@0 483 void SetEnumAttribute(TestEnum);
michael@0 484
michael@0 485 // Callback types
michael@0 486 void PassCallback(TestCallback&);
michael@0 487 void PassNullableCallback(TestCallback*);
michael@0 488 void PassOptionalCallback(const Optional<OwningNonNull<TestCallback> >&);
michael@0 489 void PassOptionalNullableCallback(const Optional<nsRefPtr<TestCallback> >&);
michael@0 490 void PassOptionalNullableCallbackWithDefaultValue(TestCallback*);
michael@0 491 already_AddRefed<TestCallback> ReceiveCallback();
michael@0 492 already_AddRefed<TestCallback> ReceiveNullableCallback();
michael@0 493 void PassNullableTreatAsNullCallback(TestTreatAsNullCallback*);
michael@0 494 void PassOptionalNullableTreatAsNullCallback(const Optional<nsRefPtr<TestTreatAsNullCallback> >&);
michael@0 495 void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(TestTreatAsNullCallback*);
michael@0 496 void SetTreatAsNullCallback(TestTreatAsNullCallback&);
michael@0 497 already_AddRefed<TestTreatAsNullCallback> TreatAsNullCallback();
michael@0 498 void SetNullableTreatAsNullCallback(TestTreatAsNullCallback*);
michael@0 499 already_AddRefed<TestTreatAsNullCallback> GetNullableTreatAsNullCallback();
michael@0 500
michael@0 501 // Any types
michael@0 502 void PassAny(JSContext*, JS::Handle<JS::Value>);
michael@0 503 void PassVariadicAny(JSContext*, const Sequence<JS::Value>&);
michael@0 504 void PassOptionalAny(JSContext*, JS::Handle<JS::Value>);
michael@0 505 void PassAnyDefaultNull(JSContext*, JS::Handle<JS::Value>);
michael@0 506 void PassSequenceOfAny(JSContext*, const Sequence<JS::Value>&);
michael@0 507 void PassNullableSequenceOfAny(JSContext*, const Nullable<Sequence<JS::Value> >&);
michael@0 508 void PassOptionalSequenceOfAny(JSContext*, const Optional<Sequence<JS::Value> >&);
michael@0 509 void PassOptionalNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<JS::Value> > >&);
michael@0 510 void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, const Nullable<Sequence<JS::Value> >&);
michael@0 511 void PassSequenceOfSequenceOfAny(JSContext*, const Sequence<Sequence<JS::Value> >&);
michael@0 512 void PassSequenceOfNullableSequenceOfAny(JSContext*, const Sequence<Nullable<Sequence<JS::Value> > >&);
michael@0 513 void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, const Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&);
michael@0 514 void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&);
michael@0 515 void PassMozMapOfAny(JSContext*, const MozMap<JS::Value>&);
michael@0 516 void PassNullableMozMapOfAny(JSContext*, const Nullable<MozMap<JS::Value> >&);
michael@0 517 void PassOptionalMozMapOfAny(JSContext*, const Optional<MozMap<JS::Value> >&);
michael@0 518 void PassOptionalNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<JS::Value> > >&);
michael@0 519 void PassOptionalMozMapOfAnyWithDefaultValue(JSContext*, const Nullable<MozMap<JS::Value> >&);
michael@0 520 void PassMozMapOfMozMapOfAny(JSContext*, const MozMap<MozMap<JS::Value> >&);
michael@0 521 void PassMozMapOfNullableMozMapOfAny(JSContext*, const MozMap<Nullable<MozMap<JS::Value> > >&);
michael@0 522 void PassNullableMozMapOfNullableMozMapOfAny(JSContext*, const Nullable<MozMap<Nullable<MozMap<JS::Value> > > >&);
michael@0 523 void PassOptionalNullableMozMapOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<MozMap<JS::Value>>>>>&);
michael@0 524 void PassOptionalNullableMozMapOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<Sequence<JS::Value>>>>>&);
michael@0 525 void PassOptionalNullableSequenceOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<MozMap<JS::Value>>>>>&);
michael@0 526 void ReceiveAny(JSContext*, JS::MutableHandle<JS::Value>);
michael@0 527
michael@0 528 // object types
michael@0 529 void PassObject(JSContext*, JS::Handle<JSObject*>);
michael@0 530 void PassVariadicObject(JSContext*, const Sequence<JSObject*>&);
michael@0 531 void PassNullableObject(JSContext*, JS::Handle<JSObject*>);
michael@0 532 void PassVariadicNullableObject(JSContext*, const Sequence<JSObject*>&);
michael@0 533 void PassOptionalObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
michael@0 534 void PassOptionalNullableObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);
michael@0 535 void PassOptionalNullableObjectWithDefaultValue(JSContext*, JS::Handle<JSObject*>);
michael@0 536 void PassSequenceOfObject(JSContext*, const Sequence<JSObject*>&);
michael@0 537 void PassSequenceOfNullableObject(JSContext*, const Sequence<JSObject*>&);
michael@0 538 void PassNullableSequenceOfObject(JSContext*, const Nullable<Sequence<JSObject*> >&);
michael@0 539 void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
michael@0 540 void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);
michael@0 541 void PassMozMapOfObject(JSContext*, const MozMap<JSObject*>&);
michael@0 542 void ReceiveObject(JSContext*, JS::MutableHandle<JSObject*>);
michael@0 543 void ReceiveNullableObject(JSContext*, JS::MutableHandle<JSObject*>);
michael@0 544
michael@0 545 // Union types
michael@0 546 void PassUnion(JSContext*, const ObjectOrLong& arg);
michael@0 547 void PassUnionWithNullable(JSContext* cx, const ObjectOrNullOrLong& arg)
michael@0 548 {
michael@0 549 OwningObjectOrLong returnValue;
michael@0 550 if (arg.IsNull()) {
michael@0 551 } else if (arg.IsObject()) {
michael@0 552 JS::Rooted<JSObject*> obj(cx, arg.GetAsObject());
michael@0 553 JS_GetClass(obj);
michael@0 554 returnValue.SetAsObject() = obj;
michael@0 555 } else {
michael@0 556 int32_t i = arg.GetAsLong();
michael@0 557 i += 1;
michael@0 558 returnValue.SetAsLong() = i;
michael@0 559 }
michael@0 560 }
michael@0 561 #ifdef DEBUG
michael@0 562 void PassUnion2(const LongOrBoolean& arg);
michael@0 563 void PassUnion3(JSContext*, const ObjectOrLongOrBoolean& arg);
michael@0 564 void PassUnion4(const NodeOrLongOrBoolean& arg);
michael@0 565 void PassUnion5(JSContext*, const ObjectOrBoolean& arg);
michael@0 566 void PassUnion6(JSContext*, const ObjectOrString& arg);
michael@0 567 void PassUnion7(JSContext*, const ObjectOrStringOrLong& arg);
michael@0 568 void PassUnion8(JSContext*, const ObjectOrStringOrBoolean& arg);
michael@0 569 void PassUnion9(JSContext*, const ObjectOrStringOrLongOrBoolean& arg);
michael@0 570 void PassUnion10(const EventInitOrLong& arg);
michael@0 571 void PassUnion11(JSContext*, const CustomEventInitOrLong& arg);
michael@0 572 void PassUnion12(const EventInitOrLong& arg);
michael@0 573 void PassUnion13(JSContext*, const ObjectOrLongOrNull& arg);
michael@0 574 void PassUnion14(JSContext*, const ObjectOrLongOrNull& arg);
michael@0 575 void PassUnionWithCallback(const EventHandlerNonNullOrNullOrLong& arg);
michael@0 576 #endif
michael@0 577 void PassNullableUnion(JSContext*, const Nullable<ObjectOrLong>&);
michael@0 578 void PassOptionalUnion(JSContext*, const Optional<ObjectOrLong>&);
michael@0 579 void PassOptionalNullableUnion(JSContext*, const Optional<Nullable<ObjectOrLong> >&);
michael@0 580 void PassOptionalNullableUnionWithDefaultValue(JSContext*, const Nullable<ObjectOrLong>&);
michael@0 581 //void PassUnionWithInterfaces(const TestInterfaceOrTestExternalInterface& arg);
michael@0 582 //void PassUnionWithInterfacesAndNullable(const TestInterfaceOrNullOrTestExternalInterface& arg);
michael@0 583 void PassUnionWithArrayBuffer(const ArrayBufferOrLong&);
michael@0 584 void PassUnionWithString(JSContext*, const StringOrObject&);
michael@0 585 //void PassUnionWithEnum(JSContext*, const TestEnumOrObject&);
michael@0 586 //void PassUnionWithCallback(JSContext*, const TestCallbackOrLong&);
michael@0 587 void PassUnionWithObject(JSContext*, const ObjectOrLong&);
michael@0 588
michael@0 589 void PassUnionWithDefaultValue1(const DoubleOrString& arg);
michael@0 590 void PassUnionWithDefaultValue2(const DoubleOrString& arg);
michael@0 591 void PassUnionWithDefaultValue3(const DoubleOrString& arg);
michael@0 592 void PassUnionWithDefaultValue4(const FloatOrString& arg);
michael@0 593 void PassUnionWithDefaultValue5(const FloatOrString& arg);
michael@0 594 void PassUnionWithDefaultValue6(const FloatOrString& arg);
michael@0 595 void PassUnionWithDefaultValue7(const UnrestrictedDoubleOrString& arg);
michael@0 596 void PassUnionWithDefaultValue8(const UnrestrictedDoubleOrString& arg);
michael@0 597 void PassUnionWithDefaultValue9(const UnrestrictedDoubleOrString& arg);
michael@0 598 void PassUnionWithDefaultValue10(const UnrestrictedDoubleOrString& arg);
michael@0 599 void PassUnionWithDefaultValue11(const UnrestrictedFloatOrString& arg);
michael@0 600 void PassUnionWithDefaultValue12(const UnrestrictedFloatOrString& arg);
michael@0 601 void PassUnionWithDefaultValue13(const UnrestrictedFloatOrString& arg);
michael@0 602 void PassUnionWithDefaultValue14(const UnrestrictedFloatOrString& arg);
michael@0 603
michael@0 604 void PassNullableUnionWithDefaultValue1(const Nullable<DoubleOrString>& arg);
michael@0 605 void PassNullableUnionWithDefaultValue2(const Nullable<DoubleOrString>& arg);
michael@0 606 void PassNullableUnionWithDefaultValue3(const Nullable<DoubleOrString>& arg);
michael@0 607 void PassNullableUnionWithDefaultValue4(const Nullable<FloatOrString>& arg);
michael@0 608 void PassNullableUnionWithDefaultValue5(const Nullable<FloatOrString>& arg);
michael@0 609 void PassNullableUnionWithDefaultValue6(const Nullable<FloatOrString>& arg);
michael@0 610 void PassNullableUnionWithDefaultValue7(const Nullable<UnrestrictedDoubleOrString>& arg);
michael@0 611 void PassNullableUnionWithDefaultValue8(const Nullable<UnrestrictedDoubleOrString>& arg);
michael@0 612 void PassNullableUnionWithDefaultValue9(const Nullable<UnrestrictedDoubleOrString>& arg);
michael@0 613 void PassNullableUnionWithDefaultValue10(const Nullable<UnrestrictedFloatOrString>& arg);
michael@0 614 void PassNullableUnionWithDefaultValue11(const Nullable<UnrestrictedFloatOrString>& arg);
michael@0 615 void PassNullableUnionWithDefaultValue12(const Nullable<UnrestrictedFloatOrString>& arg);
michael@0 616
michael@0 617 void PassSequenceOfUnions(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
michael@0 618 void PassSequenceOfUnions2(JSContext*, const Sequence<OwningObjectOrLong>&);
michael@0 619 void PassVariadicUnion(const Sequence<OwningCanvasPatternOrCanvasGradient>&);
michael@0 620
michael@0 621 void PassSequenceOfNullableUnions(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
michael@0 622 void PassVariadicNullableUnion(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);
michael@0 623 void PassMozMapOfUnions(const MozMap<OwningCanvasPatternOrCanvasGradient>&);
michael@0 624 void PassMozMapOfUnions2(JSContext*, const MozMap<OwningObjectOrLong>&);
michael@0 625
michael@0 626 void ReceiveUnion(OwningCanvasPatternOrCanvasGradient&);
michael@0 627 void ReceiveUnion2(JSContext*, OwningObjectOrLong&);
michael@0 628 void ReceiveUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
michael@0 629 void ReceiveNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
michael@0 630 void ReceiveNullableUnion2(JSContext*, Nullable<OwningObjectOrLong>&);
michael@0 631 void GetWritableUnion(OwningCanvasPatternOrCanvasGradient&);
michael@0 632 void SetWritableUnion(const CanvasPatternOrCanvasGradient&);
michael@0 633 void GetWritableUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);
michael@0 634 void SetWritableUnionContainingNull(const CanvasPatternOrNullOrCanvasGradient&);
michael@0 635 void GetWritableNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);
michael@0 636 void SetWritableNullableUnion(const Nullable<CanvasPatternOrCanvasGradient>&);
michael@0 637
michael@0 638 // Date types
michael@0 639 void PassDate(Date);
michael@0 640 void PassNullableDate(const Nullable<Date>&);
michael@0 641 void PassOptionalDate(const Optional<Date>&);
michael@0 642 void PassOptionalNullableDate(const Optional<Nullable<Date> >&);
michael@0 643 void PassOptionalNullableDateWithDefaultValue(const Nullable<Date>&);
michael@0 644 void PassDateSequence(const Sequence<Date>&);
michael@0 645 void PassDateMozMap(const MozMap<Date>&);
michael@0 646 void PassNullableDateSequence(const Sequence<Nullable<Date> >&);
michael@0 647 Date ReceiveDate();
michael@0 648 Nullable<Date> ReceiveNullableDate();
michael@0 649
michael@0 650 // binaryNames tests
michael@0 651 void MethodRenamedTo();
michael@0 652 void MethodRenamedTo(int8_t);
michael@0 653 int8_t AttributeGetterRenamedTo();
michael@0 654 int8_t AttributeRenamedTo();
michael@0 655 void SetAttributeRenamedTo(int8_t);
michael@0 656
michael@0 657 // Dictionary tests
michael@0 658 void PassDictionary(JSContext*, const Dict&);
michael@0 659 void GetReadonlyDictionary(JSContext*, Dict&);
michael@0 660 void GetReadonlyNullableDictionary(JSContext*, Nullable<Dict>&);
michael@0 661 void GetWritableDictionary(JSContext*, Dict&);
michael@0 662 void SetWritableDictionary(JSContext*, const Dict&);
michael@0 663 void GetReadonlyFrozenDictionary(JSContext*, Dict&);
michael@0 664 void GetReadonlyFrozenNullableDictionary(JSContext*, Nullable<Dict>&);
michael@0 665 void GetWritableFrozenDictionary(JSContext*, Dict&);
michael@0 666 void SetWritableFrozenDictionary(JSContext*, const Dict&);
michael@0 667 void ReceiveDictionary(JSContext*, Dict&);
michael@0 668 void ReceiveNullableDictionary(JSContext*, Nullable<Dict>&);
michael@0 669 void PassOtherDictionary(const GrandparentDict&);
michael@0 670 void PassSequenceOfDictionaries(JSContext*, const Sequence<Dict>&);
michael@0 671 void PassMozMapOfDictionaries(const MozMap<GrandparentDict>&);
michael@0 672 void PassDictionaryOrLong(JSContext*, const Dict&);
michael@0 673 void PassDictionaryOrLong(int32_t);
michael@0 674 void PassDictContainingDict(JSContext*, const DictContainingDict&);
michael@0 675 void PassDictContainingSequence(JSContext*, const DictContainingSequence&);
michael@0 676 void ReceiveDictContainingSequence(JSContext*, DictContainingSequence&);
michael@0 677
michael@0 678 // Typedefs
michael@0 679 void ExerciseTypedefInterfaces1(TestInterface&);
michael@0 680 already_AddRefed<TestInterface> ExerciseTypedefInterfaces2(TestInterface*);
michael@0 681 void ExerciseTypedefInterfaces3(TestInterface&);
michael@0 682
michael@0 683 // Static methods and attributes
michael@0 684 static void StaticMethod(const GlobalObject&, bool);
michael@0 685 static void StaticMethodWithContext(const GlobalObject&, JSContext*,
michael@0 686 JS::Value);
michael@0 687 static bool StaticAttribute(const GlobalObject&);
michael@0 688 static void SetStaticAttribute(const GlobalObject&, bool);
michael@0 689
michael@0 690 // Overload resolution tests
michael@0 691 bool Overload1(TestInterface&);
michael@0 692 TestInterface* Overload1(const nsAString&, TestInterface&);
michael@0 693 void Overload2(TestInterface&);
michael@0 694 void Overload2(JSContext*, const Dict&);
michael@0 695 void Overload2(bool);
michael@0 696 void Overload2(const nsAString&);
michael@0 697 void Overload2(Date);
michael@0 698 void Overload3(TestInterface&);
michael@0 699 void Overload3(const TestCallback&);
michael@0 700 void Overload3(bool);
michael@0 701 void Overload4(TestInterface&);
michael@0 702 void Overload4(TestCallbackInterface&);
michael@0 703 void Overload4(const nsAString&);
michael@0 704 void Overload5(int32_t);
michael@0 705 void Overload5(TestEnum);
michael@0 706 void Overload6(int32_t);
michael@0 707 void Overload6(bool);
michael@0 708 void Overload7(int32_t);
michael@0 709 void Overload7(bool);
michael@0 710 void Overload7(const nsCString&);
michael@0 711 void Overload8(int32_t);
michael@0 712 void Overload8(TestInterface&);
michael@0 713 void Overload9(const Nullable<int32_t>&);
michael@0 714 void Overload9(const nsAString&);
michael@0 715 void Overload10(const Nullable<int32_t>&);
michael@0 716 void Overload10(JSContext*, JS::Handle<JSObject*>);
michael@0 717 void Overload11(int32_t);
michael@0 718 void Overload11(const nsAString&);
michael@0 719 void Overload12(int32_t);
michael@0 720 void Overload12(const Nullable<bool>&);
michael@0 721 void Overload13(const Nullable<int32_t>&);
michael@0 722 void Overload13(bool);
michael@0 723 void Overload14(const Optional<int32_t>&);
michael@0 724 void Overload14(TestInterface&);
michael@0 725 void Overload15(int32_t);
michael@0 726 void Overload15(const Optional<NonNull<TestInterface> >&);
michael@0 727 void Overload16(int32_t);
michael@0 728 void Overload16(const Optional<TestInterface*>&);
michael@0 729
michael@0 730 // Variadic handling
michael@0 731 void PassVariadicThirdArg(const nsAString&, int32_t,
michael@0 732 const Sequence<OwningNonNull<TestInterface> >&);
michael@0 733
michael@0 734 // Conditionally exposed methods/attributes
michael@0 735 bool Prefable1();
michael@0 736 bool Prefable2();
michael@0 737 bool Prefable3();
michael@0 738 bool Prefable4();
michael@0 739 bool Prefable5();
michael@0 740 bool Prefable6();
michael@0 741 bool Prefable7();
michael@0 742 bool Prefable8();
michael@0 743 bool Prefable9();
michael@0 744 void Prefable10();
michael@0 745 void Prefable11();
michael@0 746 bool Prefable12();
michael@0 747 void Prefable13();
michael@0 748 bool Prefable14();
michael@0 749 bool Prefable15();
michael@0 750 bool Prefable16();
michael@0 751 void Prefable17();
michael@0 752 void Prefable18();
michael@0 753 void Prefable19();
michael@0 754 void Prefable20();
michael@0 755 void Prefable21();
michael@0 756 void Prefable22();
michael@0 757 void Prefable23();
michael@0 758 void Prefable24();
michael@0 759
michael@0 760 // Miscellania
michael@0 761 int32_t AttrWithLenientThis();
michael@0 762 void SetAttrWithLenientThis(int32_t);
michael@0 763 uint32_t UnforgeableAttr();
michael@0 764 uint32_t UnforgeableAttr2();
michael@0 765 void Stringify(nsString&);
michael@0 766 void PassRenamedInterface(nsRenamedInterface&);
michael@0 767 TestInterface* PutForwardsAttr();
michael@0 768 TestInterface* PutForwardsAttr2();
michael@0 769 TestInterface* PutForwardsAttr3();
michael@0 770 void GetJsonifierShouldSkipThis(JSContext*, JS::MutableHandle<JS::Value>);
michael@0 771 void SetJsonifierShouldSkipThis(JSContext*, JS::Rooted<JS::Value>&);
michael@0 772 TestParentInterface* JsonifierShouldSkipThis2();
michael@0 773 void SetJsonifierShouldSkipThis2(TestParentInterface&);
michael@0 774 TestCallbackInterface* JsonifierShouldSkipThis3();
michael@0 775 void SetJsonifierShouldSkipThis3(TestCallbackInterface&);
michael@0 776 void ThrowingMethod(ErrorResult& aRv);
michael@0 777 bool GetThrowingAttr(ErrorResult& aRv) const;
michael@0 778 void SetThrowingAttr(bool arg, ErrorResult& aRv);
michael@0 779 bool GetThrowingGetterAttr(ErrorResult& aRv) const;
michael@0 780 void SetThrowingGetterAttr(bool arg);
michael@0 781 bool ThrowingSetterAttr() const;
michael@0 782 void SetThrowingSetterAttr(bool arg, ErrorResult& aRv);
michael@0 783 int16_t LegacyCall(JS::Value, uint32_t, TestInterface&);
michael@0 784 void PassArgsWithDefaults(JSContext*, const Optional<int32_t>&,
michael@0 785 TestInterface*, const Dict&, double,
michael@0 786 const Optional<float>&);
michael@0 787
michael@0 788 // Methods and properties imported via "implements"
michael@0 789 bool ImplementedProperty();
michael@0 790 void SetImplementedProperty(bool);
michael@0 791 void ImplementedMethod();
michael@0 792 bool ImplementedParentProperty();
michael@0 793 void SetImplementedParentProperty(bool);
michael@0 794 void ImplementedParentMethod();
michael@0 795 bool IndirectlyImplementedProperty();
michael@0 796 void SetIndirectlyImplementedProperty(bool);
michael@0 797 void IndirectlyImplementedMethod();
michael@0 798 uint32_t DiamondImplementedProperty();
michael@0 799
michael@0 800 // Test EnforceRange/Clamp
michael@0 801 void DontEnforceRangeOrClamp(int8_t);
michael@0 802 void DoEnforceRange(int8_t);
michael@0 803 void DoClamp(int8_t);
michael@0 804 void SetEnforcedByte(int8_t);
michael@0 805 int8_t EnforcedByte();
michael@0 806 void SetClampedByte(int8_t);
michael@0 807 int8_t ClampedByte();
michael@0 808
michael@0 809 private:
michael@0 810 // We add signatures here that _could_ start matching if the codegen
michael@0 811 // got data types wrong. That way if it ever does we'll have a call
michael@0 812 // to these private deleted methods and compilation will fail.
michael@0 813 void SetReadonlyByte(int8_t) MOZ_DELETE;
michael@0 814 template<typename T>
michael@0 815 void SetWritableByte(T) MOZ_DELETE;
michael@0 816 template<typename T>
michael@0 817 void PassByte(T) MOZ_DELETE;
michael@0 818 void PassNullableByte(Nullable<int8_t>&) MOZ_DELETE;
michael@0 819 template<typename T>
michael@0 820 void PassOptionalByte(const Optional<T>&) MOZ_DELETE;
michael@0 821 template<typename T>
michael@0 822 void PassOptionalByteWithDefault(T) MOZ_DELETE;
michael@0 823 void PassVariadicByte(Sequence<int8_t>&) MOZ_DELETE;
michael@0 824
michael@0 825 void SetReadonlyShort(int16_t) MOZ_DELETE;
michael@0 826 template<typename T>
michael@0 827 void SetWritableShort(T) MOZ_DELETE;
michael@0 828 template<typename T>
michael@0 829 void PassShort(T) MOZ_DELETE;
michael@0 830 template<typename T>
michael@0 831 void PassOptionalShort(const Optional<T>&) MOZ_DELETE;
michael@0 832 template<typename T>
michael@0 833 void PassOptionalShortWithDefault(T) MOZ_DELETE;
michael@0 834
michael@0 835 void SetReadonlyLong(int32_t) MOZ_DELETE;
michael@0 836 template<typename T>
michael@0 837 void SetWritableLong(T) MOZ_DELETE;
michael@0 838 template<typename T>
michael@0 839 void PassLong(T) MOZ_DELETE;
michael@0 840 template<typename T>
michael@0 841 void PassOptionalLong(const Optional<T>&) MOZ_DELETE;
michael@0 842 template<typename T>
michael@0 843 void PassOptionalLongWithDefault(T) MOZ_DELETE;
michael@0 844
michael@0 845 void SetReadonlyLongLong(int64_t) MOZ_DELETE;
michael@0 846 template<typename T>
michael@0 847 void SetWritableLongLong(T) MOZ_DELETE;
michael@0 848 template<typename T>
michael@0 849 void PassLongLong(T) MOZ_DELETE;
michael@0 850 template<typename T>
michael@0 851 void PassOptionalLongLong(const Optional<T>&) MOZ_DELETE;
michael@0 852 template<typename T>
michael@0 853 void PassOptionalLongLongWithDefault(T) MOZ_DELETE;
michael@0 854
michael@0 855 void SetReadonlyOctet(uint8_t) MOZ_DELETE;
michael@0 856 template<typename T>
michael@0 857 void SetWritableOctet(T) MOZ_DELETE;
michael@0 858 template<typename T>
michael@0 859 void PassOctet(T) MOZ_DELETE;
michael@0 860 template<typename T>
michael@0 861 void PassOptionalOctet(const Optional<T>&) MOZ_DELETE;
michael@0 862 template<typename T>
michael@0 863 void PassOptionalOctetWithDefault(T) MOZ_DELETE;
michael@0 864
michael@0 865 void SetReadonlyUnsignedShort(uint16_t) MOZ_DELETE;
michael@0 866 template<typename T>
michael@0 867 void SetWritableUnsignedShort(T) MOZ_DELETE;
michael@0 868 template<typename T>
michael@0 869 void PassUnsignedShort(T) MOZ_DELETE;
michael@0 870 template<typename T>
michael@0 871 void PassOptionalUnsignedShort(const Optional<T>&) MOZ_DELETE;
michael@0 872 template<typename T>
michael@0 873 void PassOptionalUnsignedShortWithDefault(T) MOZ_DELETE;
michael@0 874
michael@0 875 void SetReadonlyUnsignedLong(uint32_t) MOZ_DELETE;
michael@0 876 template<typename T>
michael@0 877 void SetWritableUnsignedLong(T) MOZ_DELETE;
michael@0 878 template<typename T>
michael@0 879 void PassUnsignedLong(T) MOZ_DELETE;
michael@0 880 template<typename T>
michael@0 881 void PassOptionalUnsignedLong(const Optional<T>&) MOZ_DELETE;
michael@0 882 template<typename T>
michael@0 883 void PassOptionalUnsignedLongWithDefault(T) MOZ_DELETE;
michael@0 884
michael@0 885 void SetReadonlyUnsignedLongLong(uint64_t) MOZ_DELETE;
michael@0 886 template<typename T>
michael@0 887 void SetWritableUnsignedLongLong(T) MOZ_DELETE;
michael@0 888 template<typename T>
michael@0 889 void PassUnsignedLongLong(T) MOZ_DELETE;
michael@0 890 template<typename T>
michael@0 891 void PassOptionalUnsignedLongLong(const Optional<T>&) MOZ_DELETE;
michael@0 892 template<typename T>
michael@0 893 void PassOptionalUnsignedLongLongWithDefault(T) MOZ_DELETE;
michael@0 894
michael@0 895 // Enforce that only const things are passed for sequences
michael@0 896 void PassSequence(Sequence<int32_t> &) MOZ_DELETE;
michael@0 897 void PassNullableSequence(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
michael@0 898 void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) MOZ_DELETE;
michael@0 899 void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
michael@0 900 void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0 901 void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0 902 void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
michael@0 903 void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0 904 void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) MOZ_DELETE;
michael@0 905 void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;
michael@0 906 void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) MOZ_DELETE;
michael@0 907 void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) MOZ_DELETE;
michael@0 908 void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0 909 void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0 910 void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
michael@0 911 void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;
michael@0 912
michael@0 913 // Enforce that only const things are passed for optional
michael@0 914 void PassOptionalByte(Optional<int8_t>&) MOZ_DELETE;
michael@0 915 void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) MOZ_DELETE;
michael@0 916 void PassOptionalShort(Optional<int16_t>&) MOZ_DELETE;
michael@0 917 void PassOptionalLong(Optional<int32_t>&) MOZ_DELETE;
michael@0 918 void PassOptionalLongLong(Optional<int64_t>&) MOZ_DELETE;
michael@0 919 void PassOptionalOctet(Optional<uint8_t>&) MOZ_DELETE;
michael@0 920 void PassOptionalUnsignedShort(Optional<uint16_t>&) MOZ_DELETE;
michael@0 921 void PassOptionalUnsignedLong(Optional<uint32_t>&) MOZ_DELETE;
michael@0 922 void PassOptionalUnsignedLongLong(Optional<uint64_t>&) MOZ_DELETE;
michael@0 923 void PassOptionalSelf(Optional<TestInterface*> &) MOZ_DELETE;
michael@0 924 void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) MOZ_DELETE;
michael@0 925 void PassOptionalOther(Optional<IndirectlyImplementedInterface*>&);
michael@0 926 void PassOptionalNonNullOther(Optional<NonNull<IndirectlyImplementedInterface> >&);
michael@0 927 void PassOptionalExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
michael@0 928 void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;
michael@0 929 void PassOptionalSequence(Optional<Sequence<int32_t> >&) MOZ_DELETE;
michael@0 930 void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) MOZ_DELETE;
michael@0 931 void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) MOZ_DELETE;
michael@0 932 void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) MOZ_DELETE;
michael@0 933 void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) MOZ_DELETE;
michael@0 934 void PassOptionalEnum(Optional<TestEnum>&) MOZ_DELETE;
michael@0 935 void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) MOZ_DELETE;
michael@0 936 void PassOptionalNullableCallback(JSContext*, Optional<nsRefPtr<TestCallback> >&) MOZ_DELETE;
michael@0 937 void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) MOZ_DELETE;
michael@0 938
michael@0 939 // And test that string stuff is always const
michael@0 940 void PassString(nsAString&) MOZ_DELETE;
michael@0 941 void PassNullableString(nsAString&) MOZ_DELETE;
michael@0 942 void PassOptionalString(Optional<nsAString>&) MOZ_DELETE;
michael@0 943 void PassOptionalStringWithDefaultValue(nsAString&) MOZ_DELETE;
michael@0 944 void PassOptionalNullableString(Optional<nsAString>&) MOZ_DELETE;
michael@0 945 void PassOptionalNullableStringWithDefaultValue(nsAString&) MOZ_DELETE;
michael@0 946 void PassVariadicString(Sequence<nsString>&) MOZ_DELETE;
michael@0 947
michael@0 948 // cstrings should be const as well
michael@0 949 void PassByteString(nsCString&) MOZ_DELETE;
michael@0 950 void PassNullableByteString(nsCString&) MOZ_DELETE;
michael@0 951 void PassOptionalByteString(Optional<nsCString>&) MOZ_DELETE;
michael@0 952 void PassOptionalNullableByteString(Optional<nsCString>&) MOZ_DELETE;
michael@0 953 void PassVariadicByteString(Sequence<nsCString>&) MOZ_DELETE;
michael@0 954
michael@0 955 // Make sure dictionary arguments are always const
michael@0 956 void PassDictionary(JSContext*, Dict&) MOZ_DELETE;
michael@0 957 void PassOtherDictionary(GrandparentDict&) MOZ_DELETE;
michael@0 958 void PassSequenceOfDictionaries(JSContext*, Sequence<Dict>&) MOZ_DELETE;
michael@0 959 void PassDictionaryOrLong(JSContext*, Dict&) MOZ_DELETE;
michael@0 960 void PassDictContainingDict(JSContext*, DictContainingDict&) MOZ_DELETE;
michael@0 961 void PassDictContainingSequence(DictContainingSequence&) MOZ_DELETE;
michael@0 962
michael@0 963 // Make sure various nullable things are always const
michael@0 964 void PassNullableEnum(Nullable<TestEnum>&) MOZ_DELETE;
michael@0 965
michael@0 966 // Make sure unions are always const
michael@0 967 void PassUnion(JSContext*, ObjectOrLong& arg) MOZ_DELETE;
michael@0 968 void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) MOZ_DELETE;
michael@0 969 void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
michael@0 970 void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) MOZ_DELETE;
michael@0 971 void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) MOZ_DELETE;
michael@0 972 void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;
michael@0 973
michael@0 974 // Make sure various date stuff is const as needed
michael@0 975 void PassNullableDate(Nullable<Date>&) MOZ_DELETE;
michael@0 976 void PassOptionalDate(Optional<Date>&) MOZ_DELETE;
michael@0 977 void PassOptionalNullableDate(Optional<Nullable<Date> >&) MOZ_DELETE;
michael@0 978 void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) MOZ_DELETE;
michael@0 979 void PassDateSequence(Sequence<Date>&) MOZ_DELETE;
michael@0 980 void PassNullableDateSequence(Sequence<Nullable<Date> >&) MOZ_DELETE;
michael@0 981
michael@0 982 // Make sure variadics are const as needed
michael@0 983 void PassVariadicAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;
michael@0 984 void PassVariadicObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0 985 void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;
michael@0 986
michael@0 987 // Ensure NonNull does not leak in
michael@0 988 void PassSelf(NonNull<TestInterface>&) MOZ_DELETE;
michael@0 989 void PassSelf(OwningNonNull<TestInterface>&) MOZ_DELETE;
michael@0 990 void PassSelf(const NonNull<TestInterface>&) MOZ_DELETE;
michael@0 991 void PassSelf(const OwningNonNull<TestInterface>&) MOZ_DELETE;
michael@0 992 void PassOther(NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0 993 void PassOther(const NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0 994 void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0 995 void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;
michael@0 996 void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0 997 void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0 998 void PassCallbackInterface(NonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0 999 void PassCallbackInterface(const NonNull<TestCallbackInterface>&) MOZ_DELETE;
michael@0 1000 void PassCallback(OwningNonNull<TestCallback>&) MOZ_DELETE;
michael@0 1001 void PassCallback(const OwningNonNull<TestCallback>&) MOZ_DELETE;
michael@0 1002 void PassCallback(NonNull<TestCallback>&) MOZ_DELETE;
michael@0 1003 void PassCallback(const NonNull<TestCallback>&) MOZ_DELETE;
michael@0 1004 void PassString(const NonNull<nsAString>&) MOZ_DELETE;
michael@0 1005 void PassString(NonNull<nsAString>&) MOZ_DELETE;
michael@0 1006 void PassString(const OwningNonNull<nsAString>&) MOZ_DELETE;
michael@0 1007 void PassString(OwningNonNull<nsAString>&) MOZ_DELETE;
michael@0 1008 };
michael@0 1009
michael@0 1010 class TestIndexedGetterInterface : public nsISupports,
michael@0 1011 public nsWrapperCache
michael@0 1012 {
michael@0 1013 public:
michael@0 1014 NS_DECL_ISUPPORTS
michael@0 1015
michael@0 1016 // We need a GetParentObject to make binding codegen happy
michael@0 1017 virtual nsISupports* GetParentObject();
michael@0 1018
michael@0 1019 uint32_t IndexedGetter(uint32_t, bool&);
michael@0 1020 uint32_t IndexedGetter(uint32_t&) MOZ_DELETE;
michael@0 1021 uint32_t Item(uint32_t&);
michael@0 1022 uint32_t Item(uint32_t, bool&) MOZ_DELETE;
michael@0 1023 uint32_t Length();
michael@0 1024 void LegacyCall(JS::Handle<JS::Value>);
michael@0 1025 };
michael@0 1026
michael@0 1027 class TestNamedGetterInterface : public nsISupports,
michael@0 1028 public nsWrapperCache
michael@0 1029 {
michael@0 1030 public:
michael@0 1031 NS_DECL_ISUPPORTS
michael@0 1032
michael@0 1033 // We need a GetParentObject to make binding codegen happy
michael@0 1034 virtual nsISupports* GetParentObject();
michael@0 1035
michael@0 1036 void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0 1037 bool NameIsEnumerable(const nsAString&);
michael@0 1038 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1039 };
michael@0 1040
michael@0 1041 class TestIndexedGetterAndSetterAndNamedGetterInterface : public nsISupports,
michael@0 1042 public nsWrapperCache
michael@0 1043 {
michael@0 1044 public:
michael@0 1045 NS_DECL_ISUPPORTS
michael@0 1046
michael@0 1047 // We need a GetParentObject to make binding codegen happy
michael@0 1048 virtual nsISupports* GetParentObject();
michael@0 1049
michael@0 1050 void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0 1051 bool NameIsEnumerable(const nsAString&);
michael@0 1052 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1053 int32_t IndexedGetter(uint32_t, bool&);
michael@0 1054 void IndexedSetter(uint32_t, int32_t);
michael@0 1055 uint32_t Length();
michael@0 1056 };
michael@0 1057
michael@0 1058 class TestIndexedAndNamedGetterInterface : public nsISupports,
michael@0 1059 public nsWrapperCache
michael@0 1060 {
michael@0 1061 public:
michael@0 1062 NS_DECL_ISUPPORTS
michael@0 1063
michael@0 1064 // We need a GetParentObject to make binding codegen happy
michael@0 1065 virtual nsISupports* GetParentObject();
michael@0 1066
michael@0 1067 uint32_t IndexedGetter(uint32_t, bool&);
michael@0 1068 void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0 1069 bool NameIsEnumerable(const nsAString&);
michael@0 1070 void NamedItem(const nsAString&, nsAString&);
michael@0 1071 uint32_t Length();
michael@0 1072 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1073 };
michael@0 1074
michael@0 1075 class TestIndexedSetterInterface : public nsISupports,
michael@0 1076 public nsWrapperCache
michael@0 1077 {
michael@0 1078 public:
michael@0 1079 NS_DECL_ISUPPORTS
michael@0 1080
michael@0 1081 // We need a GetParentObject to make binding codegen happy
michael@0 1082 virtual nsISupports* GetParentObject();
michael@0 1083
michael@0 1084 void IndexedSetter(uint32_t, const nsAString&);
michael@0 1085 void IndexedGetter(uint32_t, bool&, nsString&);
michael@0 1086 uint32_t Length();
michael@0 1087 void SetItem(uint32_t, const nsAString&);
michael@0 1088 };
michael@0 1089
michael@0 1090 class TestNamedSetterInterface : public nsISupports,
michael@0 1091 public nsWrapperCache
michael@0 1092 {
michael@0 1093 public:
michael@0 1094 NS_DECL_ISUPPORTS
michael@0 1095
michael@0 1096 // We need a GetParentObject to make binding codegen happy
michael@0 1097 virtual nsISupports* GetParentObject();
michael@0 1098
michael@0 1099 void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
michael@0 1100 TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
michael@0 1101 bool NameIsEnumerable(const nsAString&);
michael@0 1102 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1103 };
michael@0 1104
michael@0 1105 class TestIndexedAndNamedSetterInterface : public nsISupports,
michael@0 1106 public nsWrapperCache
michael@0 1107 {
michael@0 1108 public:
michael@0 1109 NS_DECL_ISUPPORTS
michael@0 1110
michael@0 1111 // We need a GetParentObject to make binding codegen happy
michael@0 1112 virtual nsISupports* GetParentObject();
michael@0 1113
michael@0 1114 void IndexedSetter(uint32_t, TestIndexedSetterInterface&);
michael@0 1115 TestIndexedSetterInterface* IndexedGetter(uint32_t, bool&);
michael@0 1116 uint32_t Length();
michael@0 1117 void NamedSetter(const nsAString&, TestIndexedSetterInterface&);
michael@0 1118 TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);
michael@0 1119 bool NameIsEnumerable(const nsAString&);
michael@0 1120 void SetNamedItem(const nsAString&, TestIndexedSetterInterface&);
michael@0 1121 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1122 };
michael@0 1123
michael@0 1124 class TestIndexedAndNamedGetterAndSetterInterface : public TestIndexedSetterInterface
michael@0 1125 {
michael@0 1126 public:
michael@0 1127 uint32_t IndexedGetter(uint32_t, bool&);
michael@0 1128 uint32_t Item(uint32_t);
michael@0 1129 void NamedGetter(const nsAString&, bool&, nsAString&);
michael@0 1130 bool NameIsEnumerable(const nsAString&);
michael@0 1131 void NamedItem(const nsAString&, nsAString&);
michael@0 1132 void IndexedSetter(uint32_t, int32_t&);
michael@0 1133 void IndexedSetter(uint32_t, const nsAString&) MOZ_DELETE;
michael@0 1134 void NamedSetter(const nsAString&, const nsAString&);
michael@0 1135 void Stringify(nsAString&);
michael@0 1136 uint32_t Length();
michael@0 1137 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1138 };
michael@0 1139
michael@0 1140 class TestCppKeywordNamedMethodsInterface : public nsISupports,
michael@0 1141 public nsWrapperCache
michael@0 1142 {
michael@0 1143 public:
michael@0 1144 NS_DECL_ISUPPORTS
michael@0 1145
michael@0 1146 // We need a GetParentObject to make binding codegen happy
michael@0 1147 virtual nsISupports* GetParentObject();
michael@0 1148
michael@0 1149 bool Continue();
michael@0 1150 bool Delete();
michael@0 1151 int32_t Volatile();
michael@0 1152 };
michael@0 1153
michael@0 1154 class TestIndexedDeleterInterface : public nsISupports,
michael@0 1155 public nsWrapperCache
michael@0 1156 {
michael@0 1157 public:
michael@0 1158 NS_DECL_ISUPPORTS
michael@0 1159
michael@0 1160 // We need a GetParentObject to make binding codegen happy
michael@0 1161 virtual nsISupports* GetParentObject();
michael@0 1162
michael@0 1163 void IndexedDeleter(uint32_t, bool&);
michael@0 1164 void IndexedDeleter(uint32_t) MOZ_DELETE;
michael@0 1165 long IndexedGetter(uint32_t, bool&);
michael@0 1166 uint32_t Length();
michael@0 1167 void DelItem(uint32_t);
michael@0 1168 void DelItem(uint32_t, bool&) MOZ_DELETE;
michael@0 1169 };
michael@0 1170
michael@0 1171 class TestIndexedDeleterWithRetvalInterface : public nsISupports,
michael@0 1172 public nsWrapperCache
michael@0 1173 {
michael@0 1174 public:
michael@0 1175 NS_DECL_ISUPPORTS
michael@0 1176
michael@0 1177 // We need a GetParentObject to make binding codegen happy
michael@0 1178 virtual nsISupports* GetParentObject();
michael@0 1179
michael@0 1180 bool IndexedDeleter(uint32_t, bool&);
michael@0 1181 bool IndexedDeleter(uint32_t) MOZ_DELETE;
michael@0 1182 long IndexedGetter(uint32_t, bool&);
michael@0 1183 uint32_t Length();
michael@0 1184 bool DelItem(uint32_t);
michael@0 1185 bool DelItem(uint32_t, bool&) MOZ_DELETE;
michael@0 1186 };
michael@0 1187
michael@0 1188 class TestNamedDeleterInterface : public nsISupports,
michael@0 1189 public nsWrapperCache
michael@0 1190 {
michael@0 1191 public:
michael@0 1192 NS_DECL_ISUPPORTS
michael@0 1193
michael@0 1194 // We need a GetParentObject to make binding codegen happy
michael@0 1195 virtual nsISupports* GetParentObject();
michael@0 1196
michael@0 1197 void NamedDeleter(const nsAString&, bool&);
michael@0 1198 long NamedGetter(const nsAString&, bool&);
michael@0 1199 bool NameIsEnumerable(const nsAString&);
michael@0 1200 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1201 };
michael@0 1202
michael@0 1203 class TestNamedDeleterWithRetvalInterface : public nsISupports,
michael@0 1204 public nsWrapperCache
michael@0 1205 {
michael@0 1206 public:
michael@0 1207 NS_DECL_ISUPPORTS
michael@0 1208
michael@0 1209 // We need a GetParentObject to make binding codegen happy
michael@0 1210 virtual nsISupports* GetParentObject();
michael@0 1211
michael@0 1212 bool NamedDeleter(const nsAString&, bool&);
michael@0 1213 bool NamedDeleter(const nsAString&) MOZ_DELETE;
michael@0 1214 long NamedGetter(const nsAString&, bool&);
michael@0 1215 bool NameIsEnumerable(const nsAString&);
michael@0 1216 bool DelNamedItem(const nsAString&);
michael@0 1217 bool DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
michael@0 1218 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1219 };
michael@0 1220
michael@0 1221 class TestIndexedAndNamedDeleterInterface : public nsISupports,
michael@0 1222 public nsWrapperCache
michael@0 1223 {
michael@0 1224 public:
michael@0 1225 NS_DECL_ISUPPORTS
michael@0 1226
michael@0 1227 // We need a GetParentObject to make binding codegen happy
michael@0 1228 virtual nsISupports* GetParentObject();
michael@0 1229
michael@0 1230 void IndexedDeleter(uint32_t, bool&);
michael@0 1231 long IndexedGetter(uint32_t, bool&);
michael@0 1232 uint32_t Length();
michael@0 1233
michael@0 1234 void NamedDeleter(const nsAString&, bool&);
michael@0 1235 void NamedDeleter(const nsAString&) MOZ_DELETE;
michael@0 1236 long NamedGetter(const nsAString&, bool&);
michael@0 1237 bool NameIsEnumerable(const nsAString&);
michael@0 1238 void DelNamedItem(const nsAString&);
michael@0 1239 void DelNamedItem(const nsAString&, bool&) MOZ_DELETE;
michael@0 1240 void GetSupportedNames(unsigned, nsTArray<nsString>&);
michael@0 1241 };
michael@0 1242
michael@0 1243 class TestParentInterface : public nsISupports,
michael@0 1244 public nsWrapperCache
michael@0 1245 {
michael@0 1246 public:
michael@0 1247 NS_DECL_ISUPPORTS
michael@0 1248
michael@0 1249 // We need a GetParentObject to make binding codegen happy
michael@0 1250 virtual nsISupports* GetParentObject();
michael@0 1251 };
michael@0 1252
michael@0 1253 class TestChildInterface : public TestParentInterface
michael@0 1254 {
michael@0 1255 };
michael@0 1256
michael@0 1257 } // namespace dom
michael@0 1258 } // namespace mozilla
michael@0 1259
michael@0 1260 #endif /* TestBindingHeader_h */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial