//
// Automatically generated by ipdlc.
// Edit at your own risk
//

#ifndef IPCTransferable_h
#define IPCTransferable_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/ipc/BigBuffer.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "nsIPrincipal.h"
#include "nsIReferrerInfo.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/dom/IPCBlob.h"
#include "mozilla/net/NeckoChannelParams.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableDataString|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataString final
{
private:
    typedef ::mozilla::ipc::BigBuffer BigBuffer;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableDataString() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableDataString(BigBuffer&& _data) :
        data_(std::move(_data))
    {
    }

    BigBuffer&
    data()
    {
        return data_;
    }
    const BigBuffer&
    data() const
    {
        return data_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<BigBuffer> data_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataString>
{
    typedef ::mozilla::dom::IPCTransferableDataString paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableDataCString|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataCString final
{
private:
    typedef ::mozilla::ipc::BigBuffer BigBuffer;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableDataCString() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableDataCString(BigBuffer&& _data) :
        data_(std::move(_data))
    {
    }

    BigBuffer&
    data()
    {
        return data_;
    }
    const BigBuffer&
    data() const
    {
        return data_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<BigBuffer> data_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataCString>
{
    typedef ::mozilla::dom::IPCTransferableDataCString paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableDataInputStream|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataInputStream final
{
private:
    typedef ::mozilla::ipc::BigBuffer BigBuffer;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableDataInputStream() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableDataInputStream(BigBuffer&& _data) :
        data_(std::move(_data))
    {
    }

    BigBuffer&
    data()
    {
        return data_;
    }
    const BigBuffer&
    data() const
    {
        return data_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<BigBuffer> data_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataInputStream>
{
    typedef ::mozilla::dom::IPCTransferableDataInputStream paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableDataImageContainer|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataImageContainer final
{
private:
    typedef ::mozilla::dom::IPCImage IPCImage;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableDataImageContainer() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableDataImageContainer(IPCImage&& _image) :
        image_(std::move(_image))
    {
    }

    IPCImage&
    image()
    {
        return image_;
    }
    const IPCImage&
    image() const
    {
        return image_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<IPCImage> image_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataImageContainer>
{
    typedef ::mozilla::dom::IPCTransferableDataImageContainer paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableDataBlob|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataBlob final
{
private:
    typedef ::mozilla::dom::IPCBlob IPCBlob;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableDataBlob() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableDataBlob(const IPCBlob& _blob) :
        blob_(_blob)
    {
    }

    MOZ_IMPLICIT IPCTransferableDataBlob(IPCBlob&& _blob) :
        blob_(std::move(_blob))
    {
    }

    IPCBlob&
    blob()
    {
        return blob_;
    }
    const IPCBlob&
    blob() const
    {
        return blob_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<IPCBlob> blob_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataBlob>
{
    typedef ::mozilla::dom::IPCTransferableDataBlob paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union IPCTransferableDataType|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataType final
{
public:
    enum Type {
        T__None,
        TIPCTransferableDataString = 1,
        TIPCTransferableDataCString,
        TIPCTransferableDataInputStream,
        TIPCTransferableDataImageContainer,
        TIPCTransferableDataBlob,
        T__Last = TIPCTransferableDataBlob
    };

private:
    typedef ::mozilla::dom::IPCTransferableDataString IPCTransferableDataString;
    typedef ::mozilla::dom::IPCTransferableDataCString IPCTransferableDataCString;
    typedef ::mozilla::dom::IPCTransferableDataInputStream IPCTransferableDataInputStream;
    typedef ::mozilla::dom::IPCTransferableDataImageContainer IPCTransferableDataImageContainer;
    typedef ::mozilla::dom::IPCTransferableDataBlob IPCTransferableDataBlob;
    typedef IPCTransferableDataString IPCTransferableDataString__tdef;
    typedef IPCTransferableDataCString IPCTransferableDataCString__tdef;
    typedef IPCTransferableDataInputStream IPCTransferableDataInputStream__tdef;
    typedef IPCTransferableDataImageContainer IPCTransferableDataImageContainer__tdef;
    typedef IPCTransferableDataBlob IPCTransferableDataBlob__tdef;

    IPCTransferableDataString*
    ptr_IPCTransferableDataString()
    {
        return (&(mVIPCTransferableDataString));
    }
    const IPCTransferableDataString*
    constptr_IPCTransferableDataString() const
    {
        return (&(mVIPCTransferableDataString));
    }
    IPCTransferableDataCString*
    ptr_IPCTransferableDataCString()
    {
        return (&(mVIPCTransferableDataCString));
    }
    const IPCTransferableDataCString*
    constptr_IPCTransferableDataCString() const
    {
        return (&(mVIPCTransferableDataCString));
    }
    IPCTransferableDataInputStream*
    ptr_IPCTransferableDataInputStream()
    {
        return (&(mVIPCTransferableDataInputStream));
    }
    const IPCTransferableDataInputStream*
    constptr_IPCTransferableDataInputStream() const
    {
        return (&(mVIPCTransferableDataInputStream));
    }
    IPCTransferableDataImageContainer*
    ptr_IPCTransferableDataImageContainer()
    {
        return (&(mVIPCTransferableDataImageContainer));
    }
    const IPCTransferableDataImageContainer*
    constptr_IPCTransferableDataImageContainer() const
    {
        return (&(mVIPCTransferableDataImageContainer));
    }
    IPCTransferableDataBlob*
    ptr_IPCTransferableDataBlob()
    {
        return (&(mVIPCTransferableDataBlob));
    }
    const IPCTransferableDataBlob*
    constptr_IPCTransferableDataBlob() const
    {
        return (&(mVIPCTransferableDataBlob));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT IPCTransferableDataType() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT IPCTransferableDataType(IPCTransferableDataString&& aOther);

    MOZ_IMPLICIT IPCTransferableDataType(IPCTransferableDataCString&& aOther);

    MOZ_IMPLICIT IPCTransferableDataType(IPCTransferableDataInputStream&& aOther);

    MOZ_IMPLICIT IPCTransferableDataType(IPCTransferableDataImageContainer&& aOther);

    MOZ_IMPLICIT IPCTransferableDataType(const IPCTransferableDataBlob& aOther);

    MOZ_IMPLICIT IPCTransferableDataType(IPCTransferableDataBlob&& aOther);

    MOZ_IMPLICIT IPCTransferableDataType(IPCTransferableDataType&& aOther);

    ~IPCTransferableDataType();

    Type
    type() const
    {
        return mType;
    }

    IPCTransferableDataType&
    operator=(IPCTransferableDataString&& aRhs);

    IPCTransferableDataType&
    operator=(IPCTransferableDataCString&& aRhs);

    IPCTransferableDataType&
    operator=(IPCTransferableDataInputStream&& aRhs);

    IPCTransferableDataType&
    operator=(IPCTransferableDataImageContainer&& aRhs);

    IPCTransferableDataType&
    operator=(const IPCTransferableDataBlob& aRhs);

    IPCTransferableDataType&
    operator=(IPCTransferableDataBlob&& aRhs);

    IPCTransferableDataType&
    operator=(IPCTransferableDataType&& aRhs);

    IPCTransferableDataString&
    get_IPCTransferableDataString()
    {
        AssertSanity(TIPCTransferableDataString);
        return (*(ptr_IPCTransferableDataString()));
    }
    const IPCTransferableDataString&
    get_IPCTransferableDataString() const
    {
        AssertSanity(TIPCTransferableDataString);
        return (*(constptr_IPCTransferableDataString()));
    }
    operator IPCTransferableDataString&()
    {
        return get_IPCTransferableDataString();
    }
    operator const IPCTransferableDataString&() const
    {
        return get_IPCTransferableDataString();
    }

    IPCTransferableDataCString&
    get_IPCTransferableDataCString()
    {
        AssertSanity(TIPCTransferableDataCString);
        return (*(ptr_IPCTransferableDataCString()));
    }
    const IPCTransferableDataCString&
    get_IPCTransferableDataCString() const
    {
        AssertSanity(TIPCTransferableDataCString);
        return (*(constptr_IPCTransferableDataCString()));
    }
    operator IPCTransferableDataCString&()
    {
        return get_IPCTransferableDataCString();
    }
    operator const IPCTransferableDataCString&() const
    {
        return get_IPCTransferableDataCString();
    }

    IPCTransferableDataInputStream&
    get_IPCTransferableDataInputStream()
    {
        AssertSanity(TIPCTransferableDataInputStream);
        return (*(ptr_IPCTransferableDataInputStream()));
    }
    const IPCTransferableDataInputStream&
    get_IPCTransferableDataInputStream() const
    {
        AssertSanity(TIPCTransferableDataInputStream);
        return (*(constptr_IPCTransferableDataInputStream()));
    }
    operator IPCTransferableDataInputStream&()
    {
        return get_IPCTransferableDataInputStream();
    }
    operator const IPCTransferableDataInputStream&() const
    {
        return get_IPCTransferableDataInputStream();
    }

    IPCTransferableDataImageContainer&
    get_IPCTransferableDataImageContainer()
    {
        AssertSanity(TIPCTransferableDataImageContainer);
        return (*(ptr_IPCTransferableDataImageContainer()));
    }
    const IPCTransferableDataImageContainer&
    get_IPCTransferableDataImageContainer() const
    {
        AssertSanity(TIPCTransferableDataImageContainer);
        return (*(constptr_IPCTransferableDataImageContainer()));
    }
    operator IPCTransferableDataImageContainer&()
    {
        return get_IPCTransferableDataImageContainer();
    }
    operator const IPCTransferableDataImageContainer&() const
    {
        return get_IPCTransferableDataImageContainer();
    }

    IPCTransferableDataBlob&
    get_IPCTransferableDataBlob()
    {
        AssertSanity(TIPCTransferableDataBlob);
        return (*(ptr_IPCTransferableDataBlob()));
    }
    const IPCTransferableDataBlob&
    get_IPCTransferableDataBlob() const
    {
        AssertSanity(TIPCTransferableDataBlob);
        return (*(constptr_IPCTransferableDataBlob()));
    }
    operator IPCTransferableDataBlob&()
    {
        return get_IPCTransferableDataBlob();
    }
    operator const IPCTransferableDataBlob&() const
    {
        return get_IPCTransferableDataBlob();
    }

private:
    union {
        IPCTransferableDataString mVIPCTransferableDataString;
        IPCTransferableDataCString mVIPCTransferableDataCString;
        IPCTransferableDataInputStream mVIPCTransferableDataInputStream;
        IPCTransferableDataImageContainer mVIPCTransferableDataImageContainer;
        IPCTransferableDataBlob mVIPCTransferableDataBlob;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataType>
{
    typedef ::mozilla::dom::IPCTransferableDataType paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableDataItem|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataItem final
{
private:
    typedef ::nsCString nsCString;
    typedef ::mozilla::dom::IPCTransferableDataType IPCTransferableDataType;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableDataItem() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableDataItem(
            const nsCString& _flavor,
            IPCTransferableDataType&& _data) :
        flavor_(_flavor),
        data_(std::move(_data))
    {
    }

    MOZ_IMPLICIT IPCTransferableDataItem(
            nsCString&& _flavor,
            IPCTransferableDataType&& _data) :
        flavor_(std::move(_flavor)),
        data_(std::move(_data))
    {
    }

    nsCString&
    flavor()
    {
        return flavor_;
    }
    const nsCString&
    flavor() const
    {
        return flavor_;
    }

    IPCTransferableDataType&
    data()
    {
        return data_;
    }
    const IPCTransferableDataType&
    data() const
    {
        return data_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> flavor_;
    ::mozilla::ipc::IPDLStructMember<IPCTransferableDataType> data_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataItem>
{
    typedef ::mozilla::dom::IPCTransferableDataItem paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferableData|
//
namespace mozilla {
namespace dom {
class IPCTransferableData final
{
private:
    typedef ::mozilla::dom::IPCTransferableDataItem IPCTransferableDataItem;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferableData() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferableData(nsTArray<IPCTransferableDataItem>&& _items) :
        items_(std::move(_items))
    {
    }

    nsTArray<IPCTransferableDataItem>&
    items()
    {
        return items_;
    }
    const nsTArray<IPCTransferableDataItem>&
    items() const
    {
        return items_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<IPCTransferableDataItem>> items_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableData>
{
    typedef ::mozilla::dom::IPCTransferableData paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |union IPCTransferableDataOrError|
//
namespace mozilla {
namespace dom {
class IPCTransferableDataOrError final
{
public:
    enum Type {
        T__None,
        TIPCTransferableData = 1,
        Tnsresult,
        T__Last = Tnsresult
    };

private:
    typedef ::mozilla::dom::IPCTransferableData IPCTransferableData;
    typedef ::nsresult nsresult;
    typedef IPCTransferableData IPCTransferableData__tdef;
    typedef nsresult nsresult__tdef;

    IPCTransferableData*
    ptr_IPCTransferableData()
    {
        return (&(mVIPCTransferableData));
    }
    const IPCTransferableData*
    constptr_IPCTransferableData() const
    {
        return (&(mVIPCTransferableData));
    }
    nsresult*
    ptr_nsresult()
    {
        return (&(mVnsresult));
    }
    const nsresult*
    constptr_nsresult() const
    {
        return (&(mVnsresult));
    }

    void
    MaybeDestroy();

    void
    AssertSanity() const
    {
        MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
        MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
    }
    void
    AssertSanity(Type aType) const
    {
        AssertSanity();
        MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
    }

public:
    MOZ_IMPLICIT IPCTransferableDataOrError() :
        mType(T__None)
    {
    }

    MOZ_IMPLICIT IPCTransferableDataOrError(IPCTransferableData&& aOther);

    MOZ_IMPLICIT IPCTransferableDataOrError(const nsresult& aOther);

    MOZ_IMPLICIT IPCTransferableDataOrError(nsresult&& aOther);

    MOZ_IMPLICIT IPCTransferableDataOrError(IPCTransferableDataOrError&& aOther);

    ~IPCTransferableDataOrError();

    Type
    type() const
    {
        return mType;
    }

    IPCTransferableDataOrError&
    operator=(IPCTransferableData&& aRhs);

    IPCTransferableDataOrError&
    operator=(const nsresult& aRhs);

    IPCTransferableDataOrError&
    operator=(nsresult&& aRhs);

    IPCTransferableDataOrError&
    operator=(IPCTransferableDataOrError&& aRhs);

    IPCTransferableData&
    get_IPCTransferableData()
    {
        AssertSanity(TIPCTransferableData);
        return (*(ptr_IPCTransferableData()));
    }
    const IPCTransferableData&
    get_IPCTransferableData() const
    {
        AssertSanity(TIPCTransferableData);
        return (*(constptr_IPCTransferableData()));
    }
    operator IPCTransferableData&()
    {
        return get_IPCTransferableData();
    }
    operator const IPCTransferableData&() const
    {
        return get_IPCTransferableData();
    }

    nsresult&
    get_nsresult()
    {
        AssertSanity(Tnsresult);
        return (*(ptr_nsresult()));
    }
    const nsresult&
    get_nsresult() const
    {
        AssertSanity(Tnsresult);
        return (*(constptr_nsresult()));
    }
    operator nsresult&()
    {
        return get_nsresult();
    }
    operator const nsresult&() const
    {
        return get_nsresult();
    }

private:
    union {
        IPCTransferableData mVIPCTransferableData;
        nsresult mVnsresult;
    };
    Type mType;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferableDataOrError>
{
    typedef ::mozilla::dom::IPCTransferableDataOrError paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct IPCTransferable|
//
namespace mozilla {
namespace dom {
class IPCTransferable final
{
private:
    typedef ::mozilla::dom::IPCTransferableData IPCTransferableData;
    typedef ::nsIPrincipal nsIPrincipal;
    typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
    typedef ::nsContentPolicyType nsContentPolicyType;
    typedef ::nsIReferrerInfo nsIReferrerInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    IPCTransferable() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT IPCTransferable(
            IPCTransferableData&& _data,
            const bool& _isPrivateData,
            nsIPrincipal* _dataPrincipal,
            const mozilla::Maybe<CookieJarSettingsArgs>& _cookieJarSettings,
            const nsContentPolicyType& _contentPolicyType,
            nsIReferrerInfo* _referrerInfo) :
        data_(std::move(_data)),
        isPrivateData_(_isPrivateData),
        dataPrincipal_(_dataPrincipal),
        cookieJarSettings_(_cookieJarSettings),
        contentPolicyType_(_contentPolicyType),
        referrerInfo_(_referrerInfo)
    {
    }

    MOZ_IMPLICIT IPCTransferable(
            IPCTransferableData&& _data,
            bool&& _isPrivateData,
            RefPtr<nsIPrincipal>&& _dataPrincipal,
            mozilla::Maybe<CookieJarSettingsArgs>&& _cookieJarSettings,
            nsContentPolicyType&& _contentPolicyType,
            RefPtr<nsIReferrerInfo>&& _referrerInfo) :
        data_(std::move(_data)),
        isPrivateData_(std::move(_isPrivateData)),
        dataPrincipal_(std::move(_dataPrincipal)),
        cookieJarSettings_(std::move(_cookieJarSettings)),
        contentPolicyType_(std::move(_contentPolicyType)),
        referrerInfo_(std::move(_referrerInfo))
    {
    }

    IPCTransferableData&
    data()
    {
        return data_;
    }
    const IPCTransferableData&
    data() const
    {
        return data_;
    }

    bool&
    isPrivateData()
    {
        return isPrivateData_;
    }
    const bool&
    isPrivateData() const
    {
        return isPrivateData_;
    }

    RefPtr<nsIPrincipal>&
    dataPrincipal()
    {
        return dataPrincipal_;
    }
    nsIPrincipal*
    dataPrincipal() const
    {
        return dataPrincipal_;
    }

    mozilla::Maybe<CookieJarSettingsArgs>&
    cookieJarSettings()
    {
        return cookieJarSettings_;
    }
    const mozilla::Maybe<CookieJarSettingsArgs>&
    cookieJarSettings() const
    {
        return cookieJarSettings_;
    }

    nsContentPolicyType&
    contentPolicyType()
    {
        return contentPolicyType_;
    }
    const nsContentPolicyType&
    contentPolicyType() const
    {
        return contentPolicyType_;
    }

    RefPtr<nsIReferrerInfo>&
    referrerInfo()
    {
        return referrerInfo_;
    }
    nsIReferrerInfo*
    referrerInfo() const
    {
        return referrerInfo_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<IPCTransferableData> data_;
    ::mozilla::ipc::IPDLStructMember<bool> isPrivateData_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIPrincipal>> dataPrincipal_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CookieJarSettingsArgs>> cookieJarSettings_;
    ::mozilla::ipc::IPDLStructMember<nsContentPolicyType> contentPolicyType_;
    ::mozilla::ipc::IPDLStructMember<RefPtr<nsIReferrerInfo>> referrerInfo_;
};
} // namespace dom
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::IPCTransferable>
{
    typedef ::mozilla::dom::IPCTransferable paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            paramType&& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

#endif // ifndef IPCTransferable_h
