Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/ipc/URIParams.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 SimpleURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::SimpleURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).scheme());
// Sentinel = 'scheme'
(aWriter)->WriteSentinel(146080374);
IPC::WriteParam(aWriter, (aVar).path());
// Sentinel = 'path'
(aWriter)->WriteSentinel(70713774);
IPC::WriteParam(aWriter, (aVar).ref());
// Sentinel = 'ref'
(aWriter)->WriteSentinel(42533182);
IPC::WriteParam(aWriter, (aVar).query());
// Sentinel = 'query'
(aWriter)->WriteSentinel(110756407);
}
auto ParamTraits<::mozilla::ipc::SimpleURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___scheme = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___scheme) {
aReader->FatalError("Error deserializing 'scheme' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto& _scheme = *maybe___scheme;
// Sentinel = 'scheme'
if ((!((aReader)->ReadSentinel(146080374)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto maybe___path = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___path) {
aReader->FatalError("Error deserializing 'path' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto& _path = *maybe___path;
// Sentinel = 'path'
if ((!((aReader)->ReadSentinel(70713774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'path' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto maybe___ref = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___ref) {
aReader->FatalError("Error deserializing 'ref' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto& _ref = *maybe___ref;
// Sentinel = 'ref'
if ((!((aReader)->ReadSentinel(42533182)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ref' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto maybe___query = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___query) {
aReader->FatalError("Error deserializing 'query' (nsCString) member of 'SimpleURIParams'");
return {};
}
auto& _query = *maybe___query;
// Sentinel = 'query'
if ((!((aReader)->ReadSentinel(110756407)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'query' (nsCString) member of 'SimpleURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_scheme),
std::move(_path),
std::move(_ref),
std::move(_query)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DefaultURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::DefaultURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).spec());
// Sentinel = 'spec'
(aWriter)->WriteSentinel(72155564);
}
auto ParamTraits<::mozilla::ipc::DefaultURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___spec = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___spec) {
aReader->FatalError("Error deserializing 'spec' (nsCString) member of 'DefaultURIParams'");
return {};
}
auto& _spec = *maybe___spec;
// Sentinel = 'spec'
if ((!((aReader)->ReadSentinel(72155564)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'DefaultURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_spec)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StandardURLSegment|
//
namespace mozilla {
namespace ipc {
auto StandardURLSegment::StaticAssertions() const -> void
{
static_assert(
(offsetof(StandardURLSegment, length_) - offsetof(StandardURLSegment, position_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::StandardURLSegment>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).position())), 8);
// Sentinel = 'position | length'
(aWriter)->WriteSentinel(1030424244);
}
auto ParamTraits<::mozilla::ipc::StandardURLSegment>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
::int32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->position())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'position | length'
if ((!((aReader)->ReadSentinel(1030424244)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StandardURLParams|
//
namespace mozilla {
namespace ipc {
auto StandardURLParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(StandardURLParams, defaultPort_) - offsetof(StandardURLParams, urlType_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::StandardURLParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).spec());
// Sentinel = 'spec'
(aWriter)->WriteSentinel(72155564);
IPC::WriteParam(aWriter, (aVar).scheme());
// Sentinel = 'scheme'
(aWriter)->WriteSentinel(146080374);
IPC::WriteParam(aWriter, (aVar).authority());
// Sentinel = 'authority'
(aWriter)->WriteSentinel(323290090);
IPC::WriteParam(aWriter, (aVar).username());
// Sentinel = 'username'
(aWriter)->WriteSentinel(260506465);
IPC::WriteParam(aWriter, (aVar).password());
// Sentinel = 'password'
(aWriter)->WriteSentinel(261161844);
IPC::WriteParam(aWriter, (aVar).host());
// Sentinel = 'host'
(aWriter)->WriteSentinel(72024511);
IPC::WriteParam(aWriter, (aVar).path());
// Sentinel = 'path'
(aWriter)->WriteSentinel(70713774);
IPC::WriteParam(aWriter, (aVar).filePath());
// Sentinel = 'filePath'
(aWriter)->WriteSentinel(239797038);
IPC::WriteParam(aWriter, (aVar).directory());
// Sentinel = 'directory'
(aWriter)->WriteSentinel(314180566);
IPC::WriteParam(aWriter, (aVar).baseName());
// Sentinel = 'baseName'
(aWriter)->WriteSentinel(235143965);
IPC::WriteParam(aWriter, (aVar).extension());
// Sentinel = 'extension'
(aWriter)->WriteSentinel(324600798);
IPC::WriteParam(aWriter, (aVar).query());
// Sentinel = 'query'
(aWriter)->WriteSentinel(110756407);
IPC::WriteParam(aWriter, (aVar).ref());
// Sentinel = 'ref'
(aWriter)->WriteSentinel(42533182);
IPC::WriteParam(aWriter, (aVar).supportsFileURL());
// Sentinel = 'supportsFileURL'
(aWriter)->WriteSentinel(856032772);
IPC::WriteParam(aWriter, (aVar).isSubstituting());
// Sentinel = 'isSubstituting'
(aWriter)->WriteSentinel(742065650);
(aWriter)->WriteBytes((&((aVar).urlType())), 12);
// Sentinel = 'urlType | port | defaultPort'
(aWriter)->WriteSentinel(2589395645);
}
auto ParamTraits<::mozilla::ipc::StandardURLParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___spec = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___spec) {
aReader->FatalError("Error deserializing 'spec' (nsCString) member of 'StandardURLParams'");
return {};
}
auto& _spec = *maybe___spec;
// Sentinel = 'spec'
if ((!((aReader)->ReadSentinel(72155564)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'spec' (nsCString) member of 'StandardURLParams'");
return {};
}
auto maybe___scheme = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___scheme) {
aReader->FatalError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _scheme = *maybe___scheme;
// Sentinel = 'scheme'
if ((!((aReader)->ReadSentinel(146080374)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'scheme' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___authority = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___authority) {
aReader->FatalError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _authority = *maybe___authority;
// Sentinel = 'authority'
if ((!((aReader)->ReadSentinel(323290090)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'authority' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___username = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___username) {
aReader->FatalError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _username = *maybe___username;
// Sentinel = 'username'
if ((!((aReader)->ReadSentinel(260506465)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'username' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___password = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___password) {
aReader->FatalError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _password = *maybe___password;
// Sentinel = 'password'
if ((!((aReader)->ReadSentinel(261161844)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'password' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___host = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___host) {
aReader->FatalError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _host = *maybe___host;
// Sentinel = 'host'
if ((!((aReader)->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'host' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___path = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___path) {
aReader->FatalError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _path = *maybe___path;
// Sentinel = 'path'
if ((!((aReader)->ReadSentinel(70713774)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'path' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___filePath = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___filePath) {
aReader->FatalError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _filePath = *maybe___filePath;
// Sentinel = 'filePath'
if ((!((aReader)->ReadSentinel(239797038)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'filePath' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___directory = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___directory) {
aReader->FatalError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _directory = *maybe___directory;
// Sentinel = 'directory'
if ((!((aReader)->ReadSentinel(314180566)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'directory' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___baseName = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___baseName) {
aReader->FatalError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _baseName = *maybe___baseName;
// Sentinel = 'baseName'
if ((!((aReader)->ReadSentinel(235143965)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'baseName' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___extension = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___extension) {
aReader->FatalError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _extension = *maybe___extension;
// Sentinel = 'extension'
if ((!((aReader)->ReadSentinel(324600798)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'extension' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___query = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___query) {
aReader->FatalError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _query = *maybe___query;
// Sentinel = 'query'
if ((!((aReader)->ReadSentinel(110756407)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'query' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___ref = IPC::ReadParam<::mozilla::ipc::StandardURLSegment>(aReader);
if (!maybe___ref) {
aReader->FatalError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto& _ref = *maybe___ref;
// Sentinel = 'ref'
if ((!((aReader)->ReadSentinel(42533182)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ref' (StandardURLSegment) member of 'StandardURLParams'");
return {};
}
auto maybe___supportsFileURL = IPC::ReadParam<bool>(aReader);
if (!maybe___supportsFileURL) {
aReader->FatalError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
return {};
}
auto& _supportsFileURL = *maybe___supportsFileURL;
// Sentinel = 'supportsFileURL'
if ((!((aReader)->ReadSentinel(856032772)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'supportsFileURL' (bool) member of 'StandardURLParams'");
return {};
}
auto maybe___isSubstituting = IPC::ReadParam<bool>(aReader);
if (!maybe___isSubstituting) {
aReader->FatalError("Error deserializing 'isSubstituting' (bool) member of 'StandardURLParams'");
return {};
}
auto& _isSubstituting = *maybe___isSubstituting;
// Sentinel = 'isSubstituting'
if ((!((aReader)->ReadSentinel(742065650)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isSubstituting' (bool) member of 'StandardURLParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::uint32_t{0},
::int32_t{0},
::int32_t{0},
std::move(_spec),
std::move(_scheme),
std::move(_authority),
std::move(_username),
std::move(_password),
std::move(_host),
std::move(_path),
std::move(_filePath),
std::move(_directory),
std::move(_baseName),
std::move(_extension),
std::move(_query),
std::move(_ref),
std::move(_supportsFileURL),
std::move(_isSubstituting)};
if ((!((aReader)->ReadBytesInto((&((result__)->urlType())), 12)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'urlType | port | defaultPort'
if ((!((aReader)->ReadSentinel(2589395645)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct JARURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::JARURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).jarFile());
// Sentinel = 'jarFile'
(aWriter)->WriteSentinel(184353470);
IPC::WriteParam(aWriter, (aVar).jarEntry());
// Sentinel = 'jarEntry'
(aWriter)->WriteSentinel(242549584);
IPC::WriteParam(aWriter, (aVar).charset());
// Sentinel = 'charset'
(aWriter)->WriteSentinel(191890155);
}
auto ParamTraits<::mozilla::ipc::JARURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___jarFile = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
if (!maybe___jarFile) {
aReader->FatalError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
return {};
}
auto& _jarFile = *maybe___jarFile;
// Sentinel = 'jarFile'
if ((!((aReader)->ReadSentinel(184353470)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'jarFile' (URIParams) member of 'JARURIParams'");
return {};
}
auto maybe___jarEntry = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
if (!maybe___jarEntry) {
aReader->FatalError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
return {};
}
auto& _jarEntry = *maybe___jarEntry;
// Sentinel = 'jarEntry'
if ((!((aReader)->ReadSentinel(242549584)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'jarEntry' (URIParams) member of 'JARURIParams'");
return {};
}
auto maybe___charset = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___charset) {
aReader->FatalError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
return {};
}
auto& _charset = *maybe___charset;
// Sentinel = 'charset'
if ((!((aReader)->ReadSentinel(191890155)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'charset' (nsCString) member of 'JARURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_jarFile),
std::move(_jarEntry),
std::move(_charset)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IconURIParams|
//
namespace mozilla {
namespace ipc {
auto IconURIParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(IconURIParams, iconState_) - offsetof(IconURIParams, size_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::IconURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).uri());
// Sentinel = 'uri'
(aWriter)->WriteSentinel(45023569);
IPC::WriteParam(aWriter, (aVar).contentType());
// Sentinel = 'contentType'
(aWriter)->WriteSentinel(465241246);
IPC::WriteParam(aWriter, (aVar).fileName());
// Sentinel = 'fileName'
(aWriter)->WriteSentinel(238158626);
IPC::WriteParam(aWriter, (aVar).stockIcon());
// Sentinel = 'stockIcon'
(aWriter)->WriteSentinel(314508206);
(aWriter)->WriteBytes((&((aVar).size())), 12);
// Sentinel = 'size | iconSize | iconState'
(aWriter)->WriteSentinel(2358643234);
}
auto ParamTraits<::mozilla::ipc::IconURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___uri = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
if (!maybe___uri) {
aReader->FatalError("Error deserializing 'uri' (URIParams?) member of 'IconURIParams'");
return {};
}
auto& _uri = *maybe___uri;
// Sentinel = 'uri'
if ((!((aReader)->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uri' (URIParams?) member of 'IconURIParams'");
return {};
}
auto maybe___contentType = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___contentType) {
aReader->FatalError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
return {};
}
auto& _contentType = *maybe___contentType;
// Sentinel = 'contentType'
if ((!((aReader)->ReadSentinel(465241246)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsCString) member of 'IconURIParams'");
return {};
}
auto maybe___fileName = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___fileName) {
aReader->FatalError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
return {};
}
auto& _fileName = *maybe___fileName;
// Sentinel = 'fileName'
if ((!((aReader)->ReadSentinel(238158626)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fileName' (nsCString) member of 'IconURIParams'");
return {};
}
auto maybe___stockIcon = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___stockIcon) {
aReader->FatalError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
return {};
}
auto& _stockIcon = *maybe___stockIcon;
// Sentinel = 'stockIcon'
if ((!((aReader)->ReadSentinel(314508206)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'stockIcon' (nsCString) member of 'IconURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_uri),
::uint32_t{0},
std::move(_contentType),
std::move(_fileName),
std::move(_stockIcon),
::int32_t{0},
::int32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->size())), 12)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'size | iconSize | iconState'
if ((!((aReader)->ReadSentinel(2358643234)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HostObjectURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::HostObjectURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).simpleParams());
// Sentinel = 'simpleParams'
(aWriter)->WriteSentinel(541394159);
IPC::WriteParam(aWriter, (aVar).revoked());
// Sentinel = 'revoked'
(aWriter)->WriteSentinel(201065201);
}
auto ParamTraits<::mozilla::ipc::HostObjectURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___simpleParams = IPC::ReadParam<::mozilla::ipc::SimpleURIParams>(aReader);
if (!maybe___simpleParams) {
aReader->FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
return {};
}
auto& _simpleParams = *maybe___simpleParams;
// Sentinel = 'simpleParams'
if ((!((aReader)->ReadSentinel(541394159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'HostObjectURIParams'");
return {};
}
auto maybe___revoked = IPC::ReadParam<bool>(aReader);
if (!maybe___revoked) {
aReader->FatalError("Error deserializing 'revoked' (bool) member of 'HostObjectURIParams'");
return {};
}
auto& _revoked = *maybe___revoked;
// Sentinel = 'revoked'
if ((!((aReader)->ReadSentinel(201065201)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'revoked' (bool) member of 'HostObjectURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_simpleParams),
std::move(_revoked)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union URIParams|
//
namespace mozilla {
namespace ipc {
auto URIParams::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TSimpleURIParams:
{
(ptr_SimpleURIParams())->~SimpleURIParams__tdef();
break;
}
case TStandardURLParams:
{
(ptr_StandardURLParams())->~StandardURLParams__tdef();
break;
}
case TJARURIParams:
{
delete ptr_JARURIParams();
break;
}
case TIconURIParams:
{
delete ptr_IconURIParams();
break;
}
case TJSURIParams:
{
delete ptr_JSURIParams();
break;
}
case TSimpleNestedURIParams:
{
delete ptr_SimpleNestedURIParams();
break;
}
case THostObjectURIParams:
{
(ptr_HostObjectURIParams())->~HostObjectURIParams__tdef();
break;
}
case TDefaultURIParams:
{
(ptr_DefaultURIParams())->~DefaultURIParams__tdef();
break;
}
case TNestedAboutURIParams:
{
delete ptr_NestedAboutURIParams();
break;
}
case TSubstitutingJARURIParams:
{
delete ptr_SubstitutingJARURIParams();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT URIParams::URIParams(const SimpleURIParams& aOther)
{
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(aOther);
mType = TSimpleURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(SimpleURIParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move(aOther));
mType = TSimpleURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const StandardURLParams& aOther)
{
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(aOther);
mType = TStandardURLParams;
}
MOZ_IMPLICIT URIParams::URIParams(StandardURLParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move(aOther));
mType = TStandardURLParams;
}
MOZ_IMPLICIT URIParams::URIParams(const JARURIParams& aOther)
{
ptr_JARURIParams() = new JARURIParams(aOther);
mType = TJARURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(JARURIParams&& aOther)
{
ptr_JARURIParams() = new JARURIParams(std::move(aOther));
mType = TJARURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const IconURIParams& aOther)
{
ptr_IconURIParams() = new IconURIParams(aOther);
mType = TIconURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(IconURIParams&& aOther)
{
ptr_IconURIParams() = new IconURIParams(std::move(aOther));
mType = TIconURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const JSURIParams& aOther)
{
ptr_JSURIParams() = new JSURIParams(aOther);
mType = TJSURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(JSURIParams&& aOther)
{
ptr_JSURIParams() = new JSURIParams(std::move(aOther));
mType = TJSURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const SimpleNestedURIParams& aOther)
{
ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(aOther);
mType = TSimpleNestedURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(SimpleNestedURIParams&& aOther)
{
ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(std::move(aOther));
mType = TSimpleNestedURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const HostObjectURIParams& aOther)
{
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(aOther);
mType = THostObjectURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(HostObjectURIParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move(aOther));
mType = THostObjectURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const DefaultURIParams& aOther)
{
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(aOther);
mType = TDefaultURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(DefaultURIParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move(aOther));
mType = TDefaultURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const NestedAboutURIParams& aOther)
{
ptr_NestedAboutURIParams() = new NestedAboutURIParams(aOther);
mType = TNestedAboutURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(NestedAboutURIParams&& aOther)
{
ptr_NestedAboutURIParams() = new NestedAboutURIParams(std::move(aOther));
mType = TNestedAboutURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const SubstitutingJARURIParams& aOther)
{
ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(aOther);
mType = TSubstitutingJARURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(SubstitutingJARURIParams&& aOther)
{
ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(std::move(aOther));
mType = TSubstitutingJARURIParams;
}
MOZ_IMPLICIT URIParams::URIParams(const URIParams& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TSimpleURIParams:
{
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams((aOther).get_SimpleURIParams());
break;
}
case TStandardURLParams:
{
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams((aOther).get_StandardURLParams());
break;
}
case TJARURIParams:
{
ptr_JARURIParams() = new JARURIParams((aOther).get_JARURIParams());
break;
}
case TIconURIParams:
{
ptr_IconURIParams() = new IconURIParams((aOther).get_IconURIParams());
break;
}
case TJSURIParams:
{
ptr_JSURIParams() = new JSURIParams((aOther).get_JSURIParams());
break;
}
case TSimpleNestedURIParams:
{
ptr_SimpleNestedURIParams() = new SimpleNestedURIParams((aOther).get_SimpleNestedURIParams());
break;
}
case THostObjectURIParams:
{
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams((aOther).get_HostObjectURIParams());
break;
}
case TDefaultURIParams:
{
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams((aOther).get_DefaultURIParams());
break;
}
case TNestedAboutURIParams:
{
ptr_NestedAboutURIParams() = new NestedAboutURIParams((aOther).get_NestedAboutURIParams());
break;
}
case TSubstitutingJARURIParams:
{
ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams((aOther).get_SubstitutingJARURIParams());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT URIParams::URIParams(URIParams&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TSimpleURIParams:
{
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move((aOther).get_SimpleURIParams()));
(aOther).MaybeDestroy();
break;
}
case TStandardURLParams:
{
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move((aOther).get_StandardURLParams()));
(aOther).MaybeDestroy();
break;
}
case TJARURIParams:
{
ptr_JARURIParams() = (aOther).ptr_JARURIParams();
break;
}
case TIconURIParams:
{
ptr_IconURIParams() = (aOther).ptr_IconURIParams();
break;
}
case TJSURIParams:
{
ptr_JSURIParams() = (aOther).ptr_JSURIParams();
break;
}
case TSimpleNestedURIParams:
{
ptr_SimpleNestedURIParams() = (aOther).ptr_SimpleNestedURIParams();
break;
}
case THostObjectURIParams:
{
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move((aOther).get_HostObjectURIParams()));
(aOther).MaybeDestroy();
break;
}
case TDefaultURIParams:
{
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move((aOther).get_DefaultURIParams()));
(aOther).MaybeDestroy();
break;
}
case TNestedAboutURIParams:
{
ptr_NestedAboutURIParams() = (aOther).ptr_NestedAboutURIParams();
break;
}
case TSubstitutingJARURIParams:
{
ptr_SubstitutingJARURIParams() = (aOther).ptr_SubstitutingJARURIParams();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
URIParams::~URIParams()
{
MaybeDestroy();
}
auto URIParams::operator=(const SimpleURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(aRhs);
mType = TSimpleURIParams;
return (*(this));
}
auto URIParams::operator=(SimpleURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move(aRhs));
mType = TSimpleURIParams;
return (*(this));
}
auto URIParams::operator=(const StandardURLParams& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(aRhs);
mType = TStandardURLParams;
return (*(this));
}
auto URIParams::operator=(StandardURLParams&& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move(aRhs));
mType = TStandardURLParams;
return (*(this));
}
auto URIParams::operator=(const JARURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_JARURIParams() = new JARURIParams(aRhs);
mType = TJARURIParams;
return (*(this));
}
auto URIParams::operator=(JARURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_JARURIParams() = new JARURIParams(std::move(aRhs));
mType = TJARURIParams;
return (*(this));
}
auto URIParams::operator=(const IconURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_IconURIParams() = new IconURIParams(aRhs);
mType = TIconURIParams;
return (*(this));
}
auto URIParams::operator=(IconURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_IconURIParams() = new IconURIParams(std::move(aRhs));
mType = TIconURIParams;
return (*(this));
}
auto URIParams::operator=(const JSURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_JSURIParams() = new JSURIParams(aRhs);
mType = TJSURIParams;
return (*(this));
}
auto URIParams::operator=(JSURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_JSURIParams() = new JSURIParams(std::move(aRhs));
mType = TJSURIParams;
return (*(this));
}
auto URIParams::operator=(const SimpleNestedURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(aRhs);
mType = TSimpleNestedURIParams;
return (*(this));
}
auto URIParams::operator=(SimpleNestedURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_SimpleNestedURIParams() = new SimpleNestedURIParams(std::move(aRhs));
mType = TSimpleNestedURIParams;
return (*(this));
}
auto URIParams::operator=(const HostObjectURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(aRhs);
mType = THostObjectURIParams;
return (*(this));
}
auto URIParams::operator=(HostObjectURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move(aRhs));
mType = THostObjectURIParams;
return (*(this));
}
auto URIParams::operator=(const DefaultURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(aRhs);
mType = TDefaultURIParams;
return (*(this));
}
auto URIParams::operator=(DefaultURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move(aRhs));
mType = TDefaultURIParams;
return (*(this));
}
auto URIParams::operator=(const NestedAboutURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_NestedAboutURIParams() = new NestedAboutURIParams(aRhs);
mType = TNestedAboutURIParams;
return (*(this));
}
auto URIParams::operator=(NestedAboutURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_NestedAboutURIParams() = new NestedAboutURIParams(std::move(aRhs));
mType = TNestedAboutURIParams;
return (*(this));
}
auto URIParams::operator=(const SubstitutingJARURIParams& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(aRhs);
mType = TSubstitutingJARURIParams;
return (*(this));
}
auto URIParams::operator=(SubstitutingJARURIParams&& aRhs) -> URIParams&
{
MaybeDestroy();
ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams(std::move(aRhs));
mType = TSubstitutingJARURIParams;
return (*(this));
}
auto URIParams::operator=(const URIParams& aRhs) -> URIParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TSimpleURIParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams((aRhs).get_SimpleURIParams());
break;
}
case TStandardURLParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams((aRhs).get_StandardURLParams());
break;
}
case TJARURIParams:
{
MaybeDestroy();
ptr_JARURIParams() = new JARURIParams((aRhs).get_JARURIParams());
break;
}
case TIconURIParams:
{
MaybeDestroy();
ptr_IconURIParams() = new IconURIParams((aRhs).get_IconURIParams());
break;
}
case TJSURIParams:
{
MaybeDestroy();
ptr_JSURIParams() = new JSURIParams((aRhs).get_JSURIParams());
break;
}
case TSimpleNestedURIParams:
{
MaybeDestroy();
ptr_SimpleNestedURIParams() = new SimpleNestedURIParams((aRhs).get_SimpleNestedURIParams());
break;
}
case THostObjectURIParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams((aRhs).get_HostObjectURIParams());
break;
}
case TDefaultURIParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams((aRhs).get_DefaultURIParams());
break;
}
case TNestedAboutURIParams:
{
MaybeDestroy();
ptr_NestedAboutURIParams() = new NestedAboutURIParams((aRhs).get_NestedAboutURIParams());
break;
}
case TSubstitutingJARURIParams:
{
MaybeDestroy();
ptr_SubstitutingJARURIParams() = new SubstitutingJARURIParams((aRhs).get_SubstitutingJARURIParams());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto URIParams::operator=(URIParams&& aRhs) -> URIParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TSimpleURIParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_SimpleURIParams()) SimpleURIParams(std::move((aRhs).get_SimpleURIParams()));
(aRhs).MaybeDestroy();
break;
}
case TStandardURLParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StandardURLParams()) StandardURLParams(std::move((aRhs).get_StandardURLParams()));
(aRhs).MaybeDestroy();
break;
}
case TJARURIParams:
{
MaybeDestroy();
ptr_JARURIParams() = (aRhs).ptr_JARURIParams();
break;
}
case TIconURIParams:
{
MaybeDestroy();
ptr_IconURIParams() = (aRhs).ptr_IconURIParams();
break;
}
case TJSURIParams:
{
MaybeDestroy();
ptr_JSURIParams() = (aRhs).ptr_JSURIParams();
break;
}
case TSimpleNestedURIParams:
{
MaybeDestroy();
ptr_SimpleNestedURIParams() = (aRhs).ptr_SimpleNestedURIParams();
break;
}
case THostObjectURIParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_HostObjectURIParams()) HostObjectURIParams(std::move((aRhs).get_HostObjectURIParams()));
(aRhs).MaybeDestroy();
break;
}
case TDefaultURIParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_DefaultURIParams()) DefaultURIParams(std::move((aRhs).get_DefaultURIParams()));
(aRhs).MaybeDestroy();
break;
}
case TNestedAboutURIParams:
{
MaybeDestroy();
ptr_NestedAboutURIParams() = (aRhs).ptr_NestedAboutURIParams();
break;
}
case TSubstitutingJARURIParams:
{
MaybeDestroy();
ptr_SubstitutingJARURIParams() = (aRhs).ptr_SubstitutingJARURIParams();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::URIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::ipc::URIParams union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'URIParams'
(aWriter)->WriteSentinel(261227349);
switch (type) {
case union__::TSimpleURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_SimpleURIParams());
// Sentinel = 'TSimpleURIParams'
(aWriter)->WriteSentinel(852690451);
return;
}
case union__::TStandardURLParams:
{
IPC::WriteParam(aWriter, (aVar).get_StandardURLParams());
// Sentinel = 'TStandardURLParams'
(aWriter)->WriteSentinel(1081870045);
return;
}
case union__::TJARURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_JARURIParams());
// Sentinel = 'TJARURIParams'
(aWriter)->WriteSentinel(491848838);
return;
}
case union__::TIconURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_IconURIParams());
// Sentinel = 'TIconURIParams'
(aWriter)->WriteSentinel(630785330);
return;
}
case union__::TJSURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_JSURIParams());
// Sentinel = 'TJSURIParams'
(aWriter)->WriteSentinel(435225670);
return;
}
case union__::TSimpleNestedURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_SimpleNestedURIParams());
// Sentinel = 'TSimpleNestedURIParams'
(aWriter)->WriteSentinel(1626015862);
return;
}
case union__::THostObjectURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_HostObjectURIParams());
// Sentinel = 'THostObjectURIParams'
(aWriter)->WriteSentinel(1327105950);
return;
}
case union__::TDefaultURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_DefaultURIParams());
// Sentinel = 'TDefaultURIParams'
(aWriter)->WriteSentinel(948045422);
return;
}
case union__::TNestedAboutURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_NestedAboutURIParams());
// Sentinel = 'TNestedAboutURIParams'
(aWriter)->WriteSentinel(1465518087);
return;
}
case union__::TSubstitutingJARURIParams:
{
IPC::WriteParam(aWriter, (aVar).get_SubstitutingJARURIParams());
// Sentinel = 'TSubstitutingJARURIParams'
(aWriter)->WriteSentinel(2128677275);
return;
}
default:
{
aWriter->FatalError("unknown variant of union URIParams");
return;
}
}
}
auto ParamTraits<::mozilla::ipc::URIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::ipc::URIParams union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union URIParams");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'URIParams'
if ((!((aReader)->ReadSentinel(261227349)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union URIParams");
return {};
}
switch (type) {
case union__::TSimpleURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::SimpleURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TSimpleURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TSimpleURIParams'
if ((!((aReader)->ReadSentinel(852690451)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TSimpleURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TStandardURLParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::StandardURLParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStandardURLParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStandardURLParams'
if ((!((aReader)->ReadSentinel(1081870045)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStandardURLParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TJARURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::JARURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TJARURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TJARURIParams'
if ((!((aReader)->ReadSentinel(491848838)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TJARURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TIconURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::IconURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIconURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIconURIParams'
if ((!((aReader)->ReadSentinel(630785330)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIconURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TJSURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::JSURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TJSURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TJSURIParams'
if ((!((aReader)->ReadSentinel(435225670)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TJSURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TSimpleNestedURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::SimpleNestedURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TSimpleNestedURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TSimpleNestedURIParams'
if ((!((aReader)->ReadSentinel(1626015862)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TSimpleNestedURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::THostObjectURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::HostObjectURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant THostObjectURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'THostObjectURIParams'
if ((!((aReader)->ReadSentinel(1327105950)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant THostObjectURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TDefaultURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::DefaultURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TDefaultURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TDefaultURIParams'
if ((!((aReader)->ReadSentinel(948045422)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TDefaultURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TNestedAboutURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::NestedAboutURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TNestedAboutURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TNestedAboutURIParams'
if ((!((aReader)->ReadSentinel(1465518087)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TNestedAboutURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
case union__::TSubstitutingJARURIParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::ipc::SubstitutingJARURIParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TSubstitutingJARURIParams of union URIParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TSubstitutingJARURIParams'
if ((!((aReader)->ReadSentinel(2128677275)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TSubstitutingJARURIParams of union URIParams");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union URIParams");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct JSURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::JSURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).simpleParams());
// Sentinel = 'simpleParams'
(aWriter)->WriteSentinel(541394159);
IPC::WriteParam(aWriter, (aVar).baseURI());
// Sentinel = 'baseURI'
(aWriter)->WriteSentinel(179962508);
}
auto ParamTraits<::mozilla::ipc::JSURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___simpleParams = IPC::ReadParam<::mozilla::ipc::SimpleURIParams>(aReader);
if (!maybe___simpleParams) {
aReader->FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
return {};
}
auto& _simpleParams = *maybe___simpleParams;
// Sentinel = 'simpleParams'
if ((!((aReader)->ReadSentinel(541394159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'JSURIParams'");
return {};
}
auto maybe___baseURI = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
if (!maybe___baseURI) {
aReader->FatalError("Error deserializing 'baseURI' (URIParams?) member of 'JSURIParams'");
return {};
}
auto& _baseURI = *maybe___baseURI;
// Sentinel = 'baseURI'
if ((!((aReader)->ReadSentinel(179962508)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'baseURI' (URIParams?) member of 'JSURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_simpleParams),
std::move(_baseURI)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SimpleNestedURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::SimpleNestedURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).simpleParams());
// Sentinel = 'simpleParams'
(aWriter)->WriteSentinel(541394159);
IPC::WriteParam(aWriter, (aVar).innerURI());
// Sentinel = 'innerURI'
(aWriter)->WriteSentinel(244515597);
}
auto ParamTraits<::mozilla::ipc::SimpleNestedURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___simpleParams = IPC::ReadParam<::mozilla::ipc::SimpleURIParams>(aReader);
if (!maybe___simpleParams) {
aReader->FatalError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
return {};
}
auto& _simpleParams = *maybe___simpleParams;
// Sentinel = 'simpleParams'
if ((!((aReader)->ReadSentinel(541394159)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'simpleParams' (SimpleURIParams) member of 'SimpleNestedURIParams'");
return {};
}
auto maybe___innerURI = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
if (!maybe___innerURI) {
aReader->FatalError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
return {};
}
auto& _innerURI = *maybe___innerURI;
// Sentinel = 'innerURI'
if ((!((aReader)->ReadSentinel(244515597)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'innerURI' (URIParams) member of 'SimpleNestedURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_simpleParams),
std::move(_innerURI)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct NestedAboutURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::NestedAboutURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).nestedParams());
// Sentinel = 'nestedParams'
(aWriter)->WriteSentinel(536741096);
IPC::WriteParam(aWriter, (aVar).baseURI());
// Sentinel = 'baseURI'
(aWriter)->WriteSentinel(179962508);
}
auto ParamTraits<::mozilla::ipc::NestedAboutURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___nestedParams = IPC::ReadParam<::mozilla::ipc::SimpleNestedURIParams>(aReader);
if (!maybe___nestedParams) {
aReader->FatalError("Error deserializing 'nestedParams' (SimpleNestedURIParams) member of 'NestedAboutURIParams'");
return {};
}
auto& _nestedParams = *maybe___nestedParams;
// Sentinel = 'nestedParams'
if ((!((aReader)->ReadSentinel(536741096)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nestedParams' (SimpleNestedURIParams) member of 'NestedAboutURIParams'");
return {};
}
auto maybe___baseURI = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::URIParams>>(aReader);
if (!maybe___baseURI) {
aReader->FatalError("Error deserializing 'baseURI' (URIParams?) member of 'NestedAboutURIParams'");
return {};
}
auto& _baseURI = *maybe___baseURI;
// Sentinel = 'baseURI'
if ((!((aReader)->ReadSentinel(179962508)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'baseURI' (URIParams?) member of 'NestedAboutURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_nestedParams),
std::move(_baseURI)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SubstitutingJARURIParams|
//
namespace mozilla {
namespace ipc {
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::SubstitutingJARURIParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).source());
// Sentinel = 'source'
(aWriter)->WriteSentinel(154665618);
IPC::WriteParam(aWriter, (aVar).resolved());
// Sentinel = 'resolved'
(aWriter)->WriteSentinel(259523429);
}
auto ParamTraits<::mozilla::ipc::SubstitutingJARURIParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___source = IPC::ReadParam<::mozilla::ipc::URIParams>(aReader);
if (!maybe___source) {
aReader->FatalError("Error deserializing 'source' (URIParams) member of 'SubstitutingJARURIParams'");
return {};
}
auto& _source = *maybe___source;
// Sentinel = 'source'
if ((!((aReader)->ReadSentinel(154665618)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'source' (URIParams) member of 'SubstitutingJARURIParams'");
return {};
}
auto maybe___resolved = IPC::ReadParam<::mozilla::ipc::JARURIParams>(aReader);
if (!maybe___resolved) {
aReader->FatalError("Error deserializing 'resolved' (JARURIParams) member of 'SubstitutingJARURIParams'");
return {};
}
auto& _resolved = *maybe___resolved;
// Sentinel = 'resolved'
if ((!((aReader)->ReadSentinel(259523429)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'resolved' (JARURIParams) member of 'SubstitutingJARURIParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_source),
std::move(_resolved)};
return result__;
}
} // namespace IPC