//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/GfxMessageUtils.h"
#include "mozilla/dom/PContentParent.h"
#include "mozilla/dom/PContentChild.h"
#include "mozilla/dom/PBrowserParent.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/hal_sandbox/PHal.h"
#include "mozilla/hal_sandbox/PHalParent.h"
#include "mozilla/hal_sandbox/PHalChild.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 hal_sandbox {
namespace PHal {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::hal_sandbox::PHalParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::hal_sandbox::PHalChild>* aChild)
{
    return mozilla::ipc::CreateEndpoints(
        mozilla::ipc::PrivateIPDLInterface(),
        aParentDestInfo, aChildDestInfo, aParent, aChild);
}
mozilla::UniquePtr<IPC::Message>
Msg_NotifyBatteryChange(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_NotifyBatteryChange__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_NotifyNetworkChange(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_NotifyNetworkChange__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_NotifyWakeLockChange(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_NotifyWakeLockChange__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_Vibrate(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_Vibrate__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_CancelVibrate(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_CancelVibrate__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_EnableBatteryNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_EnableBatteryNotifications__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_DisableBatteryNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_DisableBatteryNotifications__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_GetCurrentBatteryInformation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetCurrentBatteryInformation__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::SYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetCurrentBatteryInformation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetCurrentBatteryInformation__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::SYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_EnableNetworkNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_EnableNetworkNotifications__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_DisableNetworkNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_DisableNetworkNotifications__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_GetCurrentNetworkInformation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetCurrentNetworkInformation__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::SYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetCurrentNetworkInformation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetCurrentNetworkInformation__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::SYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_ModifyWakeLock(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_ModifyWakeLock__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_EnableWakeLockNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_EnableWakeLockNotifications__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_DisableWakeLockNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_DisableWakeLockNotifications__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_GetWakeLockInfo(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_GetWakeLockInfo__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::SYNC, IPC::Message::NOT_REPLY));
}
mozilla::UniquePtr<IPC::Message>
Reply_GetWakeLockInfo(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_GetWakeLockInfo__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::SYNC, IPC::Message::REPLY));
}
mozilla::UniquePtr<IPC::Message>
Msg_LockScreenOrientation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_LockScreenOrientation__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_LockScreenOrientation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Reply_LockScreenOrientation__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_UnlockScreenOrientation(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_UnlockScreenOrientation__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_NotifySensorChange(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_NotifySensorChange__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_EnableSensorNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_EnableSensorNotifications__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_DisableSensorNotifications(IPC::Message::routeid_t routingId)
{
    return IPC::Message::IPDLMessage(routingId, Msg_DisableSensorNotifications__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___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));
}

} // namespace PHal
} // namespace hal_sandbox
} // namespace mozilla

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct BatteryInformation|
//
namespace mozilla {
namespace hal {
auto BatteryInformation::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(BatteryInformation, remainingTime_) - offsetof(BatteryInformation, level_)) == 8,
        "Bad assumptions about field layout!");
}

} // namespace hal
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::hal::BatteryInformation>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).charging());
    // Sentinel = 'charging'
    (aWriter)->WriteSentinel(244450116);
    (aWriter)->WriteBytes((&((aVar).level())), 16);
    // Sentinel = 'level | remainingTime'
    (aWriter)->WriteSentinel(1480656926);
}

auto ParamTraits<::mozilla::hal::BatteryInformation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___charging = IPC::ReadParam<bool>(aReader);
    if (!maybe___charging) {
        aReader->FatalError("Error deserializing 'charging' (bool) member of 'BatteryInformation'");
        return {};

    }
    auto& _charging = *maybe___charging;
    // Sentinel = 'charging'
    if ((!((aReader)->ReadSentinel(244450116)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'charging' (bool) member of 'BatteryInformation'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            double{0},
            std::move(_charging),
            double{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->level())), 16)))) {
        aReader->FatalError("Error bulk reading fields from double");
        return {};
    }
    // Sentinel = 'level | remainingTime'
    if ((!((aReader)->ReadSentinel(1480656926)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from double");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct SensorData|
//
namespace mozilla {
namespace hal {
} // namespace hal
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::hal::SensorData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).sensor());
    // Sentinel = 'sensor'
    (aWriter)->WriteSentinel(152175259);
    IPC::WriteParam(aWriter, (aVar).timestamp());
    // Sentinel = 'timestamp'
    (aWriter)->WriteSentinel(322569173);
    IPC::WriteParam(aWriter, (aVar).values());
    // Sentinel = 'values'
    (aWriter)->WriteSentinel(150667921);
}

auto ParamTraits<::mozilla::hal::SensorData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___sensor = IPC::ReadParam<::mozilla::hal::SensorType>(aReader);
    if (!maybe___sensor) {
        aReader->FatalError("Error deserializing 'sensor' (SensorType) member of 'SensorData'");
        return {};

    }
    auto& _sensor = *maybe___sensor;
    // Sentinel = 'sensor'
    if ((!((aReader)->ReadSentinel(152175259)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'sensor' (SensorType) member of 'SensorData'");
        return {};
    }
    auto maybe___timestamp = IPC::ReadParam<::PRTime>(aReader);
    if (!maybe___timestamp) {
        aReader->FatalError("Error deserializing 'timestamp' (PRTime) member of 'SensorData'");
        return {};

    }
    auto& _timestamp = *maybe___timestamp;
    // Sentinel = 'timestamp'
    if ((!((aReader)->ReadSentinel(322569173)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timestamp' (PRTime) member of 'SensorData'");
        return {};
    }
    auto maybe___values = IPC::ReadParam<nsTArray<float>>(aReader);
    if (!maybe___values) {
        aReader->FatalError("Error deserializing 'values' (float[]) member of 'SensorData'");
        return {};

    }
    auto& _values = *maybe___values;
    // Sentinel = 'values'
    if ((!((aReader)->ReadSentinel(150667921)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'values' (float[]) member of 'SensorData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_sensor),
            std::move(_timestamp),
            std::move(_values)};
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct NetworkInformation|
//
namespace mozilla {
namespace hal {
auto NetworkInformation::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(NetworkInformation, dhcpGateway_) - offsetof(NetworkInformation, type_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace hal
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::hal::NetworkInformation>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).isWifi());
    // Sentinel = 'isWifi'
    (aWriter)->WriteSentinel(143065708);
    (aWriter)->WriteBytes((&((aVar).type())), 8);
    // Sentinel = 'type | dhcpGateway'
    (aWriter)->WriteSentinel(1086326512);
}

auto ParamTraits<::mozilla::hal::NetworkInformation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___isWifi = IPC::ReadParam<bool>(aReader);
    if (!maybe___isWifi) {
        aReader->FatalError("Error deserializing 'isWifi' (bool) member of 'NetworkInformation'");
        return {};

    }
    auto& _isWifi = *maybe___isWifi;
    // Sentinel = 'isWifi'
    if ((!((aReader)->ReadSentinel(143065708)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'isWifi' (bool) member of 'NetworkInformation'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            ::uint32_t{0},
            std::move(_isWifi),
            ::uint32_t{0}};
    if ((!((aReader)->ReadBytesInto((&((result__)->type())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'type | dhcpGateway'
    if ((!((aReader)->ReadSentinel(1086326512)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct WakeLockInformation|
//
namespace mozilla {
namespace hal {
auto WakeLockInformation::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(WakeLockInformation, numHidden_) - offsetof(WakeLockInformation, numLocks_)) == 4,
        "Bad assumptions about field layout!");
}

} // namespace hal
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::hal::WakeLockInformation>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).topic());
    // Sentinel = 'topic'
    (aWriter)->WriteSentinel(109707808);
    IPC::WriteParam(aWriter, (aVar).lockingProcesses());
    // Sentinel = 'lockingProcesses'
    (aWriter)->WriteSentinel(938215071);
    (aWriter)->WriteBytes((&((aVar).numLocks())), 8);
    // Sentinel = 'numLocks | numHidden'
    (aWriter)->WriteSentinel(1355089829);
}

auto ParamTraits<::mozilla::hal::WakeLockInformation>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___topic = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___topic) {
        aReader->FatalError("Error deserializing 'topic' (nsString) member of 'WakeLockInformation'");
        return {};

    }
    auto& _topic = *maybe___topic;
    // Sentinel = 'topic'
    if ((!((aReader)->ReadSentinel(109707808)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'topic' (nsString) member of 'WakeLockInformation'");
        return {};
    }
    auto maybe___lockingProcesses = IPC::ReadParam<nsTArray<::uint64_t>>(aReader);
    if (!maybe___lockingProcesses) {
        aReader->FatalError("Error deserializing 'lockingProcesses' (uint64_t[]) member of 'WakeLockInformation'");
        return {};

    }
    auto& _lockingProcesses = *maybe___lockingProcesses;
    // Sentinel = 'lockingProcesses'
    if ((!((aReader)->ReadSentinel(938215071)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'lockingProcesses' (uint64_t[]) member of 'WakeLockInformation'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_topic),
            ::uint32_t{0},
            ::uint32_t{0},
            std::move(_lockingProcesses)};
    if ((!((aReader)->ReadBytesInto((&((result__)->numLocks())), 8)))) {
        aReader->FatalError("Error bulk reading fields from uint32_t");
        return {};
    }
    // Sentinel = 'numLocks | numHidden'
    if ((!((aReader)->ReadSentinel(1355089829)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint32_t");
        return {};
    }
    return result__;
}

} // namespace IPC