Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/cache/IPCUtils.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/ipc/TransportSecurityInfoUtils.h"
#include "mozilla/dom/cache/PCacheParent.h"
#include "mozilla/dom/cache/PCacheChild.h"
#include "mozilla/dom/cache/PCacheStreamControlParent.h"
#include "mozilla/dom/cache/PCacheStreamControlChild.h"
#include "mozilla/dom/cache/CacheTypes.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 CacheQueryParams|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheQueryParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).ignoreSearch());
// Sentinel = 'ignoreSearch'
(aWriter)->WriteSentinel(534643931);
IPC::WriteParam(aWriter, (aVar).ignoreMethod());
// Sentinel = 'ignoreMethod'
(aWriter)->WriteSentinel(536610022);
IPC::WriteParam(aWriter, (aVar).ignoreVary());
// Sentinel = 'ignoreVary'
(aWriter)->WriteSentinel(381223975);
IPC::WriteParam(aWriter, (aVar).cacheNameSet());
// Sentinel = 'cacheNameSet'
(aWriter)->WriteSentinel(501023906);
IPC::WriteParam(aWriter, (aVar).cacheName());
// Sentinel = 'cacheName'
(aWriter)->WriteSentinel(289670006);
}
auto ParamTraits<::mozilla::dom::cache::CacheQueryParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___ignoreSearch = IPC::ReadParam<bool>(aReader);
if (!maybe___ignoreSearch) {
aReader->FatalError("Error deserializing 'ignoreSearch' (bool) member of 'CacheQueryParams'");
return {};
}
auto& _ignoreSearch = *maybe___ignoreSearch;
// Sentinel = 'ignoreSearch'
if ((!((aReader)->ReadSentinel(534643931)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ignoreSearch' (bool) member of 'CacheQueryParams'");
return {};
}
auto maybe___ignoreMethod = IPC::ReadParam<bool>(aReader);
if (!maybe___ignoreMethod) {
aReader->FatalError("Error deserializing 'ignoreMethod' (bool) member of 'CacheQueryParams'");
return {};
}
auto& _ignoreMethod = *maybe___ignoreMethod;
// Sentinel = 'ignoreMethod'
if ((!((aReader)->ReadSentinel(536610022)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ignoreMethod' (bool) member of 'CacheQueryParams'");
return {};
}
auto maybe___ignoreVary = IPC::ReadParam<bool>(aReader);
if (!maybe___ignoreVary) {
aReader->FatalError("Error deserializing 'ignoreVary' (bool) member of 'CacheQueryParams'");
return {};
}
auto& _ignoreVary = *maybe___ignoreVary;
// Sentinel = 'ignoreVary'
if ((!((aReader)->ReadSentinel(381223975)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ignoreVary' (bool) member of 'CacheQueryParams'");
return {};
}
auto maybe___cacheNameSet = IPC::ReadParam<bool>(aReader);
if (!maybe___cacheNameSet) {
aReader->FatalError("Error deserializing 'cacheNameSet' (bool) member of 'CacheQueryParams'");
return {};
}
auto& _cacheNameSet = *maybe___cacheNameSet;
// Sentinel = 'cacheNameSet'
if ((!((aReader)->ReadSentinel(501023906)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cacheNameSet' (bool) member of 'CacheQueryParams'");
return {};
}
auto maybe___cacheName = IPC::ReadParam<::nsString>(aReader);
if (!maybe___cacheName) {
aReader->FatalError("Error deserializing 'cacheName' (nsString) member of 'CacheQueryParams'");
return {};
}
auto& _cacheName = *maybe___cacheName;
// Sentinel = 'cacheName'
if ((!((aReader)->ReadSentinel(289670006)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'cacheName' (nsString) member of 'CacheQueryParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_ignoreSearch),
std::move(_ignoreMethod),
std::move(_ignoreVary),
std::move(_cacheNameSet),
std::move(_cacheName)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheReadStream|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheReadStream>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).id());
// Sentinel = 'id'
(aWriter)->WriteSentinel(20447438);
IPC::WriteParam(aWriter, (aVar).control());
// Sentinel = 'control'
(aWriter)->WriteSentinel(200016642);
IPC::WriteParam(aWriter, (aVar).stream());
// Sentinel = 'stream'
(aWriter)->WriteSentinel(153223821);
}
auto ParamTraits<::mozilla::dom::cache::CacheReadStream>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___id = IPC::ReadParam<::nsID>(aReader);
if (!maybe___id) {
aReader->FatalError("Error deserializing 'id' (nsID) member of 'CacheReadStream'");
return {};
}
auto& _id = *maybe___id;
// Sentinel = 'id'
if ((!((aReader)->ReadSentinel(20447438)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'id' (nsID) member of 'CacheReadStream'");
return {};
}
auto maybe___control = IPC::ReadParam<::mozilla::ipc::SideVariant<::mozilla::dom::cache::PCacheStreamControlParent*, ::mozilla::dom::cache::PCacheStreamControlChild*>>(aReader);
if (!maybe___control) {
aReader->FatalError("Error deserializing 'control' (PCacheStreamControl) member of 'CacheReadStream'");
return {};
}
auto& _control = *maybe___control;
// Sentinel = 'control'
if ((!((aReader)->ReadSentinel(200016642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'control' (PCacheStreamControl) member of 'CacheReadStream'");
return {};
}
auto maybe___stream = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::IPCStream>>(aReader);
if (!maybe___stream) {
aReader->FatalError("Error deserializing 'stream' (IPCStream?) member of 'CacheReadStream'");
return {};
}
auto& _stream = *maybe___stream;
// Sentinel = 'stream'
if ((!((aReader)->ReadSentinel(153223821)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'stream' (IPCStream?) member of 'CacheReadStream'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_id),
_control,
std::move(_stream)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct HeadersEntry|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::HeadersEntry>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).name());
// Sentinel = 'name'
(aWriter)->WriteSentinel(69075362);
IPC::WriteParam(aWriter, (aVar).value());
// Sentinel = 'value'
(aWriter)->WriteSentinel(107610654);
}
auto ParamTraits<::mozilla::dom::cache::HeadersEntry>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___name = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___name) {
aReader->FatalError("Error deserializing 'name' (nsCString) member of 'HeadersEntry'");
return {};
}
auto& _name = *maybe___name;
// Sentinel = 'name'
if ((!((aReader)->ReadSentinel(69075362)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'HeadersEntry'");
return {};
}
auto maybe___value = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___value) {
aReader->FatalError("Error deserializing 'value' (nsCString) member of 'HeadersEntry'");
return {};
}
auto& _value = *maybe___value;
// Sentinel = 'value'
if ((!((aReader)->ReadSentinel(107610654)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'value' (nsCString) member of 'HeadersEntry'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_name),
std::move(_value)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheRequest|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheRequest>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).method());
// Sentinel = 'method'
(aWriter)->WriteSentinel(148308610);
IPC::WriteParam(aWriter, (aVar).urlWithoutQuery());
// Sentinel = 'urlWithoutQuery'
(aWriter)->WriteSentinel(851510878);
IPC::WriteParam(aWriter, (aVar).urlQuery());
// Sentinel = 'urlQuery'
(aWriter)->WriteSentinel(256574314);
IPC::WriteParam(aWriter, (aVar).urlFragment());
// Sentinel = 'urlFragment'
(aWriter)->WriteSentinel(454821000);
IPC::WriteParam(aWriter, (aVar).headers());
// Sentinel = 'headers'
(aWriter)->WriteSentinel(188220125);
IPC::WriteParam(aWriter, (aVar).headersGuard());
// Sentinel = 'headersGuard'
(aWriter)->WriteSentinel(522912976);
IPC::WriteParam(aWriter, (aVar).referrer());
// Sentinel = 'referrer'
(aWriter)->WriteSentinel(252838750);
IPC::WriteParam(aWriter, (aVar).referrerPolicy());
// Sentinel = 'referrerPolicy'
(aWriter)->WriteSentinel(729482702);
IPC::WriteParam(aWriter, (aVar).mode());
// Sentinel = 'mode'
(aWriter)->WriteSentinel(70386086);
IPC::WriteParam(aWriter, (aVar).credentials());
// Sentinel = 'credentials'
(aWriter)->WriteSentinel(454689935);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).contentPolicyType());
// Sentinel = 'contentPolicyType'
(aWriter)->WriteSentinel(1066927886);
IPC::WriteParam(aWriter, (aVar).requestCache());
// Sentinel = 'requestCache'
(aWriter)->WriteSentinel(544736478);
IPC::WriteParam(aWriter, (aVar).requestRedirect());
// Sentinel = 'requestRedirect'
(aWriter)->WriteSentinel(843974204);
IPC::WriteParam(aWriter, (aVar).integrity());
// Sentinel = 'integrity'
(aWriter)->WriteSentinel(320537568);
IPC::WriteParam(aWriter, (aVar).loadingEmbedderPolicy());
// Sentinel = 'loadingEmbedderPolicy'
(aWriter)->WriteSentinel(1541343335);
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
(aWriter)->WriteBytes((&((aVar).bodyDiskSize())), 8);
// Sentinel = 'bodyDiskSize'
(aWriter)->WriteSentinel(523896021);
}
auto ParamTraits<::mozilla::dom::cache::CacheRequest>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___method = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___method) {
aReader->FatalError("Error deserializing 'method' (nsCString) member of 'CacheRequest'");
return {};
}
auto& _method = *maybe___method;
// Sentinel = 'method'
if ((!((aReader)->ReadSentinel(148308610)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'method' (nsCString) member of 'CacheRequest'");
return {};
}
auto maybe___urlWithoutQuery = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___urlWithoutQuery) {
aReader->FatalError("Error deserializing 'urlWithoutQuery' (nsCString) member of 'CacheRequest'");
return {};
}
auto& _urlWithoutQuery = *maybe___urlWithoutQuery;
// Sentinel = 'urlWithoutQuery'
if ((!((aReader)->ReadSentinel(851510878)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'urlWithoutQuery' (nsCString) member of 'CacheRequest'");
return {};
}
auto maybe___urlQuery = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___urlQuery) {
aReader->FatalError("Error deserializing 'urlQuery' (nsCString) member of 'CacheRequest'");
return {};
}
auto& _urlQuery = *maybe___urlQuery;
// Sentinel = 'urlQuery'
if ((!((aReader)->ReadSentinel(256574314)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'urlQuery' (nsCString) member of 'CacheRequest'");
return {};
}
auto maybe___urlFragment = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___urlFragment) {
aReader->FatalError("Error deserializing 'urlFragment' (nsCString) member of 'CacheRequest'");
return {};
}
auto& _urlFragment = *maybe___urlFragment;
// Sentinel = 'urlFragment'
if ((!((aReader)->ReadSentinel(454821000)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'urlFragment' (nsCString) member of 'CacheRequest'");
return {};
}
auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::cache::HeadersEntry>>(aReader);
if (!maybe___headers) {
aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'CacheRequest'");
return {};
}
auto& _headers = *maybe___headers;
// Sentinel = 'headers'
if ((!((aReader)->ReadSentinel(188220125)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeadersEntry[]) member of 'CacheRequest'");
return {};
}
auto maybe___headersGuard = IPC::ReadParam<::mozilla::dom::HeadersGuardEnum>(aReader);
if (!maybe___headersGuard) {
aReader->FatalError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'CacheRequest'");
return {};
}
auto& _headersGuard = *maybe___headersGuard;
// Sentinel = 'headersGuard'
if ((!((aReader)->ReadSentinel(522912976)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'CacheRequest'");
return {};
}
auto maybe___referrer = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___referrer) {
aReader->FatalError("Error deserializing 'referrer' (nsCString) member of 'CacheRequest'");
return {};
}
auto& _referrer = *maybe___referrer;
// Sentinel = 'referrer'
if ((!((aReader)->ReadSentinel(252838750)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrer' (nsCString) member of 'CacheRequest'");
return {};
}
auto maybe___referrerPolicy = IPC::ReadParam<::mozilla::dom::ReferrerPolicy>(aReader);
if (!maybe___referrerPolicy) {
aReader->FatalError("Error deserializing 'referrerPolicy' (ReferrerPolicy) member of 'CacheRequest'");
return {};
}
auto& _referrerPolicy = *maybe___referrerPolicy;
// Sentinel = 'referrerPolicy'
if ((!((aReader)->ReadSentinel(729482702)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'referrerPolicy' (ReferrerPolicy) member of 'CacheRequest'");
return {};
}
auto maybe___mode = IPC::ReadParam<::mozilla::dom::RequestMode>(aReader);
if (!maybe___mode) {
aReader->FatalError("Error deserializing 'mode' (RequestMode) member of 'CacheRequest'");
return {};
}
auto& _mode = *maybe___mode;
// Sentinel = 'mode'
if ((!((aReader)->ReadSentinel(70386086)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'mode' (RequestMode) member of 'CacheRequest'");
return {};
}
auto maybe___credentials = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
if (!maybe___credentials) {
aReader->FatalError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheRequest'");
return {};
}
auto& _credentials = *maybe___credentials;
// Sentinel = 'credentials'
if ((!((aReader)->ReadSentinel(454689935)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheRequest'");
return {};
}
auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheReadStream>>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (CacheReadStream?) member of 'CacheRequest'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (CacheReadStream?) member of 'CacheRequest'");
return {};
}
auto maybe___contentPolicyType = IPC::ReadParam<::nsContentPolicyType>(aReader);
if (!maybe___contentPolicyType) {
aReader->FatalError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'CacheRequest'");
return {};
}
auto& _contentPolicyType = *maybe___contentPolicyType;
// Sentinel = 'contentPolicyType'
if ((!((aReader)->ReadSentinel(1066927886)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'contentPolicyType' (nsContentPolicyType) member of 'CacheRequest'");
return {};
}
auto maybe___requestCache = IPC::ReadParam<::mozilla::dom::RequestCache>(aReader);
if (!maybe___requestCache) {
aReader->FatalError("Error deserializing 'requestCache' (RequestCache) member of 'CacheRequest'");
return {};
}
auto& _requestCache = *maybe___requestCache;
// Sentinel = 'requestCache'
if ((!((aReader)->ReadSentinel(544736478)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestCache' (RequestCache) member of 'CacheRequest'");
return {};
}
auto maybe___requestRedirect = IPC::ReadParam<::mozilla::dom::RequestRedirect>(aReader);
if (!maybe___requestRedirect) {
aReader->FatalError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'CacheRequest'");
return {};
}
auto& _requestRedirect = *maybe___requestRedirect;
// Sentinel = 'requestRedirect'
if ((!((aReader)->ReadSentinel(843974204)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestRedirect' (RequestRedirect) member of 'CacheRequest'");
return {};
}
auto maybe___integrity = IPC::ReadParam<::nsString>(aReader);
if (!maybe___integrity) {
aReader->FatalError("Error deserializing 'integrity' (nsString) member of 'CacheRequest'");
return {};
}
auto& _integrity = *maybe___integrity;
// Sentinel = 'integrity'
if ((!((aReader)->ReadSentinel(320537568)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'integrity' (nsString) member of 'CacheRequest'");
return {};
}
auto maybe___loadingEmbedderPolicy = IPC::ReadParam<::nsILoadInfo::CrossOriginEmbedderPolicy>(aReader);
if (!maybe___loadingEmbedderPolicy) {
aReader->FatalError("Error deserializing 'loadingEmbedderPolicy' (CrossOriginEmbedderPolicy) member of 'CacheRequest'");
return {};
}
auto& _loadingEmbedderPolicy = *maybe___loadingEmbedderPolicy;
// Sentinel = 'loadingEmbedderPolicy'
if ((!((aReader)->ReadSentinel(1541343335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'loadingEmbedderPolicy' (CrossOriginEmbedderPolicy) member of 'CacheRequest'");
return {};
}
auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'CacheRequest'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'CacheRequest'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_method),
std::move(_urlWithoutQuery),
std::move(_urlQuery),
std::move(_urlFragment),
std::move(_headers),
std::move(_headersGuard),
std::move(_referrer),
std::move(_referrerPolicy),
std::move(_mode),
std::move(_credentials),
std::move(_body),
::int64_t{0},
std::move(_contentPolicyType),
std::move(_requestCache),
std::move(_requestRedirect),
std::move(_integrity),
std::move(_loadingEmbedderPolicy),
std::move(_principalInfo)};
if ((!((aReader)->ReadBytesInto((&((result__)->bodyDiskSize())), 8)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'bodyDiskSize'
if ((!((aReader)->ReadSentinel(523896021)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheResponse|
//
namespace mozilla {
namespace dom {
namespace cache {
auto CacheResponse::StaticAssertions() const -> void
{
static_assert(
(offsetof(CacheResponse, paddingSize_) - offsetof(CacheResponse, bodyDiskSize_)) == 8,
"Bad assumptions about field layout!");
static_assert(
(offsetof(CacheResponse, paddingInfo_) - offsetof(CacheResponse, status_)) == 4,
"Bad assumptions about field layout!");
}
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).type());
// Sentinel = 'type'
(aWriter)->WriteSentinel(75760067);
IPC::WriteParam(aWriter, (aVar).urlList());
// Sentinel = 'urlList'
(aWriter)->WriteSentinel(197591792);
IPC::WriteParam(aWriter, (aVar).statusText());
// Sentinel = 'statusText'
(aWriter)->WriteSentinel(397411402);
IPC::WriteParam(aWriter, (aVar).headers());
// Sentinel = 'headers'
(aWriter)->WriteSentinel(188220125);
IPC::WriteParam(aWriter, (aVar).headersGuard());
// Sentinel = 'headersGuard'
(aWriter)->WriteSentinel(522912976);
IPC::WriteParam(aWriter, (aVar).body());
// Sentinel = 'body'
(aWriter)->WriteSentinel(68813231);
IPC::WriteParam(aWriter, (aVar).securityInfo());
// Sentinel = 'securityInfo'
(aWriter)->WriteSentinel(552535301);
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
IPC::WriteParam(aWriter, (aVar).credentials());
// Sentinel = 'credentials'
(aWriter)->WriteSentinel(454689935);
(aWriter)->WriteBytes((&((aVar).bodyDiskSize())), 16);
// Sentinel = 'bodyDiskSize | paddingSize'
(aWriter)->WriteSentinel(2264926723);
(aWriter)->WriteBytes((&((aVar).status())), 8);
// Sentinel = 'status | paddingInfo'
(aWriter)->WriteSentinel(1378355140);
}
auto ParamTraits<::mozilla::dom::cache::CacheResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___type = IPC::ReadParam<::mozilla::dom::ResponseType>(aReader);
if (!maybe___type) {
aReader->FatalError("Error deserializing 'type' (ResponseType) member of 'CacheResponse'");
return {};
}
auto& _type = *maybe___type;
// Sentinel = 'type'
if ((!((aReader)->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'type' (ResponseType) member of 'CacheResponse'");
return {};
}
auto maybe___urlList = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
if (!maybe___urlList) {
aReader->FatalError("Error deserializing 'urlList' (nsCString[]) member of 'CacheResponse'");
return {};
}
auto& _urlList = *maybe___urlList;
// Sentinel = 'urlList'
if ((!((aReader)->ReadSentinel(197591792)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'urlList' (nsCString[]) member of 'CacheResponse'");
return {};
}
auto maybe___statusText = IPC::ReadParam<::nsCString>(aReader);
if (!maybe___statusText) {
aReader->FatalError("Error deserializing 'statusText' (nsCString) member of 'CacheResponse'");
return {};
}
auto& _statusText = *maybe___statusText;
// Sentinel = 'statusText'
if ((!((aReader)->ReadSentinel(397411402)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'statusText' (nsCString) member of 'CacheResponse'");
return {};
}
auto maybe___headers = IPC::ReadParam<nsTArray<::mozilla::dom::cache::HeadersEntry>>(aReader);
if (!maybe___headers) {
aReader->FatalError("Error deserializing 'headers' (HeadersEntry[]) member of 'CacheResponse'");
return {};
}
auto& _headers = *maybe___headers;
// Sentinel = 'headers'
if ((!((aReader)->ReadSentinel(188220125)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headers' (HeadersEntry[]) member of 'CacheResponse'");
return {};
}
auto maybe___headersGuard = IPC::ReadParam<::mozilla::dom::HeadersGuardEnum>(aReader);
if (!maybe___headersGuard) {
aReader->FatalError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'CacheResponse'");
return {};
}
auto& _headersGuard = *maybe___headersGuard;
// Sentinel = 'headersGuard'
if ((!((aReader)->ReadSentinel(522912976)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'headersGuard' (HeadersGuardEnum) member of 'CacheResponse'");
return {};
}
auto maybe___body = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheReadStream>>(aReader);
if (!maybe___body) {
aReader->FatalError("Error deserializing 'body' (CacheReadStream?) member of 'CacheResponse'");
return {};
}
auto& _body = *maybe___body;
// Sentinel = 'body'
if ((!((aReader)->ReadSentinel(68813231)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'body' (CacheReadStream?) member of 'CacheResponse'");
return {};
}
auto maybe___securityInfo = IPC::ReadParam<RefPtr<::nsITransportSecurityInfo>>(aReader);
if (!maybe___securityInfo) {
aReader->FatalError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'CacheResponse'");
return {};
}
auto& _securityInfo = *maybe___securityInfo;
// Sentinel = 'securityInfo'
if ((!((aReader)->ReadSentinel(552535301)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'securityInfo' (nsITransportSecurityInfo) member of 'CacheResponse'");
return {};
}
auto maybe___principalInfo = IPC::ReadParam<mozilla::Maybe<::mozilla::ipc::PrincipalInfo>>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'CacheResponse'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo?) member of 'CacheResponse'");
return {};
}
auto maybe___credentials = IPC::ReadParam<::mozilla::dom::RequestCredentials>(aReader);
if (!maybe___credentials) {
aReader->FatalError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheResponse'");
return {};
}
auto& _credentials = *maybe___credentials;
// Sentinel = 'credentials'
if ((!((aReader)->ReadSentinel(454689935)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'credentials' (RequestCredentials) member of 'CacheResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_type),
std::move(_urlList),
::uint32_t{0},
std::move(_statusText),
std::move(_headers),
std::move(_headersGuard),
std::move(_body),
::int64_t{0},
std::move(_securityInfo),
std::move(_principalInfo),
::uint32_t{0},
::int64_t{0},
std::move(_credentials)};
if ((!((aReader)->ReadBytesInto((&((result__)->bodyDiskSize())), 16)))) {
aReader->FatalError("Error bulk reading fields from int64_t");
return {};
}
// Sentinel = 'bodyDiskSize | paddingSize'
if ((!((aReader)->ReadSentinel(2264926723)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from int64_t");
return {};
}
if ((!((aReader)->ReadBytesInto((&((result__)->status())), 8)))) {
aReader->FatalError("Error bulk reading fields from uint32_t");
return {};
}
// Sentinel = 'status | paddingInfo'
if ((!((aReader)->ReadSentinel(1378355140)))) {
mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
return {};
}
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheRequestResponse|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheRequestResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).request());
// Sentinel = 'request'
(aWriter)->WriteSentinel(202703626);
IPC::WriteParam(aWriter, (aVar).response());
// Sentinel = 'response'
(aWriter)->WriteSentinel(260965232);
}
auto ParamTraits<::mozilla::dom::cache::CacheRequestResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
if (!maybe___request) {
aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'CacheRequestResponse'");
return {};
}
auto& _request = *maybe___request;
// Sentinel = 'request'
if ((!((aReader)->ReadSentinel(202703626)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'CacheRequestResponse'");
return {};
}
auto maybe___response = IPC::ReadParam<::mozilla::dom::cache::CacheResponse>(aReader);
if (!maybe___response) {
aReader->FatalError("Error deserializing 'response' (CacheResponse) member of 'CacheRequestResponse'");
return {};
}
auto& _response = *maybe___response;
// Sentinel = 'response'
if ((!((aReader)->ReadSentinel(260965232)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'response' (CacheResponse) member of 'CacheRequestResponse'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_request),
std::move(_response)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheMatchArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheMatchArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).request());
// Sentinel = 'request'
(aWriter)->WriteSentinel(202703626);
IPC::WriteParam(aWriter, (aVar).params());
// Sentinel = 'params'
(aWriter)->WriteSentinel(146997893);
IPC::WriteParam(aWriter, (aVar).openMode());
// Sentinel = 'openMode'
(aWriter)->WriteSentinel(247595832);
}
auto ParamTraits<::mozilla::dom::cache::CacheMatchArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
if (!maybe___request) {
aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'CacheMatchArgs'");
return {};
}
auto& _request = *maybe___request;
// Sentinel = 'request'
if ((!((aReader)->ReadSentinel(202703626)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'CacheMatchArgs'");
return {};
}
auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
if (!maybe___params) {
aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchArgs'");
return {};
}
auto& _params = *maybe___params;
// Sentinel = 'params'
if ((!((aReader)->ReadSentinel(146997893)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchArgs'");
return {};
}
auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
if (!maybe___openMode) {
aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchArgs'");
return {};
}
auto& _openMode = *maybe___openMode;
// Sentinel = 'openMode'
if ((!((aReader)->ReadSentinel(247595832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_request),
std::move(_params),
std::move(_openMode)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheMatchAllArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheMatchAllArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).maybeRequest());
// Sentinel = 'maybeRequest'
(aWriter)->WriteSentinel(534054136);
IPC::WriteParam(aWriter, (aVar).params());
// Sentinel = 'params'
(aWriter)->WriteSentinel(146997893);
IPC::WriteParam(aWriter, (aVar).openMode());
// Sentinel = 'openMode'
(aWriter)->WriteSentinel(247595832);
}
auto ParamTraits<::mozilla::dom::cache::CacheMatchAllArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___maybeRequest = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheRequest>>(aReader);
if (!maybe___maybeRequest) {
aReader->FatalError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheMatchAllArgs'");
return {};
}
auto& _maybeRequest = *maybe___maybeRequest;
// Sentinel = 'maybeRequest'
if ((!((aReader)->ReadSentinel(534054136)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheMatchAllArgs'");
return {};
}
auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
if (!maybe___params) {
aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchAllArgs'");
return {};
}
auto& _params = *maybe___params;
// Sentinel = 'params'
if ((!((aReader)->ReadSentinel(146997893)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheMatchAllArgs'");
return {};
}
auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
if (!maybe___openMode) {
aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchAllArgs'");
return {};
}
auto& _openMode = *maybe___openMode;
// Sentinel = 'openMode'
if ((!((aReader)->ReadSentinel(247595832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'CacheMatchAllArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_maybeRequest),
std::move(_params),
std::move(_openMode)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CachePutAllArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CachePutAllArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestResponseList());
// Sentinel = 'requestResponseList'
(aWriter)->WriteSentinel(1343490037);
}
auto ParamTraits<::mozilla::dom::cache::CachePutAllArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestResponseList = IPC::ReadParam<nsTArray<::mozilla::dom::cache::CacheRequestResponse>>(aReader);
if (!maybe___requestResponseList) {
aReader->FatalError("Error deserializing 'requestResponseList' (CacheRequestResponse[]) member of 'CachePutAllArgs'");
return {};
}
auto& _requestResponseList = *maybe___requestResponseList;
// Sentinel = 'requestResponseList'
if ((!((aReader)->ReadSentinel(1343490037)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestResponseList' (CacheRequestResponse[]) member of 'CachePutAllArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestResponseList)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheDeleteArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheDeleteArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).request());
// Sentinel = 'request'
(aWriter)->WriteSentinel(202703626);
IPC::WriteParam(aWriter, (aVar).params());
// Sentinel = 'params'
(aWriter)->WriteSentinel(146997893);
}
auto ParamTraits<::mozilla::dom::cache::CacheDeleteArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
if (!maybe___request) {
aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'CacheDeleteArgs'");
return {};
}
auto& _request = *maybe___request;
// Sentinel = 'request'
if ((!((aReader)->ReadSentinel(202703626)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'CacheDeleteArgs'");
return {};
}
auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
if (!maybe___params) {
aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheDeleteArgs'");
return {};
}
auto& _params = *maybe___params;
// Sentinel = 'params'
if ((!((aReader)->ReadSentinel(146997893)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheDeleteArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_request),
std::move(_params)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheKeysArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheKeysArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).maybeRequest());
// Sentinel = 'maybeRequest'
(aWriter)->WriteSentinel(534054136);
IPC::WriteParam(aWriter, (aVar).params());
// Sentinel = 'params'
(aWriter)->WriteSentinel(146997893);
IPC::WriteParam(aWriter, (aVar).openMode());
// Sentinel = 'openMode'
(aWriter)->WriteSentinel(247595832);
}
auto ParamTraits<::mozilla::dom::cache::CacheKeysArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___maybeRequest = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheRequest>>(aReader);
if (!maybe___maybeRequest) {
aReader->FatalError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheKeysArgs'");
return {};
}
auto& _maybeRequest = *maybe___maybeRequest;
// Sentinel = 'maybeRequest'
if ((!((aReader)->ReadSentinel(534054136)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'maybeRequest' (CacheRequest?) member of 'CacheKeysArgs'");
return {};
}
auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
if (!maybe___params) {
aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'CacheKeysArgs'");
return {};
}
auto& _params = *maybe___params;
// Sentinel = 'params'
if ((!((aReader)->ReadSentinel(146997893)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'CacheKeysArgs'");
return {};
}
auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
if (!maybe___openMode) {
aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'CacheKeysArgs'");
return {};
}
auto& _openMode = *maybe___openMode;
// Sentinel = 'openMode'
if ((!((aReader)->ReadSentinel(247595832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'CacheKeysArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_maybeRequest),
std::move(_params),
std::move(_openMode)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageMatchArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageMatchArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).request());
// Sentinel = 'request'
(aWriter)->WriteSentinel(202703626);
IPC::WriteParam(aWriter, (aVar).params());
// Sentinel = 'params'
(aWriter)->WriteSentinel(146997893);
IPC::WriteParam(aWriter, (aVar).openMode());
// Sentinel = 'openMode'
(aWriter)->WriteSentinel(247595832);
}
auto ParamTraits<::mozilla::dom::cache::StorageMatchArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___request = IPC::ReadParam<::mozilla::dom::cache::CacheRequest>(aReader);
if (!maybe___request) {
aReader->FatalError("Error deserializing 'request' (CacheRequest) member of 'StorageMatchArgs'");
return {};
}
auto& _request = *maybe___request;
// Sentinel = 'request'
if ((!((aReader)->ReadSentinel(202703626)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'request' (CacheRequest) member of 'StorageMatchArgs'");
return {};
}
auto maybe___params = IPC::ReadParam<::mozilla::dom::cache::CacheQueryParams>(aReader);
if (!maybe___params) {
aReader->FatalError("Error deserializing 'params' (CacheQueryParams) member of 'StorageMatchArgs'");
return {};
}
auto& _params = *maybe___params;
// Sentinel = 'params'
if ((!((aReader)->ReadSentinel(146997893)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'params' (CacheQueryParams) member of 'StorageMatchArgs'");
return {};
}
auto maybe___openMode = IPC::ReadParam<::mozilla::dom::cache::OpenMode>(aReader);
if (!maybe___openMode) {
aReader->FatalError("Error deserializing 'openMode' (OpenMode) member of 'StorageMatchArgs'");
return {};
}
auto& _openMode = *maybe___openMode;
// Sentinel = 'openMode'
if ((!((aReader)->ReadSentinel(247595832)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'openMode' (OpenMode) member of 'StorageMatchArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_request),
std::move(_params),
std::move(_openMode)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageHasArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageHasArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).key());
// Sentinel = 'key'
(aWriter)->WriteSentinel(42402122);
}
auto ParamTraits<::mozilla::dom::cache::StorageHasArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___key = IPC::ReadParam<::nsString>(aReader);
if (!maybe___key) {
aReader->FatalError("Error deserializing 'key' (nsString) member of 'StorageHasArgs'");
return {};
}
auto& _key = *maybe___key;
// Sentinel = 'key'
if ((!((aReader)->ReadSentinel(42402122)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'StorageHasArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_key)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageOpenArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageOpenArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).key());
// Sentinel = 'key'
(aWriter)->WriteSentinel(42402122);
}
auto ParamTraits<::mozilla::dom::cache::StorageOpenArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___key = IPC::ReadParam<::nsString>(aReader);
if (!maybe___key) {
aReader->FatalError("Error deserializing 'key' (nsString) member of 'StorageOpenArgs'");
return {};
}
auto& _key = *maybe___key;
// Sentinel = 'key'
if ((!((aReader)->ReadSentinel(42402122)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'StorageOpenArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_key)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageDeleteArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageDeleteArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).key());
// Sentinel = 'key'
(aWriter)->WriteSentinel(42402122);
}
auto ParamTraits<::mozilla::dom::cache::StorageDeleteArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___key = IPC::ReadParam<::nsString>(aReader);
if (!maybe___key) {
aReader->FatalError("Error deserializing 'key' (nsString) member of 'StorageDeleteArgs'");
return {};
}
auto& _key = *maybe___key;
// Sentinel = 'key'
if ((!((aReader)->ReadSentinel(42402122)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'key' (nsString) member of 'StorageDeleteArgs'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_key)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageKeysArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageKeysArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::cache::StorageKeysArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CacheOpArgs|
//
namespace mozilla {
namespace dom {
namespace cache {
auto CacheOpArgs::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TCacheMatchArgs:
{
(ptr_CacheMatchArgs())->~CacheMatchArgs__tdef();
break;
}
case TCacheMatchAllArgs:
{
(ptr_CacheMatchAllArgs())->~CacheMatchAllArgs__tdef();
break;
}
case TCachePutAllArgs:
{
(ptr_CachePutAllArgs())->~CachePutAllArgs__tdef();
break;
}
case TCacheDeleteArgs:
{
(ptr_CacheDeleteArgs())->~CacheDeleteArgs__tdef();
break;
}
case TCacheKeysArgs:
{
(ptr_CacheKeysArgs())->~CacheKeysArgs__tdef();
break;
}
case TStorageMatchArgs:
{
(ptr_StorageMatchArgs())->~StorageMatchArgs__tdef();
break;
}
case TStorageHasArgs:
{
(ptr_StorageHasArgs())->~StorageHasArgs__tdef();
break;
}
case TStorageOpenArgs:
{
(ptr_StorageOpenArgs())->~StorageOpenArgs__tdef();
break;
}
case TStorageDeleteArgs:
{
(ptr_StorageDeleteArgs())->~StorageDeleteArgs__tdef();
break;
}
case TStorageKeysArgs:
{
(ptr_StorageKeysArgs())->~StorageKeysArgs__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheMatchArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(aOther);
mType = TCacheMatchArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheMatchArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move(aOther));
mType = TCacheMatchArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheMatchAllArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(aOther);
mType = TCacheMatchAllArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheMatchAllArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move(aOther));
mType = TCacheMatchAllArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CachePutAllArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(aOther);
mType = TCachePutAllArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CachePutAllArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move(aOther));
mType = TCachePutAllArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheDeleteArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(aOther);
mType = TCacheDeleteArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheDeleteArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move(aOther));
mType = TCacheDeleteArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheKeysArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(aOther);
mType = TCacheKeysArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheKeysArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move(aOther));
mType = TCacheKeysArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageMatchArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(aOther);
mType = TStorageMatchArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageMatchArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move(aOther));
mType = TStorageMatchArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageHasArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(aOther);
mType = TStorageHasArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageHasArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move(aOther));
mType = TStorageHasArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageOpenArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(aOther);
mType = TStorageOpenArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageOpenArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move(aOther));
mType = TStorageOpenArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageDeleteArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(aOther);
mType = TStorageDeleteArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageDeleteArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move(aOther));
mType = TStorageDeleteArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const StorageKeysArgs& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(aOther);
mType = TStorageKeysArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(StorageKeysArgs&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move(aOther));
mType = TStorageKeysArgs;
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(const CacheOpArgs& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TCacheMatchArgs:
{
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs((aOther).get_CacheMatchArgs());
break;
}
case TCacheMatchAllArgs:
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs((aOther).get_CacheMatchAllArgs());
break;
}
case TCachePutAllArgs:
{
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs((aOther).get_CachePutAllArgs());
break;
}
case TCacheDeleteArgs:
{
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs((aOther).get_CacheDeleteArgs());
break;
}
case TCacheKeysArgs:
{
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs((aOther).get_CacheKeysArgs());
break;
}
case TStorageMatchArgs:
{
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs((aOther).get_StorageMatchArgs());
break;
}
case TStorageHasArgs:
{
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs((aOther).get_StorageHasArgs());
break;
}
case TStorageOpenArgs:
{
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs((aOther).get_StorageOpenArgs());
break;
}
case TStorageDeleteArgs:
{
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs((aOther).get_StorageDeleteArgs());
break;
}
case TStorageKeysArgs:
{
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs((aOther).get_StorageKeysArgs());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT CacheOpArgs::CacheOpArgs(CacheOpArgs&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TCacheMatchArgs:
{
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move((aOther).get_CacheMatchArgs()));
(aOther).MaybeDestroy();
break;
}
case TCacheMatchAllArgs:
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move((aOther).get_CacheMatchAllArgs()));
(aOther).MaybeDestroy();
break;
}
case TCachePutAllArgs:
{
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move((aOther).get_CachePutAllArgs()));
(aOther).MaybeDestroy();
break;
}
case TCacheDeleteArgs:
{
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move((aOther).get_CacheDeleteArgs()));
(aOther).MaybeDestroy();
break;
}
case TCacheKeysArgs:
{
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move((aOther).get_CacheKeysArgs()));
(aOther).MaybeDestroy();
break;
}
case TStorageMatchArgs:
{
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move((aOther).get_StorageMatchArgs()));
(aOther).MaybeDestroy();
break;
}
case TStorageHasArgs:
{
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move((aOther).get_StorageHasArgs()));
(aOther).MaybeDestroy();
break;
}
case TStorageOpenArgs:
{
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move((aOther).get_StorageOpenArgs()));
(aOther).MaybeDestroy();
break;
}
case TStorageDeleteArgs:
{
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move((aOther).get_StorageDeleteArgs()));
(aOther).MaybeDestroy();
break;
}
case TStorageKeysArgs:
{
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move((aOther).get_StorageKeysArgs()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
CacheOpArgs::~CacheOpArgs()
{
MaybeDestroy();
}
auto CacheOpArgs::operator=(const CacheMatchArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(aRhs);
mType = TCacheMatchArgs;
return (*(this));
}
auto CacheOpArgs::operator=(CacheMatchArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move(aRhs));
mType = TCacheMatchArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const CacheMatchAllArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(aRhs);
mType = TCacheMatchAllArgs;
return (*(this));
}
auto CacheOpArgs::operator=(CacheMatchAllArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move(aRhs));
mType = TCacheMatchAllArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const CachePutAllArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(aRhs);
mType = TCachePutAllArgs;
return (*(this));
}
auto CacheOpArgs::operator=(CachePutAllArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move(aRhs));
mType = TCachePutAllArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const CacheDeleteArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(aRhs);
mType = TCacheDeleteArgs;
return (*(this));
}
auto CacheOpArgs::operator=(CacheDeleteArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move(aRhs));
mType = TCacheDeleteArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const CacheKeysArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(aRhs);
mType = TCacheKeysArgs;
return (*(this));
}
auto CacheOpArgs::operator=(CacheKeysArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move(aRhs));
mType = TCacheKeysArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const StorageMatchArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(aRhs);
mType = TStorageMatchArgs;
return (*(this));
}
auto CacheOpArgs::operator=(StorageMatchArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move(aRhs));
mType = TStorageMatchArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const StorageHasArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(aRhs);
mType = TStorageHasArgs;
return (*(this));
}
auto CacheOpArgs::operator=(StorageHasArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move(aRhs));
mType = TStorageHasArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const StorageOpenArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(aRhs);
mType = TStorageOpenArgs;
return (*(this));
}
auto CacheOpArgs::operator=(StorageOpenArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move(aRhs));
mType = TStorageOpenArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const StorageDeleteArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(aRhs);
mType = TStorageDeleteArgs;
return (*(this));
}
auto CacheOpArgs::operator=(StorageDeleteArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move(aRhs));
mType = TStorageDeleteArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const StorageKeysArgs& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(aRhs);
mType = TStorageKeysArgs;
return (*(this));
}
auto CacheOpArgs::operator=(StorageKeysArgs&& aRhs) -> CacheOpArgs&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move(aRhs));
mType = TStorageKeysArgs;
return (*(this));
}
auto CacheOpArgs::operator=(const CacheOpArgs& aRhs) -> CacheOpArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TCacheMatchArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs((aRhs).get_CacheMatchArgs());
break;
}
case TCacheMatchAllArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs((aRhs).get_CacheMatchAllArgs());
break;
}
case TCachePutAllArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs((aRhs).get_CachePutAllArgs());
break;
}
case TCacheDeleteArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs((aRhs).get_CacheDeleteArgs());
break;
}
case TCacheKeysArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs((aRhs).get_CacheKeysArgs());
break;
}
case TStorageMatchArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs((aRhs).get_StorageMatchArgs());
break;
}
case TStorageHasArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs((aRhs).get_StorageHasArgs());
break;
}
case TStorageOpenArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs((aRhs).get_StorageOpenArgs());
break;
}
case TStorageDeleteArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs((aRhs).get_StorageDeleteArgs());
break;
}
case TStorageKeysArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs((aRhs).get_StorageKeysArgs());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto CacheOpArgs::operator=(CacheOpArgs&& aRhs) -> CacheOpArgs&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TCacheMatchArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchArgs()) CacheMatchArgs(std::move((aRhs).get_CacheMatchArgs()));
(aRhs).MaybeDestroy();
break;
}
case TCacheMatchAllArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllArgs()) CacheMatchAllArgs(std::move((aRhs).get_CacheMatchAllArgs()));
(aRhs).MaybeDestroy();
break;
}
case TCachePutAllArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllArgs()) CachePutAllArgs(std::move((aRhs).get_CachePutAllArgs()));
(aRhs).MaybeDestroy();
break;
}
case TCacheDeleteArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteArgs()) CacheDeleteArgs(std::move((aRhs).get_CacheDeleteArgs()));
(aRhs).MaybeDestroy();
break;
}
case TCacheKeysArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysArgs()) CacheKeysArgs(std::move((aRhs).get_CacheKeysArgs()));
(aRhs).MaybeDestroy();
break;
}
case TStorageMatchArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchArgs()) StorageMatchArgs(std::move((aRhs).get_StorageMatchArgs()));
(aRhs).MaybeDestroy();
break;
}
case TStorageHasArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasArgs()) StorageHasArgs(std::move((aRhs).get_StorageHasArgs()));
(aRhs).MaybeDestroy();
break;
}
case TStorageOpenArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenArgs()) StorageOpenArgs(std::move((aRhs).get_StorageOpenArgs()));
(aRhs).MaybeDestroy();
break;
}
case TStorageDeleteArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteArgs()) StorageDeleteArgs(std::move((aRhs).get_StorageDeleteArgs()));
(aRhs).MaybeDestroy();
break;
}
case TStorageKeysArgs:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysArgs()) StorageKeysArgs(std::move((aRhs).get_StorageKeysArgs()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheOpArgs>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::cache::CacheOpArgs union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'CacheOpArgs'
(aWriter)->WriteSentinel(400098337);
switch (type) {
case union__::TCacheMatchArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CacheMatchArgs());
// Sentinel = 'TCacheMatchArgs'
(aWriter)->WriteSentinel(729679267);
return;
}
case union__::TCacheMatchAllArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CacheMatchAllArgs());
// Sentinel = 'TCacheMatchAllArgs'
(aWriter)->WriteSentinel(1043007164);
return;
}
case union__::TCachePutAllArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CachePutAllArgs());
// Sentinel = 'TCachePutAllArgs'
(aWriter)->WriteSentinel(833357320);
return;
}
case union__::TCacheDeleteArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CacheDeleteArgs());
// Sentinel = 'TCacheDeleteArgs'
(aWriter)->WriteSentinel(829228553);
return;
}
case union__::TCacheKeysArgs:
{
IPC::WriteParam(aWriter, (aVar).get_CacheKeysArgs());
// Sentinel = 'TCacheKeysArgs'
(aWriter)->WriteSentinel(641860946);
return;
}
case union__::TStorageMatchArgs:
{
IPC::WriteParam(aWriter, (aVar).get_StorageMatchArgs());
// Sentinel = 'TStorageMatchArgs'
(aWriter)->WriteSentinel(994444964);
return;
}
case union__::TStorageHasArgs:
{
IPC::WriteParam(aWriter, (aVar).get_StorageHasArgs());
// Sentinel = 'TStorageHasArgs'
(aWriter)->WriteSentinel(774637011);
return;
}
case union__::TStorageOpenArgs:
{
IPC::WriteParam(aWriter, (aVar).get_StorageOpenArgs());
// Sentinel = 'TStorageOpenArgs'
(aWriter)->WriteSentinel(887424585);
return;
}
case union__::TStorageDeleteArgs:
{
IPC::WriteParam(aWriter, (aVar).get_StorageDeleteArgs());
// Sentinel = 'TStorageDeleteArgs'
(aWriter)->WriteSentinel(1110837002);
return;
}
case union__::TStorageKeysArgs:
{
IPC::WriteParam(aWriter, (aVar).get_StorageKeysArgs());
// Sentinel = 'TStorageKeysArgs'
(aWriter)->WriteSentinel(889783891);
return;
}
default:
{
aWriter->FatalError("unknown variant of union CacheOpArgs");
return;
}
}
}
auto ParamTraits<::mozilla::dom::cache::CacheOpArgs>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::cache::CacheOpArgs union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union CacheOpArgs");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'CacheOpArgs'
if ((!((aReader)->ReadSentinel(400098337)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union CacheOpArgs");
return {};
}
switch (type) {
case union__::TCacheMatchArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheMatchArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheMatchArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheMatchArgs'
if ((!((aReader)->ReadSentinel(729679267)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TCacheMatchAllArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheMatchAllArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheMatchAllArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheMatchAllArgs'
if ((!((aReader)->ReadSentinel(1043007164)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchAllArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TCachePutAllArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CachePutAllArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCachePutAllArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCachePutAllArgs'
if ((!((aReader)->ReadSentinel(833357320)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCachePutAllArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TCacheDeleteArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheDeleteArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheDeleteArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheDeleteArgs'
if ((!((aReader)->ReadSentinel(829228553)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheDeleteArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TCacheKeysArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheKeysArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheKeysArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheKeysArgs'
if ((!((aReader)->ReadSentinel(641860946)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheKeysArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TStorageMatchArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageMatchArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageMatchArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageMatchArgs'
if ((!((aReader)->ReadSentinel(994444964)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageMatchArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TStorageHasArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageHasArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageHasArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageHasArgs'
if ((!((aReader)->ReadSentinel(774637011)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageHasArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TStorageOpenArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageOpenArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageOpenArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageOpenArgs'
if ((!((aReader)->ReadSentinel(887424585)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageOpenArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TStorageDeleteArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageDeleteArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageDeleteArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageDeleteArgs'
if ((!((aReader)->ReadSentinel(1110837002)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageDeleteArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
case union__::TStorageKeysArgs:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageKeysArgs>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageKeysArgs of union CacheOpArgs");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageKeysArgs'
if ((!((aReader)->ReadSentinel(889783891)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageKeysArgs of union CacheOpArgs");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union CacheOpArgs");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheMatchResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheMatchResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).maybeResponse());
// Sentinel = 'maybeResponse'
(aWriter)->WriteSentinel(624690526);
}
auto ParamTraits<::mozilla::dom::cache::CacheMatchResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___maybeResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheResponse>>(aReader);
if (!maybe___maybeResponse) {
aReader->FatalError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'CacheMatchResult'");
return {};
}
auto& _maybeResponse = *maybe___maybeResponse;
// Sentinel = 'maybeResponse'
if ((!((aReader)->ReadSentinel(624690526)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'CacheMatchResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_maybeResponse)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheMatchAllResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheMatchAllResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).responseList());
// Sentinel = 'responseList'
(aWriter)->WriteSentinel(554894604);
}
auto ParamTraits<::mozilla::dom::cache::CacheMatchAllResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___responseList = IPC::ReadParam<nsTArray<::mozilla::dom::cache::CacheResponse>>(aReader);
if (!maybe___responseList) {
aReader->FatalError("Error deserializing 'responseList' (CacheResponse[]) member of 'CacheMatchAllResult'");
return {};
}
auto& _responseList = *maybe___responseList;
// Sentinel = 'responseList'
if ((!((aReader)->ReadSentinel(554894604)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'responseList' (CacheResponse[]) member of 'CacheMatchAllResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_responseList)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CachePutAllResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CachePutAllResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::cache::CachePutAllResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
IPC::ReadResult<paramType> result__{std::in_place};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheDeleteResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheDeleteResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).success());
// Sentinel = 'success'
(aWriter)->WriteSentinel(200082170);
}
auto ParamTraits<::mozilla::dom::cache::CacheDeleteResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___success = IPC::ReadParam<bool>(aReader);
if (!maybe___success) {
aReader->FatalError("Error deserializing 'success' (bool) member of 'CacheDeleteResult'");
return {};
}
auto& _success = *maybe___success;
// Sentinel = 'success'
if ((!((aReader)->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'success' (bool) member of 'CacheDeleteResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_success)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct CacheKeysResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheKeysResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).requestList());
// Sentinel = 'requestList'
(aWriter)->WriteSentinel(469894310);
}
auto ParamTraits<::mozilla::dom::cache::CacheKeysResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___requestList = IPC::ReadParam<nsTArray<::mozilla::dom::cache::CacheRequest>>(aReader);
if (!maybe___requestList) {
aReader->FatalError("Error deserializing 'requestList' (CacheRequest[]) member of 'CacheKeysResult'");
return {};
}
auto& _requestList = *maybe___requestList;
// Sentinel = 'requestList'
if ((!((aReader)->ReadSentinel(469894310)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'requestList' (CacheRequest[]) member of 'CacheKeysResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_requestList)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageMatchResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageMatchResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).maybeResponse());
// Sentinel = 'maybeResponse'
(aWriter)->WriteSentinel(624690526);
}
auto ParamTraits<::mozilla::dom::cache::StorageMatchResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___maybeResponse = IPC::ReadParam<mozilla::Maybe<::mozilla::dom::cache::CacheResponse>>(aReader);
if (!maybe___maybeResponse) {
aReader->FatalError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'StorageMatchResult'");
return {};
}
auto& _maybeResponse = *maybe___maybeResponse;
// Sentinel = 'maybeResponse'
if ((!((aReader)->ReadSentinel(624690526)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'maybeResponse' (CacheResponse?) member of 'StorageMatchResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_maybeResponse)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageHasResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageHasResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).success());
// Sentinel = 'success'
(aWriter)->WriteSentinel(200082170);
}
auto ParamTraits<::mozilla::dom::cache::StorageHasResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___success = IPC::ReadParam<bool>(aReader);
if (!maybe___success) {
aReader->FatalError("Error deserializing 'success' (bool) member of 'StorageHasResult'");
return {};
}
auto& _success = *maybe___success;
// Sentinel = 'success'
if ((!((aReader)->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'success' (bool) member of 'StorageHasResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_success)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageOpenResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageOpenResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).actor());
// Sentinel = 'actor'
(aWriter)->WriteSentinel(102892058);
IPC::WriteParam(aWriter, (aVar).ns());
// Sentinel = 'ns'
(aWriter)->WriteSentinel(22085858);
}
auto ParamTraits<::mozilla::dom::cache::StorageOpenResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___actor = IPC::ReadParam<::mozilla::ipc::SideVariant<::mozilla::dom::cache::PCacheParent*, ::mozilla::dom::cache::PCacheChild*>>(aReader);
if (!maybe___actor) {
aReader->FatalError("Error deserializing 'actor' (PCache) member of 'StorageOpenResult'");
return {};
}
auto& _actor = *maybe___actor;
// Sentinel = 'actor'
if ((!((aReader)->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'actor' (PCache) member of 'StorageOpenResult'");
return {};
}
auto maybe___ns = IPC::ReadParam<::mozilla::dom::cache::Namespace>(aReader);
if (!maybe___ns) {
aReader->FatalError("Error deserializing 'ns' (Namespace) member of 'StorageOpenResult'");
return {};
}
auto& _ns = *maybe___ns;
// Sentinel = 'ns'
if ((!((aReader)->ReadSentinel(22085858)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ns' (Namespace) member of 'StorageOpenResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
_actor,
std::move(_ns)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageDeleteResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageDeleteResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).success());
// Sentinel = 'success'
(aWriter)->WriteSentinel(200082170);
}
auto ParamTraits<::mozilla::dom::cache::StorageDeleteResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___success = IPC::ReadParam<bool>(aReader);
if (!maybe___success) {
aReader->FatalError("Error deserializing 'success' (bool) member of 'StorageDeleteResult'");
return {};
}
auto& _success = *maybe___success;
// Sentinel = 'success'
if ((!((aReader)->ReadSentinel(200082170)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'success' (bool) member of 'StorageDeleteResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_success)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageKeysResult|
//
namespace mozilla {
namespace dom {
namespace cache {
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::StorageKeysResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).keyList());
// Sentinel = 'keyList'
(aWriter)->WriteSentinel(192152294);
}
auto ParamTraits<::mozilla::dom::cache::StorageKeysResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___keyList = IPC::ReadParam<nsTArray<::nsString>>(aReader);
if (!maybe___keyList) {
aReader->FatalError("Error deserializing 'keyList' (nsString[]) member of 'StorageKeysResult'");
return {};
}
auto& _keyList = *maybe___keyList;
// Sentinel = 'keyList'
if ((!((aReader)->ReadSentinel(192152294)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'keyList' (nsString[]) member of 'StorageKeysResult'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_keyList)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CacheOpResult|
//
namespace mozilla {
namespace dom {
namespace cache {
auto CacheOpResult::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tvoid_t:
{
(ptr_void_t())->~void_t__tdef();
break;
}
case TCacheMatchResult:
{
(ptr_CacheMatchResult())->~CacheMatchResult__tdef();
break;
}
case TCacheMatchAllResult:
{
(ptr_CacheMatchAllResult())->~CacheMatchAllResult__tdef();
break;
}
case TCachePutAllResult:
{
(ptr_CachePutAllResult())->~CachePutAllResult__tdef();
break;
}
case TCacheDeleteResult:
{
(ptr_CacheDeleteResult())->~CacheDeleteResult__tdef();
break;
}
case TCacheKeysResult:
{
(ptr_CacheKeysResult())->~CacheKeysResult__tdef();
break;
}
case TStorageMatchResult:
{
(ptr_StorageMatchResult())->~StorageMatchResult__tdef();
break;
}
case TStorageHasResult:
{
(ptr_StorageHasResult())->~StorageHasResult__tdef();
break;
}
case TStorageOpenResult:
{
(ptr_StorageOpenResult())->~StorageOpenResult__tdef();
break;
}
case TStorageDeleteResult:
{
(ptr_StorageDeleteResult())->~StorageDeleteResult__tdef();
break;
}
case TStorageKeysResult:
{
(ptr_StorageKeysResult())->~StorageKeysResult__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const void_t& aOther)
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(aOther);
mType = Tvoid_t;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(void_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aOther));
mType = Tvoid_t;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheMatchResult& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(aOther);
mType = TCacheMatchResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheMatchResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move(aOther));
mType = TCacheMatchResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheMatchAllResult& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(aOther);
mType = TCacheMatchAllResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheMatchAllResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move(aOther));
mType = TCacheMatchAllResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CachePutAllResult& aOther)
{
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(aOther);
mType = TCachePutAllResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(CachePutAllResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move(aOther));
mType = TCachePutAllResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheDeleteResult& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(aOther);
mType = TCacheDeleteResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheDeleteResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move(aOther));
mType = TCacheDeleteResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheKeysResult& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(aOther);
mType = TCacheKeysResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheKeysResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move(aOther));
mType = TCacheKeysResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageMatchResult& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(aOther);
mType = TStorageMatchResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageMatchResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move(aOther));
mType = TStorageMatchResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageHasResult& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(aOther);
mType = TStorageHasResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageHasResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move(aOther));
mType = TStorageHasResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageOpenResult& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(aOther);
mType = TStorageOpenResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageOpenResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move(aOther));
mType = TStorageOpenResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageDeleteResult& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(aOther);
mType = TStorageDeleteResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageDeleteResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move(aOther));
mType = TStorageDeleteResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const StorageKeysResult& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(aOther);
mType = TStorageKeysResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(StorageKeysResult&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move(aOther));
mType = TStorageKeysResult;
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(const CacheOpResult& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tvoid_t:
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t((aOther).get_void_t());
break;
}
case TCacheMatchResult:
{
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult((aOther).get_CacheMatchResult());
break;
}
case TCacheMatchAllResult:
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult((aOther).get_CacheMatchAllResult());
break;
}
case TCachePutAllResult:
{
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult((aOther).get_CachePutAllResult());
break;
}
case TCacheDeleteResult:
{
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult((aOther).get_CacheDeleteResult());
break;
}
case TCacheKeysResult:
{
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult((aOther).get_CacheKeysResult());
break;
}
case TStorageMatchResult:
{
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult((aOther).get_StorageMatchResult());
break;
}
case TStorageHasResult:
{
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult((aOther).get_StorageHasResult());
break;
}
case TStorageOpenResult:
{
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult((aOther).get_StorageOpenResult());
break;
}
case TStorageDeleteResult:
{
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult((aOther).get_StorageDeleteResult());
break;
}
case TStorageKeysResult:
{
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult((aOther).get_StorageKeysResult());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT CacheOpResult::CacheOpResult(CacheOpResult&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tvoid_t:
{
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aOther).get_void_t()));
(aOther).MaybeDestroy();
break;
}
case TCacheMatchResult:
{
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move((aOther).get_CacheMatchResult()));
(aOther).MaybeDestroy();
break;
}
case TCacheMatchAllResult:
{
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move((aOther).get_CacheMatchAllResult()));
(aOther).MaybeDestroy();
break;
}
case TCachePutAllResult:
{
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move((aOther).get_CachePutAllResult()));
(aOther).MaybeDestroy();
break;
}
case TCacheDeleteResult:
{
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move((aOther).get_CacheDeleteResult()));
(aOther).MaybeDestroy();
break;
}
case TCacheKeysResult:
{
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move((aOther).get_CacheKeysResult()));
(aOther).MaybeDestroy();
break;
}
case TStorageMatchResult:
{
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move((aOther).get_StorageMatchResult()));
(aOther).MaybeDestroy();
break;
}
case TStorageHasResult:
{
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move((aOther).get_StorageHasResult()));
(aOther).MaybeDestroy();
break;
}
case TStorageOpenResult:
{
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move((aOther).get_StorageOpenResult()));
(aOther).MaybeDestroy();
break;
}
case TStorageDeleteResult:
{
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move((aOther).get_StorageDeleteResult()));
(aOther).MaybeDestroy();
break;
}
case TStorageKeysResult:
{
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move((aOther).get_StorageKeysResult()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
CacheOpResult::~CacheOpResult()
{
MaybeDestroy();
}
auto CacheOpResult::operator=(const void_t& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(aRhs);
mType = Tvoid_t;
return (*(this));
}
auto CacheOpResult::operator=(void_t&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move(aRhs));
mType = Tvoid_t;
return (*(this));
}
auto CacheOpResult::operator=(const CacheMatchResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(aRhs);
mType = TCacheMatchResult;
return (*(this));
}
auto CacheOpResult::operator=(CacheMatchResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move(aRhs));
mType = TCacheMatchResult;
return (*(this));
}
auto CacheOpResult::operator=(const CacheMatchAllResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(aRhs);
mType = TCacheMatchAllResult;
return (*(this));
}
auto CacheOpResult::operator=(CacheMatchAllResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move(aRhs));
mType = TCacheMatchAllResult;
return (*(this));
}
auto CacheOpResult::operator=(const CachePutAllResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(aRhs);
mType = TCachePutAllResult;
return (*(this));
}
auto CacheOpResult::operator=(CachePutAllResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move(aRhs));
mType = TCachePutAllResult;
return (*(this));
}
auto CacheOpResult::operator=(const CacheDeleteResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(aRhs);
mType = TCacheDeleteResult;
return (*(this));
}
auto CacheOpResult::operator=(CacheDeleteResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move(aRhs));
mType = TCacheDeleteResult;
return (*(this));
}
auto CacheOpResult::operator=(const CacheKeysResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(aRhs);
mType = TCacheKeysResult;
return (*(this));
}
auto CacheOpResult::operator=(CacheKeysResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move(aRhs));
mType = TCacheKeysResult;
return (*(this));
}
auto CacheOpResult::operator=(const StorageMatchResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(aRhs);
mType = TStorageMatchResult;
return (*(this));
}
auto CacheOpResult::operator=(StorageMatchResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move(aRhs));
mType = TStorageMatchResult;
return (*(this));
}
auto CacheOpResult::operator=(const StorageHasResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(aRhs);
mType = TStorageHasResult;
return (*(this));
}
auto CacheOpResult::operator=(StorageHasResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move(aRhs));
mType = TStorageHasResult;
return (*(this));
}
auto CacheOpResult::operator=(const StorageOpenResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(aRhs);
mType = TStorageOpenResult;
return (*(this));
}
auto CacheOpResult::operator=(StorageOpenResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move(aRhs));
mType = TStorageOpenResult;
return (*(this));
}
auto CacheOpResult::operator=(const StorageDeleteResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(aRhs);
mType = TStorageDeleteResult;
return (*(this));
}
auto CacheOpResult::operator=(StorageDeleteResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move(aRhs));
mType = TStorageDeleteResult;
return (*(this));
}
auto CacheOpResult::operator=(const StorageKeysResult& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(aRhs);
mType = TStorageKeysResult;
return (*(this));
}
auto CacheOpResult::operator=(StorageKeysResult&& aRhs) -> CacheOpResult&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move(aRhs));
mType = TStorageKeysResult;
return (*(this));
}
auto CacheOpResult::operator=(const CacheOpResult& aRhs) -> CacheOpResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tvoid_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t((aRhs).get_void_t());
break;
}
case TCacheMatchResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult((aRhs).get_CacheMatchResult());
break;
}
case TCacheMatchAllResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult((aRhs).get_CacheMatchAllResult());
break;
}
case TCachePutAllResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult((aRhs).get_CachePutAllResult());
break;
}
case TCacheDeleteResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult((aRhs).get_CacheDeleteResult());
break;
}
case TCacheKeysResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult((aRhs).get_CacheKeysResult());
break;
}
case TStorageMatchResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult((aRhs).get_StorageMatchResult());
break;
}
case TStorageHasResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult((aRhs).get_StorageHasResult());
break;
}
case TStorageOpenResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult((aRhs).get_StorageOpenResult());
break;
}
case TStorageDeleteResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult((aRhs).get_StorageDeleteResult());
break;
}
case TStorageKeysResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult((aRhs).get_StorageKeysResult());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto CacheOpResult::operator=(CacheOpResult&& aRhs) -> CacheOpResult&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tvoid_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_void_t()) void_t(std::move((aRhs).get_void_t()));
(aRhs).MaybeDestroy();
break;
}
case TCacheMatchResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchResult()) CacheMatchResult(std::move((aRhs).get_CacheMatchResult()));
(aRhs).MaybeDestroy();
break;
}
case TCacheMatchAllResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheMatchAllResult()) CacheMatchAllResult(std::move((aRhs).get_CacheMatchAllResult()));
(aRhs).MaybeDestroy();
break;
}
case TCachePutAllResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CachePutAllResult()) CachePutAllResult(std::move((aRhs).get_CachePutAllResult()));
(aRhs).MaybeDestroy();
break;
}
case TCacheDeleteResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheDeleteResult()) CacheDeleteResult(std::move((aRhs).get_CacheDeleteResult()));
(aRhs).MaybeDestroy();
break;
}
case TCacheKeysResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_CacheKeysResult()) CacheKeysResult(std::move((aRhs).get_CacheKeysResult()));
(aRhs).MaybeDestroy();
break;
}
case TStorageMatchResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageMatchResult()) StorageMatchResult(std::move((aRhs).get_StorageMatchResult()));
(aRhs).MaybeDestroy();
break;
}
case TStorageHasResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageHasResult()) StorageHasResult(std::move((aRhs).get_StorageHasResult()));
(aRhs).MaybeDestroy();
break;
}
case TStorageOpenResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageOpenResult()) StorageOpenResult(std::move((aRhs).get_StorageOpenResult()));
(aRhs).MaybeDestroy();
break;
}
case TStorageDeleteResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageDeleteResult()) StorageDeleteResult(std::move((aRhs).get_StorageDeleteResult()));
(aRhs).MaybeDestroy();
break;
}
case TStorageKeysResult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageKeysResult()) StorageKeysResult(std::move((aRhs).get_StorageKeysResult()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace cache
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::cache::CacheOpResult>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::cache::CacheOpResult union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'CacheOpResult'
(aWriter)->WriteSentinel(566363411);
switch (type) {
case union__::Tvoid_t:
{
IPC::WriteParam(aWriter, (aVar).get_void_t());
// Sentinel = 'Tvoid_t'
(aWriter)->WriteSentinel(189006554);
return;
}
case union__::TCacheMatchResult:
{
IPC::WriteParam(aWriter, (aVar).get_CacheMatchResult());
// Sentinel = 'TCacheMatchResult'
(aWriter)->WriteSentinel(946538133);
return;
}
case union__::TCacheMatchAllResult:
{
IPC::WriteParam(aWriter, (aVar).get_CacheMatchAllResult());
// Sentinel = 'TCacheMatchAllResult'
(aWriter)->WriteSentinel(1296697262);
return;
}
case union__::TCachePutAllResult:
{
IPC::WriteParam(aWriter, (aVar).get_CachePutAllResult());
// Sentinel = 'TCachePutAllResult'
(aWriter)->WriteSentinel(1063454458);
return;
}
case union__::TCacheDeleteResult:
{
IPC::WriteParam(aWriter, (aVar).get_CacheDeleteResult());
// Sentinel = 'TCacheDeleteResult'
(aWriter)->WriteSentinel(1059456763);
return;
}
case union__::TCacheKeysResult:
{
IPC::WriteParam(aWriter, (aVar).get_CacheKeysResult());
// Sentinel = 'TCacheKeysResult'
(aWriter)->WriteSentinel(848102980);
return;
}
case union__::TStorageMatchResult:
{
IPC::WriteParam(aWriter, (aVar).get_StorageMatchResult());
// Sentinel = 'TStorageMatchResult'
(aWriter)->WriteSentinel(1244989334);
return;
}
case union__::TStorageHasResult:
{
IPC::WriteParam(aWriter, (aVar).get_StorageHasResult());
// Sentinel = 'TStorageHasResult'
(aWriter)->WriteSentinel(997787333);
return;
}
case union__::TStorageOpenResult:
{
IPC::WriteParam(aWriter, (aVar).get_StorageOpenResult());
// Sentinel = 'TStorageOpenResult'
(aWriter)->WriteSentinel(1126041403);
return;
}
case union__::TStorageDeleteResult:
{
IPC::WriteParam(aWriter, (aVar).get_StorageDeleteResult());
// Sentinel = 'TStorageDeleteResult'
(aWriter)->WriteSentinel(1374750716);
return;
}
case union__::TStorageKeysResult:
{
IPC::WriteParam(aWriter, (aVar).get_StorageKeysResult());
// Sentinel = 'TStorageKeysResult'
(aWriter)->WriteSentinel(1129711429);
return;
}
default:
{
aWriter->FatalError("unknown variant of union CacheOpResult");
return;
}
}
}
auto ParamTraits<::mozilla::dom::cache::CacheOpResult>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::cache::CacheOpResult union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union CacheOpResult");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'CacheOpResult'
if ((!((aReader)->ReadSentinel(566363411)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union CacheOpResult");
return {};
}
switch (type) {
case union__::Tvoid_t:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::void_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tvoid_t of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tvoid_t'
if ((!((aReader)->ReadSentinel(189006554)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tvoid_t of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TCacheMatchResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheMatchResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheMatchResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheMatchResult'
if ((!((aReader)->ReadSentinel(946538133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TCacheMatchAllResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheMatchAllResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheMatchAllResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheMatchAllResult'
if ((!((aReader)->ReadSentinel(1296697262)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheMatchAllResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TCachePutAllResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CachePutAllResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCachePutAllResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCachePutAllResult'
if ((!((aReader)->ReadSentinel(1063454458)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCachePutAllResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TCacheDeleteResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheDeleteResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheDeleteResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheDeleteResult'
if ((!((aReader)->ReadSentinel(1059456763)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheDeleteResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TCacheKeysResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::CacheKeysResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TCacheKeysResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TCacheKeysResult'
if ((!((aReader)->ReadSentinel(848102980)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TCacheKeysResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TStorageMatchResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageMatchResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageMatchResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageMatchResult'
if ((!((aReader)->ReadSentinel(1244989334)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageMatchResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TStorageHasResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageHasResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageHasResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageHasResult'
if ((!((aReader)->ReadSentinel(997787333)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageHasResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TStorageOpenResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageOpenResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageOpenResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageOpenResult'
if ((!((aReader)->ReadSentinel(1126041403)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageOpenResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TStorageDeleteResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageDeleteResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageDeleteResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageDeleteResult'
if ((!((aReader)->ReadSentinel(1374750716)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageDeleteResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
case union__::TStorageKeysResult:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::cache::StorageKeysResult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageKeysResult of union CacheOpResult");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageKeysResult'
if ((!((aReader)->ReadSentinel(1129711429)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageKeysResult of union CacheOpResult");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union CacheOpResult");
return {};
}
}
}
} // namespace IPC