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

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


#include "mozilla/dom/PSpeechSynthesisChild.h"

#include "mozilla/dom/PContentChild.h"
#include "mozilla/dom/PSpeechSynthesisRequestChild.h"

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

namespace mozilla {
namespace dom {


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

MOZ_IMPLICIT PSpeechSynthesisChild::PSpeechSynthesisChild() :
    mozilla::ipc::IProtocol(mozilla::ipc::ChildSide),
    mLivenessState(mozilla::ipc::LivenessState::Dead)
{
    MOZ_COUNT_CTOR(PSpeechSynthesisChild);
}

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

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

auto PSpeechSynthesisChild::ManagedPSpeechSynthesisRequestChild(nsTArray<PSpeechSynthesisRequestChild*>& aArr) const -> void
{
    (mManagedPSpeechSynthesisRequestChild).ToArray(aArr);
}

auto PSpeechSynthesisChild::ManagedPSpeechSynthesisRequestChild() const -> const ManagedContainer<PSpeechSynthesisRequestChild>&
{
    return mManagedPSpeechSynthesisRequestChild;
}

auto PSpeechSynthesisChild::Send__delete__(PSpeechSynthesisChild* actor) -> bool
{
    if ((!(actor))) {
        return false;
    }

    IPC::Message* msg__ = PSpeechSynthesis::Msg___delete__((actor)->Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, actor, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);



    if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
        mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", (actor)->OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
    }
    AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg___delete__", OTHER);
    if ((!(StateTransition(true, (&((actor)->mLivenessState)))))) {
        mozilla::ipc::LogicError("Transition error");
    }

    bool sendok__ = ((actor)->GetIPCChannel())->Send(msg__);

    IProtocol* mgr = (actor)->Manager();
    (actor)->DestroySubtree(Deletion);
    (actor)->DeallocSubtree();
    (mgr)->RemoveManagee(PSpeechSynthesisMsgStart, actor);
    return sendok__;
}

auto PSpeechSynthesisChild::SendPSpeechSynthesisRequestConstructor(
        const nsString& aText,
        const nsString& aUri,
        const nsString& aLang,
        const float& aVolume,
        const float& aRate,
        const float& aPitch,
        const bool& aIsChrome) -> PSpeechSynthesisRequestChild*
{
    return SendPSpeechSynthesisRequestConstructor(AllocPSpeechSynthesisRequestChild(aText, aUri, aLang, aVolume, aRate, aPitch, aIsChrome), aText, aUri, aLang, aVolume, aRate, aPitch, aIsChrome);
}

auto PSpeechSynthesisChild::SendPSpeechSynthesisRequestConstructor(
        PSpeechSynthesisRequestChild* actor,
        const nsString& aText,
        const nsString& aUri,
        const nsString& aLang,
        const float& aVolume,
        const float& aRate,
        const float& aPitch,
        const bool& aIsChrome) -> PSpeechSynthesisRequestChild*
{
    if ((!(actor))) {
        NS_WARNING("Error constructing actor PSpeechSynthesisRequestChild");
        return nullptr;
    }
    (actor)->SetManagerAndRegister(this);
    (mManagedPSpeechSynthesisRequestChild).PutEntry(actor);
    (actor)->mLivenessState = mozilla::ipc::LivenessState::Start;

    IPC::Message* msg__ = PSpeechSynthesis::Msg_PSpeechSynthesisRequestConstructor(Id());

    MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
    WriteIPDLParam(msg__, this, actor);
    // Sentinel = 'actor'
    (msg__)->WriteSentinel(875202478);
    WriteIPDLParam(msg__, this, aText);
    // Sentinel = 'aText'
    (msg__)->WriteSentinel(711388569);
    WriteIPDLParam(msg__, this, aUri);
    // Sentinel = 'aUri'
    (msg__)->WriteSentinel(2043506205);
    WriteIPDLParam(msg__, this, aLang);
    // Sentinel = 'aLang'
    (msg__)->WriteSentinel(2802955996);
    WriteIPDLParam(msg__, this, aVolume);
    // Sentinel = 'aVolume'
    (msg__)->WriteSentinel(3908369896);
    WriteIPDLParam(msg__, this, aRate);
    // Sentinel = 'aRate'
    (msg__)->WriteSentinel(3944748486);
    WriteIPDLParam(msg__, this, aPitch);
    // Sentinel = 'aPitch'
    (msg__)->WriteSentinel(1564848579);
    WriteIPDLParam(msg__, this, aIsChrome);
    // Sentinel = 'aIsChrome'
    (msg__)->WriteSentinel(2206250586);



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

    bool sendok__ = (GetIPCChannel())->Send(msg__);
    if ((!(sendok__))) {
        FatalError("constructor for actor failed");
        return nullptr;
    }
    return actor;
}

auto PSpeechSynthesisChild::RemoveManagee(
        int32_t aProtocolId,
        IProtocol* aListener) -> void
{
    switch (aProtocolId) {
    case PSpeechSynthesisRequestMsgStart:
        {
            PSpeechSynthesisRequestChild* actor = static_cast<PSpeechSynthesisRequestChild*>(aListener);
            auto& container = mManagedPSpeechSynthesisRequestChild;
            MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");

            (container).RemoveEntry(actor);
            DeallocPSpeechSynthesisRequestChild(actor);
            return;
        }
    default:
        {
            FatalError("unreached");
            return;
        }
    }
}

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

            PickleIterator iter__(msg__);
            RemoteVoice aVoice;

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

            return MsgProcessed;
        }
    case PSpeechSynthesis::Msg_VoiceRemoved__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
                mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_VoiceRemoved", OTHER);

            PickleIterator iter__(msg__);
            nsString aUri;

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

            return MsgProcessed;
        }
    case PSpeechSynthesis::Msg_SetDefaultVoice__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
                mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_SetDefaultVoice", OTHER);

            PickleIterator iter__(msg__);
            nsString aUri;
            bool aIsDefault;

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

            return MsgProcessed;
        }
    case PSpeechSynthesis::Msg_IsSpeakingChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
                mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_IsSpeakingChanged", OTHER);

            PickleIterator iter__(msg__);
            bool aIsSpeaking;

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

            return MsgProcessed;
        }
    case PSpeechSynthesis::Msg_NotifyVoicesChanged__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
                mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_NotifyVoicesChanged", OTHER);

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

            return MsgProcessed;
        }
    case PSpeechSynthesis::Msg_InitialVoicesAndState__ID:
        {
            if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
                mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
            }
            AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_InitialVoicesAndState", OTHER);

            PickleIterator iter__(msg__);
            nsTArray<RemoteVoice> aVoices;
            nsTArray<nsString> aDefaults;
            bool aIsSpeaking;

            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aVoices)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aVoices'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1351181827)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDefaults)))))) {
                FatalError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            // Sentinel = 'aDefaults'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2428457646)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
                return MsgValueError;
            }
            if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsSpeaking)))))) {
                FatalError("Error deserializing 'bool'");
                return MsgValueError;
            }
            // Sentinel = 'aIsSpeaking'
            if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1494791872)))) {
                mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
                return MsgValueError;
            }
            (msg__).EndRead(iter__, (msg__).type());
            if ((!(StateTransition(false, (&(mLivenessState)))))) {
                FatalError("Transition error");
                return MsgValueError;
            }
            if ((!(RecvInitialVoicesAndState(std::move(aVoices), std::move(aDefaults), aIsSpeaking)))) {
                mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
                // Error handled in mozilla::ipc::IPCResult
                return MsgProcessingError;
            }

            return MsgProcessed;
        }
    case PSpeechSynthesis::Reply___delete____ID:
        {
            return MsgProcessed;
        }
    case PSpeechSynthesis::Reply_PSpeechSynthesisRequestConstructor__ID:
        {
            return MsgProcessed;
        }
    default:
        {
            return MsgNotKnown;
        }
    }
}

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

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

auto PSpeechSynthesisChild::GetProtocolTypeId() -> int32_t
{
    return PSpeechSynthesisMsgStart;
}

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

    ActorDestroyReason subtreewhy = (((why) == (Deletion)) || ((why) == (FailedConstructor)) ? AncestorDeletion : why);

    {
        // Recursively shutting down PSpeechSynthesisRequest kids
        nsTArray<PSpeechSynthesisRequestChild*> kids;
        // Accumulate kids into a stable structure to iterate over
        ManagedPSpeechSynthesisRequestChild(kids);
        for (auto& kid : kids) {
            // Guarding against a child removing a sibling from the list during the iteration.
            if ((mManagedPSpeechSynthesisRequestChild).Contains(kid)) {
                (kid)->DestroySubtree(subtreewhy);
            }
        }
    }

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

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

auto PSpeechSynthesisChild::DeallocSubtree() -> void
{
    {
        // Recursively deleting PSpeechSynthesisRequest kids
        for (auto iter = (mManagedPSpeechSynthesisRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            (((iter).Get())->GetKey())->DeallocSubtree();
        }

        for (auto iter = (mManagedPSpeechSynthesisRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
            DeallocPSpeechSynthesisRequestChild(((iter).Get())->GetKey());
        }
        (mManagedPSpeechSynthesisRequestChild).Clear();
    }
}



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

    (*(aVar)) = static_cast<mozilla::dom::PSpeechSynthesisChild*>((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/PSpeechSynthesisChild.h"
8
9		#include "mozilla/dom/PContentChild.h"
10		#include "mozilla/dom/PSpeechSynthesisRequestChild.h"
11
12		#include "nsIFile.h"
13		#include "GeckoProfiler.h"
14
15		namespace mozilla {
16		namespace dom {
17
18
19		auto PSpeechSynthesisChild::ActorDestroy(ActorDestroyReason aWhy) -> void
20	0	{
21	0	}
22
23		MOZ_IMPLICIT PSpeechSynthesisChild::PSpeechSynthesisChild() :
24		mozilla::ipc::IProtocol(mozilla::ipc::ChildSide),
25		mLivenessState(mozilla::ipc::LivenessState::Dead)
26	0	{
27	0	MOZ_COUNT_CTOR(PSpeechSynthesisChild);
28	0	}
29
30		PSpeechSynthesisChild::~PSpeechSynthesisChild()
31	0	{
32	0	MOZ_COUNT_DTOR(PSpeechSynthesisChild);
33	0	}
34
35		auto PSpeechSynthesisChild::Manager() const -> PContentChild*
36	0	{
37	0	return static_cast<PContentChild*>(IProtocol::Manager());
38	0	}
39
40		auto PSpeechSynthesisChild::ManagedPSpeechSynthesisRequestChild(nsTArray<PSpeechSynthesisRequestChild*>& aArr) const -> void
41	0	{
42	0	(mManagedPSpeechSynthesisRequestChild).ToArray(aArr);
43	0	}
44
45		auto PSpeechSynthesisChild::ManagedPSpeechSynthesisRequestChild() const -> const ManagedContainer<PSpeechSynthesisRequestChild>&
46	0	{
47	0	return mManagedPSpeechSynthesisRequestChild;
48	0	}
49
50		auto PSpeechSynthesisChild::Send__delete__(PSpeechSynthesisChild* actor) -> bool
51	0	{
52	0	if ((!(actor))) {
53	0	return false;
54	0	}
55	0
56	0	IPC::Message* msg__ = PSpeechSynthesis::Msg___delete__((actor)->Id());
57	0
58	0	MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
59	0	WriteIPDLParam(msg__, actor, actor);
60	0	// Sentinel = 'actor'
61	0	(msg__)->WriteSentinel(875202478);
62	0
63	0
64	0
65	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
66	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", (actor)->OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
67	0	}
68	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg___delete__", OTHER);
69	0	if ((!(StateTransition(true, (&((actor)->mLivenessState)))))) {
70	0	mozilla::ipc::LogicError("Transition error");
71	0	}
72	0
73	0	bool sendok__ = ((actor)->GetIPCChannel())->Send(msg__);
74	0
75	0	IProtocol* mgr = (actor)->Manager();
76	0	(actor)->DestroySubtree(Deletion);
77	0	(actor)->DeallocSubtree();
78	0	(mgr)->RemoveManagee(PSpeechSynthesisMsgStart, actor);
79	0	return sendok__;
80	0	}
81
82		auto PSpeechSynthesisChild::SendPSpeechSynthesisRequestConstructor(
83		const nsString& aText,
84		const nsString& aUri,
85		const nsString& aLang,
86		const float& aVolume,
87		const float& aRate,
88		const float& aPitch,
89		const bool& aIsChrome) -> PSpeechSynthesisRequestChild*
90	0	{
91	0	return SendPSpeechSynthesisRequestConstructor(AllocPSpeechSynthesisRequestChild(aText, aUri, aLang, aVolume, aRate, aPitch, aIsChrome), aText, aUri, aLang, aVolume, aRate, aPitch, aIsChrome);
92	0	}
93
94		auto PSpeechSynthesisChild::SendPSpeechSynthesisRequestConstructor(
95		PSpeechSynthesisRequestChild* actor,
96		const nsString& aText,
97		const nsString& aUri,
98		const nsString& aLang,
99		const float& aVolume,
100		const float& aRate,
101		const float& aPitch,
102		const bool& aIsChrome) -> PSpeechSynthesisRequestChild*
103	0	{
104	0	if ((!(actor))) {
105	0	NS_WARNING("Error constructing actor PSpeechSynthesisRequestChild");
106	0	return nullptr;
107	0	}
108	0	(actor)->SetManagerAndRegister(this);
109	0	(mManagedPSpeechSynthesisRequestChild).PutEntry(actor);
110	0	(actor)->mLivenessState = mozilla::ipc::LivenessState::Start;
111	0
112	0	IPC::Message* msg__ = PSpeechSynthesis::Msg_PSpeechSynthesisRequestConstructor(Id());
113	0
114	0	MOZ_RELEASE_ASSERT(actor, "NULL actor value passed to non-nullable param");
115	0	WriteIPDLParam(msg__, this, actor);
116	0	// Sentinel = 'actor'
117	0	(msg__)->WriteSentinel(875202478);
118	0	WriteIPDLParam(msg__, this, aText);
119	0	// Sentinel = 'aText'
120	0	(msg__)->WriteSentinel(711388569);
121	0	WriteIPDLParam(msg__, this, aUri);
122	0	// Sentinel = 'aUri'
123	0	(msg__)->WriteSentinel(2043506205);
124	0	WriteIPDLParam(msg__, this, aLang);
125	0	// Sentinel = 'aLang'
126	0	(msg__)->WriteSentinel(2802955996);
127	0	WriteIPDLParam(msg__, this, aVolume);
128	0	// Sentinel = 'aVolume'
129	0	(msg__)->WriteSentinel(3908369896);
130	0	WriteIPDLParam(msg__, this, aRate);
131	0	// Sentinel = 'aRate'
132	0	(msg__)->WriteSentinel(3944748486);
133	0	WriteIPDLParam(msg__, this, aPitch);
134	0	// Sentinel = 'aPitch'
135	0	(msg__)->WriteSentinel(1564848579);
136	0	WriteIPDLParam(msg__, this, aIsChrome);
137	0	// Sentinel = 'aIsChrome'
138	0	(msg__)->WriteSentinel(2206250586);
139	0
140	0
141	0
142	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
143	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Sending ", (msg__)->type(), mozilla::ipc::MessageDirection::eSending);
144	0	}
145	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_PSpeechSynthesisRequestConstructor", OTHER);
146	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
147	0	mozilla::ipc::LogicError("Transition error");
148	0	}
149	0
150	0	bool sendok__ = (GetIPCChannel())->Send(msg__);
151	0	if ((!(sendok__))) {
152	0	FatalError("constructor for actor failed");
153	0	return nullptr;
154	0	}
155	0	return actor;
156	0	}
157
158		auto PSpeechSynthesisChild::RemoveManagee(
159		int32_t aProtocolId,
160		IProtocol* aListener) -> void
161	0	{
162	0	switch (aProtocolId) {
163	0	case PSpeechSynthesisRequestMsgStart:
164	0	{
165	0	PSpeechSynthesisRequestChild* actor = static_cast<PSpeechSynthesisRequestChild*>(aListener);
166	0	auto& container = mManagedPSpeechSynthesisRequestChild;
167	0	MOZ_RELEASE_ASSERT((container).Contains(actor), "actor not managed by this!");
168	0
169	0	(container).RemoveEntry(actor);
170	0	DeallocPSpeechSynthesisRequestChild(actor);
171	0	return;
172	0	}
173	0	default:
174	0	{
175	0	FatalError("unreached");
176	0	return;
177	0	}
178	0	}
179	0	}
180
181		auto PSpeechSynthesisChild::OnMessageReceived(const Message& msg__) -> PSpeechSynthesisChild::Result
182	0	{
183	0	switch ((msg__).type()) {
184	0	case PSpeechSynthesis::Msg_VoiceAdded__ID:
185	0	{
186	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
187	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
188	0	}
189	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_VoiceAdded", OTHER);
190	0
191	0	PickleIterator iter__(msg__);
192	0	RemoteVoice aVoice;
193	0
194	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aVoice)))))) {
195	0	FatalError("Error deserializing 'RemoteVoice'");
196	0	return MsgValueError;
197	0	}
198	0	// Sentinel = 'aVoice'
199	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 3137890747)))) {
200	0	mozilla::ipc::SentinelReadError("Error deserializing 'RemoteVoice'");
201	0	return MsgValueError;
202	0	}
203	0	(msg__).EndRead(iter__, (msg__).type());
204	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
205	0	FatalError("Transition error");
206	0	return MsgValueError;
207	0	}
208	0	if ((!(RecvVoiceAdded(aVoice)))) {
209	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
210	0	// Error handled in mozilla::ipc::IPCResult
211	0	return MsgProcessingError;
212	0	}
213	0
214	0	return MsgProcessed;
215	0	}
216	0	case PSpeechSynthesis::Msg_VoiceRemoved__ID:
217	0	{
218	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
219	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
220	0	}
221	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_VoiceRemoved", OTHER);
222	0
223	0	PickleIterator iter__(msg__);
224	0	nsString aUri;
225	0
226	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aUri)))))) {
227	0	FatalError("Error deserializing 'nsString'");
228	0	return MsgValueError;
229	0	}
230	0	// Sentinel = 'aUri'
231	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2043506205)))) {
232	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
233	0	return MsgValueError;
234	0	}
235	0	(msg__).EndRead(iter__, (msg__).type());
236	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
237	0	FatalError("Transition error");
238	0	return MsgValueError;
239	0	}
240	0	if ((!(RecvVoiceRemoved(aUri)))) {
241	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
242	0	// Error handled in mozilla::ipc::IPCResult
243	0	return MsgProcessingError;
244	0	}
245	0
246	0	return MsgProcessed;
247	0	}
248	0	case PSpeechSynthesis::Msg_SetDefaultVoice__ID:
249	0	{
250	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
251	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
252	0	}
253	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_SetDefaultVoice", OTHER);
254	0
255	0	PickleIterator iter__(msg__);
256	0	nsString aUri;
257	0	bool aIsDefault;
258	0
259	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aUri)))))) {
260	0	FatalError("Error deserializing 'nsString'");
261	0	return MsgValueError;
262	0	}
263	0	// Sentinel = 'aUri'
264	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2043506205)))) {
265	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
266	0	return MsgValueError;
267	0	}
268	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsDefault)))))) {
269	0	FatalError("Error deserializing 'bool'");
270	0	return MsgValueError;
271	0	}
272	0	// Sentinel = 'aIsDefault'
273	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1203240634)))) {
274	0	mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
275	0	return MsgValueError;
276	0	}
277	0	(msg__).EndRead(iter__, (msg__).type());
278	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
279	0	FatalError("Transition error");
280	0	return MsgValueError;
281	0	}
282	0	if ((!(RecvSetDefaultVoice(aUri, aIsDefault)))) {
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 PSpeechSynthesis::Msg_IsSpeakingChanged__ID:
291	0	{
292	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
293	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
294	0	}
295	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_IsSpeakingChanged", OTHER);
296	0
297	0	PickleIterator iter__(msg__);
298	0	bool aIsSpeaking;
299	0
300	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsSpeaking)))))) {
301	0	FatalError("Error deserializing 'bool'");
302	0	return MsgValueError;
303	0	}
304	0	// Sentinel = 'aIsSpeaking'
305	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1494791872)))) {
306	0	mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
307	0	return MsgValueError;
308	0	}
309	0	(msg__).EndRead(iter__, (msg__).type());
310	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
311	0	FatalError("Transition error");
312	0	return MsgValueError;
313	0	}
314	0	if ((!(RecvIsSpeakingChanged(aIsSpeaking)))) {
315	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
316	0	// Error handled in mozilla::ipc::IPCResult
317	0	return MsgProcessingError;
318	0	}
319	0
320	0	return MsgProcessed;
321	0	}
322	0	case PSpeechSynthesis::Msg_NotifyVoicesChanged__ID:
323	0	{
324	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
325	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
326	0	}
327	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_NotifyVoicesChanged", OTHER);
328	0
329	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
330	0	FatalError("Transition error");
331	0	return MsgValueError;
332	0	}
333	0	if ((!(RecvNotifyVoicesChanged()))) {
334	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
335	0	// Error handled in mozilla::ipc::IPCResult
336	0	return MsgProcessingError;
337	0	}
338	0
339	0	return MsgProcessed;
340	0	}
341	0	case PSpeechSynthesis::Msg_InitialVoicesAndState__ID:
342	0	{
343	0	if (mozilla::ipc::LoggingEnabledFor("PSpeechSynthesisChild")) {
344	0	mozilla::ipc::LogMessageForProtocol("PSpeechSynthesisChild", OtherPid(), "Received ", ((&(msg__)))->type(), mozilla::ipc::MessageDirection::eReceiving);
345	0	}
346	0	AUTO_PROFILER_LABEL("PSpeechSynthesis::Msg_InitialVoicesAndState", OTHER);
347	0
348	0	PickleIterator iter__(msg__);
349	0	nsTArray<RemoteVoice> aVoices;
350	0	nsTArray<nsString> aDefaults;
351	0	bool aIsSpeaking;
352	0
353	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aVoices)))))) {
354	0	FatalError("Error deserializing 'nsTArray'");
355	0	return MsgValueError;
356	0	}
357	0	// Sentinel = 'aVoices'
358	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1351181827)))) {
359	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
360	0	return MsgValueError;
361	0	}
362	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aDefaults)))))) {
363	0	FatalError("Error deserializing 'nsTArray'");
364	0	return MsgValueError;
365	0	}
366	0	// Sentinel = 'aDefaults'
367	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 2428457646)))) {
368	0	mozilla::ipc::SentinelReadError("Error deserializing 'nsTArray'");
369	0	return MsgValueError;
370	0	}
371	0	if ((!(ReadIPDLParam((&(msg__)), (&(iter__)), this, (&(aIsSpeaking)))))) {
372	0	FatalError("Error deserializing 'bool'");
373	0	return MsgValueError;
374	0	}
375	0	// Sentinel = 'aIsSpeaking'
376	0	if ((!(((&(msg__)))->ReadSentinel((&(iter__)), 1494791872)))) {
377	0	mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
378	0	return MsgValueError;
379	0	}
380	0	(msg__).EndRead(iter__, (msg__).type());
381	0	if ((!(StateTransition(false, (&(mLivenessState)))))) {
382	0	FatalError("Transition error");
383	0	return MsgValueError;
384	0	}
385	0	if ((!(RecvInitialVoicesAndState(std::move(aVoices), std::move(aDefaults), aIsSpeaking)))) {
386	0	mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
387	0	// Error handled in mozilla::ipc::IPCResult
388	0	return MsgProcessingError;
389	0	}
390	0
391	0	return MsgProcessed;
392	0	}
393	0	case PSpeechSynthesis::Reply___delete____ID:
394	0	{
395	0	return MsgProcessed;
396	0	}
397	0	case PSpeechSynthesis::Reply_PSpeechSynthesisRequestConstructor__ID:
398	0	{
399	0	return MsgProcessed;
400	0	}
401	0	default:
402	0	{
403	0	return MsgNotKnown;
404	0	}
405	0	}
406	0	}
407
408		auto PSpeechSynthesisChild::OnMessageReceived(
409		const Message& msg__,
410		Message*& reply__) -> PSpeechSynthesisChild::Result
411	0	{
412	0	return MsgNotKnown;
413	0	}
414
415		auto PSpeechSynthesisChild::OnCallReceived(
416		const Message& msg__,
417		Message*& reply__) -> PSpeechSynthesisChild::Result
418	0	{
419	0	MOZ_ASSERT_UNREACHABLE("message protocol not supported");
420	0	return MsgNotKnown;
421	0	}
422
423		auto PSpeechSynthesisChild::GetProtocolTypeId() -> int32_t
424	0	{
425	0	return PSpeechSynthesisMsgStart;
426	0	}
427
428		auto PSpeechSynthesisChild::DestroySubtree(ActorDestroyReason why) -> void
429	0	{
430	0	// Unregister from our manager.
431	0	Unregister(Id());
432	0
433	0	ActorDestroyReason subtreewhy = (((why) == (Deletion)) \|\| ((why) == (FailedConstructor)) ? AncestorDeletion : why);
434	0
435	0	{
436	0	// Recursively shutting down PSpeechSynthesisRequest kids
437	0	nsTArray<PSpeechSynthesisRequestChild*> kids;
438	0	// Accumulate kids into a stable structure to iterate over
439	0	ManagedPSpeechSynthesisRequestChild(kids);
440	0	for (auto& kid : kids) {
441	0	// Guarding against a child removing a sibling from the list during the iteration.
442	0	if ((mManagedPSpeechSynthesisRequestChild).Contains(kid)) {
443	0	(kid)->DestroySubtree(subtreewhy);
444	0	}
445	0	}
446	0	}
447	0
448	0	// Reject owning pending responses.
449	0	(GetIPCChannel())->RejectPendingResponsesForActor(this);
450	0
451	0	// Finally, destroy "us".
452	0	ActorDestroy(why);
453	0	}
454
455		auto PSpeechSynthesisChild::DeallocSubtree() -> void
456	0	{
457	0	{
458	0	// Recursively deleting PSpeechSynthesisRequest kids
459	0	for (auto iter = (mManagedPSpeechSynthesisRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
460	0	(((iter).Get())->GetKey())->DeallocSubtree();
461	0	}
462	0
463	0	for (auto iter = (mManagedPSpeechSynthesisRequestChild).Iter(); (!((iter).Done())); (iter).Next()) {
464	0	DeallocPSpeechSynthesisRequestChild(((iter).Get())->GetKey());
465	0	}
466	0	(mManagedPSpeechSynthesisRequestChild).Clear();
467	0	}
468	0	}
469
470
471
472		} // namespace dom
473		} // namespace mozilla
474		namespace mozilla {
475		namespace ipc {
476		auto IPDLParamTraits<mozilla::dom::PSpeechSynthesisChild>::Write(
477		IPC::Message* aMsg,
478		mozilla::ipc::IProtocol* aActor,
479		const paramType& aVar) -> void
480	0	{
481	0	int32_t id;
482	0	if ((!(aVar))) {
483	0	id = 0;
484	0	}
485	0	else {
486	0	id = (aVar)->Id();
487	0	if ((1) == (id)) {
488	0	(aActor)->FatalError("actor has been \|delete\|d");
489	0	}
490	0	}
491	0	WriteIPDLParam(aMsg, aActor, id);
492	0	}
493
494		auto IPDLParamTraits<mozilla::dom::PSpeechSynthesisChild>::Read(
495		const IPC::Message* aMsg,
496		PickleIterator* aIter,
497		mozilla::ipc::IProtocol* aActor,
498		paramType* aVar) -> bool
499	0	{
500	0	mozilla::Maybe<mozilla::ipc::IProtocol*> actor = (aActor)->ReadActor(aMsg, aIter, true, "PSpeechSynthesis", PSpeechSynthesisMsgStart);
501	0	if ((actor).isNothing()) {
502	0	return false;
503	0	}
504	0
505	0	((aVar)) = static_cast<mozilla::dom::PSpeechSynthesisChild>((actor).value());
506	0	return true;
507	0	}
508
509		} // namespace ipc
510		} // namespace mozilla