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

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(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::dom::quota::PQuotaParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::quota::PQuotaChild>* aChild)
{
return mozilla::ipc::CreateEndpoints(
mozilla::ipc::PrivateIPDLInterface(),
aParentDestInfo, aChildDestInfo, 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_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_PersistentStorageInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_PersistentStorageInitialized__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_PersistentStorageInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_PersistentStorageInitialized__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_TemporaryGroupInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_TemporaryGroupInitialized__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_TemporaryGroupInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_TemporaryGroupInitialized__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_PersistentOriginInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_PersistentOriginInitialized__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_PersistentOriginInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_PersistentOriginInitialized__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_TemporaryOriginInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_TemporaryOriginInitialized__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_TemporaryOriginInitialized(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_TemporaryOriginInitialized__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_InitializePersistentStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializePersistentStorage__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_InitializePersistentStorage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializePersistentStorage__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_InitializeTemporaryGroup(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializeTemporaryGroup__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_InitializeTemporaryGroup(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializeTemporaryGroup__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_InitializePersistentOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializePersistentOrigin__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_InitializePersistentOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializePersistentOrigin__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_InitializeTemporaryOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_InitializeTemporaryOrigin__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_InitializeTemporaryOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_InitializeTemporaryOrigin__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_GetUsage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetUsage__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_GetUsage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetUsage__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_GetOriginUsage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetOriginUsage__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_GetOriginUsage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetOriginUsage__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_GetCachedOriginUsage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_GetCachedOriginUsage__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_GetCachedOriginUsage(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_GetCachedOriginUsage__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_ListCachedOrigins(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ListCachedOrigins__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_ListCachedOrigins(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ListCachedOrigins__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_ClearStoragesForClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ClearStoragesForClient__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_ClearStoragesForClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ClearStoragesForClient__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_ShutdownStoragesForOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ShutdownStoragesForOrigin__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_ShutdownStoragesForOrigin(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ShutdownStoragesForOrigin__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_ShutdownStoragesForClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Msg_ShutdownStoragesForClient__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_ShutdownStoragesForClient(int32_t routingId)
{
return IPC::Message::IPDLMessage(routingId, Reply_ShutdownStoragesForClient__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 |union UInt64Response|
//
namespace mozilla {
namespace ipc {
auto UInt64Response::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case Tuint64_t:
{
(ptr_uint64_t())->~uint64_t__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT UInt64Response::UInt64Response(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT UInt64Response::UInt64Response(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT UInt64Response::UInt64Response(const uint64_t& aOther)
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aOther);
mType = Tuint64_t;
}
MOZ_IMPLICIT UInt64Response::UInt64Response(uint64_t&& aOther)
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aOther));
mType = Tuint64_t;
}
MOZ_IMPLICIT UInt64Response::UInt64Response(const UInt64Response& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case Tuint64_t:
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aOther).get_uint64_t());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT UInt64Response::UInt64Response(UInt64Response&& 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 Tuint64_t:
{
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aOther).get_uint64_t()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
UInt64Response::~UInt64Response()
{
MaybeDestroy();
}
auto UInt64Response::operator=(const nsresult& aRhs) -> UInt64Response&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto UInt64Response::operator=(nsresult&& aRhs) -> UInt64Response&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto UInt64Response::operator=(const uint64_t& aRhs) -> UInt64Response&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(aRhs);
mType = Tuint64_t;
return (*(this));
}
auto UInt64Response::operator=(uint64_t&& aRhs) -> UInt64Response&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move(aRhs));
mType = Tuint64_t;
return (*(this));
}
auto UInt64Response::operator=(const UInt64Response& aRhs) -> UInt64Response&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case Tuint64_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t((aRhs).get_uint64_t());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto UInt64Response::operator=(UInt64Response&& aRhs) -> UInt64Response&
{
(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 Tuint64_t:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_uint64_t()) uint64_t(std::move((aRhs).get_uint64_t()));
(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::UInt64Response>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::ipc::UInt64Response union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'UInt64Response'
(aWriter)->WriteSentinel(620954938);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::Tuint64_t:
{
IPC::WriteParam(aWriter, (aVar).get_uint64_t());
// Sentinel = 'Tuint64_t'
(aWriter)->WriteSentinel(285344594);
return;
}
default:
{
aWriter->FatalError("unknown variant of union UInt64Response");
return;
}
}
}
auto ParamTraits<::mozilla::ipc::UInt64Response>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::ipc::UInt64Response union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union UInt64Response");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'UInt64Response'
if ((!((aReader)->ReadSentinel(620954938)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union UInt64Response");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union UInt64Response");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union UInt64Response");
return {};
}
return std::move(tmp);
}
case union__::Tuint64_t:
{
auto maybe__tmp = IPC::ReadParam<::uint64_t>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tuint64_t of union UInt64Response");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tuint64_t'
if ((!((aReader)->ReadSentinel(285344594)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tuint64_t of union UInt64Response");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union UInt64Response");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union CStringArrayResponse|
//
namespace mozilla {
namespace ipc {
auto CStringArrayResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TArrayOfnsCString:
{
(ptr_ArrayOfnsCString())->~ArrayOfnsCString__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT CStringArrayResponse::CStringArrayResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT CStringArrayResponse::CStringArrayResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT CStringArrayResponse::CStringArrayResponse(const nsTArray<nsCString>& aOther)
{
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>((aOther).Clone());
mType = TArrayOfnsCString;
}
MOZ_IMPLICIT CStringArrayResponse::CStringArrayResponse(nsTArray<nsCString>&& aOther)
{
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>(std::move(aOther));
mType = TArrayOfnsCString;
}
MOZ_IMPLICIT CStringArrayResponse::CStringArrayResponse(const CStringArrayResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TArrayOfnsCString:
{
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>(((aOther).get_ArrayOfnsCString()).Clone());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT CStringArrayResponse::CStringArrayResponse(CStringArrayResponse&& 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 TArrayOfnsCString:
{
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>(std::move((aOther).get_ArrayOfnsCString()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
CStringArrayResponse::~CStringArrayResponse()
{
MaybeDestroy();
}
auto CStringArrayResponse::operator=(const nsresult& aRhs) -> CStringArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto CStringArrayResponse::operator=(nsresult&& aRhs) -> CStringArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto CStringArrayResponse::operator=(const nsTArray<nsCString>& aRhs) -> CStringArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>((aRhs).Clone());
mType = TArrayOfnsCString;
return (*(this));
}
auto CStringArrayResponse::operator=(nsTArray<nsCString>&& aRhs) -> CStringArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>(std::move(aRhs));
mType = TArrayOfnsCString;
return (*(this));
}
auto CStringArrayResponse::operator=(const CStringArrayResponse& aRhs) -> CStringArrayResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TArrayOfnsCString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>(((aRhs).get_ArrayOfnsCString()).Clone());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto CStringArrayResponse::operator=(CStringArrayResponse&& aRhs) -> CStringArrayResponse&
{
(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 TArrayOfnsCString:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_ArrayOfnsCString()) nsTArray<nsCString>(std::move((aRhs).get_ArrayOfnsCString()));
(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::CStringArrayResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::ipc::CStringArrayResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'CStringArrayResponse'
(aWriter)->WriteSentinel(1374881801);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TArrayOfnsCString:
{
IPC::WriteParam(aWriter, (aVar).get_ArrayOfnsCString());
// Sentinel = 'TArrayOfnsCString'
(aWriter)->WriteSentinel(979371684);
return;
}
default:
{
aWriter->FatalError("unknown variant of union CStringArrayResponse");
return;
}
}
}
auto ParamTraits<::mozilla::ipc::CStringArrayResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::ipc::CStringArrayResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union CStringArrayResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'CStringArrayResponse'
if ((!((aReader)->ReadSentinel(1374881801)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union CStringArrayResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union CStringArrayResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union CStringArrayResponse");
return {};
}
return std::move(tmp);
}
case union__::TArrayOfnsCString:
{
auto maybe__tmp = IPC::ReadParam<nsTArray<::nsCString>>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TArrayOfnsCString of union CStringArrayResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TArrayOfnsCString'
if ((!((aReader)->ReadSentinel(979371684)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TArrayOfnsCString of union CStringArrayResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union CStringArrayResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union OriginUsageMetadataArrayResponse|
//
namespace mozilla {
namespace dom {
namespace quota {
auto OriginUsageMetadataArrayResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TOriginUsageMetadataArray:
{
(ptr_OriginUsageMetadataArray())->~OriginUsageMetadataArray__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT OriginUsageMetadataArrayResponse::OriginUsageMetadataArrayResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT OriginUsageMetadataArrayResponse::OriginUsageMetadataArrayResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT OriginUsageMetadataArrayResponse::OriginUsageMetadataArrayResponse(OriginUsageMetadataArray&& aOther)
{
new (mozilla::KnownNotNull, ptr_OriginUsageMetadataArray()) OriginUsageMetadataArray(std::move(aOther));
mType = TOriginUsageMetadataArray;
}
MOZ_IMPLICIT OriginUsageMetadataArrayResponse::OriginUsageMetadataArrayResponse(OriginUsageMetadataArrayResponse&& 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 TOriginUsageMetadataArray:
{
new (mozilla::KnownNotNull, ptr_OriginUsageMetadataArray()) OriginUsageMetadataArray(std::move((aOther).get_OriginUsageMetadataArray()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
OriginUsageMetadataArrayResponse::~OriginUsageMetadataArrayResponse()
{
MaybeDestroy();
}
auto OriginUsageMetadataArrayResponse::operator=(const nsresult& aRhs) -> OriginUsageMetadataArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto OriginUsageMetadataArrayResponse::operator=(nsresult&& aRhs) -> OriginUsageMetadataArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto OriginUsageMetadataArrayResponse::operator=(OriginUsageMetadataArray&& aRhs) -> OriginUsageMetadataArrayResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OriginUsageMetadataArray()) OriginUsageMetadataArray(std::move(aRhs));
mType = TOriginUsageMetadataArray;
return (*(this));
}
auto OriginUsageMetadataArrayResponse::operator=(OriginUsageMetadataArrayResponse&& aRhs) -> OriginUsageMetadataArrayResponse&
{
(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 TOriginUsageMetadataArray:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_OriginUsageMetadataArray()) OriginUsageMetadataArray(std::move((aRhs).get_OriginUsageMetadataArray()));
(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::OriginUsageMetadataArrayResponse>::Write(
IPC::MessageWriter* aWriter,
paramType&& aVar) -> void
{
typedef ::mozilla::dom::quota::OriginUsageMetadataArrayResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'OriginUsageMetadataArrayResponse'
(aWriter)->WriteSentinel(3494776013);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TOriginUsageMetadataArray:
{
IPC::WriteParam(aWriter, std::move((aVar).get_OriginUsageMetadataArray()));
// Sentinel = 'TOriginUsageMetadataArray'
(aWriter)->WriteSentinel(2114783698);
return;
}
default:
{
aWriter->FatalError("unknown variant of union OriginUsageMetadataArrayResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::quota::OriginUsageMetadataArrayResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::quota::OriginUsageMetadataArrayResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union OriginUsageMetadataArrayResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'OriginUsageMetadataArrayResponse'
if ((!((aReader)->ReadSentinel(3494776013)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union OriginUsageMetadataArrayResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union OriginUsageMetadataArrayResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union OriginUsageMetadataArrayResponse");
return {};
}
return std::move(tmp);
}
case union__::TOriginUsageMetadataArray:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::OriginUsageMetadataArray>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TOriginUsageMetadataArray of union OriginUsageMetadataArrayResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TOriginUsageMetadataArray'
if ((!((aReader)->ReadSentinel(2114783698)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TOriginUsageMetadataArray of union OriginUsageMetadataArrayResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union OriginUsageMetadataArrayResponse");
return {};
}
}
}
} // namespace IPC
//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |union UsageInfoResponse|
//
namespace mozilla {
namespace dom {
namespace quota {
auto UsageInfoResponse::MaybeDestroy() -> void
{
if ((mType) == (T__None)) {
return;
}
switch (mType) {
case Tnsresult:
{
(ptr_nsresult())->~nsresult__tdef();
break;
}
case TUsageInfo:
{
(ptr_UsageInfo())->~UsageInfo__tdef();
break;
}
default:
{
mozilla::ipc::LogicError("not reached");
break;
}
}
}
MOZ_IMPLICIT UsageInfoResponse::UsageInfoResponse(const nsresult& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aOther);
mType = Tnsresult;
}
MOZ_IMPLICIT UsageInfoResponse::UsageInfoResponse(nsresult&& aOther)
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aOther));
mType = Tnsresult;
}
MOZ_IMPLICIT UsageInfoResponse::UsageInfoResponse(const UsageInfo& aOther)
{
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo(aOther);
mType = TUsageInfo;
}
MOZ_IMPLICIT UsageInfoResponse::UsageInfoResponse(UsageInfo&& aOther)
{
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo(std::move(aOther));
mType = TUsageInfo;
}
MOZ_IMPLICIT UsageInfoResponse::UsageInfoResponse(const UsageInfoResponse& aOther)
{
(aOther).AssertSanity();
switch ((aOther).type()) {
case Tnsresult:
{
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aOther).get_nsresult());
break;
}
case TUsageInfo:
{
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo((aOther).get_UsageInfo());
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
mType = (aOther).type();
}
MOZ_IMPLICIT UsageInfoResponse::UsageInfoResponse(UsageInfoResponse&& 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 TUsageInfo:
{
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo(std::move((aOther).get_UsageInfo()));
(aOther).MaybeDestroy();
break;
}
case T__None:
{
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
return;
}
}
(aOther).mType = T__None;
mType = t;
}
UsageInfoResponse::~UsageInfoResponse()
{
MaybeDestroy();
}
auto UsageInfoResponse::operator=(const nsresult& aRhs) -> UsageInfoResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(aRhs);
mType = Tnsresult;
return (*(this));
}
auto UsageInfoResponse::operator=(nsresult&& aRhs) -> UsageInfoResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult(std::move(aRhs));
mType = Tnsresult;
return (*(this));
}
auto UsageInfoResponse::operator=(const UsageInfo& aRhs) -> UsageInfoResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo(aRhs);
mType = TUsageInfo;
return (*(this));
}
auto UsageInfoResponse::operator=(UsageInfo&& aRhs) -> UsageInfoResponse&
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo(std::move(aRhs));
mType = TUsageInfo;
return (*(this));
}
auto UsageInfoResponse::operator=(const UsageInfoResponse& aRhs) -> UsageInfoResponse&
{
(aRhs).AssertSanity();
Type t = (aRhs).type();
switch (t) {
case Tnsresult:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_nsresult()) nsresult((aRhs).get_nsresult());
break;
}
case TUsageInfo:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo((aRhs).get_UsageInfo());
break;
}
case T__None:
{
MaybeDestroy();
break;
}
default:
{
mozilla::ipc::LogicError("unreached");
break;
}
}
mType = t;
return (*(this));
}
auto UsageInfoResponse::operator=(UsageInfoResponse&& aRhs) -> UsageInfoResponse&
{
(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 TUsageInfo:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_UsageInfo()) UsageInfo(std::move((aRhs).get_UsageInfo()));
(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::UsageInfoResponse>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
typedef ::mozilla::dom::quota::UsageInfoResponse union__;
int type = (aVar).type();
IPC::WriteParam(aWriter, type);
// Sentinel = 'UsageInfoResponse'
(aWriter)->WriteSentinel(1004996305);
switch (type) {
case union__::Tnsresult:
{
IPC::WriteParam(aWriter, (aVar).get_nsresult());
// Sentinel = 'Tnsresult'
(aWriter)->WriteSentinel(313394133);
return;
}
case union__::TUsageInfo:
{
IPC::WriteParam(aWriter, (aVar).get_UsageInfo());
// Sentinel = 'TUsageInfo'
(aWriter)->WriteSentinel(345637846);
return;
}
default:
{
aWriter->FatalError("unknown variant of union UsageInfoResponse");
return;
}
}
}
auto ParamTraits<::mozilla::dom::quota::UsageInfoResponse>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
typedef ::mozilla::dom::quota::UsageInfoResponse union__;
auto maybe__type = IPC::ReadParam<int>(aReader);
if (!maybe__type) {
aReader->FatalError("Error deserializing type of union UsageInfoResponse");
return {};
}
auto& type = *maybe__type;
// Sentinel = 'UsageInfoResponse'
if ((!((aReader)->ReadSentinel(1004996305)))) {
mozilla::ipc::SentinelReadError("Error deserializing type of union UsageInfoResponse");
return {};
}
switch (type) {
case union__::Tnsresult:
{
auto maybe__tmp = IPC::ReadParam<::nsresult>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant Tnsresult of union UsageInfoResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'Tnsresult'
if ((!((aReader)->ReadSentinel(313394133)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant Tnsresult of union UsageInfoResponse");
return {};
}
return std::move(tmp);
}
case union__::TUsageInfo:
{
auto maybe__tmp = IPC::ReadParam<::mozilla::dom::quota::UsageInfo>(aReader);
if (!maybe__tmp) {
aReader->FatalError("Error deserializing variant TUsageInfo of union UsageInfoResponse");
return {};
}
auto& tmp = *maybe__tmp;
// Sentinel = 'TUsageInfo'
if ((!((aReader)->ReadSentinel(345637846)))) {
mozilla::ipc::SentinelReadError("Error deserializing variant TUsageInfo of union UsageInfoResponse");
return {};
}
return std::move(tmp);
}
default:
{
aReader->FatalError("unknown variant of union UsageInfoResponse");
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 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 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 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 TGetFullOriginMetadataParams:
{
(ptr_GetFullOriginMetadataParams())->~GetFullOriginMetadataParams__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 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 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 TGetFullOriginMetadataParams:
{
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams((aOther).get_GetFullOriginMetadataParams());
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 TGetFullOriginMetadataParams:
{
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(std::move((aOther).get_GetFullOriginMetadataParams()));
(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 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 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 TGetFullOriginMetadataParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams((aRhs).get_GetFullOriginMetadataParams());
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 TGetFullOriginMetadataParams:
{
MaybeDestroy();
new (mozilla::KnownNotNull, ptr_GetFullOriginMetadataParams()) GetFullOriginMetadataParams(std::move((aRhs).get_GetFullOriginMetadataParams()));
(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__::TGetFullOriginMetadataParams:
{
IPC::WriteParam(aWriter, (aVar).get_GetFullOriginMetadataParams());
// Sentinel = 'TGetFullOriginMetadataParams'
(aWriter)->WriteSentinel(2616855285);
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__::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__::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