//
// 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/DomSecurityIPCUtils.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__(IPC::Message::routeid_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__(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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_InitializeAllTemporaryOrigins(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_InitializeAllTemporaryOrigins__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_InitializeAllTemporaryOrigins(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_InitializeAllTemporaryOrigins__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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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_ListOrigins(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ListOrigins__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_ListOrigins(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_ListOrigins__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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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(IPC::Message::routeid_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));
}
mozilla::UniquePtr<IPC::Message>
Msg_SetThumbnailPrivateIdentityId(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_SetThumbnailPrivateIdentityId__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 |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;
        }
    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 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 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 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 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 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 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;
        }
    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);
        }
    default:
        {
            aReader->FatalError("unknown variant of union RequestParams");
            return {};
        }
    }
}

} // namespace IPC
