Copy as Markdown
Other Tools
//
// 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;
union Value {
mozilla::AlignedStorage2<IPCTransferableDataString> VIPCTransferableDataString;
mozilla::AlignedStorage2<IPCTransferableDataCString> VIPCTransferableDataCString;
mozilla::AlignedStorage2<IPCTransferableDataInputStream> VIPCTransferableDataInputStream;
mozilla::AlignedStorage2<IPCTransferableDataImageContainer> VIPCTransferableDataImageContainer;
mozilla::AlignedStorage2<IPCTransferableDataBlob> VIPCTransferableDataBlob;
};
IPCTransferableDataString*
ptr_IPCTransferableDataString()
{
return ((mValue).VIPCTransferableDataString).addr();
}
const IPCTransferableDataString*
constptr_IPCTransferableDataString() const
{
return ((mValue).VIPCTransferableDataString).addr();
}
IPCTransferableDataCString*
ptr_IPCTransferableDataCString()
{
return ((mValue).VIPCTransferableDataCString).addr();
}
const IPCTransferableDataCString*
constptr_IPCTransferableDataCString() const
{
return ((mValue).VIPCTransferableDataCString).addr();
}
IPCTransferableDataInputStream*
ptr_IPCTransferableDataInputStream()
{
return ((mValue).VIPCTransferableDataInputStream).addr();
}
const IPCTransferableDataInputStream*
constptr_IPCTransferableDataInputStream() const
{
return ((mValue).VIPCTransferableDataInputStream).addr();
}
IPCTransferableDataImageContainer*
ptr_IPCTransferableDataImageContainer()
{
return ((mValue).VIPCTransferableDataImageContainer).addr();
}
const IPCTransferableDataImageContainer*
constptr_IPCTransferableDataImageContainer() const
{
return ((mValue).VIPCTransferableDataImageContainer).addr();
}
IPCTransferableDataBlob*
ptr_IPCTransferableDataBlob()
{
return ((mValue).VIPCTransferableDataBlob).addr();
}
const IPCTransferableDataBlob*
constptr_IPCTransferableDataBlob() const
{
return ((mValue).VIPCTransferableDataBlob).addr();
}
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:
Value mValue;
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;
union Value {
mozilla::AlignedStorage2<IPCTransferableData> VIPCTransferableData;
mozilla::AlignedStorage2<nsresult> Vnsresult;
};
IPCTransferableData*
ptr_IPCTransferableData()
{
return ((mValue).VIPCTransferableData).addr();
}
const IPCTransferableData*
constptr_IPCTransferableData() const
{
return ((mValue).VIPCTransferableData).addr();
}
nsresult*
ptr_nsresult()
{
return ((mValue).Vnsresult).addr();
}
const nsresult*
constptr_nsresult() const
{
return ((mValue).Vnsresult).addr();
}
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:
Value mValue;
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