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

#ifndef PFetch_h
#define PFetch_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/dom/ClientIPCTypes.h"
#include "mozilla/dom/FetchTypes.h"
#include "mozilla/dom/IPCServiceWorkerDescriptor.h"
#include "mozilla/net/NeckoChannelParams.h"
#include "mozilla/ipc/PBackgroundSharedTypes.h"
#include "mozilla/dom/PerformanceTimingTypes.h"


//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct FetchOpArgs|
//
namespace mozilla {
namespace dom {
class FetchOpArgs final
{
private:
    typedef ::mozilla::dom::IPCInternalRequest IPCInternalRequest;
    typedef ::mozilla::ipc::PrincipalInfo PrincipalInfo;
    typedef ::nsCString nsCString;
    typedef ::mozilla::dom::IPCClientInfo IPCClientInfo;
    typedef ::mozilla::dom::IPCServiceWorkerDescriptor IPCServiceWorkerDescriptor;
    typedef ::mozilla::net::CookieJarSettingsArgs CookieJarSettingsArgs;
    typedef ::uint64_t uint64_t;

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

    MOZ_IMPLICIT FetchOpArgs(
            const IPCInternalRequest& _request,
            const PrincipalInfo& _principalInfo,
            const nsCString& _workerScript,
            const IPCClientInfo& _clientInfo,
            const mozilla::Maybe<IPCServiceWorkerDescriptor>& _controller,
            const mozilla::Maybe<CookieJarSettingsArgs>& _cookieJarSettings,
            const bool& _needOnDataAvailable,
            const bool& _hasCSPEventListener,
            const uint64_t& _associatedBrowsingContextID,
            const bool& _isThirdPartyContext,
            const bool& _isWorkerRequest,
            const bool& _isOn3PCBExceptionList) :
        request_(_request),
        principalInfo_(_principalInfo),
        workerScript_(_workerScript),
        clientInfo_(_clientInfo),
        controller_(_controller),
        cookieJarSettings_(_cookieJarSettings),
        needOnDataAvailable_(_needOnDataAvailable),
        hasCSPEventListener_(_hasCSPEventListener),
        isThirdPartyContext_(_isThirdPartyContext),
        isWorkerRequest_(_isWorkerRequest),
        isOn3PCBExceptionList_(_isOn3PCBExceptionList),
        associatedBrowsingContextID_(_associatedBrowsingContextID)
    {
    }

    MOZ_IMPLICIT FetchOpArgs(
            IPCInternalRequest&& _request,
            PrincipalInfo&& _principalInfo,
            nsCString&& _workerScript,
            IPCClientInfo&& _clientInfo,
            mozilla::Maybe<IPCServiceWorkerDescriptor>&& _controller,
            mozilla::Maybe<CookieJarSettingsArgs>&& _cookieJarSettings,
            bool&& _needOnDataAvailable,
            bool&& _hasCSPEventListener,
            uint64_t&& _associatedBrowsingContextID,
            bool&& _isThirdPartyContext,
            bool&& _isWorkerRequest,
            bool&& _isOn3PCBExceptionList) :
        request_(std::move(_request)),
        principalInfo_(std::move(_principalInfo)),
        workerScript_(std::move(_workerScript)),
        clientInfo_(std::move(_clientInfo)),
        controller_(std::move(_controller)),
        cookieJarSettings_(std::move(_cookieJarSettings)),
        needOnDataAvailable_(std::move(_needOnDataAvailable)),
        hasCSPEventListener_(std::move(_hasCSPEventListener)),
        isThirdPartyContext_(std::move(_isThirdPartyContext)),
        isWorkerRequest_(std::move(_isWorkerRequest)),
        isOn3PCBExceptionList_(std::move(_isOn3PCBExceptionList)),
        associatedBrowsingContextID_(std::move(_associatedBrowsingContextID))
    {
    }

    IPCInternalRequest&
    request()
    {
        return request_;
    }
    const IPCInternalRequest&
    request() const
    {
        return request_;
    }

    PrincipalInfo&
    principalInfo()
    {
        return principalInfo_;
    }
    const PrincipalInfo&
    principalInfo() const
    {
        return principalInfo_;
    }

    nsCString&
    workerScript()
    {
        return workerScript_;
    }
    const nsCString&
    workerScript() const
    {
        return workerScript_;
    }

    IPCClientInfo&
    clientInfo()
    {
        return clientInfo_;
    }
    const IPCClientInfo&
    clientInfo() const
    {
        return clientInfo_;
    }

    mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller()
    {
        return controller_;
    }
    const mozilla::Maybe<IPCServiceWorkerDescriptor>&
    controller() const
    {
        return controller_;
    }

    mozilla::Maybe<CookieJarSettingsArgs>&
    cookieJarSettings()
    {
        return cookieJarSettings_;
    }
    const mozilla::Maybe<CookieJarSettingsArgs>&
    cookieJarSettings() const
    {
        return cookieJarSettings_;
    }

    bool&
    needOnDataAvailable()
    {
        return needOnDataAvailable_;
    }
    const bool&
    needOnDataAvailable() const
    {
        return needOnDataAvailable_;
    }

    bool&
    hasCSPEventListener()
    {
        return hasCSPEventListener_;
    }
    const bool&
    hasCSPEventListener() const
    {
        return hasCSPEventListener_;
    }

    uint64_t&
    associatedBrowsingContextID()
    {
        return associatedBrowsingContextID_;
    }
    const uint64_t&
    associatedBrowsingContextID() const
    {
        return associatedBrowsingContextID_;
    }

    bool&
    isThirdPartyContext()
    {
        return isThirdPartyContext_;
    }
    const bool&
    isThirdPartyContext() const
    {
        return isThirdPartyContext_;
    }

    bool&
    isWorkerRequest()
    {
        return isWorkerRequest_;
    }
    const bool&
    isWorkerRequest() const
    {
        return isWorkerRequest_;
    }

    bool&
    isOn3PCBExceptionList()
    {
        return isOn3PCBExceptionList_;
    }
    const bool&
    isOn3PCBExceptionList() const
    {
        return isOn3PCBExceptionList_;
    }

private:
    ::mozilla::ipc::IPDLStructMember<IPCInternalRequest> request_;
    ::mozilla::ipc::IPDLStructMember<PrincipalInfo> principalInfo_;
    ::mozilla::ipc::IPDLStructMember<nsCString> workerScript_;
    ::mozilla::ipc::IPDLStructMember<IPCClientInfo> clientInfo_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<IPCServiceWorkerDescriptor>> controller_;
    ::mozilla::ipc::IPDLStructMember<mozilla::Maybe<CookieJarSettingsArgs>> cookieJarSettings_;
    ::mozilla::ipc::IPDLStructMember<bool> needOnDataAvailable_;
    ::mozilla::ipc::IPDLStructMember<bool> hasCSPEventListener_;
    ::mozilla::ipc::IPDLStructMember<bool> isThirdPartyContext_;
    ::mozilla::ipc::IPDLStructMember<bool> isWorkerRequest_;
    ::mozilla::ipc::IPDLStructMember<bool> isOn3PCBExceptionList_;
    ::mozilla::ipc::IPDLStructMember<uint64_t> associatedBrowsingContextID_;
};
} // namespace dom
} // namespace mozilla

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

namespace mozilla {
namespace dom {
class PFetchParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PFetchChild;
} // namespace dom
} // namespace mozilla

//-----------------------------------------------------------------------------
// Code common to PFetchChild and PFetchParent
//
namespace mozilla {
namespace dom {
namespace PFetch {

nsresult
CreateEndpoints(
        mozilla::ipc::EndpointProcInfo aParentDestInfo,
        mozilla::ipc::EndpointProcInfo aChildDestInfo,
        mozilla::ipc::Endpoint<::mozilla::dom::PFetchParent>* aParent,
        mozilla::ipc::Endpoint<::mozilla::dom::PFetchChild>* aChild);

enum MessageType {
    PFetchStart = PFetchMsgStart << 16,
    Msg_FetchOp__ID,
    Msg_AbortFetchOp__ID,
    Msg_OnResponseAvailableInternal__ID,
    Msg_OnResponseEnd__ID,
    Msg_OnDataAvailable__ID,
    Msg_OnFlushConsoleReport__ID,
    Msg_OnCSPViolationEvent__ID,
    Msg_OnReportPerformanceTiming__ID,
    Msg_OnNotifyNetworkMonitorAlternateStack__ID,
    Msg___delete____ID,
    Reply___delete____ID,
    PFetchEnd
};

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

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

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

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

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

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

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

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

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

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



} // namespace PFetch
} // namespace dom
} // namespace mozilla

#endif // ifndef PFetch_h
