The Tor Browser: dom/bindings/test/TestBindingHeader.h@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

     2 /* This Source Code Form is subject to the terms of the Mozilla Public

     3  * License, v. 2.0. If a copy of the MPL was not distributed with this file,

     4  * You can obtain one at http://mozilla.org/MPL/2.0/.

     5  */

     7 #ifndef TestBindingHeader_h

     8 #define TestBindingHeader_h

    10 #include "mozilla/dom/BindingUtils.h"

    11 #include "mozilla/dom/Date.h"

    12 #include "mozilla/dom/MozMap.h"

    13 #include "mozilla/dom/TypedArray.h"

    14 #include "mozilla/dom/UnionTypes.h"

    15 #include "mozilla/ErrorResult.h"

    16 #include "nsCOMPtr.h"

    17 #include "nsGenericHTMLElement.h"

    18 #include "nsWrapperCache.h"

    20 // Forward declare this before we include TestCodeGenBinding.h, because that header relies on including

    21 // this one for it, for ParentDict. Hopefully it won't begin to rely on it in more fundamental ways.

    22 namespace mozilla {

    23 namespace dom {

    24 class TestExternalInterface;

    25 } // namespace dom

    26 } // namespace mozilla

    28 // We don't export TestCodeGenBinding.h, but it's right in our parent dir.

    29 #include "../TestCodeGenBinding.h"

    31 extern bool TestFuncControlledMember(JSContext*, JSObject*);

    33 namespace mozilla {

    34 namespace dom {

    36 // IID for nsRenamedInterface

    37 #define NS_RENAMED_INTERFACE_IID \

    38 { 0xd4b19ef3, 0xe68b, 0x4e3f, \

    39  { 0x94, 0xbc, 0xc9, 0xde, 0x3a, 0x69, 0xb0, 0xe8 } }

    41 class nsRenamedInterface : public nsISupports,

    42                            public nsWrapperCache

    43 {

    44 public:

    45   NS_DECLARE_STATIC_IID_ACCESSOR(NS_RENAMED_INTERFACE_IID)

    46   NS_DECL_ISUPPORTS

    48   // We need a GetParentObject to make binding codegen happy

    49   virtual nsISupports* GetParentObject();

    50 };

    52 NS_DEFINE_STATIC_IID_ACCESSOR(nsRenamedInterface, NS_RENAMED_INTERFACE_IID)

    54 // IID for the IndirectlyImplementedInterface

    55 #define NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID \

    56 { 0xfed55b69, 0x7012, 0x4849, \

    57  { 0xaf, 0x56, 0x4b, 0xa9, 0xee, 0x41, 0x30, 0x89 } }

    59 class IndirectlyImplementedInterface : public nsISupports,

    60                                        public nsWrapperCache

    61 {

    62 public:

    63   NS_DECLARE_STATIC_IID_ACCESSOR(NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)

    64   NS_DECL_ISUPPORTS

    66   // We need a GetParentObject to make binding codegen happy

    67   virtual nsISupports* GetParentObject();

    69   bool IndirectlyImplementedProperty();

    70   void IndirectlyImplementedProperty(bool);

    71   void IndirectlyImplementedMethod();

    72 };

    74 NS_DEFINE_STATIC_IID_ACCESSOR(IndirectlyImplementedInterface, NS_INDIRECTLY_IMPLEMENTED_INTERFACE_IID)

    76 // IID for the TestExternalInterface

    77 #define NS_TEST_EXTERNAL_INTERFACE_IID \

    78 { 0xd5ba0c99, 0x9b1d, 0x4e71, \

    79  { 0x8a, 0x94, 0x56, 0x38, 0x6c, 0xa3, 0xda, 0x3d } }

    80 class TestExternalInterface : public nsISupports

    81 {

    82 public:

    83   NS_DECLARE_STATIC_IID_ACCESSOR(NS_TEST_EXTERNAL_INTERFACE_IID)

    84   NS_DECL_ISUPPORTS

    85 };

    87 NS_DEFINE_STATIC_IID_ACCESSOR(TestExternalInterface, NS_TEST_EXTERNAL_INTERFACE_IID)

    89 class TestNonWrapperCacheInterface : public nsISupports

    90 {

    91 public:

    92   NS_DECL_ISUPPORTS

    94   virtual JSObject* WrapObject(JSContext* cx);

    95 };

    97 class OnlyForUseInConstructor : public nsISupports,

    98                                 public nsWrapperCache

    99 {

   100 public:

   101   NS_DECL_ISUPPORTS

   102   // We need a GetParentObject to make binding codegen happy

   103   virtual nsISupports* GetParentObject();

   104 };

   106 class TestInterface : public nsISupports,

   107                       public nsWrapperCache

   108 {

   109 public:

   110   NS_DECL_ISUPPORTS

   112   // We need a GetParentObject to make binding codegen happy

   113   virtual nsISupports* GetParentObject();

   115   // And now our actual WebIDL API

   116   // Constructors

   117   static

   118   already_AddRefed<TestInterface>

   119     Constructor(const GlobalObject&, ErrorResult&);

   120   static

   121   already_AddRefed<TestInterface>

   122     Constructor(const GlobalObject&, const nsAString&, ErrorResult&);

   123   static

   124   already_AddRefed<TestInterface>

   125     Constructor(const GlobalObject&, uint32_t, const Nullable<bool>&,

   126                 ErrorResult&);

   127   static

   128   already_AddRefed<TestInterface>

   129     Constructor(const GlobalObject&, TestInterface*, ErrorResult&);

   130   static

   131   already_AddRefed<TestInterface>

   132     Constructor(const GlobalObject&, uint32_t, IndirectlyImplementedInterface&, ErrorResult&);

   134   static

   135   already_AddRefed<TestInterface>

   136     Constructor(const GlobalObject&, Date&, ErrorResult&);

   137   /*  static

   138   already_AddRefed<TestInterface>

   139     Constructor(const GlobalObject&, uint32_t, uint32_t,

   140                 const TestInterfaceOrOnlyForUseInConstructor&, ErrorResult&);

   141   */

   143   static

   144   already_AddRefed<TestInterface> Test(const GlobalObject&, ErrorResult&);

   145   static

   146   already_AddRefed<TestInterface> Test(const GlobalObject&, const nsAString&,

   147                                        ErrorResult&);

   148   static

   149   already_AddRefed<TestInterface> Test(const GlobalObject&, const nsACString&,

   150                                        ErrorResult&);

   152   static

   153   already_AddRefed<TestInterface> Test2(const GlobalObject&,

   154                                         JSContext*,

   155                                         const DictForConstructor&,

   156                                         JS::Handle<JS::Value>,

   157                                         JS::Handle<JSObject*>,

   158                                         JS::Handle<JSObject*>,

   159                                         const Sequence<Dict>&,

   160                                         JS::Handle<JS::Value>,

   161                                         const Optional<JS::Handle<JSObject*> >&,

   162                                         const Optional<JS::Handle<JSObject*> >&,

   163                                         ErrorResult&);

   165   // Integer types

   166   int8_t ReadonlyByte();

   167   int8_t WritableByte();

   168   void SetWritableByte(int8_t);

   169   void PassByte(int8_t);

   170   int8_t ReceiveByte();

   171   void PassOptionalByte(const Optional<int8_t>&);

   172   void PassOptionalByteBeforeRequired(const Optional<int8_t>&, int8_t);

   173   void PassOptionalByteWithDefault(int8_t);

   174   void PassOptionalByteWithDefaultBeforeRequired(int8_t, int8_t);

   175   void PassNullableByte(const Nullable<int8_t>&);

   176   void PassOptionalNullableByte(const Optional< Nullable<int8_t> >&);

   177   void PassVariadicByte(const Sequence<int8_t>&);

   178   int8_t CachedByte();

   179   int8_t CachedConstantByte();

   180   int8_t CachedWritableByte();

   181   void SetCachedWritableByte(int8_t);

   183   int16_t ReadonlyShort();

   184   int16_t WritableShort();

   185   void SetWritableShort(int16_t);

   186   void PassShort(int16_t);

   187   int16_t ReceiveShort();

   188   void PassOptionalShort(const Optional<int16_t>&);

   189   void PassOptionalShortWithDefault(int16_t);

   191   int32_t ReadonlyLong();

   192   int32_t WritableLong();

   193   void SetWritableLong(int32_t);

   194   void PassLong(int32_t);

   195   int16_t ReceiveLong();

   196   void PassOptionalLong(const Optional<int32_t>&);

   197   void PassOptionalLongWithDefault(int32_t);

   199   int64_t ReadonlyLongLong();

   200   int64_t WritableLongLong();

   201   void SetWritableLongLong(int64_t);

   202   void PassLongLong(int64_t);

   203   int64_t ReceiveLongLong();

   204   void PassOptionalLongLong(const Optional<int64_t>&);

   205   void PassOptionalLongLongWithDefault(int64_t);

   207   uint8_t ReadonlyOctet();

   208   uint8_t WritableOctet();

   209   void SetWritableOctet(uint8_t);

   210   void PassOctet(uint8_t);

   211   uint8_t ReceiveOctet();

   212   void PassOptionalOctet(const Optional<uint8_t>&);

   213   void PassOptionalOctetWithDefault(uint8_t);

   215   uint16_t ReadonlyUnsignedShort();

   216   uint16_t WritableUnsignedShort();

   217   void SetWritableUnsignedShort(uint16_t);

   218   void PassUnsignedShort(uint16_t);

   219   uint16_t ReceiveUnsignedShort();

   220   void PassOptionalUnsignedShort(const Optional<uint16_t>&);

   221   void PassOptionalUnsignedShortWithDefault(uint16_t);

   223   uint32_t ReadonlyUnsignedLong();

   224   uint32_t WritableUnsignedLong();

   225   void SetWritableUnsignedLong(uint32_t);

   226   void PassUnsignedLong(uint32_t);

   227   uint32_t ReceiveUnsignedLong();

   228   void PassOptionalUnsignedLong(const Optional<uint32_t>&);

   229   void PassOptionalUnsignedLongWithDefault(uint32_t);

   231   uint64_t ReadonlyUnsignedLongLong();

   232   uint64_t WritableUnsignedLongLong();

   233   void SetWritableUnsignedLongLong(uint64_t);

   234   void PassUnsignedLongLong(uint64_t);

   235   uint64_t ReceiveUnsignedLongLong();

   236   void PassOptionalUnsignedLongLong(const Optional<uint64_t>&);

   237   void PassOptionalUnsignedLongLongWithDefault(uint64_t);

   239   float WritableFloat() const;

   240   void SetWritableFloat(float);

   241   float WritableUnrestrictedFloat() const;

   242   void SetWritableUnrestrictedFloat(float);

   243   Nullable<float> GetWritableNullableFloat() const;

   244   void SetWritableNullableFloat(Nullable<float>);

   245   Nullable<float> GetWritableNullableUnrestrictedFloat() const;

   246   void SetWritableNullableUnrestrictedFloat(Nullable<float>);

   247   double WritableDouble() const;

   248   void SetWritableDouble(double);

   249   double WritableUnrestrictedDouble() const;

   250   void SetWritableUnrestrictedDouble(double);

   251   Nullable<double> GetWritableNullableDouble() const;

   252   void SetWritableNullableDouble(Nullable<double>);

   253   Nullable<double> GetWritableNullableUnrestrictedDouble() const;

   254   void SetWritableNullableUnrestrictedDouble(Nullable<double>);

   255   void PassFloat(float, float, Nullable<float>, Nullable<float>,

   256                  double, double, Nullable<double>, Nullable<double>,

   257                  const Sequence<float>&, const Sequence<float>&,

   258                  const Sequence<Nullable<float> >&,

   259                  const Sequence<Nullable<float> >&,

   260                  const Sequence<double>&, const Sequence<double>&,

   261                  const Sequence<Nullable<double> >&,

   262                  const Sequence<Nullable<double> >&);

   263   void PassLenientFloat(float, float, Nullable<float>, Nullable<float>,

   264                         double, double, Nullable<double>, Nullable<double>,

   265                         const Sequence<float>&, const Sequence<float>&,

   266                         const Sequence<Nullable<float> >&,

   267                         const Sequence<Nullable<float> >&,

   268                         const Sequence<double>&, const Sequence<double>&,

   269                         const Sequence<Nullable<double> >&,

   270                         const Sequence<Nullable<double> >&);

   271   float LenientFloatAttr() const;

   272   void SetLenientFloatAttr(float);

   273   double LenientDoubleAttr() const;

   274   void SetLenientDoubleAttr(double);

   276   void PassUnrestricted(float arg1,

   277                         float arg2,

   278                         float arg3,

   279                         float arg4,

   280                         double arg5,

   281                         double arg6,

   282                         double arg7,

   283                         double arg8);

   285   // Interface types

   286   already_AddRefed<TestInterface> ReceiveSelf();

   287   already_AddRefed<TestInterface> ReceiveNullableSelf();

   288   TestInterface* ReceiveWeakSelf();

   289   TestInterface* ReceiveWeakNullableSelf();

   290   void PassSelf(TestInterface&);

   291   void PassNullableSelf(TestInterface*);

   292   already_AddRefed<TestInterface> NonNullSelf();

   293   void SetNonNullSelf(TestInterface&);

   294   already_AddRefed<TestInterface> GetNullableSelf();

   295   already_AddRefed<TestInterface> CachedSelf();

   296   void SetNullableSelf(TestInterface*);

   297   void PassOptionalSelf(const Optional<TestInterface*> &);

   298   void PassOptionalNonNullSelf(const Optional<NonNull<TestInterface> >&);

   299   void PassOptionalSelfWithDefault(TestInterface*);

   301   already_AddRefed<TestNonWrapperCacheInterface> ReceiveNonWrapperCacheInterface();

   302   already_AddRefed<TestNonWrapperCacheInterface> ReceiveNullableNonWrapperCacheInterface();

   303   void ReceiveNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);

   304   void ReceiveNullableNonWrapperCacheInterfaceSequence(nsTArray<nsRefPtr<TestNonWrapperCacheInterface> >&);

   305   void ReceiveNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);

   306   void ReceiveNullableNonWrapperCacheInterfaceNullableSequence(Nullable<nsTArray<nsRefPtr<TestNonWrapperCacheInterface> > >&);

   308   already_AddRefed<IndirectlyImplementedInterface> ReceiveOther();

   309   already_AddRefed<IndirectlyImplementedInterface> ReceiveNullableOther();

   310   IndirectlyImplementedInterface* ReceiveWeakOther();

   311   IndirectlyImplementedInterface* ReceiveWeakNullableOther();

   312   void PassOther(IndirectlyImplementedInterface&);

   313   void PassNullableOther(IndirectlyImplementedInterface*);

   314   already_AddRefed<IndirectlyImplementedInterface> NonNullOther();

   315   void SetNonNullOther(IndirectlyImplementedInterface&);

   316   already_AddRefed<IndirectlyImplementedInterface> GetNullableOther();

   317   void SetNullableOther(IndirectlyImplementedInterface*);

   318   void PassOptionalOther(const Optional<IndirectlyImplementedInterface*>&);

   319   void PassOptionalNonNullOther(const Optional<NonNull<IndirectlyImplementedInterface> >&);

   320   void PassOptionalOtherWithDefault(IndirectlyImplementedInterface*);

   322   already_AddRefed<TestExternalInterface> ReceiveExternal();

   323   already_AddRefed<TestExternalInterface> ReceiveNullableExternal();

   324   TestExternalInterface* ReceiveWeakExternal();

   325   TestExternalInterface* ReceiveWeakNullableExternal();

   326   void PassExternal(TestExternalInterface*);

   327   void PassNullableExternal(TestExternalInterface*);

   328   already_AddRefed<TestExternalInterface> NonNullExternal();

   329   void SetNonNullExternal(TestExternalInterface*);

   330   already_AddRefed<TestExternalInterface> GetNullableExternal();

   331   void SetNullableExternal(TestExternalInterface*);

   332   void PassOptionalExternal(const Optional<TestExternalInterface*>&);

   333   void PassOptionalNonNullExternal(const Optional<TestExternalInterface*>&);

   334   void PassOptionalExternalWithDefault(TestExternalInterface*);

   336   already_AddRefed<TestCallbackInterface> ReceiveCallbackInterface();

   337   already_AddRefed<TestCallbackInterface> ReceiveNullableCallbackInterface();

   338   TestCallbackInterface* ReceiveWeakCallbackInterface();

   339   TestCallbackInterface* ReceiveWeakNullableCallbackInterface();

   340   void PassCallbackInterface(TestCallbackInterface&);

   341   void PassNullableCallbackInterface(TestCallbackInterface*);

   342   already_AddRefed<TestCallbackInterface> NonNullCallbackInterface();

   343   void SetNonNullCallbackInterface(TestCallbackInterface&);

   344   already_AddRefed<TestCallbackInterface> GetNullableCallbackInterface();

   345   void SetNullableCallbackInterface(TestCallbackInterface*);

   346   void PassOptionalCallbackInterface(const Optional<nsRefPtr<TestCallbackInterface> >&);

   347   void PassOptionalNonNullCallbackInterface(const Optional<OwningNonNull<TestCallbackInterface> >&);

   348   void PassOptionalCallbackInterfaceWithDefault(TestCallbackInterface*);

   350   already_AddRefed<IndirectlyImplementedInterface> ReceiveConsequentialInterface();

   351   void PassConsequentialInterface(IndirectlyImplementedInterface&);

   353   // Sequence types

   354   void GetReadonlySequence(nsTArray<int32_t>&);

   355   void GetReadonlySequenceOfDictionaries(JSContext*, nsTArray<Dict>&);

   356   void GetReadonlyNullableSequenceOfDictionaries(JSContext*, Nullable<nsTArray<Dict> >&);

   357   void GetReadonlyFrozenSequence(JSContext*, nsTArray<Dict>&);

   358   void GetReadonlyFrozenNullableSequence(JSContext*, Nullable<nsTArray<Dict>>&);

   359   void ReceiveSequence(nsTArray<int32_t>&);

   360   void ReceiveNullableSequence(Nullable< nsTArray<int32_t> >&);

   361   void ReceiveSequenceOfNullableInts(nsTArray< Nullable<int32_t> >&);

   362   void ReceiveNullableSequenceOfNullableInts(Nullable< nsTArray< Nullable<int32_t> > >&);

   363   void PassSequence(const Sequence<int32_t> &);

   364   void PassNullableSequence(const Nullable< Sequence<int32_t> >&);

   365   void PassSequenceOfNullableInts(const Sequence<Nullable<int32_t> >&);

   366   void PassOptionalSequenceOfNullableInts(const Optional<Sequence<Nullable<int32_t> > > &);

   367   void PassOptionalNullableSequenceOfNullableInts(const Optional<Nullable<Sequence<Nullable<int32_t> > > > &);

   368   void ReceiveCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);

   369   void ReceiveCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);

   370   void ReceiveNullableCastableObjectSequence(nsTArray< nsRefPtr<TestInterface> > &);

   371   void ReceiveNullableCallbackObjectSequence(nsTArray< nsRefPtr<TestCallbackInterface> > &);

   372   void ReceiveCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);

   373   void ReceiveNullableCastableObjectNullableSequence(Nullable< nsTArray< nsRefPtr<TestInterface> > >&);

   374   void ReceiveWeakCastableObjectSequence(nsTArray<TestInterface*> &);

   375   void ReceiveWeakNullableCastableObjectSequence(nsTArray<TestInterface*> &);

   376   void ReceiveWeakCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);

   377   void ReceiveWeakNullableCastableObjectNullableSequence(Nullable< nsTArray<TestInterface*> >&);

   378   void PassCastableObjectSequence(const Sequence< OwningNonNull<TestInterface> >&);

   379   void PassNullableCastableObjectSequence(const Sequence< nsRefPtr<TestInterface> > &);

   380   void PassCastableObjectNullableSequence(const Nullable< Sequence< OwningNonNull<TestInterface> > >&);

   381   void PassNullableCastableObjectNullableSequence(const Nullable< Sequence< nsRefPtr<TestInterface> > >&);

   382   void PassOptionalSequence(const Optional<Sequence<int32_t> >&);

   383   void PassOptionalNullableSequence(const Optional<Nullable<Sequence<int32_t> > >&);

   384   void PassOptionalNullableSequenceWithDefaultValue(const Nullable< Sequence<int32_t> >&);

   385   void PassOptionalObjectSequence(const Optional<Sequence<OwningNonNull<TestInterface> > >&);

   386   void PassExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);

   387   void PassNullableExternalInterfaceSequence(const Sequence<nsRefPtr<TestExternalInterface> >&);

   389   void ReceiveStringSequence(nsTArray<nsString>&);

   390   void PassStringSequence(const Sequence<nsString>&);

   392   void ReceiveByteStringSequence(nsTArray<nsCString>&);

   393   void PassByteStringSequence(const Sequence<nsCString>&);

   395   void ReceiveAnySequence(JSContext*, nsTArray<JS::Value>&);

   396   void ReceiveNullableAnySequence(JSContext*, Nullable<nsTArray<JS::Value> >&);

   397   void ReceiveAnySequenceSequence(JSContext*, nsTArray<nsTArray<JS::Value> >&);

   399   void ReceiveObjectSequence(JSContext*, nsTArray<JSObject*>&);

   400   void ReceiveNullableObjectSequence(JSContext*, nsTArray<JSObject*>&);

   402   void PassSequenceOfSequences(const Sequence< Sequence<int32_t> >&);

   403   void ReceiveSequenceOfSequences(nsTArray< nsTArray<int32_t> >&);

   405   // MozMap types

   406   void PassMozMap(const MozMap<int32_t> &);

   407   void PassNullableMozMap(const Nullable< MozMap<int32_t> >&);

   408   void PassMozMapOfNullableInts(const MozMap<Nullable<int32_t> >&);

   409   void PassOptionalMozMapOfNullableInts(const Optional<MozMap<Nullable<int32_t> > > &);

   410   void PassOptionalNullableMozMapOfNullableInts(const Optional<Nullable<MozMap<Nullable<int32_t> > > > &);

   411   void PassCastableObjectMozMap(const MozMap< OwningNonNull<TestInterface> >&);

   412   void PassNullableCastableObjectMozMap(const MozMap< nsRefPtr<TestInterface> > &);

   413   void PassCastableObjectNullableMozMap(const Nullable< MozMap< OwningNonNull<TestInterface> > >&);

   414   void PassNullableCastableObjectNullableMozMap(const Nullable< MozMap< nsRefPtr<TestInterface> > >&);

   415   void PassOptionalMozMap(const Optional<MozMap<int32_t> >&);

   416   void PassOptionalNullableMozMap(const Optional<Nullable<MozMap<int32_t> > >&);

   417   void PassOptionalNullableMozMapWithDefaultValue(const Nullable< MozMap<int32_t> >&);

   418   void PassOptionalObjectMozMap(const Optional<MozMap<OwningNonNull<TestInterface> > >&);

   419   void PassExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);

   420   void PassNullableExternalInterfaceMozMap(const MozMap<nsRefPtr<TestExternalInterface> >&);

   421   void PassStringMozMap(const MozMap<nsString>&);

   422   void PassByteStringMozMap(const MozMap<nsCString>&);

   423   void PassMozMapOfMozMaps(const MozMap< MozMap<int32_t> >&);

   424   void ReceiveMozMap(MozMap<int32_t>&);

   425   void ReceiveNullableMozMap(Nullable<MozMap<int32_t>>&);

   426   void ReceiveMozMapOfNullableInts(MozMap<Nullable<int32_t>>&);

   427   void ReceiveNullableMozMapOfNullableInts(Nullable<MozMap<Nullable<int32_t>>>&);

   428   void ReceiveMozMapOfMozMaps(MozMap<MozMap<int32_t>>&);

   429   void ReceiveAnyMozMap(JSContext*, MozMap<JS::Value>&);

   431   // Typed array types

   432   void PassArrayBuffer(const ArrayBuffer&);

   433   void PassNullableArrayBuffer(const Nullable<ArrayBuffer>&);

   434   void PassOptionalArrayBuffer(const Optional<ArrayBuffer>&);

   435   void PassOptionalNullableArrayBuffer(const Optional<Nullable<ArrayBuffer> >&);

   436   void PassOptionalNullableArrayBufferWithDefaultValue(const Nullable<ArrayBuffer>&);

   437   void PassArrayBufferView(const ArrayBufferView&);

   438   void PassInt8Array(const Int8Array&);

   439   void PassInt16Array(const Int16Array&);

   440   void PassInt32Array(const Int32Array&);

   441   void PassUint8Array(const Uint8Array&);

   442   void PassUint16Array(const Uint16Array&);

   443   void PassUint32Array(const Uint32Array&);

   444   void PassUint8ClampedArray(const Uint8ClampedArray&);

   445   void PassFloat32Array(const Float32Array&);

   446   void PassFloat64Array(const Float64Array&);

   447   void PassSequenceOfArrayBuffers(const Sequence<ArrayBuffer>&);

   448   void PassSequenceOfNullableArrayBuffers(const Sequence<Nullable<ArrayBuffer> >&);

   449   void PassMozMapOfArrayBuffers(const MozMap<ArrayBuffer>&);

   450   void PassMozMapOfNullableArrayBuffers(const MozMap<Nullable<ArrayBuffer> >&);

   451   void PassVariadicTypedArray(const Sequence<Float32Array>&);

   452   void PassVariadicNullableTypedArray(const Sequence<Nullable<Float32Array> >&);

   453   void ReceiveUint8Array(JSContext*, JS::MutableHandle<JSObject*>);

   455   // DOMString types

   456   void PassString(const nsAString&);

   457   void PassNullableString(const nsAString&);

   458   void PassOptionalString(const Optional<nsAString>&);

   459   void PassOptionalStringWithDefaultValue(const nsAString&);

   460   void PassOptionalNullableString(const Optional<nsAString>&);

   461   void PassOptionalNullableStringWithDefaultValue(const nsAString&);

   462   void PassVariadicString(const Sequence<nsString>&);

   464   // ByteString types

   465   void PassByteString(const nsCString&);

   466   void PassNullableByteString(const nsCString&);

   467   void PassOptionalByteString(const Optional<nsCString>&);

   468   void PassOptionalNullableByteString(const Optional<nsCString>&);

   469   void PassVariadicByteString(const Sequence<nsCString>&);

   471   // Enumerated types

   472   void PassEnum(TestEnum);

   473   void PassNullableEnum(const Nullable<TestEnum>&);

   474   void PassOptionalEnum(const Optional<TestEnum>&);

   475   void PassEnumWithDefault(TestEnum);

   476   void PassOptionalNullableEnum(const Optional<Nullable<TestEnum> >&);

   477   void PassOptionalNullableEnumWithDefaultValue(const Nullable<TestEnum>&);

   478   void PassOptionalNullableEnumWithDefaultValue2(const Nullable<TestEnum>&);

   479   TestEnum ReceiveEnum();

   480   Nullable<TestEnum> ReceiveNullableEnum();

   481   TestEnum EnumAttribute();

   482   TestEnum ReadonlyEnumAttribute();

   483   void SetEnumAttribute(TestEnum);

   485   // Callback types

   486   void PassCallback(TestCallback&);

   487   void PassNullableCallback(TestCallback*);

   488   void PassOptionalCallback(const Optional<OwningNonNull<TestCallback> >&);

   489   void PassOptionalNullableCallback(const Optional<nsRefPtr<TestCallback> >&);

   490   void PassOptionalNullableCallbackWithDefaultValue(TestCallback*);

   491   already_AddRefed<TestCallback> ReceiveCallback();

   492   already_AddRefed<TestCallback> ReceiveNullableCallback();

   493   void PassNullableTreatAsNullCallback(TestTreatAsNullCallback*);

   494   void PassOptionalNullableTreatAsNullCallback(const Optional<nsRefPtr<TestTreatAsNullCallback> >&);

   495   void PassOptionalNullableTreatAsNullCallbackWithDefaultValue(TestTreatAsNullCallback*);

   496   void SetTreatAsNullCallback(TestTreatAsNullCallback&);

   497   already_AddRefed<TestTreatAsNullCallback> TreatAsNullCallback();

   498   void SetNullableTreatAsNullCallback(TestTreatAsNullCallback*);

   499   already_AddRefed<TestTreatAsNullCallback> GetNullableTreatAsNullCallback();

   501   // Any types

   502   void PassAny(JSContext*, JS::Handle<JS::Value>);

   503   void PassVariadicAny(JSContext*, const Sequence<JS::Value>&);

   504   void PassOptionalAny(JSContext*, JS::Handle<JS::Value>);

   505   void PassAnyDefaultNull(JSContext*, JS::Handle<JS::Value>);

   506   void PassSequenceOfAny(JSContext*, const Sequence<JS::Value>&);

   507   void PassNullableSequenceOfAny(JSContext*, const Nullable<Sequence<JS::Value> >&);

   508   void PassOptionalSequenceOfAny(JSContext*, const Optional<Sequence<JS::Value> >&);

   509   void PassOptionalNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<JS::Value> > >&);

   510   void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, const Nullable<Sequence<JS::Value> >&);

   511   void PassSequenceOfSequenceOfAny(JSContext*, const Sequence<Sequence<JS::Value> >&);

   512   void PassSequenceOfNullableSequenceOfAny(JSContext*, const Sequence<Nullable<Sequence<JS::Value> > >&);

   513   void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, const Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&);

   514   void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&);

   515   void PassMozMapOfAny(JSContext*, const MozMap<JS::Value>&);

   516   void PassNullableMozMapOfAny(JSContext*, const Nullable<MozMap<JS::Value> >&);

   517   void PassOptionalMozMapOfAny(JSContext*, const Optional<MozMap<JS::Value> >&);

   518   void PassOptionalNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<JS::Value> > >&);

   519   void PassOptionalMozMapOfAnyWithDefaultValue(JSContext*, const Nullable<MozMap<JS::Value> >&);

   520   void PassMozMapOfMozMapOfAny(JSContext*, const MozMap<MozMap<JS::Value> >&);

   521   void PassMozMapOfNullableMozMapOfAny(JSContext*, const MozMap<Nullable<MozMap<JS::Value> > >&);

   522   void PassNullableMozMapOfNullableMozMapOfAny(JSContext*, const Nullable<MozMap<Nullable<MozMap<JS::Value> > > >&);

   523   void PassOptionalNullableMozMapOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<MozMap<JS::Value>>>>>&);

   524   void PassOptionalNullableMozMapOfNullableSequenceOfAny(JSContext*, const Optional<Nullable<MozMap<Nullable<Sequence<JS::Value>>>>>&);

   525   void PassOptionalNullableSequenceOfNullableMozMapOfAny(JSContext*, const Optional<Nullable<Sequence<Nullable<MozMap<JS::Value>>>>>&);

   526   void ReceiveAny(JSContext*, JS::MutableHandle<JS::Value>);

   528   // object types

   529   void PassObject(JSContext*, JS::Handle<JSObject*>);

   530   void PassVariadicObject(JSContext*, const Sequence<JSObject*>&);

   531   void PassNullableObject(JSContext*, JS::Handle<JSObject*>);

   532   void PassVariadicNullableObject(JSContext*, const Sequence<JSObject*>&);

   533   void PassOptionalObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);

   534   void PassOptionalNullableObject(JSContext*, const Optional<JS::Handle<JSObject*> >&);

   535   void PassOptionalNullableObjectWithDefaultValue(JSContext*, JS::Handle<JSObject*>);

   536   void PassSequenceOfObject(JSContext*, const Sequence<JSObject*>&);

   537   void PassSequenceOfNullableObject(JSContext*, const Sequence<JSObject*>&);

   538   void PassNullableSequenceOfObject(JSContext*, const Nullable<Sequence<JSObject*> >&);

   539   void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);

   540   void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, const Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&);

   541   void PassMozMapOfObject(JSContext*, const MozMap<JSObject*>&);

   542   void ReceiveObject(JSContext*, JS::MutableHandle<JSObject*>);

   543   void ReceiveNullableObject(JSContext*, JS::MutableHandle<JSObject*>);

   545   // Union types

   546   void PassUnion(JSContext*, const ObjectOrLong& arg);

   547   void PassUnionWithNullable(JSContext* cx, const ObjectOrNullOrLong& arg)

   548   {

   549     OwningObjectOrLong returnValue;

   550     if (arg.IsNull()) {

   551     } else if (arg.IsObject()) {

   552       JS::Rooted<JSObject*> obj(cx, arg.GetAsObject());

   553       JS_GetClass(obj);

   554       returnValue.SetAsObject() = obj;

   555     } else {

   556       int32_t i = arg.GetAsLong();

   557       i += 1;

   558       returnValue.SetAsLong() = i;

   559     }

   560   }

   561 #ifdef DEBUG

   562   void PassUnion2(const LongOrBoolean& arg);

   563   void PassUnion3(JSContext*, const ObjectOrLongOrBoolean& arg);

   564   void PassUnion4(const NodeOrLongOrBoolean& arg);

   565   void PassUnion5(JSContext*, const ObjectOrBoolean& arg);

   566   void PassUnion6(JSContext*, const ObjectOrString& arg);

   567   void PassUnion7(JSContext*, const ObjectOrStringOrLong& arg);

   568   void PassUnion8(JSContext*, const ObjectOrStringOrBoolean& arg);

   569   void PassUnion9(JSContext*, const ObjectOrStringOrLongOrBoolean& arg);

   570   void PassUnion10(const EventInitOrLong& arg);

   571   void PassUnion11(JSContext*, const CustomEventInitOrLong& arg);

   572   void PassUnion12(const EventInitOrLong& arg);

   573   void PassUnion13(JSContext*, const ObjectOrLongOrNull& arg);

   574   void PassUnion14(JSContext*, const ObjectOrLongOrNull& arg);

   575   void PassUnionWithCallback(const EventHandlerNonNullOrNullOrLong& arg);

   576 #endif

   577   void PassNullableUnion(JSContext*, const Nullable<ObjectOrLong>&);

   578   void PassOptionalUnion(JSContext*, const Optional<ObjectOrLong>&);

   579   void PassOptionalNullableUnion(JSContext*, const Optional<Nullable<ObjectOrLong> >&);

   580   void PassOptionalNullableUnionWithDefaultValue(JSContext*, const Nullable<ObjectOrLong>&);

   581   //void PassUnionWithInterfaces(const TestInterfaceOrTestExternalInterface& arg);

   582   //void PassUnionWithInterfacesAndNullable(const TestInterfaceOrNullOrTestExternalInterface& arg);

   583   void PassUnionWithArrayBuffer(const ArrayBufferOrLong&);

   584   void PassUnionWithString(JSContext*, const StringOrObject&);

   585   //void PassUnionWithEnum(JSContext*, const TestEnumOrObject&);

   586   //void PassUnionWithCallback(JSContext*, const TestCallbackOrLong&);

   587   void PassUnionWithObject(JSContext*, const ObjectOrLong&);

   589   void PassUnionWithDefaultValue1(const DoubleOrString& arg);

   590   void PassUnionWithDefaultValue2(const DoubleOrString& arg);

   591   void PassUnionWithDefaultValue3(const DoubleOrString& arg);

   592   void PassUnionWithDefaultValue4(const FloatOrString& arg);

   593   void PassUnionWithDefaultValue5(const FloatOrString& arg);

   594   void PassUnionWithDefaultValue6(const FloatOrString& arg);

   595   void PassUnionWithDefaultValue7(const UnrestrictedDoubleOrString& arg);

   596   void PassUnionWithDefaultValue8(const UnrestrictedDoubleOrString& arg);

   597   void PassUnionWithDefaultValue9(const UnrestrictedDoubleOrString& arg);

   598   void PassUnionWithDefaultValue10(const UnrestrictedDoubleOrString& arg);

   599   void PassUnionWithDefaultValue11(const UnrestrictedFloatOrString& arg);

   600   void PassUnionWithDefaultValue12(const UnrestrictedFloatOrString& arg);

   601   void PassUnionWithDefaultValue13(const UnrestrictedFloatOrString& arg);

   602   void PassUnionWithDefaultValue14(const UnrestrictedFloatOrString& arg);

   604   void PassNullableUnionWithDefaultValue1(const Nullable<DoubleOrString>& arg);

   605   void PassNullableUnionWithDefaultValue2(const Nullable<DoubleOrString>& arg);

   606   void PassNullableUnionWithDefaultValue3(const Nullable<DoubleOrString>& arg);

   607   void PassNullableUnionWithDefaultValue4(const Nullable<FloatOrString>& arg);

   608   void PassNullableUnionWithDefaultValue5(const Nullable<FloatOrString>& arg);

   609   void PassNullableUnionWithDefaultValue6(const Nullable<FloatOrString>& arg);

   610   void PassNullableUnionWithDefaultValue7(const Nullable<UnrestrictedDoubleOrString>& arg);

   611   void PassNullableUnionWithDefaultValue8(const Nullable<UnrestrictedDoubleOrString>& arg);

   612   void PassNullableUnionWithDefaultValue9(const Nullable<UnrestrictedDoubleOrString>& arg);

   613   void PassNullableUnionWithDefaultValue10(const Nullable<UnrestrictedFloatOrString>& arg);

   614   void PassNullableUnionWithDefaultValue11(const Nullable<UnrestrictedFloatOrString>& arg);

   615   void PassNullableUnionWithDefaultValue12(const Nullable<UnrestrictedFloatOrString>& arg);

   617   void PassSequenceOfUnions(const Sequence<OwningCanvasPatternOrCanvasGradient>&);

   618   void PassSequenceOfUnions2(JSContext*, const Sequence<OwningObjectOrLong>&);

   619   void PassVariadicUnion(const Sequence<OwningCanvasPatternOrCanvasGradient>&);

   621   void PassSequenceOfNullableUnions(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);

   622   void PassVariadicNullableUnion(const Sequence<Nullable<OwningCanvasPatternOrCanvasGradient>>&);

   623   void PassMozMapOfUnions(const MozMap<OwningCanvasPatternOrCanvasGradient>&);

   624   void PassMozMapOfUnions2(JSContext*, const MozMap<OwningObjectOrLong>&);

   626   void ReceiveUnion(OwningCanvasPatternOrCanvasGradient&);

   627   void ReceiveUnion2(JSContext*, OwningObjectOrLong&);

   628   void ReceiveUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);

   629   void ReceiveNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);

   630   void ReceiveNullableUnion2(JSContext*, Nullable<OwningObjectOrLong>&);

   631   void GetWritableUnion(OwningCanvasPatternOrCanvasGradient&);

   632   void SetWritableUnion(const CanvasPatternOrCanvasGradient&);

   633   void GetWritableUnionContainingNull(OwningCanvasPatternOrNullOrCanvasGradient&);

   634   void SetWritableUnionContainingNull(const CanvasPatternOrNullOrCanvasGradient&);

   635   void GetWritableNullableUnion(Nullable<OwningCanvasPatternOrCanvasGradient>&);

   636   void SetWritableNullableUnion(const Nullable<CanvasPatternOrCanvasGradient>&);

   638   // Date types

   639   void PassDate(Date);

   640   void PassNullableDate(const Nullable<Date>&);

   641   void PassOptionalDate(const Optional<Date>&);

   642   void PassOptionalNullableDate(const Optional<Nullable<Date> >&);

   643   void PassOptionalNullableDateWithDefaultValue(const Nullable<Date>&);

   644   void PassDateSequence(const Sequence<Date>&);

   645   void PassDateMozMap(const MozMap<Date>&);

   646   void PassNullableDateSequence(const Sequence<Nullable<Date> >&);

   647   Date ReceiveDate();

   648   Nullable<Date> ReceiveNullableDate();

   650   // binaryNames tests

   651   void MethodRenamedTo();

   652   void MethodRenamedTo(int8_t);

   653   int8_t AttributeGetterRenamedTo();

   654   int8_t AttributeRenamedTo();

   655   void SetAttributeRenamedTo(int8_t);

   657   // Dictionary tests

   658   void PassDictionary(JSContext*, const Dict&);

   659   void GetReadonlyDictionary(JSContext*, Dict&);

   660   void GetReadonlyNullableDictionary(JSContext*, Nullable<Dict>&);

   661   void GetWritableDictionary(JSContext*, Dict&);

   662   void SetWritableDictionary(JSContext*, const Dict&);

   663   void GetReadonlyFrozenDictionary(JSContext*, Dict&);

   664   void GetReadonlyFrozenNullableDictionary(JSContext*, Nullable<Dict>&);

   665   void GetWritableFrozenDictionary(JSContext*, Dict&);

   666   void SetWritableFrozenDictionary(JSContext*, const Dict&);

   667   void ReceiveDictionary(JSContext*, Dict&);

   668   void ReceiveNullableDictionary(JSContext*, Nullable<Dict>&);

   669   void PassOtherDictionary(const GrandparentDict&);

   670   void PassSequenceOfDictionaries(JSContext*, const Sequence<Dict>&);

   671   void PassMozMapOfDictionaries(const MozMap<GrandparentDict>&);

   672   void PassDictionaryOrLong(JSContext*, const Dict&);

   673   void PassDictionaryOrLong(int32_t);

   674   void PassDictContainingDict(JSContext*, const DictContainingDict&);

   675   void PassDictContainingSequence(JSContext*, const DictContainingSequence&);

   676   void ReceiveDictContainingSequence(JSContext*, DictContainingSequence&);

   678   // Typedefs

   679   void ExerciseTypedefInterfaces1(TestInterface&);

   680   already_AddRefed<TestInterface> ExerciseTypedefInterfaces2(TestInterface*);

   681   void ExerciseTypedefInterfaces3(TestInterface&);

   683   // Static methods and attributes

   684   static void StaticMethod(const GlobalObject&, bool);

   685   static void StaticMethodWithContext(const GlobalObject&, JSContext*,

   686                                       JS::Value);

   687   static bool StaticAttribute(const GlobalObject&);

   688   static void SetStaticAttribute(const GlobalObject&, bool);

   690   // Overload resolution tests

   691   bool Overload1(TestInterface&);

   692   TestInterface* Overload1(const nsAString&, TestInterface&);

   693   void Overload2(TestInterface&);

   694   void Overload2(JSContext*, const Dict&);

   695   void Overload2(bool);

   696   void Overload2(const nsAString&);

   697   void Overload2(Date);

   698   void Overload3(TestInterface&);

   699   void Overload3(const TestCallback&);

   700   void Overload3(bool);

   701   void Overload4(TestInterface&);

   702   void Overload4(TestCallbackInterface&);

   703   void Overload4(const nsAString&);

   704   void Overload5(int32_t);

   705   void Overload5(TestEnum);

   706   void Overload6(int32_t);

   707   void Overload6(bool);

   708   void Overload7(int32_t);

   709   void Overload7(bool);

   710   void Overload7(const nsCString&);

   711   void Overload8(int32_t);

   712   void Overload8(TestInterface&);

   713   void Overload9(const Nullable<int32_t>&);

   714   void Overload9(const nsAString&);

   715   void Overload10(const Nullable<int32_t>&);

   716   void Overload10(JSContext*, JS::Handle<JSObject*>);

   717   void Overload11(int32_t);

   718   void Overload11(const nsAString&);

   719   void Overload12(int32_t);

   720   void Overload12(const Nullable<bool>&);

   721   void Overload13(const Nullable<int32_t>&);

   722   void Overload13(bool);

   723   void Overload14(const Optional<int32_t>&);

   724   void Overload14(TestInterface&);

   725   void Overload15(int32_t);

   726   void Overload15(const Optional<NonNull<TestInterface> >&);

   727   void Overload16(int32_t);

   728   void Overload16(const Optional<TestInterface*>&);

   730   // Variadic handling

   731   void PassVariadicThirdArg(const nsAString&, int32_t,

   732                             const Sequence<OwningNonNull<TestInterface> >&);

   734   // Conditionally exposed methods/attributes

   735   bool Prefable1();

   736   bool Prefable2();

   737   bool Prefable3();

   738   bool Prefable4();

   739   bool Prefable5();

   740   bool Prefable6();

   741   bool Prefable7();

   742   bool Prefable8();

   743   bool Prefable9();

   744   void Prefable10();

   745   void Prefable11();

   746   bool Prefable12();

   747   void Prefable13();

   748   bool Prefable14();

   749   bool Prefable15();

   750   bool Prefable16();

   751   void Prefable17();

   752   void Prefable18();

   753   void Prefable19();

   754   void Prefable20();

   755   void Prefable21();

   756   void Prefable22();

   757   void Prefable23();

   758   void Prefable24();

   760   // Miscellania

   761   int32_t AttrWithLenientThis();

   762   void SetAttrWithLenientThis(int32_t);

   763   uint32_t UnforgeableAttr();

   764   uint32_t UnforgeableAttr2();

   765   void Stringify(nsString&);

   766   void PassRenamedInterface(nsRenamedInterface&);

   767   TestInterface* PutForwardsAttr();

   768   TestInterface* PutForwardsAttr2();

   769   TestInterface* PutForwardsAttr3();

   770   void GetJsonifierShouldSkipThis(JSContext*, JS::MutableHandle<JS::Value>);

   771   void SetJsonifierShouldSkipThis(JSContext*, JS::Rooted<JS::Value>&);

   772   TestParentInterface* JsonifierShouldSkipThis2();

   773   void SetJsonifierShouldSkipThis2(TestParentInterface&);

   774   TestCallbackInterface* JsonifierShouldSkipThis3();

   775   void SetJsonifierShouldSkipThis3(TestCallbackInterface&);

   776   void ThrowingMethod(ErrorResult& aRv);

   777   bool GetThrowingAttr(ErrorResult& aRv) const;

   778   void SetThrowingAttr(bool arg, ErrorResult& aRv);

   779   bool GetThrowingGetterAttr(ErrorResult& aRv) const;

   780   void SetThrowingGetterAttr(bool arg);

   781   bool ThrowingSetterAttr() const;

   782   void SetThrowingSetterAttr(bool arg, ErrorResult& aRv);

   783   int16_t LegacyCall(JS::Value, uint32_t, TestInterface&);

   784   void PassArgsWithDefaults(JSContext*, const Optional<int32_t>&,

   785                             TestInterface*, const Dict&, double,

   786                             const Optional<float>&);

   788   // Methods and properties imported via "implements"

   789   bool ImplementedProperty();

   790   void SetImplementedProperty(bool);

   791   void ImplementedMethod();

   792   bool ImplementedParentProperty();

   793   void SetImplementedParentProperty(bool);

   794   void ImplementedParentMethod();

   795   bool IndirectlyImplementedProperty();

   796   void SetIndirectlyImplementedProperty(bool);

   797   void IndirectlyImplementedMethod();

   798   uint32_t DiamondImplementedProperty();

   800   // Test EnforceRange/Clamp

   801   void DontEnforceRangeOrClamp(int8_t);

   802   void DoEnforceRange(int8_t);

   803   void DoClamp(int8_t);

   804   void SetEnforcedByte(int8_t);

   805   int8_t EnforcedByte();

   806   void SetClampedByte(int8_t);

   807   int8_t ClampedByte();

   809 private:

   810   // We add signatures here that _could_ start matching if the codegen

   811   // got data types wrong.  That way if it ever does we'll have a call

   812   // to these private deleted methods and compilation will fail.

   813   void SetReadonlyByte(int8_t) MOZ_DELETE;

   814   template<typename T>

   815   void SetWritableByte(T) MOZ_DELETE;

   816   template<typename T>

   817   void PassByte(T) MOZ_DELETE;

   818   void PassNullableByte(Nullable<int8_t>&) MOZ_DELETE;

   819   template<typename T>

   820   void PassOptionalByte(const Optional<T>&) MOZ_DELETE;

   821   template<typename T>

   822   void PassOptionalByteWithDefault(T) MOZ_DELETE;

   823   void PassVariadicByte(Sequence<int8_t>&) MOZ_DELETE;

   825   void SetReadonlyShort(int16_t) MOZ_DELETE;

   826   template<typename T>

   827   void SetWritableShort(T) MOZ_DELETE;

   828   template<typename T>

   829   void PassShort(T) MOZ_DELETE;

   830   template<typename T>

   831   void PassOptionalShort(const Optional<T>&) MOZ_DELETE;

   832   template<typename T>

   833   void PassOptionalShortWithDefault(T) MOZ_DELETE;

   835   void SetReadonlyLong(int32_t) MOZ_DELETE;

   836   template<typename T>

   837   void SetWritableLong(T) MOZ_DELETE;

   838   template<typename T>

   839   void PassLong(T) MOZ_DELETE;

   840   template<typename T>

   841   void PassOptionalLong(const Optional<T>&) MOZ_DELETE;

   842   template<typename T>

   843   void PassOptionalLongWithDefault(T) MOZ_DELETE;

   845   void SetReadonlyLongLong(int64_t) MOZ_DELETE;

   846   template<typename T>

   847   void SetWritableLongLong(T) MOZ_DELETE;

   848   template<typename T>

   849   void PassLongLong(T) MOZ_DELETE;

   850   template<typename T>

   851   void PassOptionalLongLong(const Optional<T>&) MOZ_DELETE;

   852   template<typename T>

   853   void PassOptionalLongLongWithDefault(T) MOZ_DELETE;

   855   void SetReadonlyOctet(uint8_t) MOZ_DELETE;

   856   template<typename T>

   857   void SetWritableOctet(T) MOZ_DELETE;

   858   template<typename T>

   859   void PassOctet(T) MOZ_DELETE;

   860   template<typename T>

   861   void PassOptionalOctet(const Optional<T>&) MOZ_DELETE;

   862   template<typename T>

   863   void PassOptionalOctetWithDefault(T) MOZ_DELETE;

   865   void SetReadonlyUnsignedShort(uint16_t) MOZ_DELETE;

   866   template<typename T>

   867   void SetWritableUnsignedShort(T) MOZ_DELETE;

   868   template<typename T>

   869   void PassUnsignedShort(T) MOZ_DELETE;

   870   template<typename T>

   871   void PassOptionalUnsignedShort(const Optional<T>&) MOZ_DELETE;

   872   template<typename T>

   873   void PassOptionalUnsignedShortWithDefault(T) MOZ_DELETE;

   875   void SetReadonlyUnsignedLong(uint32_t) MOZ_DELETE;

   876   template<typename T>

   877   void SetWritableUnsignedLong(T) MOZ_DELETE;

   878   template<typename T>

   879   void PassUnsignedLong(T) MOZ_DELETE;

   880   template<typename T>

   881   void PassOptionalUnsignedLong(const Optional<T>&) MOZ_DELETE;

   882   template<typename T>

   883   void PassOptionalUnsignedLongWithDefault(T) MOZ_DELETE;

   885   void SetReadonlyUnsignedLongLong(uint64_t) MOZ_DELETE;

   886   template<typename T>

   887   void SetWritableUnsignedLongLong(T) MOZ_DELETE;

   888   template<typename T>

   889   void PassUnsignedLongLong(T) MOZ_DELETE;

   890   template<typename T>

   891   void PassOptionalUnsignedLongLong(const Optional<T>&) MOZ_DELETE;

   892   template<typename T>

   893   void PassOptionalUnsignedLongLongWithDefault(T) MOZ_DELETE;

   895   // Enforce that only const things are passed for sequences

   896   void PassSequence(Sequence<int32_t> &) MOZ_DELETE;

   897   void PassNullableSequence(Nullable< Sequence<int32_t> >&) MOZ_DELETE;

   898   void PassOptionalNullableSequenceWithDefaultValue(Nullable< Sequence<int32_t> >&) MOZ_DELETE;

   899   void PassSequenceOfAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;

   900   void PassNullableSequenceOfAny(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;

   901   void PassOptionalSequenceOfAny(JSContext*, Optional<Sequence<JS::Value> >&) MOZ_DELETE;

   902   void PassOptionalNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;

   903   void PassOptionalSequenceOfAnyWithDefaultValue(JSContext*, Nullable<Sequence<JS::Value> >&) MOZ_DELETE;

   904   void PassSequenceOfSequenceOfAny(JSContext*, Sequence<Sequence<JS::Value> >&) MOZ_DELETE;

   905   void PassSequenceOfNullableSequenceOfAny(JSContext*, Sequence<Nullable<Sequence<JS::Value> > >&) MOZ_DELETE;

   906   void PassNullableSequenceOfNullableSequenceOfAny(JSContext*, Nullable<Sequence<Nullable<Sequence<JS::Value> > > >&) MOZ_DELETE;

   907   void PassOptionalNullableSequenceOfNullableSequenceOfAny(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JS::Value> > > > >&) MOZ_DELETE;

   908   void PassSequenceOfObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;

   909   void PassSequenceOfNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;

   910   void PassOptionalNullableSequenceOfNullableSequenceOfObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;

   911   void PassOptionalNullableSequenceOfNullableSequenceOfNullableObject(JSContext*, Optional<Nullable<Sequence<Nullable<Sequence<JSObject*> > > > >&) MOZ_DELETE;

   913   // Enforce that only const things are passed for optional

   914   void PassOptionalByte(Optional<int8_t>&) MOZ_DELETE;

   915   void PassOptionalNullableByte(Optional<Nullable<int8_t> >&) MOZ_DELETE;

   916   void PassOptionalShort(Optional<int16_t>&) MOZ_DELETE;

   917   void PassOptionalLong(Optional<int32_t>&) MOZ_DELETE;

   918   void PassOptionalLongLong(Optional<int64_t>&) MOZ_DELETE;

   919   void PassOptionalOctet(Optional<uint8_t>&) MOZ_DELETE;

   920   void PassOptionalUnsignedShort(Optional<uint16_t>&) MOZ_DELETE;

   921   void PassOptionalUnsignedLong(Optional<uint32_t>&) MOZ_DELETE;

   922   void PassOptionalUnsignedLongLong(Optional<uint64_t>&) MOZ_DELETE;

   923   void PassOptionalSelf(Optional<TestInterface*> &) MOZ_DELETE;

   924   void PassOptionalNonNullSelf(Optional<NonNull<TestInterface> >&) MOZ_DELETE;

   925   void PassOptionalOther(Optional<IndirectlyImplementedInterface*>&);

   926   void PassOptionalNonNullOther(Optional<NonNull<IndirectlyImplementedInterface> >&);

   927   void PassOptionalExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;

   928   void PassOptionalNonNullExternal(Optional<TestExternalInterface*>&) MOZ_DELETE;

   929   void PassOptionalSequence(Optional<Sequence<int32_t> >&) MOZ_DELETE;

   930   void PassOptionalNullableSequence(Optional<Nullable<Sequence<int32_t> > >&) MOZ_DELETE;

   931   void PassOptionalObjectSequence(Optional<Sequence<OwningNonNull<TestInterface> > >&) MOZ_DELETE;

   932   void PassOptionalArrayBuffer(Optional<ArrayBuffer>&) MOZ_DELETE;

   933   void PassOptionalNullableArrayBuffer(Optional<ArrayBuffer*>&) MOZ_DELETE;

   934   void PassOptionalEnum(Optional<TestEnum>&) MOZ_DELETE;

   935   void PassOptionalCallback(JSContext*, Optional<OwningNonNull<TestCallback> >&) MOZ_DELETE;

   936   void PassOptionalNullableCallback(JSContext*, Optional<nsRefPtr<TestCallback> >&) MOZ_DELETE;

   937   void PassOptionalAny(Optional<JS::Handle<JS::Value> >&) MOZ_DELETE;

   939   // And test that string stuff is always const

   940   void PassString(nsAString&) MOZ_DELETE;

   941   void PassNullableString(nsAString&) MOZ_DELETE;

   942   void PassOptionalString(Optional<nsAString>&) MOZ_DELETE;

   943   void PassOptionalStringWithDefaultValue(nsAString&) MOZ_DELETE;

   944   void PassOptionalNullableString(Optional<nsAString>&) MOZ_DELETE;

   945   void PassOptionalNullableStringWithDefaultValue(nsAString&) MOZ_DELETE;

   946   void PassVariadicString(Sequence<nsString>&) MOZ_DELETE;

   948   // cstrings should be const as well

   949   void PassByteString(nsCString&) MOZ_DELETE;

   950   void PassNullableByteString(nsCString&) MOZ_DELETE;

   951   void PassOptionalByteString(Optional<nsCString>&) MOZ_DELETE;

   952   void PassOptionalNullableByteString(Optional<nsCString>&) MOZ_DELETE;

   953   void PassVariadicByteString(Sequence<nsCString>&) MOZ_DELETE;

   955   // Make sure dictionary arguments are always const

   956   void PassDictionary(JSContext*, Dict&) MOZ_DELETE;

   957   void PassOtherDictionary(GrandparentDict&) MOZ_DELETE;

   958   void PassSequenceOfDictionaries(JSContext*, Sequence<Dict>&) MOZ_DELETE;

   959   void PassDictionaryOrLong(JSContext*, Dict&) MOZ_DELETE;

   960   void PassDictContainingDict(JSContext*, DictContainingDict&) MOZ_DELETE;

   961   void PassDictContainingSequence(DictContainingSequence&) MOZ_DELETE;

   963   // Make sure various nullable things are always const

   964   void PassNullableEnum(Nullable<TestEnum>&) MOZ_DELETE;

   966   // Make sure unions are always const

   967   void PassUnion(JSContext*, ObjectOrLong& arg) MOZ_DELETE;

   968   void PassUnionWithNullable(JSContext*, ObjectOrNullOrLong& arg) MOZ_DELETE;

   969   void PassNullableUnion(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;

   970   void PassOptionalUnion(JSContext*, Optional<ObjectOrLong>&) MOZ_DELETE;

   971   void PassOptionalNullableUnion(JSContext*, Optional<Nullable<ObjectOrLong> >&) MOZ_DELETE;

   972   void PassOptionalNullableUnionWithDefaultValue(JSContext*, Nullable<ObjectOrLong>&) MOZ_DELETE;

   974   // Make sure various date stuff is const as needed

   975   void PassNullableDate(Nullable<Date>&) MOZ_DELETE;

   976   void PassOptionalDate(Optional<Date>&) MOZ_DELETE;

   977   void PassOptionalNullableDate(Optional<Nullable<Date> >&) MOZ_DELETE;

   978   void PassOptionalNullableDateWithDefaultValue(Nullable<Date>&) MOZ_DELETE;

   979   void PassDateSequence(Sequence<Date>&) MOZ_DELETE;

   980   void PassNullableDateSequence(Sequence<Nullable<Date> >&) MOZ_DELETE;

   982   // Make sure variadics are const as needed

   983   void PassVariadicAny(JSContext*, Sequence<JS::Value>&) MOZ_DELETE;

   984   void PassVariadicObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;

   985   void PassVariadicNullableObject(JSContext*, Sequence<JSObject*>&) MOZ_DELETE;

   987   // Ensure NonNull does not leak in

   988   void PassSelf(NonNull<TestInterface>&) MOZ_DELETE;

   989   void PassSelf(OwningNonNull<TestInterface>&) MOZ_DELETE;

   990   void PassSelf(const NonNull<TestInterface>&) MOZ_DELETE;

   991   void PassSelf(const OwningNonNull<TestInterface>&) MOZ_DELETE;

   992   void PassOther(NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;

   993   void PassOther(const NonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;

   994   void PassOther(OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;

   995   void PassOther(const OwningNonNull<IndirectlyImplementedInterface>&) MOZ_DELETE;

   996   void PassCallbackInterface(OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;

   997   void PassCallbackInterface(const OwningNonNull<TestCallbackInterface>&) MOZ_DELETE;

   998   void PassCallbackInterface(NonNull<TestCallbackInterface>&) MOZ_DELETE;

   999   void PassCallbackInterface(const NonNull<TestCallbackInterface>&) MOZ_DELETE;

  1000   void PassCallback(OwningNonNull<TestCallback>&) MOZ_DELETE;

  1001   void PassCallback(const OwningNonNull<TestCallback>&) MOZ_DELETE;

  1002   void PassCallback(NonNull<TestCallback>&) MOZ_DELETE;

  1003   void PassCallback(const NonNull<TestCallback>&) MOZ_DELETE;

  1004   void PassString(const NonNull<nsAString>&) MOZ_DELETE;

  1005   void PassString(NonNull<nsAString>&) MOZ_DELETE;

  1006   void PassString(const OwningNonNull<nsAString>&) MOZ_DELETE;

  1007   void PassString(OwningNonNull<nsAString>&) MOZ_DELETE;

  1008 };

  1010 class TestIndexedGetterInterface : public nsISupports,

  1011                                    public nsWrapperCache

  1012 {

  1013 public:

  1014   NS_DECL_ISUPPORTS

  1016   // We need a GetParentObject to make binding codegen happy

  1017   virtual nsISupports* GetParentObject();

  1019   uint32_t IndexedGetter(uint32_t, bool&);

  1020   uint32_t IndexedGetter(uint32_t&) MOZ_DELETE;

  1021   uint32_t Item(uint32_t&);

  1022   uint32_t Item(uint32_t, bool&) MOZ_DELETE;

  1023   uint32_t Length();

  1024   void LegacyCall(JS::Handle<JS::Value>);

  1025 };

  1027 class TestNamedGetterInterface : public nsISupports,

  1028                                  public nsWrapperCache

  1029 {

  1030 public:

  1031   NS_DECL_ISUPPORTS

  1033   // We need a GetParentObject to make binding codegen happy

  1034   virtual nsISupports* GetParentObject();

  1036   void NamedGetter(const nsAString&, bool&, nsAString&);

  1037   bool NameIsEnumerable(const nsAString&);

  1038   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1039 };

  1041 class TestIndexedGetterAndSetterAndNamedGetterInterface : public nsISupports,

  1042                                                           public nsWrapperCache

  1043 {

  1044 public:

  1045   NS_DECL_ISUPPORTS

  1047   // We need a GetParentObject to make binding codegen happy

  1048   virtual nsISupports* GetParentObject();

  1050   void NamedGetter(const nsAString&, bool&, nsAString&);

  1051   bool NameIsEnumerable(const nsAString&);

  1052   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1053   int32_t IndexedGetter(uint32_t, bool&);

  1054   void IndexedSetter(uint32_t, int32_t);

  1055   uint32_t Length();

  1056 };

  1058 class TestIndexedAndNamedGetterInterface : public nsISupports,

  1059                                            public nsWrapperCache

  1060 {

  1061 public:

  1062   NS_DECL_ISUPPORTS

  1064   // We need a GetParentObject to make binding codegen happy

  1065   virtual nsISupports* GetParentObject();

  1067   uint32_t IndexedGetter(uint32_t, bool&);

  1068   void NamedGetter(const nsAString&, bool&, nsAString&);

  1069   bool NameIsEnumerable(const nsAString&);

  1070   void NamedItem(const nsAString&, nsAString&);

  1071   uint32_t Length();

  1072   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1073 };

  1075 class TestIndexedSetterInterface : public nsISupports,

  1076                                    public nsWrapperCache

  1077 {

  1078 public:

  1079   NS_DECL_ISUPPORTS

  1081   // We need a GetParentObject to make binding codegen happy

  1082   virtual nsISupports* GetParentObject();

  1084   void IndexedSetter(uint32_t, const nsAString&);

  1085   void IndexedGetter(uint32_t, bool&, nsString&);

  1086   uint32_t Length();

  1087   void SetItem(uint32_t, const nsAString&);

  1088 };

  1090 class TestNamedSetterInterface : public nsISupports,

  1091                                  public nsWrapperCache

  1092 {

  1093 public:

  1094   NS_DECL_ISUPPORTS

  1096   // We need a GetParentObject to make binding codegen happy

  1097   virtual nsISupports* GetParentObject();

  1099   void NamedSetter(const nsAString&, TestIndexedSetterInterface&);

  1100   TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);

  1101   bool NameIsEnumerable(const nsAString&);

  1102   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1103 };

  1105 class TestIndexedAndNamedSetterInterface : public nsISupports,

  1106                                            public nsWrapperCache

  1107 {

  1108 public:

  1109   NS_DECL_ISUPPORTS

  1111   // We need a GetParentObject to make binding codegen happy

  1112   virtual nsISupports* GetParentObject();

  1114   void IndexedSetter(uint32_t, TestIndexedSetterInterface&);

  1115   TestIndexedSetterInterface* IndexedGetter(uint32_t, bool&);

  1116   uint32_t Length();

  1117   void NamedSetter(const nsAString&, TestIndexedSetterInterface&);

  1118   TestIndexedSetterInterface* NamedGetter(const nsAString&, bool&);

  1119   bool NameIsEnumerable(const nsAString&);

  1120   void SetNamedItem(const nsAString&, TestIndexedSetterInterface&);

  1121   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1122 };

  1124 class TestIndexedAndNamedGetterAndSetterInterface : public TestIndexedSetterInterface

  1125 {

  1126 public:

  1127   uint32_t IndexedGetter(uint32_t, bool&);

  1128   uint32_t Item(uint32_t);

  1129   void NamedGetter(const nsAString&, bool&, nsAString&);

  1130   bool NameIsEnumerable(const nsAString&);

  1131   void NamedItem(const nsAString&, nsAString&);

  1132   void IndexedSetter(uint32_t, int32_t&);

  1133   void IndexedSetter(uint32_t, const nsAString&) MOZ_DELETE;

  1134   void NamedSetter(const nsAString&, const nsAString&);

  1135   void Stringify(nsAString&);

  1136   uint32_t Length();

  1137   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1138 };

  1140 class TestCppKeywordNamedMethodsInterface : public nsISupports,

  1141                                             public nsWrapperCache

  1142 {

  1143 public:

  1144   NS_DECL_ISUPPORTS

  1146   // We need a GetParentObject to make binding codegen happy

  1147   virtual nsISupports* GetParentObject();

  1149   bool Continue();

  1150   bool Delete();

  1151   int32_t Volatile();

  1152 };

  1154 class TestIndexedDeleterInterface : public nsISupports,

  1155                                     public nsWrapperCache

  1156 {

  1157 public:

  1158   NS_DECL_ISUPPORTS

  1160   // We need a GetParentObject to make binding codegen happy

  1161   virtual nsISupports* GetParentObject();

  1163   void IndexedDeleter(uint32_t, bool&);

  1164   void IndexedDeleter(uint32_t) MOZ_DELETE;

  1165   long IndexedGetter(uint32_t, bool&);

  1166   uint32_t Length();

  1167   void DelItem(uint32_t);

  1168   void DelItem(uint32_t, bool&) MOZ_DELETE;

  1169 };

  1171 class TestIndexedDeleterWithRetvalInterface : public nsISupports,

  1172                                               public nsWrapperCache

  1173 {

  1174 public:

  1175   NS_DECL_ISUPPORTS

  1177   // We need a GetParentObject to make binding codegen happy

  1178   virtual nsISupports* GetParentObject();

  1180   bool IndexedDeleter(uint32_t, bool&);

  1181   bool IndexedDeleter(uint32_t) MOZ_DELETE;

  1182   long IndexedGetter(uint32_t, bool&);

  1183   uint32_t Length();

  1184   bool DelItem(uint32_t);

  1185   bool DelItem(uint32_t, bool&) MOZ_DELETE;

  1186 };

  1188 class TestNamedDeleterInterface : public nsISupports,

  1189                                   public nsWrapperCache

  1190 {

  1191 public:

  1192   NS_DECL_ISUPPORTS

  1194   // We need a GetParentObject to make binding codegen happy

  1195   virtual nsISupports* GetParentObject();

  1197   void NamedDeleter(const nsAString&, bool&);

  1198   long NamedGetter(const nsAString&, bool&);

  1199   bool NameIsEnumerable(const nsAString&);

  1200   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1201 };

  1203 class TestNamedDeleterWithRetvalInterface : public nsISupports,

  1204                                             public nsWrapperCache

  1205 {

  1206 public:

  1207   NS_DECL_ISUPPORTS

  1209   // We need a GetParentObject to make binding codegen happy

  1210   virtual nsISupports* GetParentObject();

  1212   bool NamedDeleter(const nsAString&, bool&);

  1213   bool NamedDeleter(const nsAString&) MOZ_DELETE;

  1214   long NamedGetter(const nsAString&, bool&);

  1215   bool NameIsEnumerable(const nsAString&);

  1216   bool DelNamedItem(const nsAString&);

  1217   bool DelNamedItem(const nsAString&, bool&) MOZ_DELETE;

  1218   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1219 };

  1221 class TestIndexedAndNamedDeleterInterface : public nsISupports,

  1222                                             public nsWrapperCache

  1223 {

  1224 public:

  1225   NS_DECL_ISUPPORTS

  1227   // We need a GetParentObject to make binding codegen happy

  1228   virtual nsISupports* GetParentObject();

  1230   void IndexedDeleter(uint32_t, bool&);

  1231   long IndexedGetter(uint32_t, bool&);

  1232   uint32_t Length();

  1234   void NamedDeleter(const nsAString&, bool&);

  1235   void NamedDeleter(const nsAString&) MOZ_DELETE;

  1236   long NamedGetter(const nsAString&, bool&);

  1237   bool NameIsEnumerable(const nsAString&);

  1238   void DelNamedItem(const nsAString&);

  1239   void DelNamedItem(const nsAString&, bool&) MOZ_DELETE;

  1240   void GetSupportedNames(unsigned, nsTArray<nsString>&);

  1241 };

  1243 class TestParentInterface : public nsISupports,

  1244                             public nsWrapperCache

  1245 {

  1246 public:

  1247   NS_DECL_ISUPPORTS

  1249   // We need a GetParentObject to make binding codegen happy

  1250   virtual nsISupports* GetParentObject();

  1251 };

  1253 class TestChildInterface : public TestParentInterface

  1254 {

  1255 };

  1257 } // namespace dom

  1258 } // namespace mozilla

  1260 #endif /* TestBindingHeader_h */

The Tor Browser / file revision

dom/bindings/test/TestBindingHeader.h@129ffea94266

dom/bindings/test/TestBindingHeader.h