Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/IPCBlobUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/CSPMessageUtils.h"
#include "mozilla/dom/DocShellMessageUtils.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/TabMessageUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/dom/sessionstore/SessionStoreTypes.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct Checkbox|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::Checkbox>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::dom::sessionstore::Checkbox>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___value = IPC::ReadParam<bool>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (bool) member of 'Checkbox'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (bool) member of 'Checkbox'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct TextField|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::TextField>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::dom::sessionstore::TextField>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___value = IPC::ReadParam<::nsString>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsString) member of 'TextField'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsString) member of 'TextField'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileList|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FileList>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).valueList());
// Sentinel = 'valueList'
(aWriter)->WriteSentinel(312935354);
}
auto ParamTraits<::mozilla::dom::sessionstore::FileList>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___valueList = IPC::ReadParam<nsTArray<::nsString>>(aReader);
if (!maybe___valueList) {
aReader->FatalError("Error deserializing 'valueList' (nsString[]) member of 'FileList'");
return {};
}
auto& _valueList = *maybe___valueList;
// Sentinel = 'valueList'
if ((!((aReader)->ReadSentinel(312935354)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'valueList' (nsString[]) member of 'FileList'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_valueList)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SingleSelect|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::SingleSelect>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
(aWriter)->WriteBytes((&((aVar).index())), 4);
// Sentinel = 'index'
(aWriter)->WriteSentinel(104333849);
}
auto ParamTraits<::mozilla::dom::sessionstore::SingleSelect>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___value = IPC::ReadParam<::nsString>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsString) member of 'SingleSelect'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsString) member of 'SingleSelect'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
std::move(_value)};
if ((!((aReader)->ReadBytesInto((&((result__)->index())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'index'
if ((!((aReader)->ReadSentinel(104333849)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct MultipleSelect|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::MultipleSelect>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).valueList());
// Sentinel = 'valueList'
(aWriter)->WriteSentinel(312935354);
}
auto ParamTraits<::mozilla::dom::sessionstore::MultipleSelect>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___valueList = IPC::ReadParam<nsTArray<::nsString>>(aReader);
if (!maybe___valueList) {
aReader->FatalError("Error deserializing 'valueList' (nsString[]) member of 'MultipleSelect'");
return {};
}
auto& _valueList = *maybe___valueList;
// Sentinel = 'valueList'
if ((!((aReader)->ReadSentinel(312935354)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'valueList' (nsString[]) member of 'MultipleSelect'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_valueList)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union FormEntryValue|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
auto FormEntryValue::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TCheckbox:
{
(ptr_Checkbox())->~Checkbox__tdef();
break;
}
case TTextField:
{
(ptr_TextField())->~TextField__tdef();
break;
}
case TFileList:
{
(ptr_FileList())->~FileList__tdef();
break;
}
case TSingleSelect:
{
(ptr_SingleSelect())->~SingleSelect__tdef();
break;
}
case TMultipleSelect:
{
(ptr_MultipleSelect())->~MultipleSelect__tdef();
break;
}
case TCustomElementTuple:
{
(ptr_CustomElementTuple())->~CustomElementTuple__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const Checkbox& aOther)
{
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(aOther);
mType = TCheckbox;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(Checkbox&& aOther)
{
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move(aOther));
mType = TCheckbox;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const TextField& aOther)
{
new (mozilla::KnownNotNull, ptr_TextField()) TextField(aOther);
mType = TTextField;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(TextField&& aOther)
{
new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move(aOther));
mType = TTextField;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const FileList& aOther)
{
new (mozilla::KnownNotNull, ptr_FileList()) FileList(aOther);
mType = TFileList;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(FileList&& aOther)
{
new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move(aOther));
mType = TFileList;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const SingleSelect& aOther)
{
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(aOther);
mType = TSingleSelect;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(SingleSelect&& aOther)
{
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move(aOther));
mType = TSingleSelect;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const MultipleSelect& aOther)
{
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(aOther);
mType = TMultipleSelect;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(MultipleSelect&& aOther)
{
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move(aOther));
mType = TMultipleSelect;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const CustomElementTuple& aOther)
{
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(aOther);
mType = TCustomElementTuple;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(CustomElementTuple&& aOther)
{
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move(aOther));
mType = TCustomElementTuple;
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(const FormEntryValue& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TCheckbox:
{
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox((aOther).get_Checkbox());
break;
}
case TTextField:
{
new (mozilla::KnownNotNull, ptr_TextField()) TextField((aOther).get_TextField());
break;
}
case TFileList:
{
new (mozilla::KnownNotNull, ptr_FileList()) FileList((aOther).get_FileList());
break;
}
case TSingleSelect:
{
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect((aOther).get_SingleSelect());
break;
}
case TMultipleSelect:
{
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect((aOther).get_MultipleSelect());
break;
}
case TCustomElementTuple:
{
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple((aOther).get_CustomElementTuple());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT FormEntryValue::FormEntryValue(FormEntryValue&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TCheckbox:
{
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move((aOther).get_Checkbox()));
(aOther).MaybeDestroy();
break;
}
case TTextField:
{
new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move((aOther).get_TextField()));
(aOther).MaybeDestroy();
break;
}
case TFileList:
{
new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move((aOther).get_FileList()));
(aOther).MaybeDestroy();
break;
}
case TSingleSelect:
{
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move((aOther).get_SingleSelect()));
(aOther).MaybeDestroy();
break;
}
case TMultipleSelect:
{
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move((aOther).get_MultipleSelect()));
(aOther).MaybeDestroy();
break;
}
case TCustomElementTuple:
{
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move((aOther).get_CustomElementTuple()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
FormEntryValue::~FormEntryValue()
{
MaybeDestroy();
}
auto FormEntryValue::operator=(const Checkbox& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(aRhs);
mType = TCheckbox;
return (*(this));
}
auto FormEntryValue::operator=(Checkbox&& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move(aRhs));
mType = TCheckbox;
return (*(this));
}
auto FormEntryValue::operator=(const TextField& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_TextField()) TextField(aRhs);
mType = TTextField;
return (*(this));
}
auto FormEntryValue::operator=(TextField&& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move(aRhs));
mType = TTextField;
return (*(this));
}
auto FormEntryValue::operator=(const FileList& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileList()) FileList(aRhs);
mType = TFileList;
return (*(this));
}
auto FormEntryValue::operator=(FileList&& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move(aRhs));
mType = TFileList;
return (*(this));
}
auto FormEntryValue::operator=(const SingleSelect& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(aRhs);
mType = TSingleSelect;
return (*(this));
}
auto FormEntryValue::operator=(SingleSelect&& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move(aRhs));
mType = TSingleSelect;
return (*(this));
}
auto FormEntryValue::operator=(const MultipleSelect& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(aRhs);
mType = TMultipleSelect;
return (*(this));
}
auto FormEntryValue::operator=(MultipleSelect&& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move(aRhs));
mType = TMultipleSelect;
return (*(this));
}
auto FormEntryValue::operator=(const CustomElementTuple& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(aRhs);
mType = TCustomElementTuple;
return (*(this));
}
auto FormEntryValue::operator=(CustomElementTuple&& aRhs) -> FormEntryValue&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move(aRhs));
mType = TCustomElementTuple;
return (*(this));
}
auto FormEntryValue::operator=(const FormEntryValue& aRhs) -> FormEntryValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TCheckbox:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox((aRhs).get_Checkbox());
break;
}
case TTextField:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_TextField()) TextField((aRhs).get_TextField());
break;
}
case TFileList:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileList()) FileList((aRhs).get_FileList());
break;
}
case TSingleSelect:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect((aRhs).get_SingleSelect());
break;
}
case TMultipleSelect:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect((aRhs).get_MultipleSelect());
break;
}
case TCustomElementTuple:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple((aRhs).get_CustomElementTuple());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto FormEntryValue::operator=(FormEntryValue&& aRhs) -> FormEntryValue&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TCheckbox:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_Checkbox()) Checkbox(std::move((aRhs).get_Checkbox()));
(aRhs).MaybeDestroy();
break;
}
case TTextField:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_TextField()) TextField(std::move((aRhs).get_TextField()));
(aRhs).MaybeDestroy();
break;
}
case TFileList:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_FileList()) FileList(std::move((aRhs).get_FileList()));
(aRhs).MaybeDestroy();
break;
}
case TSingleSelect:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SingleSelect()) SingleSelect(std::move((aRhs).get_SingleSelect()));
(aRhs).MaybeDestroy();
break;
}
case TMultipleSelect:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_MultipleSelect()) MultipleSelect(std::move((aRhs).get_MultipleSelect()));
(aRhs).MaybeDestroy();
break;
}
case TCustomElementTuple:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CustomElementTuple()) CustomElementTuple(std::move((aRhs).get_CustomElementTuple()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FormEntryValue>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::sessionstore::FormEntryValue union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'FormEntryValue'
(aWriter)->WriteSentinel(695535012);
switch (type) {
case union__::TCheckbox:
{
IPC::WriteParam(aWriter, (aVar).get_Checkbox());
// Sentinel = 'TCheckbox'
(aWriter)->WriteSentinel(274858876);
return;
}
case union__::TTextField:
{
IPC::WriteParam(aWriter, (aVar).get_TextField());
// Sentinel = 'TTextField'
(aWriter)->WriteSentinel(349897694);
return;
}
case union__::TFileList:
{
IPC::WriteParam(aWriter, (aVar).get_FileList());
// Sentinel = 'TFileList'
(aWriter)->WriteSentinel(273810289);
return;
}
case union__::TSingleSelect:
{
IPC::WriteParam(aWriter, (aVar).get_SingleSelect());
// Sentinel = 'TSingleSelect'
(aWriter)->WriteSentinel(583664919);
return;
}
case union__::TMultipleSelect:
{
IPC::WriteParam(aWriter, (aVar).get_MultipleSelect());
// Sentinel = 'TMultipleSelect'
(aWriter)->WriteSentinel(794756609);
return;
}
case union__::TCustomElementTuple:
{
IPC::WriteParam(aWriter, (aVar).get_CustomElementTuple());
// Sentinel = 'TCustomElementTuple'
(aWriter)->WriteSentinel(1257179044);
return;
}
default:
{
aWriter->FatalError("unknown variant of union FormEntryValue");
return;
}
}
}
auto ParamTraits<::mozilla::dom::sessionstore::FormEntryValue>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::sessionstore::FormEntryValue union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union FormEntryValue");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'FormEntryValue'
if ((!((aReader)->ReadSentinel(695535012)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union FormEntryValue");
return {};
}
switch (type) {
case union__::TCheckbox:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::Checkbox>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCheckbox of union FormEntryValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCheckbox'
if ((!((aReader)->ReadSentinel(274858876)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCheckbox of union FormEntryValue");
return {};
}
return std::move(tmp);
}
case union__::TTextField:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::TextField>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TTextField of union FormEntryValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TTextField'
if ((!((aReader)->ReadSentinel(349897694)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TTextField of union FormEntryValue");
return {};
}
return std::move(tmp);
}
case union__::TFileList:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::FileList>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TFileList of union FormEntryValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TFileList'
if ((!((aReader)->ReadSentinel(273810289)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TFileList of union FormEntryValue");
return {};
}
return std::move(tmp);
}
case union__::TSingleSelect:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::SingleSelect>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TSingleSelect of union FormEntryValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TSingleSelect'
if ((!((aReader)->ReadSentinel(583664919)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TSingleSelect of union FormEntryValue");
return {};
}
return std::move(tmp);
}
case union__::TMultipleSelect:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::sessionstore::MultipleSelect>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TMultipleSelect of union FormEntryValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TMultipleSelect'
if ((!((aReader)->ReadSentinel(794756609)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TMultipleSelect of union FormEntryValue");
return {};
}
return std::move(tmp);
}
case union__::TCustomElementTuple:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::CustomElementTuple>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCustomElementTuple of union FormEntryValue");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCustomElementTuple'
if ((!((aReader)->ReadSentinel(1257179044)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCustomElementTuple of union FormEntryValue");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union FormEntryValue");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FormEntry|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FormEntry>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::dom::sessionstore::FormEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___id = IPC::ReadParam<::nsString>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (nsString) member of 'FormEntry'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsString) member of 'FormEntry'");
return {};
}
auto maybe___value = IPC::ReadParam<::mozilla::dom::sessionstore::FormEntryValue>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (FormEntryValue) member of 'FormEntry'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (FormEntryValue) member of 'FormEntry'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_id),
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FormData|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::FormData>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).hasData());
// Sentinel = 'hasData'
(aWriter)->WriteSentinel(182452919);
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).xpath());
// Sentinel = 'xpath'
(aWriter)->WriteSentinel(110101030);
IPC::WriteParam(aWriter, (aVar).innerHTML());
// Sentinel = 'innerHTML'
(aWriter)->WriteSentinel(298189650);
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
}
auto ParamTraits<::mozilla::dom::sessionstore::FormData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___hasData = IPC::ReadParam<bool>(aReader);
if (!maybe___hasData) {
aReader->FatalError("Error deserializing 'hasData' (bool) member of 'FormData'");
return {};
}
auto& _hasData = *maybe___hasData;
// Sentinel = 'hasData'
if ((!((aReader)->ReadSentinel(182452919)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasData' (bool) member of 'FormData'");
return {};
}
auto maybe___id = IPC::ReadParam<nsTArray<::mozilla::dom::sessionstore::FormEntry>>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (FormEntry[]) member of 'FormData'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (FormEntry[]) member of 'FormData'");
return {};
}
auto maybe___xpath = IPC::ReadParam<nsTArray<::mozilla::dom::sessionstore::FormEntry>>(aReader);
if (!maybe___xpath) {
aReader->FatalError("Error deserializing 'xpath' (FormEntry[]) member of 'FormData'");
return {};
}
auto& _xpath = *maybe___xpath;
// Sentinel = 'xpath'
if ((!((aReader)->ReadSentinel(110101030)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'xpath' (FormEntry[]) member of 'FormData'");
return {};
}
auto maybe___innerHTML = IPC::ReadParam<::nsString>(aReader);
if (!maybe___innerHTML) {
aReader->FatalError("Error deserializing 'innerHTML' (nsString) member of 'FormData'");
return {};
}
auto& _innerHTML = *maybe___innerHTML;
// Sentinel = 'innerHTML'
if ((!((aReader)->ReadSentinel(298189650)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'innerHTML' (nsString) member of 'FormData'");
return {};
}
auto maybe___uri = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___uri) {
aReader->FatalError("Error deserializing 'uri' (nsCString) member of 'FormData'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (nsCString) member of 'FormData'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_hasData),
std::move(_id),
std::move(_xpath),
std::move(_innerHTML),
std::move(_uri)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DocShellRestoreState|
//
namespace mozilla {
namespace dom {
namespace sessionstore {
} // namespace sessionstore
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::sessionstore::DocShellRestoreState>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).URI());
// Sentinel = 'URI'
(aWriter)->WriteSentinel(32440561);
IPC::WriteParam(aWriter, (aVar).docShellCaps());
// Sentinel = 'docShellCaps'
(aWriter)->WriteSentinel(510854326);
}
auto ParamTraits<::mozilla::dom::sessionstore::DocShellRestoreState>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___URI = IPC::ReadParam<RefPtr<::nsIURI>>(aReader);
if (!maybe___URI) {
aReader->FatalError("Error deserializing 'URI' (nsIURI) member of 'DocShellRestoreState'");
return {};
}
auto& _URI = *maybe___URI;
// Sentinel = 'URI'
if ((!((aReader)->ReadSentinel(32440561)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'URI' (nsIURI) member of 'DocShellRestoreState'");
return {};
}
auto maybe___docShellCaps = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___docShellCaps) {
aReader->FatalError("Error deserializing 'docShellCaps' (nsCString) member of 'DocShellRestoreState'");
return {};
}
auto& _docShellCaps = *maybe___docShellCaps;
// Sentinel = 'docShellCaps'
if ((!((aReader)->ReadSentinel(510854326)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'docShellCaps' (nsCString) member of 'DocShellRestoreState'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_URI),
std::move(_docShellCaps)};
return result__;
}
} // namespace IPC