Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#include "mozilla/net/PNeckoChild.h"
#include "SerializedLoadContext.h"
#include "mozilla/AntiTrackingIPCUtils.h"
#include "mozilla/ProfilerLabels.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/dom/FetchIPCTypes.h"
#include "mozilla/dom/PermissionMessageUtils.h"
#include "mozilla/dom/PropertyBagUtils.h"
#include "mozilla/dom/ReferrerInfoUtils.h"
#include "mozilla/dom/SessionHistoryEntry.h"
#include "mozilla/ipc/IPCStreamUtils.h"
#include "mozilla/ipc/URIUtils.h"
#include "mozilla/net/CacheInfoIPCTypes.h"
#include "mozilla/net/ClassOfService.h"
#include "mozilla/net/NeckoChild.h"
#include "nsDOMNavigationTiming.h"
#include "nsDocShellLoadState.h"
#include "nsHttp.h"
#include "nsHttpResponseHead.h"
#include "nsIPrincipal.h"
#include "nsIPropertyBag2.h"
#include "mozilla/dom/PContentChild.h"
#include "mozilla/net/PHttpChannelChild.h"
#include "mozilla/net/PCookieServiceChild.h"
#include "mozilla/dom/PBrowserChild.h"
#include "mozilla/net/PGIOChannelChild.h"
#include "mozilla/net/PWebSocketChild.h"
#include "mozilla/net/PWebSocketEventListenerChild.h"
#include "mozilla/net/PTCPSocketChild.h"
#include "mozilla/net/PTCPServerSocketChild.h"
#include "mozilla/net/PUDPSocketChild.h"
#include "mozilla/net/PDNSRequestChild.h"
#include "mozilla/net/PDataChannelChild.h"
#include "mozilla/net/PSimpleChannelChild.h"
#include "mozilla/net/PTransportProviderChild.h"
#include "mozilla/net/PStunAddrsRequestChild.h"
#include "mozilla/net/PFileChannelChild.h"
#include "mozilla/net/PWebrtcTCPSocketChild.h"
#include "mozilla/net/PSocketProcessBridgeChild.h"
#include "mozilla/net/PDocumentChannelChild.h"
#include "mozilla/net/PAltDataOutputStreamChild.h"
#include "ipc/IPCMessageUtils.h"
#include "ipc/IPCMessageUtilsSpecializations.h"
#include "nsIFile.h"
#include "mozilla/ipc/Endpoint.h"
#include "mozilla/ipc/ProtocolMessageUtils.h"
#include "mozilla/ipc/ProtocolUtils.h"
#include "mozilla/ipc/ShmemMessageUtils.h"
#include "mozilla/ipc/TaintingIPCUtils.h"
namespace mozilla {
namespace net {
auto PNeckoChild::RecvPTransportProviderConstructor(PTransportProviderChild* actor) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
auto PNeckoChild::RecvPTCPSocketConstructor(
PTCPSocketChild* actor,
const nsAString& host,
const uint16_t& port) -> mozilla::ipc::IPCResult
{
return IPC_OK();
}
MOZ_IMPLICIT PNeckoChild::PNeckoChild() :
mozilla::ipc::IRefCountedProtocol(PNeckoMsgStart, mozilla::ipc::ChildSide)
{
MOZ_COUNT_CTOR(PNeckoChild);
}
PNeckoChild::~PNeckoChild()
{
MOZ_COUNT_DTOR(PNeckoChild);
}
auto PNeckoChild::ActorAlloc() -> void
{
AddRef();
}
auto PNeckoChild::ActorDealloc() -> void
{
Release();
}
auto PNeckoChild::OtherPid() const -> ::base::ProcessId
{
::base::ProcessId pid =
::mozilla::ipc::IProtocol::ToplevelProtocol()->OtherPidMaybeInvalid();
MOZ_RELEASE_ASSERT(pid != ::base::kInvalidProcessId);
return pid;
}
auto PNeckoChild::Manager() const -> PContentChild*
{
return static_cast<PContentChild*>(IProtocol::Manager());
}
auto PNeckoChild::ManagedPHttpChannelChild(nsTArray<PHttpChannelChild*>& aArr) const -> void
{
mManagedPHttpChannelChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPHttpChannelChild() const -> const ManagedContainer<PHttpChannelChild>&
{
return mManagedPHttpChannelChild;
}
auto PNeckoChild::ManagedPCookieServiceChild(nsTArray<PCookieServiceChild*>& aArr) const -> void
{
mManagedPCookieServiceChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPCookieServiceChild() const -> const ManagedContainer<PCookieServiceChild>&
{
return mManagedPCookieServiceChild;
}
auto PNeckoChild::ManagedPWebSocketChild(nsTArray<PWebSocketChild*>& aArr) const -> void
{
mManagedPWebSocketChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPWebSocketChild() const -> const ManagedContainer<PWebSocketChild>&
{
return mManagedPWebSocketChild;
}
auto PNeckoChild::ManagedPWebSocketEventListenerChild(nsTArray<PWebSocketEventListenerChild*>& aArr) const -> void
{
mManagedPWebSocketEventListenerChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPWebSocketEventListenerChild() const -> const ManagedContainer<PWebSocketEventListenerChild>&
{
return mManagedPWebSocketEventListenerChild;
}
auto PNeckoChild::ManagedPTCPSocketChild(nsTArray<PTCPSocketChild*>& aArr) const -> void
{
mManagedPTCPSocketChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPTCPSocketChild() const -> const ManagedContainer<PTCPSocketChild>&
{
return mManagedPTCPSocketChild;
}
auto PNeckoChild::ManagedPTCPServerSocketChild(nsTArray<PTCPServerSocketChild*>& aArr) const -> void
{
mManagedPTCPServerSocketChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPTCPServerSocketChild() const -> const ManagedContainer<PTCPServerSocketChild>&
{
return mManagedPTCPServerSocketChild;
}
auto PNeckoChild::ManagedPUDPSocketChild(nsTArray<PUDPSocketChild*>& aArr) const -> void
{
mManagedPUDPSocketChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPUDPSocketChild() const -> const ManagedContainer<PUDPSocketChild>&
{
return mManagedPUDPSocketChild;
}
auto PNeckoChild::ManagedPDNSRequestChild(nsTArray<PDNSRequestChild*>& aArr) const -> void
{
mManagedPDNSRequestChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPDNSRequestChild() const -> const ManagedContainer<PDNSRequestChild>&
{
return mManagedPDNSRequestChild;
}
auto PNeckoChild::ManagedPDataChannelChild(nsTArray<PDataChannelChild*>& aArr) const -> void
{
mManagedPDataChannelChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPDataChannelChild() const -> const ManagedContainer<PDataChannelChild>&
{
return mManagedPDataChannelChild;
}
auto PNeckoChild::ManagedPGIOChannelChild(nsTArray<PGIOChannelChild*>& aArr) const -> void
{
mManagedPGIOChannelChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPGIOChannelChild() const -> const ManagedContainer<PGIOChannelChild>&
{
return mManagedPGIOChannelChild;
}
auto PNeckoChild::ManagedPSimpleChannelChild(nsTArray<PSimpleChannelChild*>& aArr) const -> void
{
mManagedPSimpleChannelChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPSimpleChannelChild() const -> const ManagedContainer<PSimpleChannelChild>&
{
return mManagedPSimpleChannelChild;
}
auto PNeckoChild::ManagedPFileChannelChild(nsTArray<PFileChannelChild*>& aArr) const -> void
{
mManagedPFileChannelChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPFileChannelChild() const -> const ManagedContainer<PFileChannelChild>&
{
return mManagedPFileChannelChild;
}
auto PNeckoChild::ManagedPTransportProviderChild(nsTArray<PTransportProviderChild*>& aArr) const -> void
{
mManagedPTransportProviderChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPTransportProviderChild() const -> const ManagedContainer<PTransportProviderChild>&
{
return mManagedPTransportProviderChild;
}
auto PNeckoChild::ManagedPAltDataOutputStreamChild(nsTArray<PAltDataOutputStreamChild*>& aArr) const -> void
{
mManagedPAltDataOutputStreamChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPAltDataOutputStreamChild() const -> const ManagedContainer<PAltDataOutputStreamChild>&
{
return mManagedPAltDataOutputStreamChild;
}
auto PNeckoChild::ManagedPStunAddrsRequestChild(nsTArray<PStunAddrsRequestChild*>& aArr) const -> void
{
mManagedPStunAddrsRequestChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPStunAddrsRequestChild() const -> const ManagedContainer<PStunAddrsRequestChild>&
{
return mManagedPStunAddrsRequestChild;
}
auto PNeckoChild::ManagedPWebrtcTCPSocketChild(nsTArray<PWebrtcTCPSocketChild*>& aArr) const -> void
{
mManagedPWebrtcTCPSocketChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPWebrtcTCPSocketChild() const -> const ManagedContainer<PWebrtcTCPSocketChild>&
{
return mManagedPWebrtcTCPSocketChild;
}
auto PNeckoChild::ManagedPDocumentChannelChild(nsTArray<PDocumentChannelChild*>& aArr) const -> void
{
mManagedPDocumentChannelChild.ToArray(aArr);
}
auto PNeckoChild::ManagedPDocumentChannelChild() const -> const ManagedContainer<PDocumentChannelChild>&
{
return mManagedPDocumentChannelChild;
}
auto PNeckoChild::AllManagedActorsCount() const -> uint32_t
{
uint32_t total = 0;
total += mManagedPHttpChannelChild.Count();
total += mManagedPCookieServiceChild.Count();
total += mManagedPWebSocketChild.Count();
total += mManagedPWebSocketEventListenerChild.Count();
total += mManagedPTCPSocketChild.Count();
total += mManagedPTCPServerSocketChild.Count();
total += mManagedPUDPSocketChild.Count();
total += mManagedPDNSRequestChild.Count();
total += mManagedPDataChannelChild.Count();
total += mManagedPGIOChannelChild.Count();
total += mManagedPSimpleChannelChild.Count();
total += mManagedPFileChannelChild.Count();
total += mManagedPTransportProviderChild.Count();
total += mManagedPAltDataOutputStreamChild.Count();
total += mManagedPStunAddrsRequestChild.Count();
total += mManagedPWebrtcTCPSocketChild.Count();
total += mManagedPDocumentChannelChild.Count();
return total;
}
auto PNeckoChild::OpenPHttpChannelEndpoint(PHttpChannelChild* aActor) -> ManagedEndpoint<PHttpChannelParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PHttpChannelChild actor");
return ManagedEndpoint<PHttpChannelParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPHttpChannelChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PHttpChannelChild actor");
return ManagedEndpoint<PHttpChannelParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PHttpChannelParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPHttpChannelEndpoint(
ManagedEndpoint<PHttpChannelChild> aEndpoint,
PHttpChannelChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPHttpChannelChild);
}
auto PNeckoChild::OpenPCookieServiceEndpoint(PCookieServiceChild* aActor) -> ManagedEndpoint<PCookieServiceParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PCookieServiceChild actor");
return ManagedEndpoint<PCookieServiceParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPCookieServiceChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PCookieServiceChild actor");
return ManagedEndpoint<PCookieServiceParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PCookieServiceParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPCookieServiceEndpoint(
ManagedEndpoint<PCookieServiceChild> aEndpoint,
PCookieServiceChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPCookieServiceChild);
}
auto PNeckoChild::OpenPWebSocketEndpoint(PWebSocketChild* aActor) -> ManagedEndpoint<PWebSocketParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebSocketChild actor");
return ManagedEndpoint<PWebSocketParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPWebSocketChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PWebSocketChild actor");
return ManagedEndpoint<PWebSocketParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PWebSocketParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPWebSocketEndpoint(
ManagedEndpoint<PWebSocketChild> aEndpoint,
PWebSocketChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWebSocketChild);
}
auto PNeckoChild::OpenPWebSocketEventListenerEndpoint(PWebSocketEventListenerChild* aActor) -> ManagedEndpoint<PWebSocketEventListenerParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebSocketEventListenerChild actor");
return ManagedEndpoint<PWebSocketEventListenerParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPWebSocketEventListenerChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PWebSocketEventListenerChild actor");
return ManagedEndpoint<PWebSocketEventListenerParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PWebSocketEventListenerParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPWebSocketEventListenerEndpoint(
ManagedEndpoint<PWebSocketEventListenerChild> aEndpoint,
PWebSocketEventListenerChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWebSocketEventListenerChild);
}
auto PNeckoChild::OpenPTCPSocketEndpoint(PTCPSocketChild* aActor) -> ManagedEndpoint<PTCPSocketParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTCPSocketChild actor");
return ManagedEndpoint<PTCPSocketParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPTCPSocketChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PTCPSocketChild actor");
return ManagedEndpoint<PTCPSocketParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PTCPSocketParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPTCPSocketEndpoint(
ManagedEndpoint<PTCPSocketChild> aEndpoint,
PTCPSocketChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPTCPSocketChild);
}
auto PNeckoChild::OpenPTCPServerSocketEndpoint(PTCPServerSocketChild* aActor) -> ManagedEndpoint<PTCPServerSocketParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTCPServerSocketChild actor");
return ManagedEndpoint<PTCPServerSocketParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPTCPServerSocketChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PTCPServerSocketChild actor");
return ManagedEndpoint<PTCPServerSocketParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PTCPServerSocketParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPTCPServerSocketEndpoint(
ManagedEndpoint<PTCPServerSocketChild> aEndpoint,
PTCPServerSocketChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPTCPServerSocketChild);
}
auto PNeckoChild::OpenPUDPSocketEndpoint(PUDPSocketChild* aActor) -> ManagedEndpoint<PUDPSocketParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PUDPSocketChild actor");
return ManagedEndpoint<PUDPSocketParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPUDPSocketChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PUDPSocketChild actor");
return ManagedEndpoint<PUDPSocketParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PUDPSocketParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPUDPSocketEndpoint(
ManagedEndpoint<PUDPSocketChild> aEndpoint,
PUDPSocketChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPUDPSocketChild);
}
auto PNeckoChild::OpenPDNSRequestEndpoint(PDNSRequestChild* aActor) -> ManagedEndpoint<PDNSRequestParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PDNSRequestChild actor");
return ManagedEndpoint<PDNSRequestParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPDNSRequestChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PDNSRequestChild actor");
return ManagedEndpoint<PDNSRequestParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PDNSRequestParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPDNSRequestEndpoint(
ManagedEndpoint<PDNSRequestChild> aEndpoint,
PDNSRequestChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPDNSRequestChild);
}
auto PNeckoChild::OpenPDataChannelEndpoint(PDataChannelChild* aActor) -> ManagedEndpoint<PDataChannelParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PDataChannelChild actor");
return ManagedEndpoint<PDataChannelParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPDataChannelChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PDataChannelChild actor");
return ManagedEndpoint<PDataChannelParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PDataChannelParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPDataChannelEndpoint(
ManagedEndpoint<PDataChannelChild> aEndpoint,
PDataChannelChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPDataChannelChild);
}
auto PNeckoChild::OpenPGIOChannelEndpoint(PGIOChannelChild* aActor) -> ManagedEndpoint<PGIOChannelParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PGIOChannelChild actor");
return ManagedEndpoint<PGIOChannelParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPGIOChannelChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PGIOChannelChild actor");
return ManagedEndpoint<PGIOChannelParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PGIOChannelParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPGIOChannelEndpoint(
ManagedEndpoint<PGIOChannelChild> aEndpoint,
PGIOChannelChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPGIOChannelChild);
}
auto PNeckoChild::OpenPSimpleChannelEndpoint(PSimpleChannelChild* aActor) -> ManagedEndpoint<PSimpleChannelParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PSimpleChannelChild actor");
return ManagedEndpoint<PSimpleChannelParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPSimpleChannelChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PSimpleChannelChild actor");
return ManagedEndpoint<PSimpleChannelParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PSimpleChannelParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPSimpleChannelEndpoint(
ManagedEndpoint<PSimpleChannelChild> aEndpoint,
PSimpleChannelChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPSimpleChannelChild);
}
auto PNeckoChild::OpenPFileChannelEndpoint(PFileChannelChild* aActor) -> ManagedEndpoint<PFileChannelParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PFileChannelChild actor");
return ManagedEndpoint<PFileChannelParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPFileChannelChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PFileChannelChild actor");
return ManagedEndpoint<PFileChannelParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PFileChannelParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPFileChannelEndpoint(
ManagedEndpoint<PFileChannelChild> aEndpoint,
PFileChannelChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPFileChannelChild);
}
auto PNeckoChild::OpenPTransportProviderEndpoint(PTransportProviderChild* aActor) -> ManagedEndpoint<PTransportProviderParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PTransportProviderChild actor");
return ManagedEndpoint<PTransportProviderParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPTransportProviderChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PTransportProviderChild actor");
return ManagedEndpoint<PTransportProviderParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PTransportProviderParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPTransportProviderEndpoint(
ManagedEndpoint<PTransportProviderChild> aEndpoint,
PTransportProviderChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPTransportProviderChild);
}
auto PNeckoChild::OpenPAltDataOutputStreamEndpoint(PAltDataOutputStreamChild* aActor) -> ManagedEndpoint<PAltDataOutputStreamParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PAltDataOutputStreamChild actor");
return ManagedEndpoint<PAltDataOutputStreamParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPAltDataOutputStreamChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PAltDataOutputStreamChild actor");
return ManagedEndpoint<PAltDataOutputStreamParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PAltDataOutputStreamParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPAltDataOutputStreamEndpoint(
ManagedEndpoint<PAltDataOutputStreamChild> aEndpoint,
PAltDataOutputStreamChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPAltDataOutputStreamChild);
}
auto PNeckoChild::OpenPStunAddrsRequestEndpoint(PStunAddrsRequestChild* aActor) -> ManagedEndpoint<PStunAddrsRequestParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PStunAddrsRequestChild actor");
return ManagedEndpoint<PStunAddrsRequestParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPStunAddrsRequestChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PStunAddrsRequestChild actor");
return ManagedEndpoint<PStunAddrsRequestParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PStunAddrsRequestParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPStunAddrsRequestEndpoint(
ManagedEndpoint<PStunAddrsRequestChild> aEndpoint,
PStunAddrsRequestChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPStunAddrsRequestChild);
}
auto PNeckoChild::OpenPWebrtcTCPSocketEndpoint(PWebrtcTCPSocketChild* aActor) -> ManagedEndpoint<PWebrtcTCPSocketParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PWebrtcTCPSocketChild actor");
return ManagedEndpoint<PWebrtcTCPSocketParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPWebrtcTCPSocketChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PWebrtcTCPSocketChild actor");
return ManagedEndpoint<PWebrtcTCPSocketParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PWebrtcTCPSocketParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPWebrtcTCPSocketEndpoint(
ManagedEndpoint<PWebrtcTCPSocketChild> aEndpoint,
PWebrtcTCPSocketChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPWebrtcTCPSocketChild);
}
auto PNeckoChild::OpenPDocumentChannelEndpoint(PDocumentChannelChild* aActor) -> ManagedEndpoint<PDocumentChannelParent>
{
if (!aActor) {
NS_WARNING("Cannot bind null PDocumentChannelChild actor");
return ManagedEndpoint<PDocumentChannelParent>();
}
if (aActor->SetManagerAndRegister(this)) {
mManagedPDocumentChannelChild.Insert(aActor);
} else {
NS_WARNING("Failed to bind PDocumentChannelChild actor");
return ManagedEndpoint<PDocumentChannelParent>();
}
// Mark our actor as awaiting the other side to be bound. This will
// be cleared when a `MANAGED_ENDPOINT_{DROPPED,BOUND}` message is
// received.
aActor->mAwaitingManagedEndpointBind = true;
return ManagedEndpoint<PDocumentChannelParent>(mozilla::ipc::PrivateIPDLInterface(), aActor);
}
auto PNeckoChild::BindPDocumentChannelEndpoint(
ManagedEndpoint<PDocumentChannelChild> aEndpoint,
PDocumentChannelChild* aActor) -> bool
{
return aEndpoint.Bind(mozilla::ipc::PrivateIPDLInterface(), aActor, this, mManagedPDocumentChannelChild);
}
auto PNeckoChild::Send__delete__(PNeckoChild* actor) -> bool
{
if (!actor || !actor->CanSend()) {
NS_WARNING("Attempt to __delete__ missing or closed actor");
return false;
}
UniquePtr<IPC::Message> msg__ = PNecko::Msg___delete__((actor)->Id());
IPC::MessageWriter writer__{
(*(msg__)),
actor};
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
actor->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg___delete__", OTHER);
bool sendok__ = (actor)->ChannelSend(std::move(msg__));
actor->ActorDisconnected(Deletion);
return sendok__;
}
auto PNeckoChild::SendPCookieServiceConstructor() -> PCookieServiceChild*
{
PCookieServiceChild* actor = (static_cast<NeckoChild*>(this))->AllocPCookieServiceChild();
return SendPCookieServiceConstructor(std::move(actor));
}
auto PNeckoChild::SendPCookieServiceConstructor(PCookieServiceChild* actor) -> PCookieServiceChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PCookieServiceChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPCookieServiceChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PCookieServiceChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PCookieServiceConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PCookieServiceConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PCookieServiceChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPHttpChannelConstructor(
PHttpChannelChild* actor,
PBrowserChild* browser,
const SerializedLoadContext& loadContext,
const HttpChannelCreationArgs& args) -> PHttpChannelChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PHttpChannelChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPHttpChannelChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PHttpChannelChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PHttpChannelConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), browser);
// Sentinel = 'browser'
((&(writer__)))->WriteSentinel(201130757);
IPC::WriteParam((&(writer__)), loadContext);
// Sentinel = 'loadContext'
((&(writer__)))->WriteSentinel(444990598);
IPC::WriteParam((&(writer__)), args);
// Sentinel = 'args'
((&(writer__)))->WriteSentinel(69140910);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PHttpChannelConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PHttpChannelChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPWebSocketConstructor(
PBrowserChild* browser,
const SerializedLoadContext& loadContext,
const uint32_t& aSerialID) -> PWebSocketChild*
{
PWebSocketChild* actor = (static_cast<NeckoChild*>(this))->AllocPWebSocketChild(browser, loadContext, aSerialID);
return SendPWebSocketConstructor(std::move(actor), browser, std::move(loadContext), std::move(aSerialID));
}
auto PNeckoChild::SendPWebSocketConstructor(
PWebSocketChild* actor,
PBrowserChild* browser,
const SerializedLoadContext& loadContext,
const uint32_t& aSerialID) -> PWebSocketChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PWebSocketChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPWebSocketChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PWebSocketChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PWebSocketConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), browser);
// Sentinel = 'browser'
((&(writer__)))->WriteSentinel(201130757);
IPC::WriteParam((&(writer__)), loadContext);
// Sentinel = 'loadContext'
((&(writer__)))->WriteSentinel(444990598);
IPC::WriteParam((&(writer__)), aSerialID);
// Sentinel = 'aSerialID'
((&(writer__)))->WriteSentinel(287572815);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PWebSocketConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PWebSocketChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPTCPServerSocketConstructor(
const uint16_t& localPort,
const uint16_t& backlog,
const bool& useArrayBuffers) -> PTCPServerSocketChild*
{
PTCPServerSocketChild* actor = (static_cast<NeckoChild*>(this))->AllocPTCPServerSocketChild(localPort, backlog, useArrayBuffers);
return SendPTCPServerSocketConstructor(std::move(actor), std::move(localPort), std::move(backlog), std::move(useArrayBuffers));
}
auto PNeckoChild::SendPTCPServerSocketConstructor(
PTCPServerSocketChild* actor,
const uint16_t& localPort,
const uint16_t& backlog,
const bool& useArrayBuffers) -> PTCPServerSocketChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PTCPServerSocketChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPTCPServerSocketChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PTCPServerSocketChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PTCPServerSocketConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), localPort);
// Sentinel = 'localPort'
((&(writer__)))->WriteSentinel(306774961);
IPC::WriteParam((&(writer__)), backlog);
// Sentinel = 'backlog'
((&(writer__)))->WriteSentinel(186581716);
IPC::WriteParam((&(writer__)), useArrayBuffers);
// Sentinel = 'useArrayBuffers'
((&(writer__)))->WriteSentinel(815007258);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PTCPServerSocketConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PTCPServerSocketChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPUDPSocketConstructor(
nsIPrincipal* principal,
const nsACString& filter) -> PUDPSocketChild*
{
PUDPSocketChild* actor = (static_cast<NeckoChild*>(this))->AllocPUDPSocketChild(principal, filter);
return SendPUDPSocketConstructor(std::move(actor), principal, std::move(filter));
}
auto PNeckoChild::SendPUDPSocketConstructor(
PUDPSocketChild* actor,
nsIPrincipal* principal,
const nsACString& filter) -> PUDPSocketChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PUDPSocketChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPUDPSocketChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PUDPSocketChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PUDPSocketConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), filter);
// Sentinel = 'filter'
((&(writer__)))->WriteSentinel(146735751);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PUDPSocketConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PUDPSocketChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPDNSRequestConstructor(
PDNSRequestChild* actor,
const nsACString& hostName,
const nsACString& trrServer,
const int32_t& port,
const uint16_t& type,
const OriginAttributes& originAttributes,
const DNSFlags& flags) -> PDNSRequestChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PDNSRequestChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPDNSRequestChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PDNSRequestChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PDNSRequestConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), hostName);
// Sentinel = 'hostName'
((&(writer__)))->WriteSentinel(249627456);
IPC::WriteParam((&(writer__)), trrServer);
// Sentinel = 'trrServer'
((&(writer__)))->WriteSentinel(320603088);
IPC::WriteParam((&(writer__)), port);
// Sentinel = 'port'
((&(writer__)))->WriteSentinel(73990598);
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
IPC::WriteParam((&(writer__)), originAttributes);
// Sentinel = 'originAttributes'
((&(writer__)))->WriteSentinel(947259056);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PDNSRequestConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PDNSRequestChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPDocumentChannelConstructor(
PDocumentChannelChild* actor,
const MaybeDiscardedBrowsingContext& browsingContext,
const DocumentChannelCreationArgs& args) -> PDocumentChannelChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PDocumentChannelChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPDocumentChannelChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PDocumentChannelChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PDocumentChannelConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), browsingContext);
// Sentinel = 'browsingContext'
((&(writer__)))->WriteSentinel(844695121);
IPC::WriteParam((&(writer__)), args);
// Sentinel = 'args'
((&(writer__)))->WriteSentinel(69140910);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PDocumentChannelConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PDocumentChannelChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPWebSocketEventListenerConstructor(const uint64_t& aInnerWindowID) -> PWebSocketEventListenerChild*
{
PWebSocketEventListenerChild* actor = (static_cast<NeckoChild*>(this))->AllocPWebSocketEventListenerChild(aInnerWindowID);
return SendPWebSocketEventListenerConstructor(std::move(actor), std::move(aInnerWindowID));
}
auto PNeckoChild::SendPWebSocketEventListenerConstructor(
PWebSocketEventListenerChild* actor,
const uint64_t& aInnerWindowID) -> PWebSocketEventListenerChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PWebSocketEventListenerChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPWebSocketEventListenerChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PWebSocketEventListenerChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PWebSocketEventListenerConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), aInnerWindowID);
// Sentinel = 'aInnerWindowID'
((&(writer__)))->WriteSentinel(687670627);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PWebSocketEventListenerConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PWebSocketEventListenerChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPredPredict(
nsIURI* targetURI,
nsIURI* sourceURI,
const uint32_t& reason,
const OriginAttributes& originAttributes,
const bool& hasVerifier) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PredPredict(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), targetURI);
// Sentinel = 'targetURI'
((&(writer__)))->WriteSentinel(308413304);
IPC::WriteParam((&(writer__)), sourceURI);
// Sentinel = 'sourceURI'
((&(writer__)))->WriteSentinel(316277634);
IPC::WriteParam((&(writer__)), reason);
// Sentinel = 'reason'
((&(writer__)))->WriteSentinel(148112009);
IPC::WriteParam((&(writer__)), originAttributes);
// Sentinel = 'originAttributes'
((&(writer__)))->WriteSentinel(947259056);
IPC::WriteParam((&(writer__)), hasVerifier);
// Sentinel = 'hasVerifier'
((&(writer__)))->WriteSentinel(445842553);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PredPredict", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendPredLearn(
nsIURI* targetURI,
nsIURI* sourceURI,
const uint32_t& reason,
const OriginAttributes& originAttributes) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PredLearn(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), targetURI);
// Sentinel = 'targetURI'
((&(writer__)))->WriteSentinel(308413304);
IPC::WriteParam((&(writer__)), sourceURI);
// Sentinel = 'sourceURI'
((&(writer__)))->WriteSentinel(316277634);
IPC::WriteParam((&(writer__)), reason);
// Sentinel = 'reason'
((&(writer__)))->WriteSentinel(148112009);
IPC::WriteParam((&(writer__)), originAttributes);
// Sentinel = 'originAttributes'
((&(writer__)))->WriteSentinel(947259056);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PredLearn", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendPredReset() -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PredReset(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PredReset", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendSpeculativeConnect(
nsIURI* uri,
nsIPrincipal* principal,
const mozilla::Maybe<OriginAttributes>& originAttributes,
const bool& anonymous) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_SpeculativeConnect(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), principal);
// Sentinel = 'principal'
((&(writer__)))->WriteSentinel(319620035);
IPC::WriteParam((&(writer__)), originAttributes);
// Sentinel = 'originAttributes'
((&(writer__)))->WriteSentinel(947259056);
IPC::WriteParam((&(writer__)), anonymous);
// Sentinel = 'anonymous'
((&(writer__)))->WriteSentinel(322569194);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_SpeculativeConnect", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendHTMLDNSPrefetch(
const nsAString& hostname,
const bool& isHttps,
const OriginAttributes& originAttributes,
const DNSFlags& flags) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_HTMLDNSPrefetch(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), hostname);
// Sentinel = 'hostname'
((&(writer__)))->WriteSentinel(258016096);
IPC::WriteParam((&(writer__)), isHttps);
// Sentinel = 'isHttps'
((&(writer__)))->WriteSentinel(192873200);
IPC::WriteParam((&(writer__)), originAttributes);
// Sentinel = 'originAttributes'
((&(writer__)))->WriteSentinel(947259056);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_HTMLDNSPrefetch", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendCancelHTMLDNSPrefetch(
const nsAString& hostname,
const bool& isHttps,
const OriginAttributes& originAttributes,
const DNSFlags& flags,
const nsresult& reason) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_CancelHTMLDNSPrefetch(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), hostname);
// Sentinel = 'hostname'
((&(writer__)))->WriteSentinel(258016096);
IPC::WriteParam((&(writer__)), isHttps);
// Sentinel = 'isHttps'
((&(writer__)))->WriteSentinel(192873200);
IPC::WriteParam((&(writer__)), originAttributes);
// Sentinel = 'originAttributes'
((&(writer__)))->WriteSentinel(947259056);
IPC::WriteParam((&(writer__)), flags);
// Sentinel = 'flags'
((&(writer__)))->WriteSentinel(102171150);
IPC::WriteParam((&(writer__)), reason);
// Sentinel = 'reason'
((&(writer__)))->WriteSentinel(148112009);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_CancelHTMLDNSPrefetch", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendPDataChannelConstructor(
PDataChannelChild* actor,
const uint32_t& channelId) -> PDataChannelChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PDataChannelChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPDataChannelChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PDataChannelChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PDataChannelConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), channelId);
// Sentinel = 'channelId'
((&(writer__)))->WriteSentinel(301138823);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PDataChannelConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PDataChannelChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPGIOChannelConstructor(
PBrowserChild* browser,
const SerializedLoadContext& loadContext,
const GIOChannelCreationArgs& args) -> PGIOChannelChild*
{
PGIOChannelChild* actor = (static_cast<NeckoChild*>(this))->AllocPGIOChannelChild(browser, loadContext, args);
return SendPGIOChannelConstructor(std::move(actor), browser, std::move(loadContext), std::move(args));
}
auto PNeckoChild::SendPGIOChannelConstructor(
PGIOChannelChild* actor,
PBrowserChild* browser,
const SerializedLoadContext& loadContext,
const GIOChannelCreationArgs& args) -> PGIOChannelChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PGIOChannelChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPGIOChannelChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PGIOChannelChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PGIOChannelConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), browser);
// Sentinel = 'browser'
((&(writer__)))->WriteSentinel(201130757);
IPC::WriteParam((&(writer__)), loadContext);
// Sentinel = 'loadContext'
((&(writer__)))->WriteSentinel(444990598);
IPC::WriteParam((&(writer__)), args);
// Sentinel = 'args'
((&(writer__)))->WriteSentinel(69140910);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PGIOChannelConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PGIOChannelChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPSimpleChannelConstructor(const uint32_t& channelId) -> PSimpleChannelChild*
{
PSimpleChannelChild* actor = (static_cast<NeckoChild*>(this))->AllocPSimpleChannelChild(channelId);
return SendPSimpleChannelConstructor(std::move(actor), std::move(channelId));
}
auto PNeckoChild::SendPSimpleChannelConstructor(
PSimpleChannelChild* actor,
const uint32_t& channelId) -> PSimpleChannelChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PSimpleChannelChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPSimpleChannelChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PSimpleChannelChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PSimpleChannelConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), channelId);
// Sentinel = 'channelId'
((&(writer__)))->WriteSentinel(301138823);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PSimpleChannelConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PSimpleChannelChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPFileChannelConstructor(
PFileChannelChild* actor,
const uint32_t& channelId) -> PFileChannelChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PFileChannelChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPFileChannelChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PFileChannelChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PFileChannelConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), channelId);
// Sentinel = 'channelId'
((&(writer__)))->WriteSentinel(301138823);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PFileChannelConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PFileChannelChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendRequestContextLoadBegin(const uint64_t& rcid) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_RequestContextLoadBegin(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), rcid);
// Sentinel = 'rcid'
((&(writer__)))->WriteSentinel(69927331);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_RequestContextLoadBegin", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendRequestContextAfterDOMContentLoaded(const uint64_t& rcid) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_RequestContextAfterDOMContentLoaded(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), rcid);
// Sentinel = 'rcid'
((&(writer__)))->WriteSentinel(69927331);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_RequestContextAfterDOMContentLoaded", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendRemoveRequestContext(const uint64_t& rcid) -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_RemoveRequestContext(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), rcid);
// Sentinel = 'rcid'
((&(writer__)))->WriteSentinel(69927331);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_RemoveRequestContext", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendPAltDataOutputStreamConstructor(
const nsACString& type,
const int64_t& predictedSize,
mozilla::NotNull<PHttpChannelChild*> channel) -> PAltDataOutputStreamChild*
{
PAltDataOutputStreamChild* actor = (static_cast<NeckoChild*>(this))->AllocPAltDataOutputStreamChild(type, predictedSize, channel);
return SendPAltDataOutputStreamConstructor(std::move(actor), std::move(type), std::move(predictedSize), channel);
}
auto PNeckoChild::SendPAltDataOutputStreamConstructor(
PAltDataOutputStreamChild* actor,
const nsACString& type,
const int64_t& predictedSize,
mozilla::NotNull<PHttpChannelChild*> channel) -> PAltDataOutputStreamChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PAltDataOutputStreamChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPAltDataOutputStreamChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PAltDataOutputStreamChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PAltDataOutputStreamConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), type);
// Sentinel = 'type'
((&(writer__)))->WriteSentinel(75760067);
IPC::WriteParam((&(writer__)), predictedSize);
// Sentinel = 'predictedSize'
((&(writer__)))->WriteSentinel(628819280);
IPC::WriteParam((&(writer__)), channel);
// Sentinel = 'channel'
((&(writer__)))->WriteSentinel(189334234);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PAltDataOutputStreamConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PAltDataOutputStreamChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPStunAddrsRequestConstructor() -> PStunAddrsRequestChild*
{
PStunAddrsRequestChild* actor = (static_cast<NeckoChild*>(this))->AllocPStunAddrsRequestChild();
return SendPStunAddrsRequestConstructor(std::move(actor));
}
auto PNeckoChild::SendPStunAddrsRequestConstructor(PStunAddrsRequestChild* actor) -> PStunAddrsRequestChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PStunAddrsRequestChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPStunAddrsRequestChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PStunAddrsRequestChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PStunAddrsRequestConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PStunAddrsRequestConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PStunAddrsRequestChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendPWebrtcTCPSocketConstructor(const mozilla::Maybe<TabId>& tabId) -> PWebrtcTCPSocketChild*
{
PWebrtcTCPSocketChild* actor = (static_cast<NeckoChild*>(this))->AllocPWebrtcTCPSocketChild(tabId);
return SendPWebrtcTCPSocketConstructor(std::move(actor), std::move(tabId));
}
auto PNeckoChild::SendPWebrtcTCPSocketConstructor(
PWebrtcTCPSocketChild* actor,
const mozilla::Maybe<TabId>& tabId) -> PWebrtcTCPSocketChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PWebrtcTCPSocketChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPWebrtcTCPSocketChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PWebrtcTCPSocketChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PWebrtcTCPSocketConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), tabId);
// Sentinel = 'tabId'
((&(writer__)))->WriteSentinel(99156453);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PWebrtcTCPSocketConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PWebrtcTCPSocketChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::SendGetExtensionStream(
nsIURI* uri,
mozilla::ipc::ResolveCallback<RefPtr<nsIInputStream>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_GetExtensionStream(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionStream", OTHER);
ChannelSend(std::move(msg__), PNecko::Reply_GetExtensionStream__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PNeckoChild::SendGetExtensionStream(nsIURI* uri) -> RefPtr<GetExtensionStreamPromise>
{
RefPtr<MozPromise<RefPtr<nsIInputStream>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<RefPtr<nsIInputStream>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetExtensionStream(std::move(uri), [promise__](RefPtr<nsIInputStream>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PNeckoChild::SendGetExtensionFD(
nsIURI* uri,
mozilla::ipc::ResolveCallback<FileDescriptor>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_GetExtensionFD(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionFD", OTHER);
ChannelSend(std::move(msg__), PNecko::Reply_GetExtensionFD__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PNeckoChild::SendGetExtensionFD(nsIURI* uri) -> RefPtr<GetExtensionFDPromise>
{
RefPtr<MozPromise<FileDescriptor, ResponseRejectReason, true>::Private> promise__ = new MozPromise<FileDescriptor, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetExtensionFD(std::move(uri), [promise__](FileDescriptor&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PNeckoChild::SendInitSocketProcessBridge(
mozilla::ipc::ResolveCallback<Endpoint<::mozilla::net::PSocketProcessBridgeChild>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_InitSocketProcessBridge(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_InitSocketProcessBridge", OTHER);
ChannelSend(std::move(msg__), PNecko::Reply_InitSocketProcessBridge__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PNeckoChild::SendInitSocketProcessBridge() -> RefPtr<InitSocketProcessBridgePromise>
{
RefPtr<MozPromise<Endpoint<::mozilla::net::PSocketProcessBridgeChild>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<Endpoint<::mozilla::net::PSocketProcessBridgeChild>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendInitSocketProcessBridge([promise__](Endpoint<::mozilla::net::PSocketProcessBridgeChild>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PNeckoChild::SendResetSocketProcessBridge() -> bool
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_ResetSocketProcessBridge(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_ResetSocketProcessBridge", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
return sendok__;
}
auto PNeckoChild::SendEnsureHSTSData(
mozilla::ipc::ResolveCallback<bool>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_EnsureHSTSData(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_EnsureHSTSData", OTHER);
ChannelSend(std::move(msg__), PNecko::Reply_EnsureHSTSData__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PNeckoChild::SendEnsureHSTSData() -> RefPtr<EnsureHSTSDataPromise>
{
RefPtr<MozPromise<bool, ResponseRejectReason, true>::Private> promise__ = new MozPromise<bool, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendEnsureHSTSData([promise__](bool&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PNeckoChild::SendGetPageThumbStream(
nsIURI* uri,
const LoadInfoArgs& loadInfo,
mozilla::ipc::ResolveCallback<mozilla::Maybe<RemoteStreamInfo>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_GetPageThumbStream(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), loadInfo);
// Sentinel = 'loadInfo'
((&(writer__)))->WriteSentinel(240386861);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetPageThumbStream", OTHER);
ChannelSend(std::move(msg__), PNecko::Reply_GetPageThumbStream__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PNeckoChild::SendGetPageThumbStream(
nsIURI* uri,
const LoadInfoArgs& loadInfo) -> RefPtr<GetPageThumbStreamPromise>
{
RefPtr<MozPromise<mozilla::Maybe<RemoteStreamInfo>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<RemoteStreamInfo>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetPageThumbStream(std::move(uri), std::move(loadInfo), [promise__](mozilla::Maybe<RemoteStreamInfo>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PNeckoChild::SendGetPageIconStream(
nsIURI* uri,
const LoadInfoArgs& loadInfo,
mozilla::ipc::ResolveCallback<mozilla::Maybe<RemoteStreamInfo>>&& aResolve,
mozilla::ipc::RejectCallback&& aReject) -> void
{
UniquePtr<IPC::Message> msg__ = PNecko::Msg_GetPageIconStream(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), uri);
// Sentinel = 'uri'
((&(writer__)))->WriteSentinel(45023569);
IPC::WriteParam((&(writer__)), loadInfo);
// Sentinel = 'loadInfo'
((&(writer__)))->WriteSentinel(240386861);
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetPageIconStream", OTHER);
ChannelSend(std::move(msg__), PNecko::Reply_GetPageIconStream__ID, std::move(aResolve), std::move(aReject));
return;
}
auto PNeckoChild::SendGetPageIconStream(
nsIURI* uri,
const LoadInfoArgs& loadInfo) -> RefPtr<GetPageIconStreamPromise>
{
RefPtr<MozPromise<mozilla::Maybe<RemoteStreamInfo>, ResponseRejectReason, true>::Private> promise__ = new MozPromise<mozilla::Maybe<RemoteStreamInfo>, ResponseRejectReason, true>::Private(__func__);
promise__->UseDirectTaskDispatch(__func__);
SendGetPageIconStream(std::move(uri), std::move(loadInfo), [promise__](mozilla::Maybe<RemoteStreamInfo>&& aValue) {
promise__->Resolve(std::move(aValue), __func__);
}, [promise__](ResponseRejectReason&& aReason) {
promise__->Reject(std::move(aReason), __func__);
});
return promise__;
}
auto PNeckoChild::SendPTCPSocketConstructor(
const nsAString& host,
const uint16_t& port) -> PTCPSocketChild*
{
PTCPSocketChild* actor = (static_cast<NeckoChild*>(this))->AllocPTCPSocketChild(host, port);
return SendPTCPSocketConstructor(std::move(actor), std::move(host), std::move(port));
}
auto PNeckoChild::SendPTCPSocketConstructor(
PTCPSocketChild* actor,
const nsAString& host,
const uint16_t& port) -> PTCPSocketChild*
{
if (!actor) {
NS_WARNING("Cannot bind null PTCPSocketChild actor");
return nullptr;
}
if (actor->SetManagerAndRegister(this)) {
mManagedPTCPSocketChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PTCPSocketChild actor");
return nullptr;
}
// Build our constructor message.
UniquePtr<IPC::Message> msg__ = PNecko::Msg_PTCPSocketConstructor(Id());
IPC::MessageWriter writer__{
(*(msg__)),
this};
IPC::WriteParam((&(writer__)), actor);
// Sentinel = 'actor'
((&(writer__)))->WriteSentinel(102892058);
IPC::WriteParam((&(writer__)), host);
// Sentinel = 'host'
((&(writer__)))->WriteSentinel(72024511);
IPC::WriteParam((&(writer__)), port);
// Sentinel = 'port'
((&(writer__)))->WriteSentinel(73990598);
// Notify the other side about the newly created actor. This can
// fail if our manager has already been destroyed.
//
// NOTE: If the send call fails due to toplevel channel teardown,
// the `IProtocol::ChannelSend` wrapper absorbs the error for us,
// so we don't tear down actors unexpectedly.
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Sending ",
msg__->type(),
mozilla::ipc::MessageDirection::eSending);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PTCPSocketConstructor", OTHER);
bool sendok__ = ChannelSend(std::move(msg__));
// Warn, destroy the actor, and return null if the message failed to
// send. Otherwise, return the successfully created actor reference.
if (!sendok__) {
NS_WARNING("Error sending PTCPSocketChild constructor");
actor->ActorDisconnected(FailedConstructor);
return nullptr;
}
return actor;
}
auto PNeckoChild::RemoveManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PHttpChannelMsgStart:
mManagedPHttpChannelChild.EnsureRemoved(static_cast<PHttpChannelChild*>(aListener));
return;
case PCookieServiceMsgStart:
mManagedPCookieServiceChild.EnsureRemoved(static_cast<PCookieServiceChild*>(aListener));
return;
case PWebSocketMsgStart:
mManagedPWebSocketChild.EnsureRemoved(static_cast<PWebSocketChild*>(aListener));
return;
case PWebSocketEventListenerMsgStart:
mManagedPWebSocketEventListenerChild.EnsureRemoved(static_cast<PWebSocketEventListenerChild*>(aListener));
return;
case PTCPSocketMsgStart:
mManagedPTCPSocketChild.EnsureRemoved(static_cast<PTCPSocketChild*>(aListener));
return;
case PTCPServerSocketMsgStart:
mManagedPTCPServerSocketChild.EnsureRemoved(static_cast<PTCPServerSocketChild*>(aListener));
return;
case PUDPSocketMsgStart:
mManagedPUDPSocketChild.EnsureRemoved(static_cast<PUDPSocketChild*>(aListener));
return;
case PDNSRequestMsgStart:
mManagedPDNSRequestChild.EnsureRemoved(static_cast<PDNSRequestChild*>(aListener));
return;
case PDataChannelMsgStart:
mManagedPDataChannelChild.EnsureRemoved(static_cast<PDataChannelChild*>(aListener));
return;
case PGIOChannelMsgStart:
mManagedPGIOChannelChild.EnsureRemoved(static_cast<PGIOChannelChild*>(aListener));
return;
case PSimpleChannelMsgStart:
mManagedPSimpleChannelChild.EnsureRemoved(static_cast<PSimpleChannelChild*>(aListener));
return;
case PFileChannelMsgStart:
mManagedPFileChannelChild.EnsureRemoved(static_cast<PFileChannelChild*>(aListener));
return;
case PTransportProviderMsgStart:
mManagedPTransportProviderChild.EnsureRemoved(static_cast<PTransportProviderChild*>(aListener));
return;
case PAltDataOutputStreamMsgStart:
mManagedPAltDataOutputStreamChild.EnsureRemoved(static_cast<PAltDataOutputStreamChild*>(aListener));
return;
case PStunAddrsRequestMsgStart:
mManagedPStunAddrsRequestChild.EnsureRemoved(static_cast<PStunAddrsRequestChild*>(aListener));
return;
case PWebrtcTCPSocketMsgStart:
mManagedPWebrtcTCPSocketChild.EnsureRemoved(static_cast<PWebrtcTCPSocketChild*>(aListener));
return;
case PDocumentChannelMsgStart:
mManagedPDocumentChannelChild.EnsureRemoved(static_cast<PDocumentChannelChild*>(aListener));
return;
default:
FatalError("unreached");
return; }
}
auto PNeckoChild::DeallocManagee(
int32_t aProtocolId,
IProtocol* aListener) -> void
{
switch (aProtocolId) {
case PCookieServiceMsgStart:
static_cast<NeckoChild*>(this)->DeallocPCookieServiceChild(static_cast<PCookieServiceChild*>(aListener));
return;
case PWebSocketMsgStart:
static_cast<NeckoChild*>(this)->DeallocPWebSocketChild(static_cast<PWebSocketChild*>(aListener));
return;
case PWebSocketEventListenerMsgStart:
static_cast<NeckoChild*>(this)->DeallocPWebSocketEventListenerChild(static_cast<PWebSocketEventListenerChild*>(aListener));
return;
case PTCPSocketMsgStart:
static_cast<NeckoChild*>(this)->DeallocPTCPSocketChild(static_cast<PTCPSocketChild*>(aListener));
return;
case PTCPServerSocketMsgStart:
static_cast<NeckoChild*>(this)->DeallocPTCPServerSocketChild(static_cast<PTCPServerSocketChild*>(aListener));
return;
case PUDPSocketMsgStart:
static_cast<NeckoChild*>(this)->DeallocPUDPSocketChild(static_cast<PUDPSocketChild*>(aListener));
return;
case PGIOChannelMsgStart:
static_cast<NeckoChild*>(this)->DeallocPGIOChannelChild(static_cast<PGIOChannelChild*>(aListener));
return;
case PSimpleChannelMsgStart:
static_cast<NeckoChild*>(this)->DeallocPSimpleChannelChild(static_cast<PSimpleChannelChild*>(aListener));
return;
case PTransportProviderMsgStart:
static_cast<NeckoChild*>(this)->DeallocPTransportProviderChild(static_cast<PTransportProviderChild*>(aListener));
return;
case PAltDataOutputStreamMsgStart:
static_cast<NeckoChild*>(this)->DeallocPAltDataOutputStreamChild(static_cast<PAltDataOutputStreamChild*>(aListener));
return;
case PStunAddrsRequestMsgStart:
static_cast<NeckoChild*>(this)->DeallocPStunAddrsRequestChild(static_cast<PStunAddrsRequestChild*>(aListener));
return;
case PWebrtcTCPSocketMsgStart:
static_cast<NeckoChild*>(this)->DeallocPWebrtcTCPSocketChild(static_cast<PWebrtcTCPSocketChild*>(aListener));
return;
default:
FatalError("unreached");
return;
}
}
auto PNeckoChild::OnMessageReceived(const Message& msg__) -> PNeckoChild::Result
{
switch (msg__.type()) {
case MANAGED_ENDPOINT_BOUND_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
return MsgProcessed;
}
case MANAGED_ENDPOINT_DROPPED_MESSAGE_TYPE:
{
if (!mAwaitingManagedEndpointBind) {
NS_WARNING("Unexpected managed endpoint lifecycle message after actor bound!");
return MsgNotAllowed;
}
mAwaitingManagedEndpointBind = false;
this->ActorDisconnected(ManagedEndpointDropped);
return MsgProcessed;
}
case PNecko::Reply___delete____ID:
{
return MsgProcessed;
}
case PNecko::Reply_PCookieServiceConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PHttpChannelConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PWebSocketConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PTCPServerSocketConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PUDPSocketConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PDNSRequestConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PDocumentChannelConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PWebSocketEventListenerConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PDataChannelConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PGIOChannelConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PSimpleChannelConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PFileChannelConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PAltDataOutputStreamConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PStunAddrsRequestConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_PWebrtcTCPSocketConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Reply_GetExtensionStream__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionStream", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<RefPtr<nsIInputStream>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__stream = IPC::ReadParam<RefPtr<nsIInputStream>>((&(reader__)));
if (!maybe__stream) {
FatalError("Error deserializing 'nsIInputStream'");
return MsgValueError;
}
auto& stream = *maybe__stream;
// Sentinel = 'stream'
if ((!(((&(reader__)))->ReadSentinel(153223821)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIInputStream'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(stream));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PNecko::Reply_GetExtensionFD__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetExtensionFD", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<FileDescriptor> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__fd = IPC::ReadParam<FileDescriptor>((&(reader__)));
if (!maybe__fd) {
FatalError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
auto& fd = *maybe__fd;
// Sentinel = 'fd'
if ((!(((&(reader__)))->ReadSentinel(20054219)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'FileDescriptor'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(fd));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PNecko::Reply_InitSocketProcessBridge__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_InitSocketProcessBridge", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<Endpoint<::mozilla::net::PSocketProcessBridgeChild>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__endpoint = IPC::ReadParam<Endpoint<::mozilla::net::PSocketProcessBridgeChild>>((&(reader__)));
if (!maybe__endpoint) {
FatalError("Error deserializing 'Endpoint<::mozilla::net::PSocketProcessBridgeChild>'");
return MsgValueError;
}
auto& endpoint = *maybe__endpoint;
// Sentinel = 'endpoint'
if ((!(((&(reader__)))->ReadSentinel(251724642)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'Endpoint<::mozilla::net::PSocketProcessBridgeChild>'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(endpoint));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PNecko::Reply_EnsureHSTSData__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_EnsureHSTSData", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<bool> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__result = IPC::ReadParam<bool>((&(reader__)));
if (!maybe__result) {
FatalError("Error deserializing 'bool'");
return MsgValueError;
}
auto& result = *maybe__result;
// Sentinel = 'result'
if ((!(((&(reader__)))->ReadSentinel(153223840)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'bool'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(result));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PNecko::Reply_GetPageThumbStream__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetPageThumbStream", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<mozilla::Maybe<RemoteStreamInfo>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__info = IPC::ReadParam<mozilla::Maybe<RemoteStreamInfo>>((&(reader__)));
if (!maybe__info) {
FatalError("Error deserializing 'RemoteStreamInfo?'");
return MsgValueError;
}
auto& info = *maybe__info;
// Sentinel = 'info'
if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RemoteStreamInfo?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(info));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PNecko::Reply_GetPageIconStream__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_GetPageIconStream", OTHER);
IPC::MessageReader reader__{
msg__,
this};
bool resolve__ = false;
if (!IPC::ReadParam(&reader__, &resolve__)) {
FatalError("Error deserializing bool");
return MsgValueError;
}
UniquePtr<MessageChannel::UntypedCallbackHolder> untypedCallback =
GetIPCChannel()->PopCallback(msg__, Id());
typedef MessageChannel::CallbackHolder<mozilla::Maybe<RemoteStreamInfo>> CallbackHolder;
auto* callback = static_cast<CallbackHolder*>(untypedCallback.get());
if (!callback) {
FatalError("Error unknown callback");
return MsgProcessingError;
}
if (resolve__) {
auto maybe__info = IPC::ReadParam<mozilla::Maybe<RemoteStreamInfo>>((&(reader__)));
if (!maybe__info) {
FatalError("Error deserializing 'RemoteStreamInfo?'");
return MsgValueError;
}
auto& info = *maybe__info;
// Sentinel = 'info'
if ((!(((&(reader__)))->ReadSentinel(70058413)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'RemoteStreamInfo?'");
return MsgValueError;
}
reader__.EndRead();
callback->Resolve(std::move(info));
} else {
ResponseRejectReason reason__{};
if (!IPC::ReadParam(&reader__, &reason__)) {
FatalError("Error deserializing ResponseRejectReason");
return MsgValueError;
}
reader__.EndRead();
callback->Reject(std::move(reason__));
}
return MsgProcessed;
}
case PNecko::Msg_PredOnPredictPrefetch__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictPrefetch", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto maybe__httpStatus = IPC::ReadParam<uint32_t>((&(reader__)));
if (!maybe__httpStatus) {
FatalError("Error deserializing 'uint32_t'");
return MsgValueError;
}
auto& httpStatus = *maybe__httpStatus;
// Sentinel = 'httpStatus'
if ((!(((&(reader__)))->ReadSentinel(391185477)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint32_t'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvPredOnPredictPrefetch(uri, std::move(httpStatus));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Msg_PredOnPredictPreconnect__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictPreconnect", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvPredOnPredictPreconnect(uri);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Msg_PredOnPredictDNS__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PredOnPredictDNS", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__uri = IPC::ReadParam<RefPtr<nsIURI>>((&(reader__)));
if (!maybe__uri) {
FatalError("Error deserializing 'nsIURI'");
return MsgValueError;
}
auto& uri = *maybe__uri;
// Sentinel = 'uri'
if ((!(((&(reader__)))->ReadSentinel(45023569)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsIURI'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvPredOnPredictDNS(uri);
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Msg_SpeculativeConnectRequest__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_SpeculativeConnectRequest", OTHER);
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvSpeculativeConnectRequest();
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Msg_NetworkChangeNotification__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_NetworkChangeNotification", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__type = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__type) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& type = *maybe__type;
// Sentinel = 'type'
if ((!(((&(reader__)))->ReadSentinel(75760067)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvNetworkChangeNotification(std::move(type));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Msg_PTransportProviderConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PTransportProviderConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
reader__.EndRead();
PTransportProviderChild* actor = (static_cast<NeckoChild*>(this))->AllocPTransportProviderChild();
if (!actor) {
NS_WARNING("Cannot bind null PTransportProviderChild actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPTransportProviderChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PTransportProviderChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvPTransportProviderConstructor(std::move(actor));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Msg_SetTRRDomain__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_SetTRRDomain", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__domain = IPC::ReadParam<nsCString>((&(reader__)));
if (!maybe__domain) {
FatalError("Error deserializing 'nsCString'");
return MsgValueError;
}
auto& domain = *maybe__domain;
// Sentinel = 'domain'
if ((!(((&(reader__)))->ReadSentinel(144704121)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsCString'");
return MsgValueError;
}
reader__.EndRead();
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvSetTRRDomain(std::move(domain));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
case PNecko::Reply_PTCPSocketConstructor__ID:
{
return MsgProcessed;
}
case PNecko::Msg_PTCPSocketConstructor__ID:
{
if (mozilla::ipc::LoggingEnabledFor("PNecko", mozilla::ipc::ChildSide)) {
mozilla::ipc::LogMessageForProtocol(
"PNeckoChild",
this->ToplevelProtocol()->OtherPidMaybeInvalid(),
"Received ",
(&(msg__))->type(),
mozilla::ipc::MessageDirection::eReceiving);
}
AUTO_PROFILER_LABEL("PNecko::Msg_PTCPSocketConstructor", OTHER);
IPC::MessageReader reader__{
msg__,
this};
auto maybe__handle__ = IPC::ReadParam<ActorHandle>((&(reader__)));
if (!maybe__handle__) {
FatalError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto& handle__ = *maybe__handle__;
// Sentinel = 'actor'
if ((!(((&(reader__)))->ReadSentinel(102892058)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'ActorHandle'");
return MsgValueError;
}
auto maybe__host = IPC::ReadParam<nsString>((&(reader__)));
if (!maybe__host) {
FatalError("Error deserializing 'nsString'");
return MsgValueError;
}
auto& host = *maybe__host;
// Sentinel = 'host'
if ((!(((&(reader__)))->ReadSentinel(72024511)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'nsString'");
return MsgValueError;
}
auto maybe__port = IPC::ReadParam<uint16_t>((&(reader__)));
if (!maybe__port) {
FatalError("Error deserializing 'uint16_t'");
return MsgValueError;
}
auto& port = *maybe__port;
// Sentinel = 'port'
if ((!(((&(reader__)))->ReadSentinel(73990598)))) {
mozilla::ipc::SentinelReadError("Error deserializing 'uint16_t'");
return MsgValueError;
}
reader__.EndRead();
PTCPSocketChild* actor = (static_cast<NeckoChild*>(this))->AllocPTCPSocketChild(host, port);
if (!actor) {
NS_WARNING("Cannot bind null PTCPSocketChild actor");
return MsgValueError;
}
if (actor->SetManagerAndRegister(this, (handle__).mId)) {
mManagedPTCPSocketChild.Insert(actor);
} else {
NS_WARNING("Failed to bind PTCPSocketChild actor");
return MsgValueError;
}
mozilla::ipc::IPCResult __ok = (static_cast<NeckoChild*>(this))->RecvPTCPSocketConstructor(std::move(actor), std::move(host), std::move(port));
if ((!(__ok))) {
mozilla::ipc::ProtocolErrorBreakpoint("Handler returned error code!");
// Error handled in mozilla::ipc::IPCResult
return MsgProcessingError;
}
return MsgProcessed;
}
default:
return MsgNotKnown;
}
}
auto PNeckoChild::OnMessageReceived(
const Message& msg__,
UniquePtr<Message>& reply__) -> PNeckoChild::Result
{
return MsgNotKnown;
}
auto PNeckoChild::DoomSubtree() -> void
{
for (auto* key : mManagedPHttpChannelChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPCookieServiceChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPWebSocketChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPWebSocketEventListenerChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPTCPSocketChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPTCPServerSocketChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPUDPSocketChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPDNSRequestChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPDataChannelChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPGIOChannelChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPSimpleChannelChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPFileChannelChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPTransportProviderChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPAltDataOutputStreamChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPStunAddrsRequestChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPWebrtcTCPSocketChild) {
key->DoomSubtree();
}
for (auto* key : mManagedPDocumentChannelChild) {
key->DoomSubtree();
}
SetDoomed();
}
auto PNeckoChild::PeekManagedActor() -> IProtocol*
{
if (IProtocol* actor = mManagedPHttpChannelChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPCookieServiceChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPWebSocketChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPWebSocketEventListenerChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPTCPSocketChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPTCPServerSocketChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPUDPSocketChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPDNSRequestChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPDataChannelChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPGIOChannelChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPSimpleChannelChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPFileChannelChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPTransportProviderChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPAltDataOutputStreamChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPStunAddrsRequestChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPWebrtcTCPSocketChild.Peek()) {
return actor;
}
if (IProtocol* actor = mManagedPDocumentChannelChild.Peek()) {
return actor;
}
return nullptr;
}
} // namespace net
} // namespace mozilla
namespace IPC {
auto ParamTraits<::mozilla::net::PNeckoChild*>::Write(
IPC::MessageWriter* aWriter,
const paramType& aVar) -> void
{
MOZ_RELEASE_ASSERT(
aWriter->GetActor(),
"Cannot serialize managed actors without an actor");
int32_t id;
if (!aVar) {
id = 0; // kNullActorId
} else {
id = aVar->Id();
if (id == 1) { // kFreedActorId
aVar->FatalError("Actor has been |delete|d");
}
MOZ_RELEASE_ASSERT(
aWriter->GetActor()->GetIPCChannel() == aVar->GetIPCChannel(),
"Actor must be from the same channel as the"
" actor it's being sent over");
MOZ_RELEASE_ASSERT(
aVar->CanSend(),
"Actor must still be open when sending");
}
IPC::WriteParam(aWriter, id);
}
auto ParamTraits<::mozilla::net::PNeckoChild*>::Read(IPC::MessageReader* aReader) -> IPC::ReadResult<paramType>
{
MOZ_RELEASE_ASSERT(
aReader->GetActor(),
"Cannot deserialize managed actors without an actor");
mozilla::Maybe<mozilla::ipc::IProtocol*> actor = aReader->GetActor()
->ReadActor(aReader, true, "PNecko", PNeckoMsgStart);
if (actor.isSome()) {
return static_cast<::mozilla::net::PNeckoChild*>(actor.ref());
}
return {};
}
} // namespace IPC