mozilla-central/__GENERATED__/ipc/ipdl/PBackgroundIDBSharedTypes.cpp (file symbol)

Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/indexedDB/SerializationHelpers.h"
#include "mozilla/dom/quota/SerializationHelpers.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileParent.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBDatabaseFileChild.h"
#include "mozilla/dom/DomSecurityIPCUtils.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/dom/notification/IPCUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/layers/LayersMessageUtils.h"
#include "mozilla/net/NeckoMessageUtils.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.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 SerializedKeyRange|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedKeyRange>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).lower());
// Sentinel = 'lower'
(aWriter)->WriteSentinel(108921386);
IPC::WriteParam(aWriter, (aVar).upper());
// Sentinel = 'upper'
(aWriter)->WriteSentinel(110756397);
IPC::WriteParam(aWriter, (aVar).lowerOpen());
// Sentinel = 'lowerOpen'
(aWriter)->WriteSentinel(317326268);
IPC::WriteParam(aWriter, (aVar).upperOpen());
// Sentinel = 'upperOpen'
(aWriter)->WriteSentinel(319947711);
IPC::WriteParam(aWriter, (aVar).isOnly());
// Sentinel = 'isOnly'
(aWriter)->WriteSentinel(143786623);
}
auto ParamTraits<::mozilla::dom::indexedDB::SerializedKeyRange>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___lower = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
if (!maybe___lower) {
aReader->FatalError("Error deserializing 'lower' (Key) member of 'SerializedKeyRange'");
return {};
}
auto& _lower = *maybe___lower;
// Sentinel = 'lower'
if ((!((aReader)->ReadSentinel(108921386)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'lower' (Key) member of 'SerializedKeyRange'");
return {};
}
auto maybe___upper = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
if (!maybe___upper) {
aReader->FatalError("Error deserializing 'upper' (Key) member of 'SerializedKeyRange'");
return {};
}
auto& _upper = *maybe___upper;
// Sentinel = 'upper'
if ((!((aReader)->ReadSentinel(110756397)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'upper' (Key) member of 'SerializedKeyRange'");
return {};
}
auto maybe___lowerOpen = IPC::ReadParam<bool>(aReader);
if (!maybe___lowerOpen) {
aReader->FatalError("Error deserializing 'lowerOpen' (bool) member of 'SerializedKeyRange'");
return {};
}
auto& _lowerOpen = *maybe___lowerOpen;
// Sentinel = 'lowerOpen'
if ((!((aReader)->ReadSentinel(317326268)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'lowerOpen' (bool) member of 'SerializedKeyRange'");
return {};
}
auto maybe___upperOpen = IPC::ReadParam<bool>(aReader);
if (!maybe___upperOpen) {
aReader->FatalError("Error deserializing 'upperOpen' (bool) member of 'SerializedKeyRange'");
return {};
}
auto& _upperOpen = *maybe___upperOpen;
// Sentinel = 'upperOpen'
if ((!((aReader)->ReadSentinel(319947711)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'upperOpen' (bool) member of 'SerializedKeyRange'");
return {};
}
auto maybe___isOnly = IPC::ReadParam<bool>(aReader);
if (!maybe___isOnly) {
aReader->FatalError("Error deserializing 'isOnly' (bool) member of 'SerializedKeyRange'");
return {};
}
auto& _isOnly = *maybe___isOnly;
// Sentinel = 'isOnly'
if ((!((aReader)->ReadSentinel(143786623)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'isOnly' (bool) member of 'SerializedKeyRange'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_lower),
std::move(_upper),
std::move(_lowerOpen),
std::move(_upperOpen),
std::move(_isOnly)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union NullableBlob|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto NullableBlob::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnull_t:
{
(ptr_null_t())->~null_t__tdef();
break;
}
case TIPCBlob:
{
(ptr_IPCBlob())->~IPCBlob__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT NullableBlob::NullableBlob(const null_t& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aOther);
mType = Tnull_t;
}
MOZ_IMPLICIT NullableBlob::NullableBlob(null_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aOther));
mType = Tnull_t;
}
MOZ_IMPLICIT NullableBlob::NullableBlob(const IPCBlob& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(aOther);
mType = TIPCBlob;
}
MOZ_IMPLICIT NullableBlob::NullableBlob(IPCBlob&& aOther)
{
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move(aOther));
mType = TIPCBlob;
}
MOZ_IMPLICIT NullableBlob::NullableBlob(const NullableBlob& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t((aOther).get_null_t());
break;
}
case TIPCBlob:
{
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob((aOther).get_IPCBlob());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT NullableBlob::NullableBlob(NullableBlob&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnull_t:
{
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aOther).get_null_t()));
(aOther).MaybeDestroy();
break;
}
case TIPCBlob:
{
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move((aOther).get_IPCBlob()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
NullableBlob::~NullableBlob()
{
MaybeDestroy();
}
auto NullableBlob::operator=(const null_t& aRhs) -> NullableBlob&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(aRhs);
mType = Tnull_t;
return (*(this));
}
auto NullableBlob::operator=(null_t&& aRhs) -> NullableBlob&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move(aRhs));
mType = Tnull_t;
return (*(this));
}
auto NullableBlob::operator=(const IPCBlob& aRhs) -> NullableBlob&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(aRhs);
mType = TIPCBlob;
return (*(this));
}
auto NullableBlob::operator=(IPCBlob&& aRhs) -> NullableBlob&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move(aRhs));
mType = TIPCBlob;
return (*(this));
}
auto NullableBlob::operator=(const NullableBlob& aRhs) -> NullableBlob&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t((aRhs).get_null_t());
break;
}
case TIPCBlob:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob((aRhs).get_IPCBlob());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto NullableBlob::operator=(NullableBlob&& aRhs) -> NullableBlob&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnull_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_null_t()) null_t(std::move((aRhs).get_null_t()));
(aRhs).MaybeDestroy();
break;
}
case TIPCBlob:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IPCBlob()) IPCBlob(std::move((aRhs).get_IPCBlob()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::NullableBlob>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::indexedDB::NullableBlob union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'NullableBlob'
(aWriter)->WriteSentinel(511837359);
switch (type) {
case union__::Tnull_t:
{
IPC::WriteParam(aWriter, (aVar).get_null_t());
// Sentinel = 'Tnull_t'
(aWriter)->WriteSentinel(190186211);
return;
}
case union__::TIPCBlob:
{
IPC::WriteParam(aWriter, (aVar).get_IPCBlob());
// Sentinel = 'TIPCBlob'
(aWriter)->WriteSentinel(190972592);
return;
}
default:
{
aWriter->FatalError("unknown variant of union NullableBlob");
return;
}
}
}
auto ParamTraits<::mozilla::dom::indexedDB::NullableBlob>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::indexedDB::NullableBlob union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union NullableBlob");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'NullableBlob'
if ((!((aReader)->ReadSentinel(511837359)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union NullableBlob");
return {};
}
switch (type) {
case union__::Tnull_t:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::null_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnull_t of union NullableBlob");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnull_t'
if ((!((aReader)->ReadSentinel(190186211)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnull_t of union NullableBlob");
return {};
}
return std::move(tmp);
}
case union__::TIPCBlob:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::IPCBlob>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIPCBlob of union NullableBlob");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIPCBlob'
if ((!((aReader)->ReadSentinel(190972592)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIPCBlob of union NullableBlob");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union NullableBlob");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SerializedStructuredCloneFile|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneFile>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).file());
// Sentinel = 'file'
(aWriter)->WriteSentinel(68420001);
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
}
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneFile>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___file = IPC::ReadParam<::mozilla::dom::indexedDB::NullableBlob>(aReader);
if (!maybe___file) {
aReader->FatalError("Error deserializing 'file' (NullableBlob) member of 'SerializedStructuredCloneFile'");
return {};
}
auto& _file = *maybe___file;
// Sentinel = 'file'
if ((!((aReader)->ReadSentinel(68420001)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'file' (NullableBlob) member of 'SerializedStructuredCloneFile'");
return {};
}
auto maybe___type = IPC::ReadParam<::mozilla::dom::indexedDB::StructuredCloneFileBase::FileType>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (FileType) member of 'SerializedStructuredCloneFile'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (FileType) member of 'SerializedStructuredCloneFile'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_file),
std::move(_type)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SerializedStructuredCloneReadInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
IPC::WriteParam(aWriter, (aVar).files());
// Sentinel = 'files'
(aWriter)->WriteSentinel(103285268);
IPC::WriteParam(aWriter, (aVar).hasPreprocessInfo());
// Sentinel = 'hasPreprocessInfo'
(aWriter)->WriteSentinel(1045169903);
}
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___data = IPC::ReadParam<::mozilla::SerializedStructuredCloneBuffer>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'SerializedStructuredCloneReadInfo'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'SerializedStructuredCloneReadInfo'");
return {};
}
auto maybe___files = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::SerializedStructuredCloneFile>>(aReader);
if (!maybe___files) {
aReader->FatalError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'SerializedStructuredCloneReadInfo'");
return {};
}
auto& _files = *maybe___files;
// Sentinel = 'files'
if ((!((aReader)->ReadSentinel(103285268)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'files' (SerializedStructuredCloneFile[]) member of 'SerializedStructuredCloneReadInfo'");
return {};
}
auto maybe___hasPreprocessInfo = IPC::ReadParam<bool>(aReader);
if (!maybe___hasPreprocessInfo) {
aReader->FatalError("Error deserializing 'hasPreprocessInfo' (bool) member of 'SerializedStructuredCloneReadInfo'");
return {};
}
auto& _hasPreprocessInfo = *maybe___hasPreprocessInfo;
// Sentinel = 'hasPreprocessInfo'
if ((!((aReader)->ReadSentinel(1045169903)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'hasPreprocessInfo' (bool) member of 'SerializedStructuredCloneReadInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_data),
std::move(_files),
std::move(_hasPreprocessInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SerializedStructuredCloneWriteInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneWriteInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).data());
// Sentinel = 'data'
(aWriter)->WriteSentinel(67109275);
(aWriter)->WriteBytes((&((aVar).offsetToKeyProp())), 8);
// Sentinel = 'offsetToKeyProp'
(aWriter)->WriteSentinel(816645653);
}
auto ParamTraits<::mozilla::dom::indexedDB::SerializedStructuredCloneWriteInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___data = IPC::ReadParam<::mozilla::SerializedStructuredCloneBuffer>(aReader);
if (!maybe___data) {
aReader->FatalError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'SerializedStructuredCloneWriteInfo'");
return {};
}
auto& _data = *maybe___data;
// Sentinel = 'data'
if ((!((aReader)->ReadSentinel(67109275)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'data' (SerializedStructuredCloneBuffer) member of 'SerializedStructuredCloneWriteInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_data),
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->offsetToKeyProp())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'offsetToKeyProp'
if ((!((aReader)->ReadSentinel(816645653)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexUpdateInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexUpdateInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
IPC::WriteParam(aWriter, (aVar).localizedValue());
// Sentinel = 'localizedValue'
(aWriter)->WriteSentinel(721487285);
(aWriter)->WriteBytes((&((aVar).indexId())), 8);
// Sentinel = 'indexId'
(aWriter)->WriteSentinel(190841542);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexUpdateInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___value = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (Key) member of 'IndexUpdateInfo'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (Key) member of 'IndexUpdateInfo'");
return {};
}
auto maybe___localizedValue = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
if (!maybe___localizedValue) {
aReader->FatalError("Error deserializing 'localizedValue' (Key) member of 'IndexUpdateInfo'");
return {};
}
auto& _localizedValue = *maybe___localizedValue;
// Sentinel = 'localizedValue'
if ((!((aReader)->ReadSentinel(721487285)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'localizedValue' (Key) member of 'IndexUpdateInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_value),
std::move(_localizedValue)};
if ((!((aReader)->ReadBytesInto((&((result__)->indexId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'indexId'
if ((!((aReader)->ReadSentinel(190841542)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DatabaseMetadata|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::DatabaseMetadata>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).persistenceType());
// Sentinel = 'persistenceType'
(aWriter)->WriteSentinel(853345864);
(aWriter)->WriteBytes((&((aVar).version())), 8);
// Sentinel = 'version'
(aWriter)->WriteSentinel(204210951);
}
auto ParamTraits<::mozilla::dom::indexedDB::DatabaseMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsString) member of 'DatabaseMetadata'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'DatabaseMetadata'");
return {};
}
auto maybe___persistenceType = IPC::ReadParam<::mozilla::dom::quota::PersistenceType>(aReader);
if (!maybe___persistenceType) {
aReader->FatalError("Error deserializing 'persistenceType' (PersistenceType) member of 'DatabaseMetadata'");
return {};
}
auto& _persistenceType = *maybe___persistenceType;
// Sentinel = 'persistenceType'
if ((!((aReader)->ReadSentinel(853345864)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'DatabaseMetadata'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_name),
::uint64_t{0},
std::move(_persistenceType)};
if ((!((aReader)->ReadBytesInto((&((result__)->version())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint64_t");
return {};
}
// Sentinel = 'version'
if ((!((aReader)->ReadSentinel(204210951)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreMetadata|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreMetadata>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).keyPath());
// Sentinel = 'keyPath'
(aWriter)->WriteSentinel(190972631);
IPC::WriteParam(aWriter, (aVar).autoIncrement());
// Sentinel = 'autoIncrement'
(aWriter)->WriteSentinel(626394463);
(aWriter)->WriteBytes((&((aVar).id())), 8);
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsString) member of 'ObjectStoreMetadata'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'ObjectStoreMetadata'");
return {};
}
auto maybe___keyPath = IPC::ReadParam<::mozilla::dom::indexedDB::KeyPath>(aReader);
if (!maybe___keyPath) {
aReader->FatalError("Error deserializing 'keyPath' (KeyPath) member of 'ObjectStoreMetadata'");
return {};
}
auto& _keyPath = *maybe___keyPath;
// Sentinel = 'keyPath'
if ((!((aReader)->ReadSentinel(190972631)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyPath' (KeyPath) member of 'ObjectStoreMetadata'");
return {};
}
auto maybe___autoIncrement = IPC::ReadParam<bool>(aReader);
if (!maybe___autoIncrement) {
aReader->FatalError("Error deserializing 'autoIncrement' (bool) member of 'ObjectStoreMetadata'");
return {};
}
auto& _autoIncrement = *maybe___autoIncrement;
// Sentinel = 'autoIncrement'
if ((!((aReader)->ReadSentinel(626394463)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'autoIncrement' (bool) member of 'ObjectStoreMetadata'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_name),
std::move(_keyPath),
std::move(_autoIncrement)};
if ((!((aReader)->ReadBytesInto((&((result__)->id())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexMetadata|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexMetadata>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).keyPath());
// Sentinel = 'keyPath'
(aWriter)->WriteSentinel(190972631);
IPC::WriteParam(aWriter, (aVar).locale());
// Sentinel = 'locale'
(aWriter)->WriteSentinel(145031793);
IPC::WriteParam(aWriter, (aVar).unique());
// Sentinel = 'unique'
(aWriter)->WriteSentinel(154141336);
IPC::WriteParam(aWriter, (aVar).multiEntry());
// Sentinel = 'multiEntry'
(aWriter)->WriteSentinel(389350462);
IPC::WriteParam(aWriter, (aVar).autoLocale());
// Sentinel = 'autoLocale'
(aWriter)->WriteSentinel(377029642);
(aWriter)->WriteBytes((&((aVar).id())), 8);
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexMetadata>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsString) member of 'IndexMetadata'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsString) member of 'IndexMetadata'");
return {};
}
auto maybe___keyPath = IPC::ReadParam<::mozilla::dom::indexedDB::KeyPath>(aReader);
if (!maybe___keyPath) {
aReader->FatalError("Error deserializing 'keyPath' (KeyPath) member of 'IndexMetadata'");
return {};
}
auto& _keyPath = *maybe___keyPath;
// Sentinel = 'keyPath'
if ((!((aReader)->ReadSentinel(190972631)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyPath' (KeyPath) member of 'IndexMetadata'");
return {};
}
auto maybe___locale = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___locale) {
aReader->FatalError("Error deserializing 'locale' (nsCString) member of 'IndexMetadata'");
return {};
}
auto& _locale = *maybe___locale;
// Sentinel = 'locale'
if ((!((aReader)->ReadSentinel(145031793)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'locale' (nsCString) member of 'IndexMetadata'");
return {};
}
auto maybe___unique = IPC::ReadParam<bool>(aReader);
if (!maybe___unique) {
aReader->FatalError("Error deserializing 'unique' (bool) member of 'IndexMetadata'");
return {};
}
auto& _unique = *maybe___unique;
// Sentinel = 'unique'
if ((!((aReader)->ReadSentinel(154141336)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'unique' (bool) member of 'IndexMetadata'");
return {};
}
auto maybe___multiEntry = IPC::ReadParam<bool>(aReader);
if (!maybe___multiEntry) {
aReader->FatalError("Error deserializing 'multiEntry' (bool) member of 'IndexMetadata'");
return {};
}
auto& _multiEntry = *maybe___multiEntry;
// Sentinel = 'multiEntry'
if ((!((aReader)->ReadSentinel(389350462)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'multiEntry' (bool) member of 'IndexMetadata'");
return {};
}
auto maybe___autoLocale = IPC::ReadParam<bool>(aReader);
if (!maybe___autoLocale) {
aReader->FatalError("Error deserializing 'autoLocale' (bool) member of 'IndexMetadata'");
return {};
}
auto& _autoLocale = *maybe___autoLocale;
// Sentinel = 'autoLocale'
if ((!((aReader)->ReadSentinel(377029642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'autoLocale' (bool) member of 'IndexMetadata'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_name),
std::move(_keyPath),
std::move(_locale),
std::move(_unique),
std::move(_multiEntry),
std::move(_autoLocale)};
if ((!((aReader)->ReadBytesInto((&((result__)->id())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct DatabaseSpec|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::DatabaseSpec>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).metadata());
// Sentinel = 'metadata'
(aWriter)->WriteSentinel(248251202);
IPC::WriteParam(aWriter, (aVar).objectStores());
// Sentinel = 'objectStores'
(aWriter)->WriteSentinel(535823608);
}
auto ParamTraits<::mozilla::dom::indexedDB::DatabaseSpec>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___metadata = IPC::ReadParam<::mozilla::dom::indexedDB::DatabaseMetadata>(aReader);
if (!maybe___metadata) {
aReader->FatalError("Error deserializing 'metadata' (DatabaseMetadata) member of 'DatabaseSpec'");
return {};
}
auto& _metadata = *maybe___metadata;
// Sentinel = 'metadata'
if ((!((aReader)->ReadSentinel(248251202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (DatabaseMetadata) member of 'DatabaseSpec'");
return {};
}
auto maybe___objectStores = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::ObjectStoreSpec>>(aReader);
if (!maybe___objectStores) {
aReader->FatalError("Error deserializing 'objectStores' (ObjectStoreSpec[]) member of 'DatabaseSpec'");
return {};
}
auto& _objectStores = *maybe___objectStores;
// Sentinel = 'objectStores'
if ((!((aReader)->ReadSentinel(535823608)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'objectStores' (ObjectStoreSpec[]) member of 'DatabaseSpec'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_metadata),
std::move(_objectStores)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreSpec|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreSpec>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).metadata());
// Sentinel = 'metadata'
(aWriter)->WriteSentinel(248251202);
IPC::WriteParam(aWriter, (aVar).indexes());
// Sentinel = 'indexes'
(aWriter)->WriteSentinel(195494641);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreSpec>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___metadata = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreMetadata>(aReader);
if (!maybe___metadata) {
aReader->FatalError("Error deserializing 'metadata' (ObjectStoreMetadata) member of 'ObjectStoreSpec'");
return {};
}
auto& _metadata = *maybe___metadata;
// Sentinel = 'metadata'
if ((!((aReader)->ReadSentinel(248251202)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'metadata' (ObjectStoreMetadata) member of 'ObjectStoreSpec'");
return {};
}
auto maybe___indexes = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::IndexMetadata>>(aReader);
if (!maybe___indexes) {
aReader->FatalError("Error deserializing 'indexes' (IndexMetadata[]) member of 'ObjectStoreSpec'");
return {};
}
auto& _indexes = *maybe___indexes;
// Sentinel = 'indexes'
if ((!((aReader)->ReadSentinel(195494641)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'indexes' (IndexMetadata[]) member of 'ObjectStoreSpec'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_metadata),
std::move(_indexes)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CommonOpenCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::CommonOpenCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
IPC::WriteParam(aWriter, (aVar).direction());
// Sentinel = 'direction'
(aWriter)->WriteSentinel(311886786);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::CommonOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'CommonOpenCursorParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'CommonOpenCursorParams'");
return {};
}
auto maybe___direction = IPC::ReadParam<::mozilla::dom::IDBCursor::Direction>(aReader);
if (!maybe___direction) {
aReader->FatalError("Error deserializing 'direction' (Direction) member of 'CommonOpenCursorParams'");
return {};
}
auto& _direction = *maybe___direction;
// Sentinel = 'direction'
if ((!((aReader)->ReadSentinel(311886786)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'direction' (Direction) member of 'CommonOpenCursorParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_optionalKeyRange),
std::move(_direction)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreOpenCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreOpenCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonParams());
// Sentinel = 'commonParams'
(aWriter)->WriteSentinel(537068782);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonOpenCursorParams>(aReader);
if (!maybe___commonParams) {
aReader->FatalError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenCursorParams'");
return {};
}
auto& _commonParams = *maybe___commonParams;
// Sentinel = 'commonParams'
if ((!((aReader)->ReadSentinel(537068782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenCursorParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreOpenKeyCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreOpenKeyCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonParams());
// Sentinel = 'commonParams'
(aWriter)->WriteSentinel(537068782);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreOpenKeyCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonOpenCursorParams>(aReader);
if (!maybe___commonParams) {
aReader->FatalError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenKeyCursorParams'");
return {};
}
auto& _commonParams = *maybe___commonParams;
// Sentinel = 'commonParams'
if ((!((aReader)->ReadSentinel(537068782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'ObjectStoreOpenKeyCursorParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CommonIndexOpenCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonParams());
// Sentinel = 'commonParams'
(aWriter)->WriteSentinel(537068782);
(aWriter)->WriteBytes((&((aVar).indexId())), 8);
// Sentinel = 'indexId'
(aWriter)->WriteSentinel(190841542);
}
auto ParamTraits<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonOpenCursorParams>(aReader);
if (!maybe___commonParams) {
aReader->FatalError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'CommonIndexOpenCursorParams'");
return {};
}
auto& _commonParams = *maybe___commonParams;
// Sentinel = 'commonParams'
if ((!((aReader)->ReadSentinel(537068782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (CommonOpenCursorParams) member of 'CommonIndexOpenCursorParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonParams),
::int64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->indexId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'indexId'
if ((!((aReader)->ReadSentinel(190841542)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexOpenCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexOpenCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonIndexParams());
// Sentinel = 'commonIndexParams'
(aWriter)->WriteSentinel(1041762022);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexOpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonIndexParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>(aReader);
if (!maybe___commonIndexParams) {
aReader->FatalError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenCursorParams'");
return {};
}
auto& _commonIndexParams = *maybe___commonIndexParams;
// Sentinel = 'commonIndexParams'
if ((!((aReader)->ReadSentinel(1041762022)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenCursorParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonIndexParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexOpenKeyCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexOpenKeyCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonIndexParams());
// Sentinel = 'commonIndexParams'
(aWriter)->WriteSentinel(1041762022);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexOpenKeyCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonIndexParams = IPC::ReadParam<::mozilla::dom::indexedDB::CommonIndexOpenCursorParams>(aReader);
if (!maybe___commonIndexParams) {
aReader->FatalError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenKeyCursorParams'");
return {};
}
auto& _commonIndexParams = *maybe___commonIndexParams;
// Sentinel = 'commonIndexParams'
if ((!((aReader)->ReadSentinel(1041762022)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonIndexParams' (CommonIndexOpenCursorParams) member of 'IndexOpenKeyCursorParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonIndexParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OpenCursorParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto OpenCursorParams::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TObjectStoreOpenCursorParams:
{
(ptr_ObjectStoreOpenCursorParams())->~ObjectStoreOpenCursorParams__tdef();
break;
}
case TObjectStoreOpenKeyCursorParams:
{
(ptr_ObjectStoreOpenKeyCursorParams())->~ObjectStoreOpenKeyCursorParams__tdef();
break;
}
case TIndexOpenCursorParams:
{
(ptr_IndexOpenCursorParams())->~IndexOpenCursorParams__tdef();
break;
}
case TIndexOpenKeyCursorParams:
{
(ptr_IndexOpenKeyCursorParams())->~IndexOpenKeyCursorParams__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const ObjectStoreOpenCursorParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(aOther);
mType = TObjectStoreOpenCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(ObjectStoreOpenCursorParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move(aOther));
mType = TObjectStoreOpenCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const ObjectStoreOpenKeyCursorParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(aOther);
mType = TObjectStoreOpenKeyCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(ObjectStoreOpenKeyCursorParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move(aOther));
mType = TObjectStoreOpenKeyCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const IndexOpenCursorParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(aOther);
mType = TIndexOpenCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(IndexOpenCursorParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move(aOther));
mType = TIndexOpenCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const IndexOpenKeyCursorParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(aOther);
mType = TIndexOpenKeyCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(IndexOpenKeyCursorParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move(aOther));
mType = TIndexOpenKeyCursorParams;
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(const OpenCursorParams& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TObjectStoreOpenCursorParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams((aOther).get_ObjectStoreOpenCursorParams());
break;
}
case TObjectStoreOpenKeyCursorParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams((aOther).get_ObjectStoreOpenKeyCursorParams());
break;
}
case TIndexOpenCursorParams:
{
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams((aOther).get_IndexOpenCursorParams());
break;
}
case TIndexOpenKeyCursorParams:
{
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams((aOther).get_IndexOpenKeyCursorParams());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT OpenCursorParams::OpenCursorParams(OpenCursorParams&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TObjectStoreOpenCursorParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move((aOther).get_ObjectStoreOpenCursorParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreOpenKeyCursorParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move((aOther).get_ObjectStoreOpenKeyCursorParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexOpenCursorParams:
{
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move((aOther).get_IndexOpenCursorParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexOpenKeyCursorParams:
{
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move((aOther).get_IndexOpenKeyCursorParams()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
OpenCursorParams::~OpenCursorParams()
{
MaybeDestroy();
}
auto OpenCursorParams::operator=(const ObjectStoreOpenCursorParams& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(aRhs);
mType = TObjectStoreOpenCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(ObjectStoreOpenCursorParams&& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move(aRhs));
mType = TObjectStoreOpenCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(const ObjectStoreOpenKeyCursorParams& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(aRhs);
mType = TObjectStoreOpenKeyCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(ObjectStoreOpenKeyCursorParams&& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move(aRhs));
mType = TObjectStoreOpenKeyCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(const IndexOpenCursorParams& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(aRhs);
mType = TIndexOpenCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(IndexOpenCursorParams&& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move(aRhs));
mType = TIndexOpenCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(const IndexOpenKeyCursorParams& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(aRhs);
mType = TIndexOpenKeyCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(IndexOpenKeyCursorParams&& aRhs) -> OpenCursorParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move(aRhs));
mType = TIndexOpenKeyCursorParams;
return (*(this));
}
auto OpenCursorParams::operator=(const OpenCursorParams& aRhs) -> OpenCursorParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TObjectStoreOpenCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams((aRhs).get_ObjectStoreOpenCursorParams());
break;
}
case TObjectStoreOpenKeyCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams((aRhs).get_ObjectStoreOpenKeyCursorParams());
break;
}
case TIndexOpenCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams((aRhs).get_IndexOpenCursorParams());
break;
}
case TIndexOpenKeyCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams((aRhs).get_IndexOpenKeyCursorParams());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto OpenCursorParams::operator=(OpenCursorParams&& aRhs) -> OpenCursorParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TObjectStoreOpenCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenCursorParams()) ObjectStoreOpenCursorParams(std::move((aRhs).get_ObjectStoreOpenCursorParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreOpenKeyCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreOpenKeyCursorParams()) ObjectStoreOpenKeyCursorParams(std::move((aRhs).get_ObjectStoreOpenKeyCursorParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexOpenCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenCursorParams()) IndexOpenCursorParams(std::move((aRhs).get_IndexOpenCursorParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexOpenKeyCursorParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexOpenKeyCursorParams()) IndexOpenKeyCursorParams(std::move((aRhs).get_IndexOpenKeyCursorParams()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::OpenCursorParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::indexedDB::OpenCursorParams union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'OpenCursorParams'
(aWriter)->WriteSentinel(904463989);
switch (type) {
case union__::TObjectStoreOpenCursorParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreOpenCursorParams());
// Sentinel = 'TObjectStoreOpenCursorParams'
(aWriter)->WriteSentinel(2666662701);
return;
}
case union__::TObjectStoreOpenKeyCursorParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreOpenKeyCursorParams());
// Sentinel = 'TObjectStoreOpenKeyCursorParams'
(aWriter)->WriteSentinel(3252882518);
return;
}
case union__::TIndexOpenCursorParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexOpenCursorParams());
// Sentinel = 'TIndexOpenCursorParams'
(aWriter)->WriteSentinel(1647970497);
return;
}
case union__::TIndexOpenKeyCursorParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexOpenKeyCursorParams());
// Sentinel = 'TIndexOpenKeyCursorParams'
(aWriter)->WriteSentinel(2112293354);
return;
}
default:
{
aWriter->FatalError("unknown variant of union OpenCursorParams");
return;
}
}
}
auto ParamTraits<::mozilla::dom::indexedDB::OpenCursorParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::indexedDB::OpenCursorParams union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union OpenCursorParams");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'OpenCursorParams'
if ((!((aReader)->ReadSentinel(904463989)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union OpenCursorParams");
return {};
}
switch (type) {
case union__::TObjectStoreOpenCursorParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreOpenCursorParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreOpenCursorParams of union OpenCursorParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreOpenCursorParams'
if ((!((aReader)->ReadSentinel(2666662701)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreOpenCursorParams of union OpenCursorParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreOpenKeyCursorParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreOpenKeyCursorParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreOpenKeyCursorParams of union OpenCursorParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreOpenKeyCursorParams'
if ((!((aReader)->ReadSentinel(3252882518)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreOpenKeyCursorParams of union OpenCursorParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexOpenCursorParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexOpenCursorParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexOpenCursorParams of union OpenCursorParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexOpenCursorParams'
if ((!((aReader)->ReadSentinel(1647970497)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexOpenCursorParams of union OpenCursorParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexOpenKeyCursorParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexOpenKeyCursorParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexOpenKeyCursorParams of union OpenCursorParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexOpenKeyCursorParams'
if ((!((aReader)->ReadSentinel(2112293354)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexOpenKeyCursorParams of union OpenCursorParams");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union OpenCursorParams");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct FileAddInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::FileAddInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).file());
// Sentinel = 'file'
(aWriter)->WriteSentinel(68420001);
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
}
auto ParamTraits<::mozilla::dom::indexedDB::FileAddInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___file = IPC::ReadParam<mozilla::NotNull<::mozilla::ipc::SideVariant<::mozilla::dom::indexedDB::PBackgroundIDBDatabaseFileParent*, ::mozilla::dom::indexedDB::PBackgroundIDBDatabaseFileChild*>>>(aReader);
if (!maybe___file) {
aReader->FatalError("Error deserializing 'file' (NotNull<PBackgroundIDBDatabaseFile>) member of 'FileAddInfo'");
return {};
}
auto& _file = *maybe___file;
// Sentinel = 'file'
if ((!((aReader)->ReadSentinel(68420001)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'file' (NotNull<PBackgroundIDBDatabaseFile>) member of 'FileAddInfo'");
return {};
}
auto maybe___type = IPC::ReadParam<::mozilla::dom::indexedDB::StructuredCloneFileBase::FileType>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (FileType) member of 'FileAddInfo'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (FileType) member of 'FileAddInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_file),
std::move(_type)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreAddPutParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).cloneInfo());
// Sentinel = 'cloneInfo'
(aWriter)->WriteSentinel(304284574);
IPC::WriteParam(aWriter, (aVar).key());
// Sentinel = 'key'
(aWriter)->WriteSentinel(42402122);
IPC::WriteParam(aWriter, (aVar).indexUpdateInfos());
// Sentinel = 'indexUpdateInfos'
(aWriter)->WriteSentinel(923797115);
IPC::WriteParam(aWriter, (aVar).fileAddInfos());
// Sentinel = 'fileAddInfos'
(aWriter)->WriteSentinel(501220521);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___cloneInfo = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedStructuredCloneWriteInfo>(aReader);
if (!maybe___cloneInfo) {
aReader->FatalError("Error deserializing 'cloneInfo' (SerializedStructuredCloneWriteInfo) member of 'ObjectStoreAddPutParams'");
return {};
}
auto& _cloneInfo = *maybe___cloneInfo;
// Sentinel = 'cloneInfo'
if ((!((aReader)->ReadSentinel(304284574)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cloneInfo' (SerializedStructuredCloneWriteInfo) member of 'ObjectStoreAddPutParams'");
return {};
}
auto maybe___key = IPC::ReadParam<::mozilla::dom::indexedDB::Key>(aReader);
if (!maybe___key) {
aReader->FatalError("Error deserializing 'key' (Key) member of 'ObjectStoreAddPutParams'");
return {};
}
auto& _key = *maybe___key;
// Sentinel = 'key'
if ((!((aReader)->ReadSentinel(42402122)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'key' (Key) member of 'ObjectStoreAddPutParams'");
return {};
}
auto maybe___indexUpdateInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::IndexUpdateInfo>>(aReader);
if (!maybe___indexUpdateInfos) {
aReader->FatalError("Error deserializing 'indexUpdateInfos' (IndexUpdateInfo[]) member of 'ObjectStoreAddPutParams'");
return {};
}
auto& _indexUpdateInfos = *maybe___indexUpdateInfos;
// Sentinel = 'indexUpdateInfos'
if ((!((aReader)->ReadSentinel(923797115)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'indexUpdateInfos' (IndexUpdateInfo[]) member of 'ObjectStoreAddPutParams'");
return {};
}
auto maybe___fileAddInfos = IPC::ReadParam<nsTArray<::mozilla::dom::indexedDB::FileAddInfo>>(aReader);
if (!maybe___fileAddInfos) {
aReader->FatalError("Error deserializing 'fileAddInfos' (FileAddInfo[]) member of 'ObjectStoreAddPutParams'");
return {};
}
auto& _fileAddInfos = *maybe___fileAddInfos;
// Sentinel = 'fileAddInfos'
if ((!((aReader)->ReadSentinel(501220521)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fileAddInfos' (FileAddInfo[]) member of 'ObjectStoreAddPutParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_cloneInfo),
std::move(_key),
std::move(_indexUpdateInfos),
std::move(_fileAddInfos)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreAddParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonParams());
// Sentinel = 'commonParams'
(aWriter)->WriteSentinel(537068782);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreAddParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>(aReader);
if (!maybe___commonParams) {
aReader->FatalError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStoreAddParams'");
return {};
}
auto& _commonParams = *maybe___commonParams;
// Sentinel = 'commonParams'
if ((!((aReader)->ReadSentinel(537068782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStoreAddParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStorePutParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStorePutParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonParams());
// Sentinel = 'commonParams'
(aWriter)->WriteSentinel(537068782);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStorePutParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreAddPutParams>(aReader);
if (!maybe___commonParams) {
aReader->FatalError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStorePutParams'");
return {};
}
auto& _commonParams = *maybe___commonParams;
// Sentinel = 'commonParams'
if ((!((aReader)->ReadSentinel(537068782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (ObjectStoreAddPutParams) member of 'ObjectStorePutParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreGetParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).keyRange());
// Sentinel = 'keyRange'
(aWriter)->WriteSentinel(244581175);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
if (!maybe___keyRange) {
aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetParams'");
return {};
}
auto& _keyRange = *maybe___keyRange;
// Sentinel = 'keyRange'
if ((!((aReader)->ReadSentinel(244581175)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_keyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreGetKeyParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetKeyParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).keyRange());
// Sentinel = 'keyRange'
(aWriter)->WriteSentinel(244581175);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetKeyParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
if (!maybe___keyRange) {
aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetKeyParams'");
return {};
}
auto& _keyRange = *maybe___keyRange;
// Sentinel = 'keyRange'
if ((!((aReader)->ReadSentinel(244581175)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreGetKeyParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_keyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreGetAllParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
(aWriter)->WriteBytes((&((aVar).limit())), 4);
// Sentinel = 'limit'
(aWriter)->WriteSentinel(106037792);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_optionalKeyRange),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'limit'
if ((!((aReader)->ReadSentinel(106037792)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreGetAllKeysParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
(aWriter)->WriteBytes((&((aVar).limit())), 4);
// Sentinel = 'limit'
(aWriter)->WriteSentinel(106037792);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllKeysParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreGetAllKeysParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_optionalKeyRange),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'limit'
if ((!((aReader)->ReadSentinel(106037792)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreDeleteParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreDeleteParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).keyRange());
// Sentinel = 'keyRange'
(aWriter)->WriteSentinel(244581175);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreDeleteParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
if (!maybe___keyRange) {
aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreDeleteParams'");
return {};
}
auto& _keyRange = *maybe___keyRange;
// Sentinel = 'keyRange'
if ((!((aReader)->ReadSentinel(244581175)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'ObjectStoreDeleteParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_keyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreClearParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreClearParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreClearParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ObjectStoreCountParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreCountParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 8);
// Sentinel = 'objectStoreId'
(aWriter)->WriteSentinel(620234034);
}
auto ParamTraits<::mozilla::dom::indexedDB::ObjectStoreCountParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreCountParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'ObjectStoreCountParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
std::move(_optionalKeyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId'
if ((!((aReader)->ReadSentinel(620234034)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(IndexGetParams, indexId_) - offsetof(IndexGetParams, objectStoreId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).keyRange());
// Sentinel = 'keyRange'
(aWriter)->WriteSentinel(244581175);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
// Sentinel = 'objectStoreId | indexId'
(aWriter)->WriteSentinel(1793132723);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
if (!maybe___keyRange) {
aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetParams'");
return {};
}
auto& _keyRange = *maybe___keyRange;
// Sentinel = 'keyRange'
if ((!((aReader)->ReadSentinel(244581175)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
::int64_t{0},
std::move(_keyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId | indexId'
if ((!((aReader)->ReadSentinel(1793132723)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetKeyParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetKeyParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(IndexGetKeyParams, indexId_) - offsetof(IndexGetKeyParams, objectStoreId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetKeyParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).keyRange());
// Sentinel = 'keyRange'
(aWriter)->WriteSentinel(244581175);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
// Sentinel = 'objectStoreId | indexId'
(aWriter)->WriteSentinel(1793132723);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetKeyParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___keyRange = IPC::ReadParam<::mozilla::dom::indexedDB::SerializedKeyRange>(aReader);
if (!maybe___keyRange) {
aReader->FatalError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetKeyParams'");
return {};
}
auto& _keyRange = *maybe___keyRange;
// Sentinel = 'keyRange'
if ((!((aReader)->ReadSentinel(244581175)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyRange' (SerializedKeyRange) member of 'IndexGetKeyParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
::int64_t{0},
std::move(_keyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId | indexId'
if ((!((aReader)->ReadSentinel(1793132723)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetAllParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetAllParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(IndexGetAllParams, indexId_) - offsetof(IndexGetAllParams, objectStoreId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
// Sentinel = 'objectStoreId | indexId'
(aWriter)->WriteSentinel(1793132723);
(aWriter)->WriteBytes((&((aVar).limit())), 4);
// Sentinel = 'limit'
(aWriter)->WriteSentinel(106037792);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
::int64_t{0},
std::move(_optionalKeyRange),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId | indexId'
if ((!((aReader)->ReadSentinel(1793132723)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'limit'
if ((!((aReader)->ReadSentinel(106037792)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexGetAllKeysParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexGetAllKeysParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(IndexGetAllKeysParams, indexId_) - offsetof(IndexGetAllKeysParams, objectStoreId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllKeysParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
// Sentinel = 'objectStoreId | indexId'
(aWriter)->WriteSentinel(1793132723);
(aWriter)->WriteBytes((&((aVar).limit())), 4);
// Sentinel = 'limit'
(aWriter)->WriteSentinel(106037792);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexGetAllKeysParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllKeysParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexGetAllKeysParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
::int64_t{0},
std::move(_optionalKeyRange),
::uint32_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId | indexId'
if ((!((aReader)->ReadSentinel(1793132723)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->limit())), 4)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'limit'
if ((!((aReader)->ReadSentinel(106037792)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IndexCountParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto IndexCountParams::StaticAssertions() const -> void
{
static_assert(
(offsetof(IndexCountParams, indexId_) - offsetof(IndexCountParams, objectStoreId_)) == 8,
"Bad assumptions about field layout!");
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::IndexCountParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).optionalKeyRange());
// Sentinel = 'optionalKeyRange'
(aWriter)->WriteSentinel(944572029);
(aWriter)->WriteBytes((&((aVar).objectStoreId())), 16);
// Sentinel = 'objectStoreId | indexId'
(aWriter)->WriteSentinel(1793132723);
}
auto ParamTraits<::mozilla::dom::indexedDB::IndexCountParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___optionalKeyRange = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::indexedDB::SerializedKeyRange>>(aReader);
if (!maybe___optionalKeyRange) {
aReader->FatalError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexCountParams'");
return {};
}
auto& _optionalKeyRange = *maybe___optionalKeyRange;
// Sentinel = 'optionalKeyRange'
if ((!((aReader)->ReadSentinel(944572029)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'optionalKeyRange' (SerializedKeyRange?) member of 'IndexCountParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
::int64_t{0},
::int64_t{0},
std::move(_optionalKeyRange)};
if ((!((aReader)->ReadBytesInto((&((result__)->objectStoreId())), 16)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'objectStoreId | indexId'
if ((!((aReader)->ReadSentinel(1793132723)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union RequestParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto RequestParams::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TObjectStoreAddParams:
{
(ptr_ObjectStoreAddParams())->~ObjectStoreAddParams__tdef();
break;
}
case TObjectStorePutParams:
{
(ptr_ObjectStorePutParams())->~ObjectStorePutParams__tdef();
break;
}
case TObjectStoreGetParams:
{
(ptr_ObjectStoreGetParams())->~ObjectStoreGetParams__tdef();
break;
}
case TObjectStoreGetKeyParams:
{
(ptr_ObjectStoreGetKeyParams())->~ObjectStoreGetKeyParams__tdef();
break;
}
case TObjectStoreGetAllParams:
{
(ptr_ObjectStoreGetAllParams())->~ObjectStoreGetAllParams__tdef();
break;
}
case TObjectStoreGetAllKeysParams:
{
(ptr_ObjectStoreGetAllKeysParams())->~ObjectStoreGetAllKeysParams__tdef();
break;
}
case TObjectStoreDeleteParams:
{
(ptr_ObjectStoreDeleteParams())->~ObjectStoreDeleteParams__tdef();
break;
}
case TObjectStoreClearParams:
{
(ptr_ObjectStoreClearParams())->~ObjectStoreClearParams__tdef();
break;
}
case TObjectStoreCountParams:
{
(ptr_ObjectStoreCountParams())->~ObjectStoreCountParams__tdef();
break;
}
case TIndexGetParams:
{
(ptr_IndexGetParams())->~IndexGetParams__tdef();
break;
}
case TIndexGetKeyParams:
{
(ptr_IndexGetKeyParams())->~IndexGetKeyParams__tdef();
break;
}
case TIndexGetAllParams:
{
(ptr_IndexGetAllParams())->~IndexGetAllParams__tdef();
break;
}
case TIndexGetAllKeysParams:
{
(ptr_IndexGetAllKeysParams())->~IndexGetAllKeysParams__tdef();
break;
}
case TIndexCountParams:
{
(ptr_IndexCountParams())->~IndexCountParams__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreAddParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move(aOther));
mType = TObjectStoreAddParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStorePutParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move(aOther));
mType = TObjectStorePutParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(aOther);
mType = TObjectStoreGetParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move(aOther));
mType = TObjectStoreGetParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetKeyParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(aOther);
mType = TObjectStoreGetKeyParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetKeyParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move(aOther));
mType = TObjectStoreGetKeyParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetAllParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(aOther);
mType = TObjectStoreGetAllParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetAllParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move(aOther));
mType = TObjectStoreGetAllParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreGetAllKeysParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(aOther);
mType = TObjectStoreGetAllKeysParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreGetAllKeysParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move(aOther));
mType = TObjectStoreGetAllKeysParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreDeleteParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(aOther);
mType = TObjectStoreDeleteParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreDeleteParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move(aOther));
mType = TObjectStoreDeleteParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreClearParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(aOther);
mType = TObjectStoreClearParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreClearParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move(aOther));
mType = TObjectStoreClearParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ObjectStoreCountParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(aOther);
mType = TObjectStoreCountParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ObjectStoreCountParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move(aOther));
mType = TObjectStoreCountParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(aOther);
mType = TIndexGetParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(IndexGetParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move(aOther));
mType = TIndexGetParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetKeyParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(aOther);
mType = TIndexGetKeyParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(IndexGetKeyParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move(aOther));
mType = TIndexGetKeyParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetAllParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(aOther);
mType = TIndexGetAllParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(IndexGetAllParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move(aOther));
mType = TIndexGetAllParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const IndexGetAllKeysParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(aOther);
mType = TIndexGetAllKeysParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(IndexGetAllKeysParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move(aOther));
mType = TIndexGetAllKeysParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const IndexCountParams& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(aOther);
mType = TIndexCountParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(IndexCountParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move(aOther));
mType = TIndexCountParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(RequestParams&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TObjectStoreAddParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move((aOther).get_ObjectStoreAddParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStorePutParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move((aOther).get_ObjectStorePutParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreGetParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move((aOther).get_ObjectStoreGetParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreGetKeyParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move((aOther).get_ObjectStoreGetKeyParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreGetAllParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move((aOther).get_ObjectStoreGetAllParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreGetAllKeysParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move((aOther).get_ObjectStoreGetAllKeysParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreDeleteParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move((aOther).get_ObjectStoreDeleteParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreClearParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move((aOther).get_ObjectStoreClearParams()));
(aOther).MaybeDestroy();
break;
}
case TObjectStoreCountParams:
{
new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move((aOther).get_ObjectStoreCountParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexGetParams:
{
new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move((aOther).get_IndexGetParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexGetKeyParams:
{
new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move((aOther).get_IndexGetKeyParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexGetAllParams:
{
new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move((aOther).get_IndexGetAllParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexGetAllKeysParams:
{
new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move((aOther).get_IndexGetAllKeysParams()));
(aOther).MaybeDestroy();
break;
}
case TIndexCountParams:
{
new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move((aOther).get_IndexCountParams()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
RequestParams::~RequestParams()
{
MaybeDestroy();
}
auto RequestParams::operator=(ObjectStoreAddParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move(aRhs));
mType = TObjectStoreAddParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStorePutParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move(aRhs));
mType = TObjectStorePutParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreGetParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(aRhs);
mType = TObjectStoreGetParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreGetParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move(aRhs));
mType = TObjectStoreGetParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreGetKeyParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(aRhs);
mType = TObjectStoreGetKeyParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreGetKeyParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move(aRhs));
mType = TObjectStoreGetKeyParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreGetAllParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(aRhs);
mType = TObjectStoreGetAllParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreGetAllParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move(aRhs));
mType = TObjectStoreGetAllParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreGetAllKeysParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(aRhs);
mType = TObjectStoreGetAllKeysParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreGetAllKeysParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move(aRhs));
mType = TObjectStoreGetAllKeysParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreDeleteParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(aRhs);
mType = TObjectStoreDeleteParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreDeleteParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move(aRhs));
mType = TObjectStoreDeleteParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreClearParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(aRhs);
mType = TObjectStoreClearParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreClearParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move(aRhs));
mType = TObjectStoreClearParams;
return (*(this));
}
auto RequestParams::operator=(const ObjectStoreCountParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(aRhs);
mType = TObjectStoreCountParams;
return (*(this));
}
auto RequestParams::operator=(ObjectStoreCountParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move(aRhs));
mType = TObjectStoreCountParams;
return (*(this));
}
auto RequestParams::operator=(const IndexGetParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(aRhs);
mType = TIndexGetParams;
return (*(this));
}
auto RequestParams::operator=(IndexGetParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move(aRhs));
mType = TIndexGetParams;
return (*(this));
}
auto RequestParams::operator=(const IndexGetKeyParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(aRhs);
mType = TIndexGetKeyParams;
return (*(this));
}
auto RequestParams::operator=(IndexGetKeyParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move(aRhs));
mType = TIndexGetKeyParams;
return (*(this));
}
auto RequestParams::operator=(const IndexGetAllParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(aRhs);
mType = TIndexGetAllParams;
return (*(this));
}
auto RequestParams::operator=(IndexGetAllParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move(aRhs));
mType = TIndexGetAllParams;
return (*(this));
}
auto RequestParams::operator=(const IndexGetAllKeysParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(aRhs);
mType = TIndexGetAllKeysParams;
return (*(this));
}
auto RequestParams::operator=(IndexGetAllKeysParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move(aRhs));
mType = TIndexGetAllKeysParams;
return (*(this));
}
auto RequestParams::operator=(const IndexCountParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(aRhs);
mType = TIndexCountParams;
return (*(this));
}
auto RequestParams::operator=(IndexCountParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move(aRhs));
mType = TIndexCountParams;
return (*(this));
}
auto RequestParams::operator=(RequestParams&& aRhs) -> RequestParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TObjectStoreAddParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreAddParams()) ObjectStoreAddParams(std::move((aRhs).get_ObjectStoreAddParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStorePutParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStorePutParams()) ObjectStorePutParams(std::move((aRhs).get_ObjectStorePutParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreGetParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetParams()) ObjectStoreGetParams(std::move((aRhs).get_ObjectStoreGetParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreGetKeyParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetKeyParams()) ObjectStoreGetKeyParams(std::move((aRhs).get_ObjectStoreGetKeyParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreGetAllParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllParams()) ObjectStoreGetAllParams(std::move((aRhs).get_ObjectStoreGetAllParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreGetAllKeysParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreGetAllKeysParams()) ObjectStoreGetAllKeysParams(std::move((aRhs).get_ObjectStoreGetAllKeysParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreDeleteParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreDeleteParams()) ObjectStoreDeleteParams(std::move((aRhs).get_ObjectStoreDeleteParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreClearParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreClearParams()) ObjectStoreClearParams(std::move((aRhs).get_ObjectStoreClearParams()));
(aRhs).MaybeDestroy();
break;
}
case TObjectStoreCountParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ObjectStoreCountParams()) ObjectStoreCountParams(std::move((aRhs).get_ObjectStoreCountParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexGetParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetParams()) IndexGetParams(std::move((aRhs).get_IndexGetParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexGetKeyParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetKeyParams()) IndexGetKeyParams(std::move((aRhs).get_IndexGetKeyParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexGetAllParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetAllParams()) IndexGetAllParams(std::move((aRhs).get_IndexGetAllParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexGetAllKeysParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexGetAllKeysParams()) IndexGetAllKeysParams(std::move((aRhs).get_IndexGetAllKeysParams()));
(aRhs).MaybeDestroy();
break;
}
case TIndexCountParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_IndexCountParams()) IndexCountParams(std::move((aRhs).get_IndexCountParams()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::RequestParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::indexedDB::RequestParams union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'RequestParams'
(aWriter)->WriteSentinel(615384398);
switch (type) {
case union__::TObjectStoreAddParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreAddParams());
// Sentinel = 'TObjectStoreAddParams'
(aWriter)->WriteSentinel(1479280678);
return;
}
case union__::TObjectStorePutParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStorePutParams());
// Sentinel = 'TObjectStorePutParams'
(aWriter)->WriteSentinel(1504381014);
return;
}
case union__::TObjectStoreGetParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetParams());
// Sentinel = 'TObjectStoreGetParams'
(aWriter)->WriteSentinel(1490683965);
return;
}
case union__::TObjectStoreGetKeyParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetKeyParams());
// Sentinel = 'TObjectStoreGetKeyParams'
(aWriter)->WriteSentinel(1937705318);
return;
}
case union__::TObjectStoreGetAllParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllParams());
// Sentinel = 'TObjectStoreGetAllParams'
(aWriter)->WriteSentinel(1929513302);
return;
}
case union__::TObjectStoreGetAllKeysParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreGetAllKeysParams());
// Sentinel = 'TObjectStoreGetAllKeysParams'
(aWriter)->WriteSentinel(2620525298);
return;
}
case union__::TObjectStoreDeleteParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreDeleteParams());
// Sentinel = 'TObjectStoreDeleteParams'
(aWriter)->WriteSentinel(1944127856);
return;
}
case union__::TObjectStoreClearParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreClearParams());
// Sentinel = 'TObjectStoreClearParams'
(aWriter)->WriteSentinel(1782909188);
return;
}
case union__::TObjectStoreCountParams:
{
IPC::WriteParam(aWriter, (aVar).get_ObjectStoreCountParams());
// Sentinel = 'TObjectStoreCountParams'
(aWriter)->WriteSentinel(1802045734);
return;
}
case union__::TIndexGetParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexGetParams());
// Sentinel = 'TIndexGetParams'
(aWriter)->WriteSentinel(756418001);
return;
}
case union__::TIndexGetKeyParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexGetKeyParams());
// Sentinel = 'TIndexGetKeyParams'
(aWriter)->WriteSentinel(1081542394);
return;
}
case union__::TIndexGetAllParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexGetAllParams());
// Sentinel = 'TIndexGetAllParams'
(aWriter)->WriteSentinel(1073350378);
return;
}
case union__::TIndexGetAllKeysParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexGetAllKeysParams());
// Sentinel = 'TIndexGetAllKeysParams'
(aWriter)->WriteSentinel(1601833094);
return;
}
case union__::TIndexCountParams:
{
IPC::WriteParam(aWriter, (aVar).get_IndexCountParams());
// Sentinel = 'TIndexCountParams'
(aWriter)->WriteSentinel(986515130);
return;
}
default:
{
aWriter->FatalError("unknown variant of union RequestParams");
return;
}
}
}
auto ParamTraits<::mozilla::dom::indexedDB::RequestParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::indexedDB::RequestParams union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union RequestParams");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'RequestParams'
if ((!((aReader)->ReadSentinel(615384398)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union RequestParams");
return {};
}
switch (type) {
case union__::TObjectStoreAddParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreAddParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreAddParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreAddParams'
if ((!((aReader)->ReadSentinel(1479280678)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreAddParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStorePutParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStorePutParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStorePutParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStorePutParams'
if ((!((aReader)->ReadSentinel(1504381014)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStorePutParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreGetParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreGetParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreGetParams'
if ((!((aReader)->ReadSentinel(1490683965)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreGetKeyParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetKeyParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreGetKeyParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreGetKeyParams'
if ((!((aReader)->ReadSentinel(1937705318)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetKeyParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreGetAllParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetAllParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreGetAllParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreGetAllParams'
if ((!((aReader)->ReadSentinel(1929513302)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreGetAllKeysParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreGetAllKeysParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreGetAllKeysParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreGetAllKeysParams'
if ((!((aReader)->ReadSentinel(2620525298)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreGetAllKeysParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreDeleteParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreDeleteParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreDeleteParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreDeleteParams'
if ((!((aReader)->ReadSentinel(1944127856)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreDeleteParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreClearParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreClearParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreClearParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreClearParams'
if ((!((aReader)->ReadSentinel(1782909188)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreClearParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TObjectStoreCountParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::ObjectStoreCountParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TObjectStoreCountParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TObjectStoreCountParams'
if ((!((aReader)->ReadSentinel(1802045734)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TObjectStoreCountParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexGetParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexGetParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexGetParams'
if ((!((aReader)->ReadSentinel(756418001)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexGetKeyParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetKeyParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexGetKeyParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexGetKeyParams'
if ((!((aReader)->ReadSentinel(1081542394)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetKeyParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexGetAllParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetAllParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexGetAllParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexGetAllParams'
if ((!((aReader)->ReadSentinel(1073350378)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetAllParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexGetAllKeysParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexGetAllKeysParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexGetAllKeysParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexGetAllKeysParams'
if ((!((aReader)->ReadSentinel(1601833094)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexGetAllKeysParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TIndexCountParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::indexedDB::IndexCountParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TIndexCountParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TIndexCountParams'
if ((!((aReader)->ReadSentinel(986515130)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TIndexCountParams of union RequestParams");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union RequestParams");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct LoggingInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
auto LoggingInfo::StaticAssertions() const -> void
{
static_assert(
(offsetof(LoggingInfo, nextRequestSerialNumber_) - offsetof(LoggingInfo, nextTransactionSerialNumber_)) == 16,
"Bad assumptions about field layout!");
}
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::indexedDB::LoggingInfo>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).backgroundChildLoggingId());
// Sentinel = 'backgroundChildLoggingId'
(aWriter)->WriteSentinel(2010253689);
(aWriter)->WriteBytes((&((aVar).nextTransactionSerialNumber())), 24);
// Sentinel = 'nextTransactionSerialNumber | nextVersionChangeTransactionSerialNumber | nextRequestSerialNumber'
(aWriter)->WriteSentinel(1100293682);
}
auto ParamTraits<::mozilla::dom::indexedDB::LoggingInfo>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___backgroundChildLoggingId = IPC::ReadParam<::nsID>(aReader);
if (!maybe___backgroundChildLoggingId) {
aReader->FatalError("Error deserializing 'backgroundChildLoggingId' (nsID) member of 'LoggingInfo'");
return {};
}
auto& _backgroundChildLoggingId = *maybe___backgroundChildLoggingId;
// Sentinel = 'backgroundChildLoggingId'
if ((!((aReader)->ReadSentinel(2010253689)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'backgroundChildLoggingId' (nsID) member of 'LoggingInfo'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_backgroundChildLoggingId),
::int64_t{0},
::int64_t{0},
::uint64_t{0}};
if ((!((aReader)->ReadBytesInto((&((result__)->nextTransactionSerialNumber())), 24)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'nextTransactionSerialNumber | nextVersionChangeTransactionSerialNumber | nextRequestSerialNumber'
if ((!((aReader)->ReadSentinel(1100293682)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC