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


#include "mozilla/dom/PerformanceTimingTypes.h"

#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"


//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCServerTiming|
//
namespace mozilla {
namespace dom {
} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCServerTiming>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).name());
    // Sentinel = 'name'
    (aWriter)->WriteSentinel(69075362);
    IPC::WriteParam(aWriter, (aVar).description());
    // Sentinel = 'description'
    (aWriter)->WriteSentinel(461833381);
    (aWriter)->WriteBytes((&((aVar).duration())), 8);
    // Sentinel = 'duration'
    (aWriter)->WriteSentinel(256050023);
}

auto ParamTraits<::mozilla::dom::IPCServerTiming>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___name = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___name) {
        aReader->FatalError("Error deserializing 'name' (nsCString) member of 'IPCServerTiming'");
        return {};

    }
    auto& _name = *maybe___name;
    // Sentinel = 'name'
    if ((!((aReader)->ReadSentinel(69075362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'name' (nsCString) member of 'IPCServerTiming'");
        return {};
    }
    auto maybe___description = IPC::ReadParam<::nsCString>(aReader);
    if (!maybe___description) {
        aReader->FatalError("Error deserializing 'description' (nsCString) member of 'IPCServerTiming'");
        return {};

    }
    auto& _description = *maybe___description;
    // Sentinel = 'description'
    if ((!((aReader)->ReadSentinel(461833381)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'description' (nsCString) member of 'IPCServerTiming'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_name),
            double{0},
            std::move(_description)};
    if ((!((aReader)->ReadBytesInto((&((result__)->duration())), 8)))) {
        aReader->FatalError("Error bulk reading fields from double");
        return {};
    }
    // Sentinel = 'duration'
    if ((!((aReader)->ReadSentinel(256050023)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from double");
        return {};
    }
    return result__;
}

} // namespace IPC

//-----------------------------------------------------------------------------
// Method definitions for the IPDL type |struct IPCPerformanceTimingData|
//
namespace mozilla {
namespace dom {
auto IPCPerformanceTimingData::StaticAssertions() const -> void
{
    static_assert(
        (offsetof(IPCPerformanceTimingData, decodedBodySize_) - offsetof(IPCPerformanceTimingData, encodedBodySize_)) == 16,
        "Bad assumptions about field layout!");
}

} // namespace dom
} // namespace mozilla

namespace IPC {
auto ParamTraits<::mozilla::dom::IPCPerformanceTimingData>::Write(
        IPC::MessageWriter* aWriter,
        const paramType& aVar) -> void
{
    IPC::WriteParam(aWriter, (aVar).serverTiming());
    // Sentinel = 'serverTiming'
    (aWriter)->WriteSentinel(551421184);
    IPC::WriteParam(aWriter, (aVar).nextHopProtocol());
    // Sentinel = 'nextHopProtocol'
    (aWriter)->WriteSentinel(832046649);
    IPC::WriteParam(aWriter, (aVar).asyncOpen());
    // Sentinel = 'asyncOpen'
    (aWriter)->WriteSentinel(312476593);
    IPC::WriteParam(aWriter, (aVar).redirectStart());
    // Sentinel = 'redirectStart'
    (aWriter)->WriteSentinel(628753761);
    IPC::WriteParam(aWriter, (aVar).redirectEnd());
    // Sentinel = 'redirectEnd'
    (aWriter)->WriteSentinel(452527210);
    IPC::WriteParam(aWriter, (aVar).domainLookupStart());
    // Sentinel = 'domainLookupStart'
    (aWriter)->WriteSentinel(1047070465);
    IPC::WriteParam(aWriter, (aVar).domainLookupEnd());
    // Sentinel = 'domainLookupEnd'
    (aWriter)->WriteSentinel(816317962);
    IPC::WriteParam(aWriter, (aVar).connectStart());
    // Sentinel = 'connectStart'
    (aWriter)->WriteSentinel(538838265);
    IPC::WriteParam(aWriter, (aVar).secureConnectionStart());
    // Sentinel = 'secureConnectionStart'
    (aWriter)->WriteSentinel(1588725926);
    IPC::WriteParam(aWriter, (aVar).connectEnd());
    // Sentinel = 'connectEnd'
    (aWriter)->WriteSentinel(376243202);
    IPC::WriteParam(aWriter, (aVar).requestStart());
    // Sentinel = 'requestStart'
    (aWriter)->WriteSentinel(556860696);
    IPC::WriteParam(aWriter, (aVar).responseStart());
    // Sentinel = 'responseStart'
    (aWriter)->WriteSentinel(648545662);
    IPC::WriteParam(aWriter, (aVar).cacheReadStart());
    // Sentinel = 'cacheReadStart'
    (aWriter)->WriteSentinel(677774719);
    IPC::WriteParam(aWriter, (aVar).responseEnd());
    // Sentinel = 'responseEnd'
    (aWriter)->WriteSentinel(468518023);
    IPC::WriteParam(aWriter, (aVar).cacheReadEnd());
    // Sentinel = 'cacheReadEnd'
    (aWriter)->WriteSentinel(497616008);
    IPC::WriteParam(aWriter, (aVar).workerStart());
    // Sentinel = 'workerStart'
    (aWriter)->WriteSentinel(472974505);
    IPC::WriteParam(aWriter, (aVar).workerRequestStart());
    // Sentinel = 'workerRequestStart'
    (aWriter)->WriteSentinel(1210648466);
    IPC::WriteParam(aWriter, (aVar).workerResponseEnd());
    // Sentinel = 'workerResponseEnd'
    (aWriter)->WriteSentinel(1080755969);
    IPC::WriteParam(aWriter, (aVar).zeroTime());
    // Sentinel = 'zeroTime'
    (aWriter)->WriteSentinel(255591248);
    IPC::WriteParam(aWriter, (aVar).fetchStart());
    // Sentinel = 'fetchStart'
    (aWriter)->WriteSentinel(373425177);
    IPC::WriteParam(aWriter, (aVar).renderBlocking());
    // Sentinel = 'renderBlocking'
    (aWriter)->WriteSentinel(713688490);
    IPC::WriteParam(aWriter, (aVar).contentType());
    // Sentinel = 'contentType'
    (aWriter)->WriteSentinel(465241246);
    IPC::WriteParam(aWriter, (aVar).allRedirectsSameOrigin());
    // Sentinel = 'allRedirectsSameOrigin'
    (aWriter)->WriteSentinel(1689716941);
    IPC::WriteParam(aWriter, (aVar).allRedirectsPassTAO());
    // Sentinel = 'allRedirectsPassTAO'
    (aWriter)->WriteSentinel(1265174362);
    IPC::WriteParam(aWriter, (aVar).secureConnection());
    // Sentinel = 'secureConnection'
    (aWriter)->WriteSentinel(936380056);
    IPC::WriteParam(aWriter, (aVar).bodyInfoAccessAllowed());
    // Sentinel = 'bodyInfoAccessAllowed'
    (aWriter)->WriteSentinel(1526663253);
    IPC::WriteParam(aWriter, (aVar).timingAllowed());
    // Sentinel = 'timingAllowed'
    (aWriter)->WriteSentinel(628491601);
    IPC::WriteParam(aWriter, (aVar).initialized());
    // Sentinel = 'initialized'
    (aWriter)->WriteSentinel(464258199);
    (aWriter)->WriteBytes((&((aVar).encodedBodySize())), 24);
    // Sentinel = 'encodedBodySize | transferSize | decodedBodySize'
    (aWriter)->WriteSentinel(3272938085);
    (aWriter)->WriteBytes((&((aVar).responseStatus())), 2);
    // Sentinel = 'responseStatus'
    (aWriter)->WriteSentinel(748750324);
    (aWriter)->WriteBytes((&((aVar).redirectCount())), 1);
    // Sentinel = 'redirectCount'
    (aWriter)->WriteSentinel(625608028);
}

auto ParamTraits<::mozilla::dom::IPCPerformanceTimingData>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
    auto maybe___serverTiming = IPC::ReadParam<nsTArray<::mozilla::dom::IPCServerTiming>>(aReader);
    if (!maybe___serverTiming) {
        aReader->FatalError("Error deserializing 'serverTiming' (IPCServerTiming[]) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _serverTiming = *maybe___serverTiming;
    // Sentinel = 'serverTiming'
    if ((!((aReader)->ReadSentinel(551421184)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'serverTiming' (IPCServerTiming[]) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___nextHopProtocol = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___nextHopProtocol) {
        aReader->FatalError("Error deserializing 'nextHopProtocol' (nsString) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _nextHopProtocol = *maybe___nextHopProtocol;
    // Sentinel = 'nextHopProtocol'
    if ((!((aReader)->ReadSentinel(832046649)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'nextHopProtocol' (nsString) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___asyncOpen = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___asyncOpen) {
        aReader->FatalError("Error deserializing 'asyncOpen' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _asyncOpen = *maybe___asyncOpen;
    // Sentinel = 'asyncOpen'
    if ((!((aReader)->ReadSentinel(312476593)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'asyncOpen' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___redirectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___redirectStart) {
        aReader->FatalError("Error deserializing 'redirectStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _redirectStart = *maybe___redirectStart;
    // Sentinel = 'redirectStart'
    if ((!((aReader)->ReadSentinel(628753761)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'redirectStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___redirectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___redirectEnd) {
        aReader->FatalError("Error deserializing 'redirectEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _redirectEnd = *maybe___redirectEnd;
    // Sentinel = 'redirectEnd'
    if ((!((aReader)->ReadSentinel(452527210)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'redirectEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___domainLookupStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___domainLookupStart) {
        aReader->FatalError("Error deserializing 'domainLookupStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _domainLookupStart = *maybe___domainLookupStart;
    // Sentinel = 'domainLookupStart'
    if ((!((aReader)->ReadSentinel(1047070465)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'domainLookupStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___domainLookupEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___domainLookupEnd) {
        aReader->FatalError("Error deserializing 'domainLookupEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _domainLookupEnd = *maybe___domainLookupEnd;
    // Sentinel = 'domainLookupEnd'
    if ((!((aReader)->ReadSentinel(816317962)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'domainLookupEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___connectStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___connectStart) {
        aReader->FatalError("Error deserializing 'connectStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _connectStart = *maybe___connectStart;
    // Sentinel = 'connectStart'
    if ((!((aReader)->ReadSentinel(538838265)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'connectStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___secureConnectionStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___secureConnectionStart) {
        aReader->FatalError("Error deserializing 'secureConnectionStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _secureConnectionStart = *maybe___secureConnectionStart;
    // Sentinel = 'secureConnectionStart'
    if ((!((aReader)->ReadSentinel(1588725926)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'secureConnectionStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___connectEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___connectEnd) {
        aReader->FatalError("Error deserializing 'connectEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _connectEnd = *maybe___connectEnd;
    // Sentinel = 'connectEnd'
    if ((!((aReader)->ReadSentinel(376243202)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'connectEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___requestStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___requestStart) {
        aReader->FatalError("Error deserializing 'requestStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _requestStart = *maybe___requestStart;
    // Sentinel = 'requestStart'
    if ((!((aReader)->ReadSentinel(556860696)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'requestStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___responseStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___responseStart) {
        aReader->FatalError("Error deserializing 'responseStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _responseStart = *maybe___responseStart;
    // Sentinel = 'responseStart'
    if ((!((aReader)->ReadSentinel(648545662)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'responseStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___cacheReadStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___cacheReadStart) {
        aReader->FatalError("Error deserializing 'cacheReadStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _cacheReadStart = *maybe___cacheReadStart;
    // Sentinel = 'cacheReadStart'
    if ((!((aReader)->ReadSentinel(677774719)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheReadStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___responseEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___responseEnd) {
        aReader->FatalError("Error deserializing 'responseEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _responseEnd = *maybe___responseEnd;
    // Sentinel = 'responseEnd'
    if ((!((aReader)->ReadSentinel(468518023)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'responseEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___cacheReadEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___cacheReadEnd) {
        aReader->FatalError("Error deserializing 'cacheReadEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _cacheReadEnd = *maybe___cacheReadEnd;
    // Sentinel = 'cacheReadEnd'
    if ((!((aReader)->ReadSentinel(497616008)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'cacheReadEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___workerStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___workerStart) {
        aReader->FatalError("Error deserializing 'workerStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _workerStart = *maybe___workerStart;
    // Sentinel = 'workerStart'
    if ((!((aReader)->ReadSentinel(472974505)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'workerStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___workerRequestStart = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___workerRequestStart) {
        aReader->FatalError("Error deserializing 'workerRequestStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _workerRequestStart = *maybe___workerRequestStart;
    // Sentinel = 'workerRequestStart'
    if ((!((aReader)->ReadSentinel(1210648466)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'workerRequestStart' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___workerResponseEnd = IPC::ReadParam<::mozilla::TimeStamp>(aReader);
    if (!maybe___workerResponseEnd) {
        aReader->FatalError("Error deserializing 'workerResponseEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _workerResponseEnd = *maybe___workerResponseEnd;
    // Sentinel = 'workerResponseEnd'
    if ((!((aReader)->ReadSentinel(1080755969)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'workerResponseEnd' (TimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___zeroTime = IPC::ReadParam<::DOMHighResTimeStamp>(aReader);
    if (!maybe___zeroTime) {
        aReader->FatalError("Error deserializing 'zeroTime' (DOMHighResTimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _zeroTime = *maybe___zeroTime;
    // Sentinel = 'zeroTime'
    if ((!((aReader)->ReadSentinel(255591248)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'zeroTime' (DOMHighResTimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___fetchStart = IPC::ReadParam<::DOMHighResTimeStamp>(aReader);
    if (!maybe___fetchStart) {
        aReader->FatalError("Error deserializing 'fetchStart' (DOMHighResTimeStamp) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _fetchStart = *maybe___fetchStart;
    // Sentinel = 'fetchStart'
    if ((!((aReader)->ReadSentinel(373425177)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'fetchStart' (DOMHighResTimeStamp) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___renderBlocking = IPC::ReadParam<bool>(aReader);
    if (!maybe___renderBlocking) {
        aReader->FatalError("Error deserializing 'renderBlocking' (bool) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _renderBlocking = *maybe___renderBlocking;
    // Sentinel = 'renderBlocking'
    if ((!((aReader)->ReadSentinel(713688490)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'renderBlocking' (bool) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___contentType = IPC::ReadParam<::nsString>(aReader);
    if (!maybe___contentType) {
        aReader->FatalError("Error deserializing 'contentType' (nsString) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _contentType = *maybe___contentType;
    // Sentinel = 'contentType'
    if ((!((aReader)->ReadSentinel(465241246)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'contentType' (nsString) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___allRedirectsSameOrigin = IPC::ReadParam<bool>(aReader);
    if (!maybe___allRedirectsSameOrigin) {
        aReader->FatalError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _allRedirectsSameOrigin = *maybe___allRedirectsSameOrigin;
    // Sentinel = 'allRedirectsSameOrigin'
    if ((!((aReader)->ReadSentinel(1689716941)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsSameOrigin' (bool) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___allRedirectsPassTAO = IPC::ReadParam<bool>(aReader);
    if (!maybe___allRedirectsPassTAO) {
        aReader->FatalError("Error deserializing 'allRedirectsPassTAO' (bool) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _allRedirectsPassTAO = *maybe___allRedirectsPassTAO;
    // Sentinel = 'allRedirectsPassTAO'
    if ((!((aReader)->ReadSentinel(1265174362)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'allRedirectsPassTAO' (bool) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___secureConnection = IPC::ReadParam<bool>(aReader);
    if (!maybe___secureConnection) {
        aReader->FatalError("Error deserializing 'secureConnection' (bool) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _secureConnection = *maybe___secureConnection;
    // Sentinel = 'secureConnection'
    if ((!((aReader)->ReadSentinel(936380056)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'secureConnection' (bool) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___bodyInfoAccessAllowed = IPC::ReadParam<::nsITimedChannel::BodyInfoAccess>(aReader);
    if (!maybe___bodyInfoAccessAllowed) {
        aReader->FatalError("Error deserializing 'bodyInfoAccessAllowed' (BodyInfoAccess) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _bodyInfoAccessAllowed = *maybe___bodyInfoAccessAllowed;
    // Sentinel = 'bodyInfoAccessAllowed'
    if ((!((aReader)->ReadSentinel(1526663253)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'bodyInfoAccessAllowed' (BodyInfoAccess) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___timingAllowed = IPC::ReadParam<bool>(aReader);
    if (!maybe___timingAllowed) {
        aReader->FatalError("Error deserializing 'timingAllowed' (bool) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _timingAllowed = *maybe___timingAllowed;
    // Sentinel = 'timingAllowed'
    if ((!((aReader)->ReadSentinel(628491601)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'timingAllowed' (bool) member of 'IPCPerformanceTimingData'");
        return {};
    }
    auto maybe___initialized = IPC::ReadParam<bool>(aReader);
    if (!maybe___initialized) {
        aReader->FatalError("Error deserializing 'initialized' (bool) member of 'IPCPerformanceTimingData'");
        return {};

    }
    auto& _initialized = *maybe___initialized;
    // Sentinel = 'initialized'
    if ((!((aReader)->ReadSentinel(464258199)))) {
        mozilla::ipc::SentinelReadError("Error deserializing 'initialized' (bool) member of 'IPCPerformanceTimingData'");
        return {};
    }
    IPC::ReadResult<paramType> result__{
            std::in_place,
            std::move(_serverTiming),
            std::move(_nextHopProtocol),
            std::move(_asyncOpen),
            std::move(_redirectStart),
            std::move(_redirectEnd),
            std::move(_domainLookupStart),
            std::move(_domainLookupEnd),
            std::move(_connectStart),
            std::move(_secureConnectionStart),
            std::move(_connectEnd),
            std::move(_requestStart),
            std::move(_responseStart),
            std::move(_cacheReadStart),
            std::move(_responseEnd),
            std::move(_cacheReadEnd),
            std::move(_workerStart),
            std::move(_workerRequestStart),
            std::move(_workerResponseEnd),
            std::move(_zeroTime),
            std::move(_fetchStart),
            ::uint64_t{0},
            ::uint64_t{0},
            ::uint64_t{0},
            ::uint16_t{0},
            ::uint8_t{0},
            std::move(_renderBlocking),
            std::move(_contentType),
            std::move(_allRedirectsSameOrigin),
            std::move(_allRedirectsPassTAO),
            std::move(_secureConnection),
            std::move(_bodyInfoAccessAllowed),
            std::move(_timingAllowed),
            std::move(_initialized)};
    if ((!((aReader)->ReadBytesInto((&((result__)->encodedBodySize())), 24)))) {
        aReader->FatalError("Error bulk reading fields from uint64_t");
        return {};
    }
    // Sentinel = 'encodedBodySize | transferSize | decodedBodySize'
    if ((!((aReader)->ReadSentinel(3272938085)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint64_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->responseStatus())), 2)))) {
        aReader->FatalError("Error bulk reading fields from uint16_t");
        return {};
    }
    // Sentinel = 'responseStatus'
    if ((!((aReader)->ReadSentinel(748750324)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint16_t");
        return {};
    }
    if ((!((aReader)->ReadBytesInto((&((result__)->redirectCount())), 1)))) {
        aReader->FatalError("Error bulk reading fields from uint8_t");
        return {};
    }
    // Sentinel = 'redirectCount'
    if ((!((aReader)->ReadSentinel(625608028)))) {
        mozilla::ipc::SentinelReadError("Error bulk reading fields from uint8_t");
        return {};
    }
    return result__;
}

} // namespace IPC
