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

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


#include "mozilla/dom/PVideoDecoderParent.h"

#include "mozilla/dom/PVideoDecoderManagerParent.h"

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

namespace mozilla {
namespace dom {


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

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

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

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

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

auto PVideoDecoderParent::SendInitComplete(
        const nsCString& decoderDescription,
        const bool& hardware,
        const nsCString& hardwareReason,
        const uint32_t& conversion) -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_InitComplete(Id());

    WriteIPDLParam(msg__, this, decoderDescription);
    // Sentinel = 'decoderDescription'
    (msg__)->WriteSentinel(3655557388);
    WriteIPDLParam(msg__, this, hardware);
    // Sentinel = 'hardware'
    (msg__)->WriteSentinel(2165251472);
    WriteIPDLParam(msg__, this, hardwareReason);
    // Sentinel = 'hardwareReason'
    (msg__)->WriteSentinel(360765986);
    WriteIPDLParam(msg__, this, conversion);
    // Sentinel = 'conversion'
    (msg__)->WriteSentinel(1292757922);




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

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

auto PVideoDecoderParent::SendInitFailed(const nsresult& reason) -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_InitFailed(Id());

    WriteIPDLParam(msg__, this, reason);
    // Sentinel = 'reason'
    (msg__)->WriteSentinel(4151390930);




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

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

auto PVideoDecoderParent::SendFlushComplete() -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_FlushComplete(Id());





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

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

auto PVideoDecoderParent::SendOutput(const VideoDataIPDL& data) -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_Output(Id());

    WriteIPDLParam(msg__, this, data);
    // Sentinel = 'data'
    (msg__)->WriteSentinel(843352540);




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

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

auto PVideoDecoderParent::SendInputExhausted() -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_InputExhausted(Id());





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

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

auto PVideoDecoderParent::SendDrainComplete() -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_DrainComplete(Id());





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

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

auto PVideoDecoderParent::SendError(const nsresult& error) -> bool
{
    IPC::Message* msg__ = PVideoDecoder::Msg_Error(Id());

    WriteIPDLParam(msg__, this, error);
    // Sentinel = 'error'
    (msg__)->WriteSentinel(313726327);




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

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

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

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

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

            return MsgProcessed;
        }
    case PVideoDecoder::Msg_Input__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
                mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Input", OTHER);

            PickleIterator iter__(msg__);
            MediaRawDataIPDL data;

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

            return MsgProcessed;
        }
    case PVideoDecoder::Msg_Flush__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
                mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Flush", OTHER);

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

            return MsgProcessed;
        }
    case PVideoDecoder::Msg_Drain__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
                mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Drain", OTHER);

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

            return MsgProcessed;
        }
    case PVideoDecoder::Msg_Shutdown__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
                mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Shutdown", OTHER);

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

            return MsgProcessed;
        }
    case PVideoDecoder::Msg_SetSeekThreshold__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
                mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVideoDecoder::Msg_SetSeekThreshold", OTHER);

            PickleIterator iter__(msg__);
            int64_t time;

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

            return MsgProcessed;
        }
    case PVideoDecoder::Msg___delete____ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
                mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PVideoDecoder::Msg___delete__", OTHER);

            PickleIterator iter__(msg__);
            PVideoDecoderParent* actor;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(actor)))))) {
                FatalError("Error deserializing 'PVideoDecoderParent'");
                return MsgValueError;
            }
            if ((!((*((&(actor))))))) {
                FatalError("Error deserializing 'PVideoDecoderParent'");
                return MsgValueError;
            }
            // Sentinel = 'actor'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'PVideoDecoderParent'");
                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(PVideoDecoderMsgStart, actor);

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

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

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

auto PVideoDecoderParent::GetProtocolTypeId() -> int32_t
{
    return PVideoDecoderMsgStart;
}

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

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

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

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



} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace ipc {
auto IPDLParamTraits<mozilla::dom::PVideoDecoderParent>::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::dom::PVideoDecoderParent>::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, "PVideoDecoder", PVideoDecoderMsgStart);
    if ((actor).isNothing()) {
        return false;
    }

    (*(aVar)) = static_cast<mozilla::dom::PVideoDecoderParent*>((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/dom/PVideoDecoderParent.h"
8
9		#include "mozilla/dom/PVideoDecoderManagerParent.h"
10
11		#include "nsIFile.h"
12		#include "GeckoProfiler.h"
13
14		namespace mozilla {
15		namespace dom {
16
17
18		auto PVideoDecoderParent::Recv__delete__() -> mozilla::ipc::IPCResult
19	0	{
20	0	return IPC_OK();
21	0	}
22
23		auto PVideoDecoderParent::ActorDestroy(ActorDestroyReason aWhy) -> void
24	0	{
25	0	}
26
27		MOZ_IMPLICIT PVideoDecoderParent::PVideoDecoderParent() :
28		mozilla::ipc::IProtocol(mozilla::ipc::ParentSide),
29		mLivenessState(mozilla::ipc::LivenessState::Dead)
30	0	{
31	0	MOZ_COUNT_CTOR(PVideoDecoderParent);
32	0	}
33
34		PVideoDecoderParent::~PVideoDecoderParent()
35	0	{
36	0	MOZ_COUNT_DTOR(PVideoDecoderParent);
37	0	}
38
39		auto PVideoDecoderParent::Manager() const -> PVideoDecoderManagerParent*
40	0	{
41	0	return static_cast<PVideoDecoderManagerParent*>(IProtocol::Manager());
42	0	}
43
44		auto PVideoDecoderParent::SendInitComplete(
45		const nsCString& decoderDescription,
46		const bool& hardware,
47		const nsCString& hardwareReason,
48		const uint32_t& conversion) -> bool
49	0	{
50	0	IPC::Message* msg__ = PVideoDecoder::Msg_InitComplete(Id());
51	0
52	0	WriteIPDLParam(msg__, this, decoderDescription);
53	0	// Sentinel = 'decoderDescription'
54	0	(msg__)->WriteSentinel(3655557388);
55	0	WriteIPDLParam(msg__, this, hardware);
56	0	// Sentinel = 'hardware'
57	0	(msg__)->WriteSentinel(2165251472);
58	0	WriteIPDLParam(msg__, this, hardwareReason);
59	0	// Sentinel = 'hardwareReason'
60	0	(msg__)->WriteSentinel(360765986);
61	0	WriteIPDLParam(msg__, this, conversion);
62	0	// Sentinel = 'conversion'
63	0	(msg__)->WriteSentinel(1292757922);
64	0
65	0
66	0
67	0
68	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
69	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
70	0	}
71	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_InitComplete", OTHER);
72	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
73	0	mozilla::ipc::LogicError("Transition error");
74	0	}
75	0
76	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
77	0	return sendok__;
78	0	}
79
80		auto PVideoDecoderParent::SendInitFailed(const nsresult& reason) -> bool
81	0	{
82	0	IPC::Message* msg__ = PVideoDecoder::Msg_InitFailed(Id());
83	0
84	0	WriteIPDLParam(msg__, this, reason);
85	0	// Sentinel = 'reason'
86	0	(msg__)->WriteSentinel(4151390930);
87	0
88	0
89	0
90	0
91	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
92	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
93	0	}
94	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_InitFailed", OTHER);
95	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
96	0	mozilla::ipc::LogicError("Transition error");
97	0	}
98	0
99	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
100	0	return sendok__;
101	0	}
102
103		auto PVideoDecoderParent::SendFlushComplete() -> bool
104	0	{
105	0	IPC::Message* msg__ = PVideoDecoder::Msg_FlushComplete(Id());
106	0
107	0
108	0
109	0
110	0
111	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
112	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
113	0	}
114	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_FlushComplete", OTHER);
115	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
116	0	mozilla::ipc::LogicError("Transition error");
117	0	}
118	0
119	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
120	0	return sendok__;
121	0	}
122
123		auto PVideoDecoderParent::SendOutput(const VideoDataIPDL& data) -> bool
124	0	{
125	0	IPC::Message* msg__ = PVideoDecoder::Msg_Output(Id());
126	0
127	0	WriteIPDLParam(msg__, this, data);
128	0	// Sentinel = 'data'
129	0	(msg__)->WriteSentinel(843352540);
130	0
131	0
132	0
133	0
134	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
135	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
136	0	}
137	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Output", OTHER);
138	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
139	0	mozilla::ipc::LogicError("Transition error");
140	0	}
141	0
142	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
143	0	return sendok__;
144	0	}
145
146		auto PVideoDecoderParent::SendInputExhausted() -> bool
147	0	{
148	0	IPC::Message* msg__ = PVideoDecoder::Msg_InputExhausted(Id());
149	0
150	0
151	0
152	0
153	0
154	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
155	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
156	0	}
157	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_InputExhausted", OTHER);
158	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
159	0	mozilla::ipc::LogicError("Transition error");
160	0	}
161	0
162	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
163	0	return sendok__;
164	0	}
165
166		auto PVideoDecoderParent::SendDrainComplete() -> bool
167	0	{
168	0	IPC::Message* msg__ = PVideoDecoder::Msg_DrainComplete(Id());
169	0
170	0
171	0
172	0
173	0
174	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
175	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
176	0	}
177	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_DrainComplete", OTHER);
178	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
179	0	mozilla::ipc::LogicError("Transition error");
180	0	}
181	0
182	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
183	0	return sendok__;
184	0	}
185
186		auto PVideoDecoderParent::SendError(const nsresult& error) -> bool
187	0	{
188	0	IPC::Message* msg__ = PVideoDecoder::Msg_Error(Id());
189	0
190	0	WriteIPDLParam(msg__, this, error);
191	0	// Sentinel = 'error'
192	0	(msg__)->WriteSentinel(313726327);
193	0
194	0
195	0
196	0
197	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
198	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
199	0	}
200	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Error", OTHER);
201	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
202	0	mozilla::ipc::LogicError("Transition error");
203	0	}
204	0
205	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
206	0	return sendok__;
207	0	}
208
209		auto PVideoDecoderParent::RemoveManagee(
210		int32_t aProtocolId,
211		IProtocol* aListener) -> void
212	0	{
213	0	FatalError("unreached");
214	0	return;
215	0	}
216
217		auto PVideoDecoderParent::OnMessageReceived(const Message& msg__) -> PVideoDecoderParent::Result
218	0	{
219	0	switch ((msg__).type()) {
220	0	case PVideoDecoder::Msg_Init__ID:
221	0	{
222	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
223	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
224	0	}
225	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Init", OTHER);
226	0
227	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
228	0	FatalError("Transition error");
229	0	return MsgValueError;
230	0	}
231	0	if ((!(RecvInit()))) {
232	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
233	0	// Error handled in mozilla::ipc::IPCResult
234	0	return MsgProcessingError;
235	0	}
236	0
237	0	return MsgProcessed;
238	0	}
239	0	case PVideoDecoder::Msg_Input__ID:
240	0	{
241	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
242	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
243	0	}
244	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Input", OTHER);
245	0
246	0	PickleIterator iter__(msg__);
247	0	MediaRawDataIPDL data;
248	0
249	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(data)))))) {
250	0	FatalError("Error deserializing 'MediaRawDataIPDL'");
251	0	return MsgValueError;
252	0	}
253	0	// Sentinel = 'data'
254	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 843352540)))) {
255	0	mozilla::ipc::SentinelReadError("Error deserializing 'MediaRawDataIPDL'");
256	0	return MsgValueError;
257	0	}
258	0	(msg__).EndRead(iter__, (msg__).type());
259	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
260	0	FatalError("Transition error");
261	0	return MsgValueError;
262	0	}
263	0	if ((!(RecvInput(data)))) {
264	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
265	0	// Error handled in mozilla::ipc::IPCResult
266	0	return MsgProcessingError;
267	0	}
268	0
269	0	return MsgProcessed;
270	0	}
271	0	case PVideoDecoder::Msg_Flush__ID:
272	0	{
273	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
274	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
275	0	}
276	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Flush", OTHER);
277	0
278	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
279	0	FatalError("Transition error");
280	0	return MsgValueError;
281	0	}
282	0	if ((!(RecvFlush()))) {
283	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
284	0	// Error handled in mozilla::ipc::IPCResult
285	0	return MsgProcessingError;
286	0	}
287	0
288	0	return MsgProcessed;
289	0	}
290	0	case PVideoDecoder::Msg_Drain__ID:
291	0	{
292	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
293	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
294	0	}
295	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Drain", OTHER);
296	0
297	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
298	0	FatalError("Transition error");
299	0	return MsgValueError;
300	0	}
301	0	if ((!(RecvDrain()))) {
302	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
303	0	// Error handled in mozilla::ipc::IPCResult
304	0	return MsgProcessingError;
305	0	}
306	0
307	0	return MsgProcessed;
308	0	}
309	0	case PVideoDecoder::Msg_Shutdown__ID:
310	0	{
311	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
312	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
313	0	}
314	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_Shutdown", OTHER);
315	0
316	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
317	0	FatalError("Transition error");
318	0	return MsgValueError;
319	0	}
320	0	if ((!(RecvShutdown()))) {
321	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
322	0	// Error handled in mozilla::ipc::IPCResult
323	0	return MsgProcessingError;
324	0	}
325	0
326	0	return MsgProcessed;
327	0	}
328	0	case PVideoDecoder::Msg_SetSeekThreshold__ID:
329	0	{
330	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
331	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
332	0	}
333	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg_SetSeekThreshold", OTHER);
334	0
335	0	PickleIterator iter__(msg__);
336	0	int64_t time;
337	0
338	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(time)))))) {
339	0	FatalError("Error deserializing 'int64_t'");
340	0	return MsgValueError;
341	0	}
342	0	// Sentinel = 'time'
343	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 4231890935)))) {
344	0	mozilla::ipc::SentinelReadError("Error deserializing 'int64_t'");
345	0	return MsgValueError;
346	0	}
347	0	(msg__).EndRead(iter__, (msg__).type());
348	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
349	0	FatalError("Transition error");
350	0	return MsgValueError;
351	0	}
352	0	if ((!(RecvSetSeekThreshold(time)))) {
353	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
354	0	// Error handled in mozilla::ipc::IPCResult
355	0	return MsgProcessingError;
356	0	}
357	0
358	0	return MsgProcessed;
359	0	}
360	0	case PVideoDecoder::Msg___delete____ID:
361	0	{
362	0	if (mozilla::ipc::LoggingEnabledFor("PVideoDecoderParent")) {
363	0	mozilla::ipc::LogMessageForProtocol("PVideoDecoderParent", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
364	0	}
365	0	AUTO_PROFILER_LABEL("PVideoDecoder::Msg___delete__", OTHER);
366	0
367	0	PickleIterator iter__(msg__);
368	0	PVideoDecoderParent* actor;
369	0
370	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(actor)))))) {
371	0	FatalError("Error deserializing 'PVideoDecoderParent'");
372	0	return MsgValueError;
373	0	}
374	0	if ((!((*((&(actor))))))) {
375	0	FatalError("Error deserializing 'PVideoDecoderParent'");
376	0	return MsgValueError;
377	0	}
378	0	// Sentinel = 'actor'
379	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 875202478)))) {
380	0	mozilla::ipc::SentinelReadError("Error deserializing 'PVideoDecoderParent'");
381	0	return MsgValueError;
382	0	}
383	0	(msg__).EndRead(iter__, (msg__).type());
384	0	if ((!(StateTransition(true, (&(mLivenessState)))))) {
385	0	FatalError("Transition error");
386	0	return MsgValueError;
387	0	}
388	0	if ((!(Recv__delete__()))) {
389	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
390	0	// Error handled in mozilla::ipc::IPCResult
391	0	return MsgProcessingError;
392	0	}
393	0
394	0
395	0	IProtocol* mgr = (actor)->Manager();
396	0	(actor)->DestroySubtree(Deletion);
397	0	(actor)->DeallocSubtree();
398	0	(mgr)->RemoveManagee(PVideoDecoderMsgStart, actor);
399	0
400	0	return MsgProcessed;
401	0	}
402	0	default:
403	0	{
404	0	return MsgNotKnown;
405	0	}
406	0	}
407	0	}
408
409		auto PVideoDecoderParent::OnMessageReceived(
410		const Message& msg__,
411		Message*& reply__) -> PVideoDecoderParent::Result
412	0	{
413	0	return MsgNotKnown;
414	0	}
415
416		auto PVideoDecoderParent::OnCallReceived(
417		const Message& msg__,
418		Message*& reply__) -> PVideoDecoderParent::Result
419	0	{
420	0	MOZ_ASSERT_UNREACHABLE("message protocol not supported");
421	0	return MsgNotKnown;
422	0	}
423
424		auto PVideoDecoderParent::GetProtocolTypeId() -> int32_t
425	0	{
426	0	return PVideoDecoderMsgStart;
427	0	}
428
429		auto PVideoDecoderParent::DestroySubtree(ActorDestroyReason why) -> void
430	0	{
431	0	// Unregister from our manager.
432	0	Unregister(Id());
433	0
434	0	// Reject owning pending responses.
435	0	(GetIPCChannel())->RejectPendingResponsesForActor(this);
436	0
437	0	// Finally, destroy "us".
438	0	ActorDestroy(why);
439	0	}
440
441		auto PVideoDecoderParent::DeallocSubtree() -> void
442	0	{
443	0	}
444
445
446
447		} // namespace dom
448		} // namespace mozilla
449		namespace mozilla {
450		namespace ipc {
451		auto IPDLParamTraits<mozilla::dom::PVideoDecoderParent>::Write(
452		IPC::Message* aMsg,
453		mozilla::ipc::IProtocol* aActor,
454		const paramType& aVar) -> void
455	0	{
456	0	int32_t id;
457	0	if ((!(aVar))) {
458	0	id = 0;
459	0	}
460	0	else {
461	0	id = (aVar)->Id();
462	0	if ((1) == (id)) {
463	0	(aActor)->FatalError("actor has been \|delete\|d");
464	0	}
465	0	}
466	0	WriteIPDLParam(aMsg, aActor, id);
467	0	}
468
469		auto IPDLParamTraits<mozilla::dom::PVideoDecoderParent>::Read(
470		const IPC::Message* aMsg,
471		PickleIterator* aIter,
472		mozilla::ipc::IProtocol* aActor,
473		paramType* aVar) -> bool
474	0	{
475	0	mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PVideoDecoder", PVideoDecoderMsgStart);
476	0	if ((actor).isNothing()) {
477	0	return false;
478	0	}
479	0
480	0	((aVar)) = static_cast<mozilla::dom::PVideoDecoderParent>((actor).value());
481	0	return true;
482	0	}
483
484		} // namespace ipc
485		} // namespace mozilla