Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/dom/quota/SerializationHelpers.h"
#include "mozilla/ipc/PBackgroundParent.h"
#include "mozilla/ipc/PBackgroundChild.h"
#include "mozilla/dom/quota/PQuotaRequestParent.h"
#include "mozilla/dom/quota/PQuotaRequestChild.h"
#include "mozilla/dom/quota/PQuotaUsageRequestParent.h"
#include "mozilla/dom/quota/PQuotaUsageRequestChild.h"
#include "mozilla/dom/quota/PQuota.h"
#include "mozilla/dom/quota/PQuotaParent.h"
#include "mozilla/dom/quota/PQuotaChild.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"
namespace mozilla {
namespace dom {
namespace quota {
namespace PQuota {
nsresult
CreateEndpoints(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::quota::PQuotaParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::quota::PQuotaChild>* aChild)
{
return mozilla::ipc::CreateEndpoints(
mozilla::ipc::PrivateIPDLInterface(),
aParentDestPid, aChildDestPid, aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply___delete____ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_PQuotaUsageRequestConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_PQuotaUsageRequestConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_PQuotaUsageRequestConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_PQuotaUsageRequestConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_PQuotaRequestConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_PQuotaRequestConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_PQuotaRequestConstructor(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_PQuotaRequestConstructor__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_StorageInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_StorageInitialized__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_StorageInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_StorageInitialized__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_TemporaryStorageInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_TemporaryStorageInitialized__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_TemporaryStorageInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_TemporaryStorageInitialized__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_InitializeStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializeStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_InitializeStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializeStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_InitializePersistentClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializePersistentClient__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_InitializePersistentClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializePersistentClient__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_InitializeTemporaryClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializeTemporaryClient__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_InitializeTemporaryClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializeTemporaryClient__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_InitializeTemporaryStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializeTemporaryStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_InitializeTemporaryStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializeTemporaryStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ClearStoragesForOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ClearStoragesForOrigin__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_ClearStoragesForOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ClearStoragesForOrigin__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ClearStoragesForOriginPrefix(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ClearStoragesForOriginPrefix__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_ClearStoragesForOriginPrefix(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ClearStoragesForOriginPrefix__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ClearStoragesForOriginAttributesPattern(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ClearStoragesForOriginAttributesPattern__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_ClearStoragesForOriginAttributesPattern(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ClearStoragesForOriginAttributesPattern__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ClearStoragesForPrivateBrowsing(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ClearStoragesForPrivateBrowsing__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_ClearStoragesForPrivateBrowsing(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ClearStoragesForPrivateBrowsing__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ClearStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ClearStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_ClearStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ClearStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ShutdownStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ShutdownStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_ShutdownStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ShutdownStorage__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_StartIdleMaintenance(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_StartIdleMaintenance__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_StopIdleMaintenance(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_StopIdleMaintenance__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_AbortOperationsForProcess(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_AbortOperationsForProcess__ID, 0, IPC::Message::HeaderFlags(IPC::Message::NOT_NESTED, IPC::Message::NORMAL_PRIORITY, IPC::Message::COMPRESSION_NONE, IPC::Message::EAGER_SEND, IPC::Message::NOT_CONSTRUCTOR, IPC::Message::ASYNC, IPC::Message::NOT_REPLY));
}
} // namespace PQuota
} // namespace quota
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union BoolResponse|
//
namespace mozilla {
namespace ipc {
auto BoolResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case Tbool:
{
(ptr_bool())->~bool__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT BoolResponse::BoolResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT BoolResponse::BoolResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT BoolResponse::BoolResponse(const bool& aOther)
{
new (mozilla::KnownNotNull, ptr_bool()) bool(aOther);
mType = Tbool;
}
MOZ_IMPLICIT BoolResponse::BoolResponse(bool&& aOther)
{
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aOther));
mType = Tbool;
}
MOZ_IMPLICIT BoolResponse::BoolResponse(const BoolResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case Tbool:
{
new (mozilla::KnownNotNull, ptr_bool()) bool((aOther).get_bool());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT BoolResponse::BoolResponse(BoolResponse&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aOther).get_nsresult()));
(aOther).MaybeDestroy();
break;
}
case Tbool:
{
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aOther).get_bool()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
BoolResponse::~BoolResponse()
{
MaybeDestroy();
}
auto BoolResponse::operator=(const nsresult& aRhs) -> BoolResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto BoolResponse::operator=(nsresult&& aRhs) -> BoolResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto BoolResponse::operator=(const bool& aRhs) -> BoolResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(aRhs);
mType = Tbool;
return (*(this));
}
auto BoolResponse::operator=(bool&& aRhs) -> BoolResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move(aRhs));
mType = Tbool;
return (*(this));
}
auto BoolResponse::operator=(const BoolResponse& aRhs) -> BoolResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case Tbool:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool((aRhs).get_bool());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto BoolResponse::operator=(BoolResponse&& aRhs) -> BoolResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move((aRhs).get_nsresult()));
(aRhs).MaybeDestroy();
break;
}
case Tbool:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_bool()) bool(std::move((aRhs).get_bool()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace ipc
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::ipc::BoolResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::ipc::BoolResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'BoolResponse'
(aWriter)->WriteSentinel(512820444);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::Tbool:
{
IPC::WriteParam(aWriter, (aVar).get_bool());
// Sentinel = 'Tbool'
(aWriter)->WriteSentinel(96993793);
return;
}
default:
{
aWriter->FatalError("unknown variant of union BoolResponse");
return;
}
}
}
auto ParamTraits<::mozilla::ipc::BoolResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::ipc::BoolResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union BoolResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'BoolResponse'
if ((!((aReader)->ReadSentinel(512820444)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union BoolResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union BoolResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union BoolResponse");
return {};
}
return std::move(tmp);
}
case union__::Tbool:
{
auto maybe__tmp = IPC::ReadParam<bool>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tbool of union BoolResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tbool'
if ((!((aReader)->ReadSentinel(96993793)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tbool of union BoolResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union BoolResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct StorageNameParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::StorageNameParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::quota::StorageNameParams>::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 InitializePersistentOriginParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::InitializePersistentOriginParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
}
auto ParamTraits<::mozilla::dom::quota::InitializePersistentOriginParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'InitializePersistentOriginParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'InitializePersistentOriginParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct InitializeTemporaryOriginParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::InitializeTemporaryOriginParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).persistenceType());
// Sentinel = 'persistenceType'
(aWriter)->WriteSentinel(853345864);
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
}
auto ParamTraits<::mozilla::dom::quota::InitializeTemporaryOriginParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___persistenceType = IPC::ReadParam<::mozilla::dom::quota::PersistenceType>(aReader);
if (!maybe___persistenceType) {
aReader->FatalError("Error deserializing 'persistenceType' (PersistenceType) member of 'InitializeTemporaryOriginParams'");
return {};
}
auto& _persistenceType = *maybe___persistenceType;
// Sentinel = 'persistenceType'
if ((!((aReader)->ReadSentinel(853345864)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'InitializeTemporaryOriginParams'");
return {};
}
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'InitializeTemporaryOriginParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'InitializeTemporaryOriginParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_persistenceType),
std::move(_principalInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct GetFullOriginMetadataParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::GetFullOriginMetadataParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).persistenceType());
// Sentinel = 'persistenceType'
(aWriter)->WriteSentinel(853345864);
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
}
auto ParamTraits<::mozilla::dom::quota::GetFullOriginMetadataParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___persistenceType = IPC::ReadParam<::mozilla::dom::quota::PersistenceType>(aReader);
if (!maybe___persistenceType) {
aReader->FatalError("Error deserializing 'persistenceType' (PersistenceType) member of 'GetFullOriginMetadataParams'");
return {};
}
auto& _persistenceType = *maybe___persistenceType;
// Sentinel = 'persistenceType'
if ((!((aReader)->ReadSentinel(853345864)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'GetFullOriginMetadataParams'");
return {};
}
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'GetFullOriginMetadataParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'GetFullOriginMetadataParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_persistenceType),
std::move(_principalInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct AllUsageParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::AllUsageParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).getAll());
// Sentinel = 'getAll'
(aWriter)->WriteSentinel(138412634);
}
auto ParamTraits<::mozilla::dom::quota::AllUsageParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___getAll = IPC::ReadParam<bool>(aReader);
if (!maybe___getAll) {
aReader->FatalError("Error deserializing 'getAll' (bool) member of 'AllUsageParams'");
return {};
}
auto& _getAll = *maybe___getAll;
// Sentinel = 'getAll'
if ((!((aReader)->ReadSentinel(138412634)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'getAll' (bool) member of 'AllUsageParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_getAll)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct OriginUsageParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::OriginUsageParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
IPC::WriteParam(aWriter, (aVar).fromMemory());
// Sentinel = 'fromMemory'
(aWriter)->WriteSentinel(379585582);
}
auto ParamTraits<::mozilla::dom::quota::OriginUsageParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'OriginUsageParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'OriginUsageParams'");
return {};
}
auto maybe___fromMemory = IPC::ReadParam<bool>(aReader);
if (!maybe___fromMemory) {
aReader->FatalError("Error deserializing 'fromMemory' (bool) member of 'OriginUsageParams'");
return {};
}
auto& _fromMemory = *maybe___fromMemory;
// Sentinel = 'fromMemory'
if ((!((aReader)->ReadSentinel(379585582)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'fromMemory' (bool) member of 'OriginUsageParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo),
std::move(_fromMemory)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union UsageRequestParams|
//
namespace mozilla {
namespace dom {
namespace quota {
auto UsageRequestParams::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TAllUsageParams:
{
(ptr_AllUsageParams())->~AllUsageParams__tdef();
break;
}
case TOriginUsageParams:
{
(ptr_OriginUsageParams())->~OriginUsageParams__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(const AllUsageParams& aOther)
{
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(aOther);
mType = TAllUsageParams;
}
MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(AllUsageParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(std::move(aOther));
mType = TAllUsageParams;
}
MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(const OriginUsageParams& aOther)
{
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(aOther);
mType = TOriginUsageParams;
}
MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(OriginUsageParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(std::move(aOther));
mType = TOriginUsageParams;
}
MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(const UsageRequestParams& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TAllUsageParams:
{
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams((aOther).get_AllUsageParams());
break;
}
case TOriginUsageParams:
{
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams((aOther).get_OriginUsageParams());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT UsageRequestParams::UsageRequestParams(UsageRequestParams&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TAllUsageParams:
{
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(std::move((aOther).get_AllUsageParams()));
(aOther).MaybeDestroy();
break;
}
case TOriginUsageParams:
{
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(std::move((aOther).get_OriginUsageParams()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
UsageRequestParams::~UsageRequestParams()
{
MaybeDestroy();
}
auto UsageRequestParams::operator=(const AllUsageParams& aRhs) -> UsageRequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(aRhs);
mType = TAllUsageParams;
return (*(this));
}
auto UsageRequestParams::operator=(AllUsageParams&& aRhs) -> UsageRequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(std::move(aRhs));
mType = TAllUsageParams;
return (*(this));
}
auto UsageRequestParams::operator=(const OriginUsageParams& aRhs) -> UsageRequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(aRhs);
mType = TOriginUsageParams;
return (*(this));
}
auto UsageRequestParams::operator=(OriginUsageParams&& aRhs) -> UsageRequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(std::move(aRhs));
mType = TOriginUsageParams;
return (*(this));
}
auto UsageRequestParams::operator=(const UsageRequestParams& aRhs) -> UsageRequestParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TAllUsageParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams((aRhs).get_AllUsageParams());
break;
}
case TOriginUsageParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams((aRhs).get_OriginUsageParams());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto UsageRequestParams::operator=(UsageRequestParams&& aRhs) -> UsageRequestParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TAllUsageParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_AllUsageParams()) AllUsageParams(std::move((aRhs).get_AllUsageParams()));
(aRhs).MaybeDestroy();
break;
}
case TOriginUsageParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OriginUsageParams()) OriginUsageParams(std::move((aRhs).get_OriginUsageParams()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::UsageRequestParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::quota::UsageRequestParams union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'UsageRequestParams'
(aWriter)->WriteSentinel(1139738435);
switch (type) {
case union__::TAllUsageParams:
{
IPC::WriteParam(aWriter, (aVar).get_AllUsageParams());
// Sentinel = 'TAllUsageParams'
(aWriter)->WriteSentinel(748357063);
return;
}
case union__::TOriginUsageParams:
{
IPC::WriteParam(aWriter, (aVar).get_OriginUsageParams());
// Sentinel = 'TOriginUsageParams'
(aWriter)->WriteSentinel(1109722902);
return;
}
default:
{
aWriter->FatalError("unknown variant of union UsageRequestParams");
return;
}
}
}
auto ParamTraits<::mozilla::dom::quota::UsageRequestParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::quota::UsageRequestParams union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union UsageRequestParams");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'UsageRequestParams'
if ((!((aReader)->ReadSentinel(1139738435)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union UsageRequestParams");
return {};
}
switch (type) {
case union__::TAllUsageParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::AllUsageParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TAllUsageParams of union UsageRequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TAllUsageParams'
if ((!((aReader)->ReadSentinel(748357063)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TAllUsageParams of union UsageRequestParams");
return {};
}
return std::move(tmp);
}
case union__::TOriginUsageParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::OriginUsageParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOriginUsageParams of union UsageRequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOriginUsageParams'
if ((!((aReader)->ReadSentinel(1109722902)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOriginUsageParams of union UsageRequestParams");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union UsageRequestParams");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ClearResetOriginParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::ClearResetOriginParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
IPC::WriteParam(aWriter, (aVar).persistenceType());
// Sentinel = 'persistenceType'
(aWriter)->WriteSentinel(853345864);
IPC::WriteParam(aWriter, (aVar).persistenceTypeIsExplicit());
// Sentinel = 'persistenceTypeIsExplicit'
(aWriter)->WriteSentinel(2261846598);
IPC::WriteParam(aWriter, (aVar).clientType());
// Sentinel = 'clientType'
(aWriter)->WriteSentinel(378995746);
IPC::WriteParam(aWriter, (aVar).clientTypeIsExplicit());
// Sentinel = 'clientTypeIsExplicit'
(aWriter)->WriteSentinel(1427048480);
}
auto ParamTraits<::mozilla::dom::quota::ClearResetOriginParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'ClearResetOriginParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'ClearResetOriginParams'");
return {};
}
auto maybe___persistenceType = IPC::ReadParam<::mozilla::dom::quota::PersistenceType>(aReader);
if (!maybe___persistenceType) {
aReader->FatalError("Error deserializing 'persistenceType' (PersistenceType) member of 'ClearResetOriginParams'");
return {};
}
auto& _persistenceType = *maybe___persistenceType;
// Sentinel = 'persistenceType'
if ((!((aReader)->ReadSentinel(853345864)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'persistenceType' (PersistenceType) member of 'ClearResetOriginParams'");
return {};
}
auto maybe___persistenceTypeIsExplicit = IPC::ReadParam<bool>(aReader);
if (!maybe___persistenceTypeIsExplicit) {
aReader->FatalError("Error deserializing 'persistenceTypeIsExplicit' (bool) member of 'ClearResetOriginParams'");
return {};
}
auto& _persistenceTypeIsExplicit = *maybe___persistenceTypeIsExplicit;
// Sentinel = 'persistenceTypeIsExplicit'
if ((!((aReader)->ReadSentinel(2261846598)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'persistenceTypeIsExplicit' (bool) member of 'ClearResetOriginParams'");
return {};
}
auto maybe___clientType = IPC::ReadParam<::mozilla::dom::quota::Client::Type>(aReader);
if (!maybe___clientType) {
aReader->FatalError("Error deserializing 'clientType' (Type) member of 'ClearResetOriginParams'");
return {};
}
auto& _clientType = *maybe___clientType;
// Sentinel = 'clientType'
if ((!((aReader)->ReadSentinel(378995746)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clientType' (Type) member of 'ClearResetOriginParams'");
return {};
}
auto maybe___clientTypeIsExplicit = IPC::ReadParam<bool>(aReader);
if (!maybe___clientTypeIsExplicit) {
aReader->FatalError("Error deserializing 'clientTypeIsExplicit' (bool) member of 'ClearResetOriginParams'");
return {};
}
auto& _clientTypeIsExplicit = *maybe___clientTypeIsExplicit;
// Sentinel = 'clientTypeIsExplicit'
if ((!((aReader)->ReadSentinel(1427048480)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'clientTypeIsExplicit' (bool) member of 'ClearResetOriginParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo),
std::move(_persistenceType),
std::move(_persistenceTypeIsExplicit),
std::move(_clientType),
std::move(_clientTypeIsExplicit)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ResetOriginParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::ResetOriginParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).commonParams());
// Sentinel = 'commonParams'
(aWriter)->WriteSentinel(537068782);
}
auto ParamTraits<::mozilla::dom::quota::ResetOriginParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___commonParams = IPC::ReadParam<::mozilla::dom::quota::ClearResetOriginParams>(aReader);
if (!maybe___commonParams) {
aReader->FatalError("Error deserializing 'commonParams' (ClearResetOriginParams) member of 'ResetOriginParams'");
return {};
}
auto& _commonParams = *maybe___commonParams;
// Sentinel = 'commonParams'
if ((!((aReader)->ReadSentinel(537068782)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'commonParams' (ClearResetOriginParams) member of 'ResetOriginParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_commonParams)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PersistedParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::PersistedParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
}
auto ParamTraits<::mozilla::dom::quota::PersistedParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'PersistedParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'PersistedParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct PersistParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::PersistParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
}
auto ParamTraits<::mozilla::dom::quota::PersistParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'PersistParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'PersistParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct EstimateParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::EstimateParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
IPC::WriteParam(aWriter, (aVar).principalInfo());
// Sentinel = 'principalInfo'
(aWriter)->WriteSentinel(633472335);
}
auto ParamTraits<::mozilla::dom::quota::EstimateParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
auto maybe___principalInfo = IPC::ReadParam<::mozilla::ipc::PrincipalInfo>(aReader);
if (!maybe___principalInfo) {
aReader->FatalError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'EstimateParams'");
return {};
}
auto& _principalInfo = *maybe___principalInfo;
// Sentinel = 'principalInfo'
if ((!((aReader)->ReadSentinel(633472335)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'principalInfo' (PrincipalInfo) member of 'EstimateParams'");
return {};
}
IPC::ReadResult<paramType> result__{
std::in_place,
std::move(_principalInfo)};
return result__;
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct ListOriginsParams|
//
namespace mozilla {
namespace dom {
namespace quota {
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::ListOriginsParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
}
auto ParamTraits<::mozilla::dom::quota::ListOriginsParams>::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 RequestParams|
//
namespace mozilla {
namespace dom {
namespace quota {
auto RequestParams::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case TStorageNameParams:
{
(ptr_StorageNameParams())->~StorageNameParams__tdef();
break;
}
case TInitializePersistentOriginParams:
{
(ptr_InitializePersistentOriginParams())->~InitializePersistentOriginParams__tdef();
break;
}
case TInitializeTemporaryOriginParams:
{
(ptr_InitializeTemporaryOriginParams())->~InitializeTemporaryOriginParams__tdef();
break;
}
case TGetFullOriginMetadataParams:
{
(ptr_GetFullOriginMetadataParams())->~GetFullOriginMetadataParams__tdef();
break;
}
case TResetOriginParams:
{
(ptr_ResetOriginParams())->~ResetOriginParams__tdef();
break;
}
case TPersistedParams:
{
(ptr_PersistedParams())->~PersistedParams__tdef();
break;
}
case TPersistParams:
{
(ptr_PersistParams())->~PersistParams__tdef();
break;
}
case TEstimateParams:
{
(ptr_EstimateParams())->~EstimateParams__tdef();
break;
}
case TListOriginsParams:
{
(ptr_ListOriginsParams())->~ListOriginsParams__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT RequestParams::RequestParams(const StorageNameParams& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams(aOther);
mType = TStorageNameParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(StorageNameParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams(std::move(aOther));
mType = TStorageNameParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const InitializePersistentOriginParams& aOther)
{
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams(aOther);
mType = TInitializePersistentOriginParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(InitializePersistentOriginParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams(std::move(aOther));
mType = TInitializePersistentOriginParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const InitializeTemporaryOriginParams& aOther)
{
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams(aOther);
mType = TInitializeTemporaryOriginParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(InitializeTemporaryOriginParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams(std::move(aOther));
mType = TInitializeTemporaryOriginParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const GetFullOriginMetadataParams& aOther)
{
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(aOther);
mType = TGetFullOriginMetadataParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(GetFullOriginMetadataParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(std::move(aOther));
mType = TGetFullOriginMetadataParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ResetOriginParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams(aOther);
mType = TResetOriginParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ResetOriginParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams(std::move(aOther));
mType = TResetOriginParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const PersistedParams& aOther)
{
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(aOther);
mType = TPersistedParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(PersistedParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(std::move(aOther));
mType = TPersistedParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const PersistParams& aOther)
{
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(aOther);
mType = TPersistParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(PersistParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(std::move(aOther));
mType = TPersistParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const EstimateParams& aOther)
{
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams(aOther);
mType = TEstimateParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(EstimateParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams(std::move(aOther));
mType = TEstimateParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const ListOriginsParams& aOther)
{
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams(aOther);
mType = TListOriginsParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(ListOriginsParams&& aOther)
{
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams(std::move(aOther));
mType = TListOriginsParams;
}
MOZ_IMPLICIT RequestParams::RequestParams(const RequestParams& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case TStorageNameParams:
{
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams((aOther).get_StorageNameParams());
break;
}
case TInitializePersistentOriginParams:
{
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams((aOther).get_InitializePersistentOriginParams());
break;
}
case TInitializeTemporaryOriginParams:
{
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams((aOther).get_InitializeTemporaryOriginParams());
break;
}
case TGetFullOriginMetadataParams:
{
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams((aOther).get_GetFullOriginMetadataParams());
break;
}
case TResetOriginParams:
{
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams((aOther).get_ResetOriginParams());
break;
}
case TPersistedParams:
{
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams((aOther).get_PersistedParams());
break;
}
case TPersistParams:
{
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams((aOther).get_PersistParams());
break;
}
case TEstimateParams:
{
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams((aOther).get_EstimateParams());
break;
}
case TListOriginsParams:
{
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams((aOther).get_ListOriginsParams());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT RequestParams::RequestParams(RequestParams&& aOther)
{
(aOther).AssertSanity();
Type t = (aOther).type();
switch (t) {
case TStorageNameParams:
{
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams(std::move((aOther).get_StorageNameParams()));
(aOther).MaybeDestroy();
break;
}
case TInitializePersistentOriginParams:
{
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams(std::move((aOther).get_InitializePersistentOriginParams()));
(aOther).MaybeDestroy();
break;
}
case TInitializeTemporaryOriginParams:
{
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams(std::move((aOther).get_InitializeTemporaryOriginParams()));
(aOther).MaybeDestroy();
break;
}
case TGetFullOriginMetadataParams:
{
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(std::move((aOther).get_GetFullOriginMetadataParams()));
(aOther).MaybeDestroy();
break;
}
case TResetOriginParams:
{
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams(std::move((aOther).get_ResetOriginParams()));
(aOther).MaybeDestroy();
break;
}
case TPersistedParams:
{
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(std::move((aOther).get_PersistedParams()));
(aOther).MaybeDestroy();
break;
}
case TPersistParams:
{
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(std::move((aOther).get_PersistParams()));
(aOther).MaybeDestroy();
break;
}
case TEstimateParams:
{
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams(std::move((aOther).get_EstimateParams()));
(aOther).MaybeDestroy();
break;
}
case TListOriginsParams:
{
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams(std::move((aOther).get_ListOriginsParams()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
RequestParams::~RequestParams()
{
MaybeDestroy();
}
auto RequestParams::operator=(const StorageNameParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams(aRhs);
mType = TStorageNameParams;
return (*(this));
}
auto RequestParams::operator=(StorageNameParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams(std::move(aRhs));
mType = TStorageNameParams;
return (*(this));
}
auto RequestParams::operator=(const InitializePersistentOriginParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams(aRhs);
mType = TInitializePersistentOriginParams;
return (*(this));
}
auto RequestParams::operator=(InitializePersistentOriginParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams(std::move(aRhs));
mType = TInitializePersistentOriginParams;
return (*(this));
}
auto RequestParams::operator=(const InitializeTemporaryOriginParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams(aRhs);
mType = TInitializeTemporaryOriginParams;
return (*(this));
}
auto RequestParams::operator=(InitializeTemporaryOriginParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams(std::move(aRhs));
mType = TInitializeTemporaryOriginParams;
return (*(this));
}
auto RequestParams::operator=(const GetFullOriginMetadataParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(aRhs);
mType = TGetFullOriginMetadataParams;
return (*(this));
}
auto RequestParams::operator=(GetFullOriginMetadataParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(std::move(aRhs));
mType = TGetFullOriginMetadataParams;
return (*(this));
}
auto RequestParams::operator=(const ResetOriginParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams(aRhs);
mType = TResetOriginParams;
return (*(this));
}
auto RequestParams::operator=(ResetOriginParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams(std::move(aRhs));
mType = TResetOriginParams;
return (*(this));
}
auto RequestParams::operator=(const PersistedParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(aRhs);
mType = TPersistedParams;
return (*(this));
}
auto RequestParams::operator=(PersistedParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(std::move(aRhs));
mType = TPersistedParams;
return (*(this));
}
auto RequestParams::operator=(const PersistParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(aRhs);
mType = TPersistParams;
return (*(this));
}
auto RequestParams::operator=(PersistParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(std::move(aRhs));
mType = TPersistParams;
return (*(this));
}
auto RequestParams::operator=(const EstimateParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams(aRhs);
mType = TEstimateParams;
return (*(this));
}
auto RequestParams::operator=(EstimateParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams(std::move(aRhs));
mType = TEstimateParams;
return (*(this));
}
auto RequestParams::operator=(const ListOriginsParams& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams(aRhs);
mType = TListOriginsParams;
return (*(this));
}
auto RequestParams::operator=(ListOriginsParams&& aRhs) -> RequestParams&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams(std::move(aRhs));
mType = TListOriginsParams;
return (*(this));
}
auto RequestParams::operator=(const RequestParams& aRhs) -> RequestParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TStorageNameParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams((aRhs).get_StorageNameParams());
break;
}
case TInitializePersistentOriginParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams((aRhs).get_InitializePersistentOriginParams());
break;
}
case TInitializeTemporaryOriginParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams((aRhs).get_InitializeTemporaryOriginParams());
break;
}
case TGetFullOriginMetadataParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams((aRhs).get_GetFullOriginMetadataParams());
break;
}
case TResetOriginParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams((aRhs).get_ResetOriginParams());
break;
}
case TPersistedParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams((aRhs).get_PersistedParams());
break;
}
case TPersistParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams((aRhs).get_PersistParams());
break;
}
case TEstimateParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams((aRhs).get_EstimateParams());
break;
}
case TListOriginsParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams((aRhs).get_ListOriginsParams());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto RequestParams::operator=(RequestParams&& aRhs) -> RequestParams&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case TStorageNameParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_StorageNameParams()) StorageNameParams(std::move((aRhs).get_StorageNameParams()));
(aRhs).MaybeDestroy();
break;
}
case TInitializePersistentOriginParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializePersistentOriginParams()) InitializePersistentOriginParams(std::move((aRhs).get_InitializePersistentOriginParams()));
(aRhs).MaybeDestroy();
break;
}
case TInitializeTemporaryOriginParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_InitializeTemporaryOriginParams()) InitializeTemporaryOriginParams(std::move((aRhs).get_InitializeTemporaryOriginParams()));
(aRhs).MaybeDestroy();
break;
}
case TGetFullOriginMetadataParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(std::move((aRhs).get_GetFullOriginMetadataParams()));
(aRhs).MaybeDestroy();
break;
}
case TResetOriginParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ResetOriginParams()) ResetOriginParams(std::move((aRhs).get_ResetOriginParams()));
(aRhs).MaybeDestroy();
break;
}
case TPersistedParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistedParams()) PersistedParams(std::move((aRhs).get_PersistedParams()));
(aRhs).MaybeDestroy();
break;
}
case TPersistParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_PersistParams()) PersistParams(std::move((aRhs).get_PersistParams()));
(aRhs).MaybeDestroy();
break;
}
case TEstimateParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_EstimateParams()) EstimateParams(std::move((aRhs).get_EstimateParams()));
(aRhs).MaybeDestroy();
break;
}
case TListOriginsParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ListOriginsParams()) ListOriginsParams(std::move((aRhs).get_ListOriginsParams()));
(aRhs).MaybeDestroy();
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
(aRhs).mType = T__None;
mType = t;
return (*(this));
}
} // namespace quota
} // namespace dom
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::dom::quota::RequestParams>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::quota::RequestParams union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'RequestParams'
(aWriter)->WriteSentinel(615384398);
switch (type) {
case union__::TStorageNameParams:
{
IPC::WriteParam(aWriter, (aVar).get_StorageNameParams());
// Sentinel = 'TStorageNameParams'
(aWriter)->WriteSentinel(1110378255);
return;
}
case union__::TInitializePersistentOriginParams:
{
IPC::WriteParam(aWriter, (aVar).get_InitializePersistentOriginParams());
// Sentinel = 'TInitializePersistentOriginParams'
(aWriter)->WriteSentinel(3784838500);
return;
}
case union__::TInitializeTemporaryOriginParams:
{
IPC::WriteParam(aWriter, (aVar).get_InitializeTemporaryOriginParams());
// Sentinel = 'TInitializeTemporaryOriginParams'
(aWriter)->WriteSentinel(3553430774);
return;
}
case union__::TGetFullOriginMetadataParams:
{
IPC::WriteParam(aWriter, (aVar).get_GetFullOriginMetadataParams());
// Sentinel = 'TGetFullOriginMetadataParams'
(aWriter)->WriteSentinel(2616855285);
return;
}
case union__::TResetOriginParams:
{
IPC::WriteParam(aWriter, (aVar).get_ResetOriginParams());
// Sentinel = 'TResetOriginParams'
(aWriter)->WriteSentinel(1115490084);
return;
}
case union__::TPersistedParams:
{
IPC::WriteParam(aWriter, (aVar).get_PersistedParams());
// Sentinel = 'TPersistedParams'
(aWriter)->WriteSentinel(900335212);
return;
}
case union__::TPersistParams:
{
IPC::WriteParam(aWriter, (aVar).get_PersistParams());
// Sentinel = 'TPersistParams'
(aWriter)->WriteSentinel(692585891);
return;
}
case union__::TEstimateParams:
{
IPC::WriteParam(aWriter, (aVar).get_EstimateParams());
// Sentinel = 'TEstimateParams'
(aWriter)->WriteSentinel(781583861);
return;
}
case union__::TListOriginsParams:
{
IPC::WriteParam(aWriter, (aVar).get_ListOriginsParams());
// Sentinel = 'TListOriginsParams'
(aWriter)->WriteSentinel(1121060656);
return;
}
default:
{
aWriter->FatalError("unknown variant of union RequestParams");
return;
}
}
}
auto ParamTraits<::mozilla::dom::quota::RequestParams>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::quota::RequestParams union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union RequestParams");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'RequestParams'
if ((!((aReader)->ReadSentinel(615384398)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union RequestParams");
return {};
}
switch (type) {
case union__::TStorageNameParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::StorageNameParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TStorageNameParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TStorageNameParams'
if ((!((aReader)->ReadSentinel(1110378255)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TStorageNameParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TInitializePersistentOriginParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::InitializePersistentOriginParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TInitializePersistentOriginParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TInitializePersistentOriginParams'
if ((!((aReader)->ReadSentinel(3784838500)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TInitializePersistentOriginParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TInitializeTemporaryOriginParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::InitializeTemporaryOriginParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TInitializeTemporaryOriginParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TInitializeTemporaryOriginParams'
if ((!((aReader)->ReadSentinel(3553430774)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TInitializeTemporaryOriginParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TGetFullOriginMetadataParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::GetFullOriginMetadataParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TGetFullOriginMetadataParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TGetFullOriginMetadataParams'
if ((!((aReader)->ReadSentinel(2616855285)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TGetFullOriginMetadataParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TResetOriginParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::ResetOriginParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TResetOriginParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TResetOriginParams'
if ((!((aReader)->ReadSentinel(1115490084)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TResetOriginParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TPersistedParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::PersistedParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TPersistedParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TPersistedParams'
if ((!((aReader)->ReadSentinel(900335212)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TPersistedParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TPersistParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::PersistParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TPersistParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TPersistParams'
if ((!((aReader)->ReadSentinel(692585891)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TPersistParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TEstimateParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::EstimateParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TEstimateParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TEstimateParams'
if ((!((aReader)->ReadSentinel(781583861)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TEstimateParams of union RequestParams");
return {};
}
return std::move(tmp);
}
case union__::TListOriginsParams:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::ListOriginsParams>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TListOriginsParams of union RequestParams");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TListOriginsParams'
if ((!((aReader)->ReadSentinel(1121060656)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TListOriginsParams of union RequestParams");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union RequestParams");
return {};
}
}
}
} // namespace IPC