/* THIS FILE IS AUTOGENERATED FROM ChannelWrapper.webidl BY Codegen.py - DO NOT EDIT */

#ifndef mozilla_dom_ChannelWrapperBinding_h

#define mozilla_dom_ChannelWrapperBinding_h

#include "GeckoProfiler.h"

#include "js/RootingAPI.h"

#include "jspubtd.h"

#include "mozilla/ErrorResult.h"

#include "mozilla/dom/BindingDeclarations.h"

#include "mozilla/dom/Nullable.h"

#include "mozilla/dom/PrototypeList.h"

#include "mozilla/extensions/MatchPattern.h"

namespace mozilla {

namespace dom {

struct MozFrameAncestorInfoAtoms;

struct MozHTTPHeaderAtoms;

struct MozProxyInfoAtoms;

struct MozRequestFilterAtoms;

struct MozRequestMatchOptionsAtoms;

struct NativePropertyHooks;

class ProtoAndIfaceCache;

} // namespace dom

namespace extensions {

class ChannelWrapper;

struct ChannelWrapperAtoms;

class MatchPatternSet;

} // namespace extensions

} // namespace mozilla

namespace mozilla {

namespace dom {

enum class MozContentPolicyType : uint8_t {

  Main_frame,

  Sub_frame,

  Stylesheet,

  Script,

  Image,

  Object,

  Object_subrequest,

  Xmlhttprequest,

  Fetch,

  Xbl,

  Xslt,

  Ping,

  Beacon,

  Xml_dtd,

  Font,

  Media,

  Websocket,

  Csp_report,

  Imageset,

  Web_manifest,

  Speculative,

  Other,

  EndGuard_

};

namespace MozContentPolicyTypeValues {

extern const EnumEntry strings[23];

} // namespace MozContentPolicyTypeValues

bool

ToJSValue(JSContext* aCx, MozContentPolicyType aArgument, JS::MutableHandle<JS::Value> aValue);

struct MozFrameAncestorInfo : public DictionaryBase

{

  MOZ_INIT_OUTSIDE_CTOR uint64_t mFrameId;

  MOZ_INIT_OUTSIDE_CTOR nsCString mUrl;

  MozFrameAncestorInfo();

  explicit inline MozFrameAncestorInfo(const FastDictionaryInitializer& )

  {

    // Do nothing here; this is used by our "Fast" subclass

  }

  explicit inline MozFrameAncestorInfo(const MozFrameAncestorInfo& aOther)

  {

    *this = aOther;

  }

  bool

  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool

  Init(const nsAString& aJSON);

  bool

  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool

  ToJSON(nsAString& aJSON) const;

  void

  TraceDictionary(JSTracer* trc);

  MozFrameAncestorInfo&

  operator=(const MozFrameAncestorInfo& aOther);

private:

  static bool

  InitIds(JSContext* cx, MozFrameAncestorInfoAtoms* atomsCache);

};

namespace binding_detail {

struct FastMozFrameAncestorInfo : public MozFrameAncestorInfo

{

  inline FastMozFrameAncestorInfo()

    : MozFrameAncestorInfo(FastDictionaryInitializer())

  {

    // Doesn't matter what int we pass to the parent constructor

  }

};

} // namespace binding_detail

struct MozHTTPHeader : public DictionaryBase

{

  MOZ_INIT_OUTSIDE_CTOR nsCString mName;

  MOZ_INIT_OUTSIDE_CTOR nsCString mValue;

  MozHTTPHeader();

  explicit inline MozHTTPHeader(const FastDictionaryInitializer& )

  {

    // Do nothing here; this is used by our "Fast" subclass

  }

  explicit inline MozHTTPHeader(const MozHTTPHeader& aOther)

  {

    *this = aOther;

  }

  bool

  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool

  Init(const nsAString& aJSON);

  bool

  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool

  ToJSON(nsAString& aJSON) const;

  void

  TraceDictionary(JSTracer* trc);

  MozHTTPHeader&

  operator=(const MozHTTPHeader& aOther);

private:

  static bool

  InitIds(JSContext* cx, MozHTTPHeaderAtoms* atomsCache);

};

namespace binding_detail {

struct FastMozHTTPHeader : public MozHTTPHeader

{

  inline FastMozHTTPHeader()

    : MozHTTPHeader(FastDictionaryInitializer())

  {

    // Doesn't matter what int we pass to the parent constructor

  }

};

} // namespace binding_detail

struct MozProxyInfo : public DictionaryBase

{

  MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mFailoverTimeout;

  MOZ_INIT_OUTSIDE_CTOR nsCString mHost;

  MOZ_INIT_OUTSIDE_CTOR int32_t mPort;

  MOZ_INIT_OUTSIDE_CTOR bool mProxyDNS;

  MOZ_INIT_OUTSIDE_CTOR nsCString mType;

  MOZ_INIT_OUTSIDE_CTOR nsCString mUsername;

  MozProxyInfo();

  explicit inline MozProxyInfo(const FastDictionaryInitializer& )

  {

    // Do nothing here; this is used by our "Fast" subclass

  }

  explicit inline MozProxyInfo(const MozProxyInfo& aOther)

  {

    *this = aOther;

  }

  bool

  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool

  Init(const nsAString& aJSON);

  bool

  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool

  ToJSON(nsAString& aJSON) const;

  void

  TraceDictionary(JSTracer* trc);

  MozProxyInfo&

  operator=(const MozProxyInfo& aOther);

private:

  static bool

  InitIds(JSContext* cx, MozProxyInfoAtoms* atomsCache);

};

namespace binding_detail {

struct FastMozProxyInfo : public MozProxyInfo

{

  inline FastMozProxyInfo()

    : MozProxyInfo(FastDictionaryInitializer())

  {

    // Doesn't matter what int we pass to the parent constructor

  }

};

} // namespace binding_detail

struct MozRequestFilter : public DictionaryBase

{

  MOZ_INIT_OUTSIDE_CTOR Nullable<Sequence<MozContentPolicyType>> mTypes;

  MOZ_INIT_OUTSIDE_CTOR RefPtr<mozilla::extensions::MatchPatternSet> mUrls;

  MozRequestFilter();

  explicit inline MozRequestFilter(const FastDictionaryInitializer& )

  {

    // Do nothing here; this is used by our "Fast" subclass

  }

  explicit inline MozRequestFilter(const MozRequestFilter& aOther)

  {

    *this = aOther;

  }

  bool

  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool

  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  void

  TraceDictionary(JSTracer* trc);

  inline void

  TraverseForCC(nsCycleCollectionTraversalCallback& aCallback, uint32_t aFlags)

  {

    ImplCycleCollectionTraverse(aCallback, mUrls, "mUrls", aFlags);

  }

  inline void

  UnlinkForCC()

  {

    ImplCycleCollectionUnlink(mUrls);

  }

  MozRequestFilter&

  operator=(const MozRequestFilter& aOther);

private:

  static bool

  InitIds(JSContext* cx, MozRequestFilterAtoms* atomsCache);

};

namespace binding_detail {

struct FastMozRequestFilter : public MozRequestFilter

{

  inline FastMozRequestFilter()

    : MozRequestFilter(FastDictionaryInitializer())

  {

    // Doesn't matter what int we pass to the parent constructor

  }

};

} // namespace binding_detail

struct MozRequestMatchOptions : public DictionaryBase

{

  MOZ_INIT_OUTSIDE_CTOR bool mIsProxy;

  MozRequestMatchOptions();

  explicit inline MozRequestMatchOptions(const FastDictionaryInitializer& )

  {

    // Do nothing here; this is used by our "Fast" subclass

  }

  explicit inline MozRequestMatchOptions(const MozRequestMatchOptions& aOther)

  {

    *this = aOther;

  }

  bool

  Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);

  bool

  Init(const nsAString& aJSON);

  bool

  ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;

  bool

  ToJSON(nsAString& aJSON) const;

  void

  TraceDictionary(JSTracer* trc);

  MozRequestMatchOptions&

  operator=(const MozRequestMatchOptions& aOther);

private:

  static bool

  InitIds(JSContext* cx, MozRequestMatchOptionsAtoms* atomsCache);

};

namespace binding_detail {

struct FastMozRequestMatchOptions : public MozRequestMatchOptions

{

  inline FastMozRequestMatchOptions()

    : MozRequestMatchOptions(FastDictionaryInitializer())

  {

    // Doesn't matter what int we pass to the parent constructor

  }

};

} // namespace binding_detail

namespace ChannelWrapper_Binding {

  typedef mozilla::extensions::ChannelWrapper NativeType;

  bool

  ConstructorEnabled(JSContext* aCx, JS::Handle<JSObject*> aObj);

  const JSClass*

  GetJSClass();

  bool

  Wrap(JSContext* aCx, mozilla::extensions::ChannelWrapper* aObject, nsWrapperCache* aCache, JS::Handle<JSObject*> aGivenProto, JS::MutableHandle<JSObject*> aReflector);

  template <class T>

  inline JSObject* Wrap(JSContext* aCx, T* aObject, JS::Handle<JSObject*> aGivenProto)

  {

    JS::Rooted<JSObject*> reflector(aCx);

    return Wrap(aCx, aObject, aObject, aGivenProto, &reflector) ? reflector.get() : nullptr;

  }

  void

  ClearCachedMethodValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedTypeValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedFinalURIValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedFinalURLValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedStatusCodeValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedStatusLineValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedErrorStringValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedProxyInfoValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedRemoteAddressValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedLoadInfoValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedIsSystemLoadValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedOriginURLValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedDocumentURLValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedCanModifyValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedBrowserElementValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  ClearCachedFrameAncestorsValue(mozilla::extensions::ChannelWrapper* aObject);

  void

  CreateInterfaceObjects(JSContext* aCx, JS::Handle<JSObject*> aGlobal, ProtoAndIfaceCache& aProtoAndIfaceCache, bool aDefineOnGlobal);

  inline JS::Handle<JSObject*> GetProtoObjectHandle(JSContext* aCx)

  {

    /* Get the interface prototype object for this class.  This will create the

       object as needed. */

    return GetPerInterfaceObjectHandle(aCx, prototypes::id::ChannelWrapper,

                                       &CreateInterfaceObjects,

                                       /* aDefineOnGlobal = */ true);

  }

  inline JS::Handle<JSObject*> GetConstructorObjectHandle(JSContext* aCx, bool aDefineOnGlobal = true)

  {

    /* Get the interface object for this class.  This will create the object as

       needed. */

    return GetPerInterfaceObjectHandle(aCx, constructors::id::ChannelWrapper,

                                       &CreateInterfaceObjects,

                                       aDefineOnGlobal);

  }

  JSObject*

  GetConstructorObject(JSContext* aCx);

} // namespace ChannelWrapper_Binding

} // namespace dom

} // namespace mozilla

#endif // mozilla_dom_ChannelWrapperBinding_h