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

#ifndef PSocketProcess_h
#define PSocketProcess_h

#include "mozilla/Attributes.h"
#include "IPCMessageStart.h"
#include "mozilla/RefPtr.h"
#include "nsString.h"
#include "nsTArray.h"
#include "nsTHashtable.h"
#include "mozilla/MozPromise.h"
#include "mozilla/OperatorNewExtensions.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/ipc/ByteBuf.h"
#include "mozilla/ipc/FileDescriptor.h"
#include "mozilla/ipc/IPCForwards.h"
#include "mozilla/ipc/Shmem.h"

// Headers for typedefs
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/net/DashboardTypes.h"
#include "CrashReporter/CrashReporterInitArgs.h"
#include "mozilla/dom/MemoryReportTypes.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/dom/PrefsTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct HttpHandlerInitArgs|
//
namespace mozilla {
namespace net {
class HttpHandlerInitArgs final
{
private:
    typedef ::nsCString nsCString;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    HttpHandlerInitArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT HttpHandlerInitArgs(
            const nsCString& _mLegacyAppName,
            const nsCString& _mLegacyAppVersion,
            const nsCString& _mPlatform,
            const nsCString& _mOscpu,
            const nsCString& _mMisc,
            const nsCString& _mProduct,
            const nsCString& _mProductSub,
            const nsCString& _mAppName,
            const nsCString& _mAppVersion,
            const nsCString& _mCompatFirefox,
            const nsCString& _mCompatDevice,
            const nsCString& _mDeviceModelId) :
        mLegacyAppName_(_mLegacyAppName),
        mLegacyAppVersion_(_mLegacyAppVersion),
        mPlatform_(_mPlatform),
        mOscpu_(_mOscpu),
        mMisc_(_mMisc),
        mProduct_(_mProduct),
        mProductSub_(_mProductSub),
        mAppName_(_mAppName),
        mAppVersion_(_mAppVersion),
        mCompatFirefox_(_mCompatFirefox),
        mCompatDevice_(_mCompatDevice),
        mDeviceModelId_(_mDeviceModelId)
    {
    }

    MOZ_IMPLICIT HttpHandlerInitArgs(
            nsCString&& _mLegacyAppName,
            nsCString&& _mLegacyAppVersion,
            nsCString&& _mPlatform,
            nsCString&& _mOscpu,
            nsCString&& _mMisc,
            nsCString&& _mProduct,
            nsCString&& _mProductSub,
            nsCString&& _mAppName,
            nsCString&& _mAppVersion,
            nsCString&& _mCompatFirefox,
            nsCString&& _mCompatDevice,
            nsCString&& _mDeviceModelId) :
        mLegacyAppName_(std::move(_mLegacyAppName)),
        mLegacyAppVersion_(std::move(_mLegacyAppVersion)),
        mPlatform_(std::move(_mPlatform)),
        mOscpu_(std::move(_mOscpu)),
        mMisc_(std::move(_mMisc)),
        mProduct_(std::move(_mProduct)),
        mProductSub_(std::move(_mProductSub)),
        mAppName_(std::move(_mAppName)),
        mAppVersion_(std::move(_mAppVersion)),
        mCompatFirefox_(std::move(_mCompatFirefox)),
        mCompatDevice_(std::move(_mCompatDevice)),
        mDeviceModelId_(std::move(_mDeviceModelId))
    {
    }

    nsCString&
    mLegacyAppName()
    {
        return mLegacyAppName_;
    }
    const nsCString&
    mLegacyAppName() const
    {
        return mLegacyAppName_;
    }

    nsCString&
    mLegacyAppVersion()
    {
        return mLegacyAppVersion_;
    }
    const nsCString&
    mLegacyAppVersion() const
    {
        return mLegacyAppVersion_;
    }

    nsCString&
    mPlatform()
    {
        return mPlatform_;
    }
    const nsCString&
    mPlatform() const
    {
        return mPlatform_;
    }

    nsCString&
    mOscpu()
    {
        return mOscpu_;
    }
    const nsCString&
    mOscpu() const
    {
        return mOscpu_;
    }

    nsCString&
    mMisc()
    {
        return mMisc_;
    }
    const nsCString&
    mMisc() const
    {
        return mMisc_;
    }

    nsCString&
    mProduct()
    {
        return mProduct_;
    }
    const nsCString&
    mProduct() const
    {
        return mProduct_;
    }

    nsCString&
    mProductSub()
    {
        return mProductSub_;
    }
    const nsCString&
    mProductSub() const
    {
        return mProductSub_;
    }

    nsCString&
    mAppName()
    {
        return mAppName_;
    }
    const nsCString&
    mAppName() const
    {
        return mAppName_;
    }

    nsCString&
    mAppVersion()
    {
        return mAppVersion_;
    }
    const nsCString&
    mAppVersion() const
    {
        return mAppVersion_;
    }

    nsCString&
    mCompatFirefox()
    {
        return mCompatFirefox_;
    }
    const nsCString&
    mCompatFirefox() const
    {
        return mCompatFirefox_;
    }

    nsCString&
    mCompatDevice()
    {
        return mCompatDevice_;
    }
    const nsCString&
    mCompatDevice() const
    {
        return mCompatDevice_;
    }

    nsCString&
    mDeviceModelId()
    {
        return mDeviceModelId_;
    }
    const nsCString&
    mDeviceModelId() const
    {
        return mDeviceModelId_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<nsCString> mLegacyAppName_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mLegacyAppVersion_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mPlatform_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mOscpu_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mMisc_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mProduct_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mProductSub_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mAppName_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mAppVersion_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mCompatFirefox_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mCompatDevice_;
    ::mozilla::ipc::IPDLStructMember<nsCString> mDeviceModelId_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::HttpHandlerInitArgs>
{
    typedef ::mozilla::net::HttpHandlerInitArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SocketDataArgs|
//
namespace mozilla {
namespace net {
class SocketDataArgs final
{
private:
    typedef ::uint64_t uint64_t;
    typedef ::mozilla::net::SocketInfo SocketInfo;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SocketDataArgs() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT SocketDataArgs(
            const uint64_t& _totalSent,
            const uint64_t& _totalRecv,
            const nsTArray<SocketInfo>& _info) :
        info_(_info),
        totalSent_(_totalSent),
        totalRecv_(_totalRecv)
    {
    }

    MOZ_IMPLICIT SocketDataArgs(
            uint64_t&& _totalSent,
            uint64_t&& _totalRecv,
            nsTArray<SocketInfo>&& _info) :
        info_(std::move(_info)),
        totalSent_(std::move(_totalSent)),
        totalRecv_(std::move(_totalRecv))
    {
    }

    uint64_t&
    totalSent()
    {
        return totalSent_;
    }
    const uint64_t&
    totalSent() const
    {
        return totalSent_;
    }

    uint64_t&
    totalRecv()
    {
        return totalRecv_;
    }
    const uint64_t&
    totalRecv() const
    {
        return totalRecv_;
    }

    nsTArray<SocketInfo>&
    info()
    {
        return info_;
    }
    const nsTArray<SocketInfo>&
    info() const
    {
        return info_;
    }

private:
    void
    StaticAssertions() const;
    ::mozilla::ipc::IPDLStructMember<CopyableTArray<SocketInfo>> info_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> totalSent_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> totalRecv_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::SocketDataArgs>
{
    typedef ::mozilla::net::SocketDataArgs paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct SocketPorcessInitAttributes|
//
namespace mozilla {
namespace net {
class SocketPorcessInitAttributes final
{
private:
    typedef ::mozilla::ipc::FileDescriptor FileDescriptor;

public:
#ifdef __clang__
#  pragma clang diagnostic push
#  if __has_warning("-Wdefaulted-function-deleted")
#    pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
#  endif
#endif
    SocketPorcessInitAttributes() = default;
#ifdef __clang__
#  pragma clang diagnostic pop
#endif

    MOZ_IMPLICIT SocketPorcessInitAttributes(
            const bool& _mOffline,
            const bool& _mConnectivity,
            const bool& _mInitSandbox,
            const mozilla::Maybe<FileDescriptor>& _mSandboxBroker) :
        mOffline_(_mOffline),
        mConnectivity_(_mConnectivity),
        mInitSandbox_(_mInitSandbox),
        mSandboxBroker_(_mSandboxBroker)
    {
    }

    MOZ_IMPLICIT SocketPorcessInitAttributes(
            bool&& _mOffline,
            bool&& _mConnectivity,
            bool&& _mInitSandbox,
            mozilla::Maybe<FileDescriptor>&& _mSandboxBroker) :
        mOffline_(std::move(_mOffline)),
        mConnectivity_(std::move(_mConnectivity)),
        mInitSandbox_(std::move(_mInitSandbox)),
        mSandboxBroker_(std::move(_mSandboxBroker))
    {
    }

    bool&
    mOffline()
    {
        return mOffline_;
    }
    const bool&
    mOffline() const
    {
        return mOffline_;
    }

    bool&
    mConnectivity()
    {
        return mConnectivity_;
    }
    const bool&
    mConnectivity() const
    {
        return mConnectivity_;
    }

    bool&
    mInitSandbox()
    {
        return mInitSandbox_;
    }
    const bool&
    mInitSandbox() const
    {
        return mInitSandbox_;
    }

    mozilla::Maybe<FileDescriptor>&
    mSandboxBroker()
    {
        return mSandboxBroker_;
    }
    const mozilla::Maybe<FileDescriptor>&
    mSandboxBroker() const
    {
        return mSandboxBroker_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<bool> mOffline_;
    ::mozilla::ipc::IPDLStructMember<bool> mConnectivity_;
    ::mozilla::ipc::IPDLStructMember<bool> mInitSandbox_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<FileDescriptor>> mSandboxBroker_;
};
} // namespace net
} // namespace mozilla

namespace IPC {
template<>
struct ParamTraits <::mozilla::net::SocketPorcessInitAttributes>
{
    typedef ::mozilla::net::SocketPorcessInitAttributes paramType;
    static void
    Write(
            IPC::MessageWriter* aWriter,
            const paramType& aVar);
    static IPC::ReadResult<paramType>
    Read(IPC::MessageReader* aReader);
};
} // namespace IPC

namespace mozilla {
namespace net {
class PSocketProcessParent;
} // namespace net
} // namespace mozilla
namespace mozilla {
namespace net {
class PSocketProcessChild;
} // namespace net
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PSocketProcessChild and PSocketProcessParent
//
namespace mozilla {
namespace net {
namespace PSocketProcess {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::net::PSocketProcessParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::net::PSocketProcessChild>* aChild);

enum MessageType {
    PSocketProcessStart = PSocketProcessMsgStart << 16,
    Msg_InitCrashReporter__ID,
    Msg_AddMemoryReport__ID,
    Msg_AccumulateChildHistograms__ID,
    Msg_AccumulateChildKeyedHistograms__ID,
    Msg_UpdateChildScalars__ID,
    Msg_UpdateChildKeyedScalars__ID,
    Msg_RecordChildEvents__ID,
    Msg_RecordDiscardedData__ID,
    Msg_PWebrtcTCPSocketConstructor__ID,
    Reply_PWebrtcTCPSocketConstructor__ID,
    Msg_ObserveHttpActivity__ID,
    Msg_InitSocketBackground__ID,
    Msg_PAltServiceConstructor__ID,
    Reply_PAltServiceConstructor__ID,
    Msg_PProxyConfigLookupConstructor__ID,
    Reply_PProxyConfigLookupConstructor__ID,
    Msg_ExcludeHttp2OrHttp3__ID,
    Msg_OnConsoleMessage__ID,
    Msg_FOGData__ID,
    Msg_GeckoTraceExport__ID,
    Msg_Init__ID,
    Msg_PreferenceUpdate__ID,
    Msg_RequestMemoryReport__ID,
    Reply_RequestMemoryReport__ID,
    Msg_SetOffline__ID,
    Msg_SetConnectivity__ID,
    Msg_InitLinuxSandbox__ID,
    Msg_InitSocketProcessBridgeParent__ID,
    Msg_InitProfiler__ID,
    Msg_SocketProcessTelemetryPing__ID,
    Msg_PHttpTransactionConstructor__ID,
    Reply_PHttpTransactionConstructor__ID,
    Msg_PHttpConnectionMgrConstructor__ID,
    Reply_PHttpConnectionMgrConstructor__ID,
    Msg_UpdateDeviceModelId__ID,
    Msg_OnHttpActivityDistributorActivated__ID,
    Msg_OnHttpActivityDistributorObserveProxyResponse__ID,
    Msg_OnHttpActivityDistributorObserveConnection__ID,
    Msg_PInputChannelThrottleQueueConstructor__ID,
    Reply_PInputChannelThrottleQueueConstructor__ID,
    Msg_PAltSvcTransactionConstructor__ID,
    Reply_PAltSvcTransactionConstructor__ID,
    Msg_ClearSessionCache__ID,
    Reply_ClearSessionCache__ID,
    Msg_PTRRServiceConstructor__ID,
    Reply_PTRRServiceConstructor__ID,
    Msg_PNativeDNSResolverOverrideConstructor__ID,
    Reply_PNativeDNSResolverOverrideConstructor__ID,
    Msg_NotifyObserver__ID,
    Msg_GetSocketData__ID,
    Reply_GetSocketData__ID,
    Msg_GetDNSCacheEntries__ID,
    Reply_GetDNSCacheEntries__ID,
    Msg_GetHttpConnectionData__ID,
    Reply_GetHttpConnectionData__ID,
    Msg_GetHttp3ConnectionStatsData__ID,
    Reply_GetHttp3ConnectionStatsData__ID,
    Msg_InitProxyAutoConfigChild__ID,
    Msg_RecheckIPConnectivity__ID,
    Msg_RecheckDNS__ID,
    Msg_FlushFOGData__ID,
    Reply_FlushFOGData__ID,
    Msg_TestTriggerMetrics__ID,
    Reply_TestTriggerMetrics__ID,
    Msg_AddNetAddrOverride__ID,
    Msg_ClearNetAddrOverrides__ID,
    Msg_PDNSRequestConstructor__ID,
    Reply_PDNSRequestConstructor__ID,
    PSocketProcessEnd
};

mozilla::UniquePtr<IPC::Message>
Msg_InitCrashReporter(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_AddMemoryReport(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_AccumulateChildHistograms(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_AccumulateChildKeyedHistograms(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_UpdateChildScalars(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_UpdateChildKeyedScalars(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_RecordChildEvents(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_RecordDiscardedData(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PWebrtcTCPSocketConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PWebrtcTCPSocketConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ObserveHttpActivity(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_InitSocketBackground(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PAltServiceConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PAltServiceConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PProxyConfigLookupConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PProxyConfigLookupConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ExcludeHttp2OrHttp3(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_OnConsoleMessage(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_FOGData(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GeckoTraceExport(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_Init(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PreferenceUpdate(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_RequestMemoryReport(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_RequestMemoryReport(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_SetOffline(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_SetConnectivity(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_InitLinuxSandbox(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_InitSocketProcessBridgeParent(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_InitProfiler(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_SocketProcessTelemetryPing(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PHttpTransactionConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PHttpTransactionConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PHttpConnectionMgrConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PHttpConnectionMgrConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_UpdateDeviceModelId(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_OnHttpActivityDistributorActivated(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_OnHttpActivityDistributorObserveProxyResponse(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_OnHttpActivityDistributorObserveConnection(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PInputChannelThrottleQueueConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PInputChannelThrottleQueueConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PAltSvcTransactionConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PAltSvcTransactionConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ClearSessionCache(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_ClearSessionCache(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PTRRServiceConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PTRRServiceConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PNativeDNSResolverOverrideConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PNativeDNSResolverOverrideConstructor(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_NotifyObserver(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GetSocketData(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetSocketData(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GetDNSCacheEntries(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetDNSCacheEntries(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GetHttpConnectionData(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetHttpConnectionData(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_GetHttp3ConnectionStatsData(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_GetHttp3ConnectionStatsData(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_InitProxyAutoConfigChild(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_RecheckIPConnectivity(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_RecheckDNS(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_FlushFOGData(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_FlushFOGData(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_TestTriggerMetrics(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_TestTriggerMetrics(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_AddNetAddrOverride(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_ClearNetAddrOverrides(IPC::Message::routeid_t routingId);

mozilla::UniquePtr<IPC::Message>
Msg_PDNSRequestConstructor(IPC::Message::routeid_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply_PDNSRequestConstructor(IPC::Message::routeid_t routingId);



} // namespace PSocketProcess
} // namespace net
} // namespace mozilla

#endif // ifndef PSocketProcess_h
