/work/obj-fuzz/ipc/ipdl/PFTPChannelParent.cpp

Source (jump to first uncovered line)
//
// Automatically generated by ipdlc.
// Edit at your own risk
//


#include "mozilla/net/PFTPChannelParent.h"

#include "mozilla/net/PNeckoParent.h"

#include "nsIFile.h"
#include "GeckoProfiler.h"

namespace mozilla {
namespace net {


auto PFTPChannelParent::Recv__delete__() -> mozilla::ipc::IPCResult
{
    return IPC_OK();
}

auto PFTPChannelParent::ActorDestroy(ActorDestroyReason aWhy) -> void
{
}

MOZ_IMPLICIT PFTPChannelParent::PFTPChannelParent() :
    mozilla::ipc::IProtocol(mozilla::ipc::ParentSide),
    mLivenessState(mozilla::ipc::LivenessState::Dead)
{
    MOZ_COUNT_CTOR(PFTPChannelParent);
}

PFTPChannelParent::~PFTPChannelParent()
{
    MOZ_COUNT_DTOR(PFTPChannelParent);
}

auto PFTPChannelParent::Manager() const -> PNeckoParent*
{
    return static_cast<PNeckoParent*>(IProtocol::Manager());
}

auto PFTPChannelParent::SendOnStartRequest(
        const nsresult& aChannelStatus,
        const int64_t& aContentLength,
        const nsCString& aContentType,
        const PRTime& aLastModified,
        const nsCString& aEntityID,
        const URIParams& aURI) -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_OnStartRequest(Id());

    WriteIPDLParam(msg__, this, aChannelStatus);
    // Sentinel = 'aChannelStatus'
    (msg__)->WriteSentinel(1494802930);
    WriteIPDLParam(msg__, this, aContentLength);
    // Sentinel = 'aContentLength'
    (msg__)->WriteSentinel(773059686);
    WriteIPDLParam(msg__, this, aContentType);
    // Sentinel = 'aContentType'
    (msg__)->WriteSentinel(694407768);
    WriteIPDLParam(msg__, this, aLastModified);
    // Sentinel = 'aLastModified'
    (msg__)->WriteSentinel(3690958509);
    WriteIPDLParam(msg__, this, aEntityID);
    // Sentinel = 'aEntityID'
    (msg__)->WriteSentinel(2409181170);
    WriteIPDLParam(msg__, this, aURI);
    // Sentinel = 'aURI'
    (msg__)->WriteSentinel(2075506333);




    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_OnStartRequest", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::SendOnDataAvailable(
        const nsresult& channelStatus,
        const nsCString& data,
        const uint64_t& offset,
        const uint32_t& count) -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_OnDataAvailable(Id());

    WriteIPDLParam(msg__, this, channelStatus);
    // Sentinel = 'channelStatus'
    (msg__)->WriteSentinel(3148019746);
    WriteIPDLParam(msg__, this, data);
    // Sentinel = 'data'
    (msg__)->WriteSentinel(843352540);
    WriteIPDLParam(msg__, this, offset);
    // Sentinel = 'offset'
    (msg__)->WriteSentinel(1369947863);
    WriteIPDLParam(msg__, this, count);
    // Sentinel = 'count'
    (msg__)->WriteSentinel(2126421856);




    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_OnDataAvailable", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::SendOnStopRequest(
        const nsresult& channelStatus,
        const nsCString& aErrorMsg,
        const bool& aUseUTF8) -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_OnStopRequest(Id());

    WriteIPDLParam(msg__, this, channelStatus);
    // Sentinel = 'channelStatus'
    (msg__)->WriteSentinel(3148019746);
    WriteIPDLParam(msg__, this, aErrorMsg);
    // Sentinel = 'aErrorMsg'
    (msg__)->WriteSentinel(2060733517);
    WriteIPDLParam(msg__, this, aUseUTF8);
    // Sentinel = 'aUseUTF8'
    (msg__)->WriteSentinel(403508847);




    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_OnStopRequest", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::SendFailedAsyncOpen(const nsresult& statusCode) -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_FailedAsyncOpen(Id());

    WriteIPDLParam(msg__, this, statusCode);
    // Sentinel = 'statusCode'
    (msg__)->WriteSentinel(2709278591);




    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_FailedAsyncOpen", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::SendFlushedForDiversion() -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_FlushedForDiversion(Id());





    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_FlushedForDiversion", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::SendDivertMessages() -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_DivertMessages(Id());





    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertMessages", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::SendDeleteSelf() -> bool
{
    IPC::Message* msg__ = PFTPChannel::Msg_DeleteSelf(Id());





    if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
        mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PFTPChannel::Msg_DeleteSelf", OTHER);
    if ((!(StateTransition(false, (&(mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    return sendok__;
}

auto PFTPChannelParent::RemoveManagee(
        int32_t aProtocolId,
        IProtocol* aListener) -> void
{
    FatalError("unreached");
    return;
}

auto PFTPChannelParent::OnMessageReceived(const Message& msg__) -> PFTPChannelParent::Result
{
    switch ((msg__).type()) {
    case PFTPChannel::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg___delete__", OTHER);

            PickleIterator iter__(msg__);
            PFTPChannelParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(actor)))))) {
                FatalError("Error deserializing 'PFTPChannelParent'");
                return MsgValueError;
            }
            if ((!((*((&(actor))))))) {
                FatalError("Error deserializing 'PFTPChannelParent'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PFTPChannelParent'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(true, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(Recv__delete__()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }


            IProtocol* mgr = (actor)->Manager();
            (actor)->DestroySubtree(Deletion);
            (actor)->DeallocSubtree();
            (mgr)->RemoveManagee(PFTPChannelMsgStart, actor);

            return MsgProcessed;
        }
    case PFTPChannel::Msg_Cancel__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg_Cancel", OTHER);

            PickleIterator iter__(msg__);
            nsresult status;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(status)))))) {
                FatalError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            // Sentinel = 'status'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3714608576)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvCancel(status)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PFTPChannel::Msg_Suspend__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg_Suspend", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvSuspend()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PFTPChannel::Msg_Resume__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg_Resume", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvResume()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PFTPChannel::Msg_DivertOnDataAvailable__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertOnDataAvailable", OTHER);

            PickleIterator iter__(msg__);
            nsCString data;
            uint64_t offset;
            uint32_t count;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(data)))))) {
                FatalError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            // Sentinel = 'data'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 843352540)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(offset)))))) {
                FatalError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            // Sentinel = 'offset'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1369947863)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(count)))))) {
                FatalError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            // Sentinel = 'count'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2126421856)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDivertOnDataAvailable(data, offset, count)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PFTPChannel::Msg_DivertOnStopRequest__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertOnStopRequest", OTHER);

            PickleIterator iter__(msg__);
            nsresult statusCode;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(statusCode)))))) {
                FatalError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            // Sentinel = 'statusCode'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2709278591)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDivertOnStopRequest(statusCode)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PFTPChannel::Msg_DivertComplete__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
                mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertComplete", OTHER);

            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvDivertComplete()))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

auto PFTPChannelParent::OnMessageReceived(
        const Message& msg__,
        Message*& reply__) -> PFTPChannelParent::Result
{
    return MsgNotKnown;
}

auto PFTPChannelParent::OnCallReceived(
        const Message& msg__,
        Message*& reply__) -> PFTPChannelParent::Result
{
    MOZ_ASSERT_UNREACHABLE("message protocol not supported");
    return MsgNotKnown;
}

auto PFTPChannelParent::GetProtocolTypeId() -> int32_t
{
    return PFTPChannelMsgStart;
}

auto PFTPChannelParent::DestroySubtree(ActorDestroyReason why) -> void
{
    // Unregister from our manager.
    Unregister(Id());

    // Reject owning pending responses.
    (GetIPCChannel())->RejectPendingResponsesForActor(this);

    // Finally, destroy "us".
    ActorDestroy(why);
}

auto PFTPChannelParent::DeallocSubtree() -> void
{
}



} // namespace net
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::net::PFTPChannelParent>::Write(
        IPC::Message* aMsg,
        mozilla::ipc::IProtocol* aActor,
        const paramType& aVar) -> void
{
    int32_t id;
    if ((!(aVar))) {
        id = 0;
    }
    else {
        id = (aVar)->Id();
        if ((1) == (id)) {
            (aActor)->FatalError("actor has been |delete|d");
        }
    }
    WriteIPDLParam(aMsg, aActor, id);
}

auto IPDLParamTraits<mozilla::net::PFTPChannelParent>::Read(
        const IPC::Message* aMsg,
        PickleIterator* aIter,
        mozilla::ipc::IProtocol* aActor,
        paramType* aVar) -> bool
{
    mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PFTPChannel", PFTPChannelMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(aVar)) = static_cast<mozilla::net::PFTPChannelParent*>((actor).value());
    return true;
}

} // namespace ipc
} // namespace mozilla

Coverage Report

Created: 2018-09-25 14:53

Line	Count	Source (jump to first uncovered line)
1		//
2		// Automatically generated by ipdlc.
3		// Edit at your own risk
4		//
5
6
7		#include "mozilla/net/PFTPChannelParent.h"
8
9		#include "mozilla/net/PNeckoParent.h"
10
11		#include "nsIFile.h"
12		#include "GeckoProfiler.h"
13
14		namespace mozilla {
15		namespace net {
16
17
18		auto PFTPChannelParent::Recv__delete__() -> mozilla::ipc::IPCResult
19	0	{
20	0	return IPC_OK();
21	0	}
22
23		auto PFTPChannelParent::ActorDestroy(ActorDestroyReason aWhy) -> void
24	0	{
25	0	}
26
27		MOZ_IMPLICIT PFTPChannelParent::PFTPChannelParent() :
28		mozilla::ipc::IProtocol(mozilla::ipc::ParentSide),
29		mLivenessState(mozilla::ipc::LivenessState::Dead)
30	0	{
31	0	MOZ_COUNT_CTOR(PFTPChannelParent);
32	0	}
33
34		PFTPChannelParent::~PFTPChannelParent()
35	0	{
36	0	MOZ_COUNT_DTOR(PFTPChannelParent);
37	0	}
38
39		auto PFTPChannelParent::Manager() const -> PNeckoParent*
40	0	{
41	0	return static_cast<PNeckoParent*>(IProtocol::Manager());
42	0	}
43
44		auto PFTPChannelParent::SendOnStartRequest(
45		const nsresult& aChannelStatus,
46		const int64_t& aContentLength,
47		const nsCString& aContentType,
48		const PRTime& aLastModified,
49		const nsCString& aEntityID,
50		const URIParams& aURI) -> bool
51	0	{
52	0	IPC::Message* msg__ = PFTPChannel::Msg_OnStartRequest(Id());
53	0
54	0	WriteIPDLParam(msg__, this, aChannelStatus);
55	0	// Sentinel = 'aChannelStatus'
56	0	(msg__)->WriteSentinel(1494802930);
57	0	WriteIPDLParam(msg__, this, aContentLength);
58	0	// Sentinel = 'aContentLength'
59	0	(msg__)->WriteSentinel(773059686);
60	0	WriteIPDLParam(msg__, this, aContentType);
61	0	// Sentinel = 'aContentType'
62	0	(msg__)->WriteSentinel(694407768);
63	0	WriteIPDLParam(msg__, this, aLastModified);
64	0	// Sentinel = 'aLastModified'
65	0	(msg__)->WriteSentinel(3690958509);
66	0	WriteIPDLParam(msg__, this, aEntityID);
67	0	// Sentinel = 'aEntityID'
68	0	(msg__)->WriteSentinel(2409181170);
69	0	WriteIPDLParam(msg__, this, aURI);
70	0	// Sentinel = 'aURI'
71	0	(msg__)->WriteSentinel(2075506333);
72	0
73	0
74	0
75	0
76	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
77	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
78	0	}
79	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_OnStartRequest", OTHER);
80	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
81	0	mozilla::ipc::LogicError("Transition error");
82	0	}
83	0
84	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
85	0	return sendok__;
86	0	}
87
88		auto PFTPChannelParent::SendOnDataAvailable(
89		const nsresult& channelStatus,
90		const nsCString& data,
91		const uint64_t& offset,
92		const uint32_t& count) -> bool
93	0	{
94	0	IPC::Message* msg__ = PFTPChannel::Msg_OnDataAvailable(Id());
95	0
96	0	WriteIPDLParam(msg__, this, channelStatus);
97	0	// Sentinel = 'channelStatus'
98	0	(msg__)->WriteSentinel(3148019746);
99	0	WriteIPDLParam(msg__, this, data);
100	0	// Sentinel = 'data'
101	0	(msg__)->WriteSentinel(843352540);
102	0	WriteIPDLParam(msg__, this, offset);
103	0	// Sentinel = 'offset'
104	0	(msg__)->WriteSentinel(1369947863);
105	0	WriteIPDLParam(msg__, this, count);
106	0	// Sentinel = 'count'
107	0	(msg__)->WriteSentinel(2126421856);
108	0
109	0
110	0
111	0
112	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
113	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
114	0	}
115	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_OnDataAvailable", OTHER);
116	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
117	0	mozilla::ipc::LogicError("Transition error");
118	0	}
119	0
120	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
121	0	return sendok__;
122	0	}
123
124		auto PFTPChannelParent::SendOnStopRequest(
125		const nsresult& channelStatus,
126		const nsCString& aErrorMsg,
127		const bool& aUseUTF8) -> bool
128	0	{
129	0	IPC::Message* msg__ = PFTPChannel::Msg_OnStopRequest(Id());
130	0
131	0	WriteIPDLParam(msg__, this, channelStatus);
132	0	// Sentinel = 'channelStatus'
133	0	(msg__)->WriteSentinel(3148019746);
134	0	WriteIPDLParam(msg__, this, aErrorMsg);
135	0	// Sentinel = 'aErrorMsg'
136	0	(msg__)->WriteSentinel(2060733517);
137	0	WriteIPDLParam(msg__, this, aUseUTF8);
138	0	// Sentinel = 'aUseUTF8'
139	0	(msg__)->WriteSentinel(403508847);
140	0
141	0
142	0
143	0
144	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
145	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
146	0	}
147	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_OnStopRequest", OTHER);
148	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
149	0	mozilla::ipc::LogicError("Transition error");
150	0	}
151	0
152	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
153	0	return sendok__;
154	0	}
155
156		auto PFTPChannelParent::SendFailedAsyncOpen(const nsresult& statusCode) -> bool
157	0	{
158	0	IPC::Message* msg__ = PFTPChannel::Msg_FailedAsyncOpen(Id());
159	0
160	0	WriteIPDLParam(msg__, this, statusCode);
161	0	// Sentinel = 'statusCode'
162	0	(msg__)->WriteSentinel(2709278591);
163	0
164	0
165	0
166	0
167	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
168	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
169	0	}
170	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_FailedAsyncOpen", OTHER);
171	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
172	0	mozilla::ipc::LogicError("Transition error");
173	0	}
174	0
175	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
176	0	return sendok__;
177	0	}
178
179		auto PFTPChannelParent::SendFlushedForDiversion() -> bool
180	0	{
181	0	IPC::Message* msg__ = PFTPChannel::Msg_FlushedForDiversion(Id());
182	0
183	0
184	0
185	0
186	0
187	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
188	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
189	0	}
190	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_FlushedForDiversion", OTHER);
191	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
192	0	mozilla::ipc::LogicError("Transition error");
193	0	}
194	0
195	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
196	0	return sendok__;
197	0	}
198
199		auto PFTPChannelParent::SendDivertMessages() -> bool
200	0	{
201	0	IPC::Message* msg__ = PFTPChannel::Msg_DivertMessages(Id());
202	0
203	0
204	0
205	0
206	0
207	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
208	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
209	0	}
210	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertMessages", OTHER);
211	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
212	0	mozilla::ipc::LogicError("Transition error");
213	0	}
214	0
215	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
216	0	return sendok__;
217	0	}
218
219		auto PFTPChannelParent::SendDeleteSelf() -> bool
220	0	{
221	0	IPC::Message* msg__ = PFTPChannel::Msg_DeleteSelf(Id());
222	0
223	0
224	0
225	0
226	0
227	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
228	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
229	0	}
230	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_DeleteSelf", OTHER);
231	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
232	0	mozilla::ipc::LogicError("Transition error");
233	0	}
234	0
235	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
236	0	return sendok__;
237	0	}
238
239		auto PFTPChannelParent::RemoveManagee(
240		int32_t aProtocolId,
241		IProtocol* aListener) -> void
242	0	{
243	0	FatalError("unreached");
244	0	return;
245	0	}
246
247		auto PFTPChannelParent::OnMessageReceived(const Message& msg__) -> PFTPChannelParent::Result
248	0	{
249	0	switch ((msg__).type()) {
250	0	case PFTPChannel::Msg___delete____ID:
251	0	{
252	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
253	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
254	0	}
255	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg___delete__", OTHER);
256	0
257	0	PickleIterator iter__(msg__);
258	0	PFTPChannelParent* actor;
259	0
260	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(actor)))))) {
261	0	FatalError("Error deserializing 'PFTPChannelParent'");
262	0	return MsgValueError;
263	0	}
264	0	if ((!((*((&(actor))))))) {
265	0	FatalError("Error deserializing 'PFTPChannelParent'");
266	0	return MsgValueError;
267	0	}
268	0	// Sentinel = 'actor'
269	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
270	0	mozilla::ipc::SentinelReadError("Error deserializing 'PFTPChannelParent'");
271	0	return MsgValueError;
272	0	}
273	0	(msg__).EndRead(iter__, (msg__).type());
274	0	if ((!(StateTransition(true, (&(mLivenessState)))))) {
275	0	FatalError("Transition error");
276	0	return MsgValueError;
277	0	}
278	0	if ((!(Recv__delete__()))) {
279	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
280	0	// Error handled in mozilla::ipc::IPCResult
281	0	return MsgProcessingError;
282	0	}
283	0
284	0
285	0	IProtocol* mgr = (actor)->Manager();
286	0	(actor)->DestroySubtree(Deletion);
287	0	(actor)->DeallocSubtree();
288	0	(mgr)->RemoveManagee(PFTPChannelMsgStart, actor);
289	0
290	0	return MsgProcessed;
291	0	}
292	0	case PFTPChannel::Msg_Cancel__ID:
293	0	{
294	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
295	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
296	0	}
297	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_Cancel", OTHER);
298	0
299	0	PickleIterator iter__(msg__);
300	0	nsresult status;
301	0
302	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(status)))))) {
303	0	FatalError("Error deserializing 'nsresult'");
304	0	return MsgValueError;
305	0	}
306	0	// Sentinel = 'status'
307	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3714608576)))) {
308	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
309	0	return MsgValueError;
310	0	}
311	0	(msg__).EndRead(iter__, (msg__).type());
312	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
313	0	FatalError("Transition error");
314	0	return MsgValueError;
315	0	}
316	0	if ((!(RecvCancel(status)))) {
317	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
318	0	// Error handled in mozilla::ipc::IPCResult
319	0	return MsgProcessingError;
320	0	}
321	0
322	0	return MsgProcessed;
323	0	}
324	0	case PFTPChannel::Msg_Suspend__ID:
325	0	{
326	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
327	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
328	0	}
329	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_Suspend", OTHER);
330	0
331	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
332	0	FatalError("Transition error");
333	0	return MsgValueError;
334	0	}
335	0	if ((!(RecvSuspend()))) {
336	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
337	0	// Error handled in mozilla::ipc::IPCResult
338	0	return MsgProcessingError;
339	0	}
340	0
341	0	return MsgProcessed;
342	0	}
343	0	case PFTPChannel::Msg_Resume__ID:
344	0	{
345	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
346	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
347	0	}
348	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_Resume", OTHER);
349	0
350	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
351	0	FatalError("Transition error");
352	0	return MsgValueError;
353	0	}
354	0	if ((!(RecvResume()))) {
355	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
356	0	// Error handled in mozilla::ipc::IPCResult
357	0	return MsgProcessingError;
358	0	}
359	0
360	0	return MsgProcessed;
361	0	}
362	0	case PFTPChannel::Msg_DivertOnDataAvailable__ID:
363	0	{
364	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
365	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
366	0	}
367	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertOnDataAvailable", OTHER);
368	0
369	0	PickleIterator iter__(msg__);
370	0	nsCString data;
371	0	uint64_t offset;
372	0	uint32_t count;
373	0
374	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(data)))))) {
375	0	FatalError("Error deserializing 'nsCString'");
376	0	return MsgValueError;
377	0	}
378	0	// Sentinel = 'data'
379	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 843352540)))) {
380	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
381	0	return MsgValueError;
382	0	}
383	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(offset)))))) {
384	0	FatalError("Error deserializing 'uint64_t'");
385	0	return MsgValueError;
386	0	}
387	0	// Sentinel = 'offset'
388	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1369947863)))) {
389	0	mozilla::ipc::SentinelReadError("Error deserializing 'uint64_t'");
390	0	return MsgValueError;
391	0	}
392	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(count)))))) {
393	0	FatalError("Error deserializing 'uint32_t'");
394	0	return MsgValueError;
395	0	}
396	0	// Sentinel = 'count'
397	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2126421856)))) {
398	0	mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
399	0	return MsgValueError;
400	0	}
401	0	(msg__).EndRead(iter__, (msg__).type());
402	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
403	0	FatalError("Transition error");
404	0	return MsgValueError;
405	0	}
406	0	if ((!(RecvDivertOnDataAvailable(data, offset, count)))) {
407	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
408	0	// Error handled in mozilla::ipc::IPCResult
409	0	return MsgProcessingError;
410	0	}
411	0
412	0	return MsgProcessed;
413	0	}
414	0	case PFTPChannel::Msg_DivertOnStopRequest__ID:
415	0	{
416	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
417	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
418	0	}
419	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertOnStopRequest", OTHER);
420	0
421	0	PickleIterator iter__(msg__);
422	0	nsresult statusCode;
423	0
424	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(statusCode)))))) {
425	0	FatalError("Error deserializing 'nsresult'");
426	0	return MsgValueError;
427	0	}
428	0	// Sentinel = 'statusCode'
429	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2709278591)))) {
430	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsresult'");
431	0	return MsgValueError;
432	0	}
433	0	(msg__).EndRead(iter__, (msg__).type());
434	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
435	0	FatalError("Transition error");
436	0	return MsgValueError;
437	0	}
438	0	if ((!(RecvDivertOnStopRequest(statusCode)))) {
439	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
440	0	// Error handled in mozilla::ipc::IPCResult
441	0	return MsgProcessingError;
442	0	}
443	0
444	0	return MsgProcessed;
445	0	}
446	0	case PFTPChannel::Msg_DivertComplete__ID:
447	0	{
448	0	if (mozilla::ipc::LoggingEnabledFor("PFTPChannelParent")) {
449	0	mozilla::ipc::LogMessageForProtocol("PFTPChannelParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
450	0	}
451	0	AUTO_PROFILER_LABEL("PFTPChannel::Msg_DivertComplete", OTHER);
452	0
453	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
454	0	FatalError("Transition error");
455	0	return MsgValueError;
456	0	}
457	0	if ((!(RecvDivertComplete()))) {
458	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
459	0	// Error handled in mozilla::ipc::IPCResult
460	0	return MsgProcessingError;
461	0	}
462	0
463	0	return MsgProcessed;
464	0	}
465	0	default:
466	0	{
467	0	return MsgNotKnown;
468	0	}
469	0	}
470	0	}
471
472		auto PFTPChannelParent::OnMessageReceived(
473		const Message& msg__,
474		Message*& reply__) -> PFTPChannelParent::Result
475	0	{
476	0	return MsgNotKnown;
477	0	}
478
479		auto PFTPChannelParent::OnCallReceived(
480		const Message& msg__,
481		Message*& reply__) -> PFTPChannelParent::Result
482	0	{
483	0	MOZ_ASSERT_UNREACHABLE("message protocol not supported");
484	0	return MsgNotKnown;
485	0	}
486
487		auto PFTPChannelParent::GetProtocolTypeId() -> int32_t
488	0	{
489	0	return PFTPChannelMsgStart;
490	0	}
491
492		auto PFTPChannelParent::DestroySubtree(ActorDestroyReason why) -> void
493	0	{
494	0	// Unregister from our manager.
495	0	Unregister(Id());
496	0
497	0	// Reject owning pending responses.
498	0	(GetIPCChannel())->RejectPendingResponsesForActor(this);
499	0
500	0	// Finally, destroy "us".
501	0	ActorDestroy(why);
502	0	}
503
504		auto PFTPChannelParent::DeallocSubtree() -> void
505	0	{
506	0	}
507
508
509
510		} // namespace net
511		} // namespace mozilla
512		namespace mozilla {
513		namespace ipc {
514		auto IPDLParamTraits<mozilla::net::PFTPChannelParent>::Write(
515		IPC::Message* aMsg,
516		mozilla::ipc::IProtocol* aActor,
517		const paramType& aVar) -> void
518	0	{
519	0	int32_t id;
520	0	if ((!(aVar))) {
521	0	id = 0;
522	0	}
523	0	else {
524	0	id = (aVar)->Id();
525	0	if ((1) == (id)) {
526	0	(aActor)->FatalError("actor has been \|delete\|d");
527	0	}
528	0	}
529	0	WriteIPDLParam(aMsg, aActor, id);
530	0	}
531
532		auto IPDLParamTraits<mozilla::net::PFTPChannelParent>::Read(
533		const IPC::Message* aMsg,
534		PickleIterator* aIter,
535		mozilla::ipc::IProtocol* aActor,
536		paramType* aVar) -> bool
537	0	{
538	0	mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PFTPChannel", PFTPChannelMsgStart);
539	0	if ((actor).isNothing()) {
540	0	return false;
541	0	}
542	0
543	0	((aVar)) = static_cast<mozilla::net::PFTPChannelParent>((actor).value());
544	0	return true;
545	0	}
546
547		} // namespace ipc
548		} // namespace mozilla