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

#ifndef PRemoteSpellcheckEngineParent_h
#define PRemoteSpellcheckEngineParent_h

#include "mozilla/PRemoteSpellcheckEngine.h"
#ifdef DEBUG
#include "prenv.h"
#endif // DEBUG
#include "base/id_map.h"
#include "mozilla/ipc/MessageChannel.h"

namespace mozilla {
namespace dom {
class PContentParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PContentChild;
} // namespace dom
} // namespace mozilla

namespace mozilla {
namespace dom {
class PContentParent;
} // namespace dom
} // namespace mozilla

namespace mozilla {


class PRemoteSpellcheckEngineParent :
    public mozilla::ipc::IProtocol
{
    friend class mozilla::dom::PContentParent;

protected:
    typedef mozilla::ipc::ActorHandle ActorHandle;
    template<class FooSide> using Endpoint = mozilla::ipc::Endpoint<FooSide>;
    typedef mozilla::ipc::FileDescriptor FileDescriptor;
    typedef base::ProcessId ProcessId;
    typedef mozilla::ipc::ProtocolId ProtocolId;
    typedef mozilla::ipc::Shmem Shmem;
    typedef mozilla::ipc::Transport Transport;
    typedef mozilla::ipc::TransportDescriptor TransportDescriptor;
    typedef mozilla::dom::PContentParent PContentParent;
    typedef mozilla::dom::PContentChild PContentChild;

    typedef PRemoteSpellcheckEngine::State State;

    virtual bool
    Recv__delete__();
    virtual bool
    RecvCheck(
            const nsString& aWord,
            bool* aIsMisspelled) = 0;
    virtual bool
    RecvCheckAndSuggest(
            const nsString& aWord,
            bool* aIsMisspelled,
            nsTArray<nsString>* aSuggestions) = 0;
    virtual bool
    RecvSetDictionary(
            const nsString& aDictionary,
            bool* success) = 0;

    virtual void
    ActorDestroy(ActorDestroyReason aWhy) = 0;

public:
    typedef mozilla::ipc::IProtocol ProtocolBase;
    typedef IPC::Message Message;
    typedef mozilla::ipc::MessageChannel Channel;
    typedef mozilla::ipc::IProtocol ChannelListener;
    typedef base::ProcessHandle ProcessHandle;
    typedef mozilla::ipc::MessageChannel MessageChannel;
    typedef mozilla::ipc::SharedMemory SharedMemory;
    typedef mozilla::ipc::Trigger Trigger;

public:
    MOZ_IMPLICIT PRemoteSpellcheckEngineParent();

    virtual ~PRemoteSpellcheckEngineParent();

    PContentParent*
    Manager() const;

    PRemoteSpellcheckEngine::State
    state();

    virtual void
    RemoveManagee(
            int32_t aProtocolId,
            ProtocolBase* aListener);

    virtual Result
    OnMessageReceived(const Message& msg__);

    virtual Result
    OnMessageReceived(
            const Message& msg__,
            Message*& reply__);

    virtual Result
    OnCallReceived(
            const Message& msg__,
            Message*& reply__);

    int32_t
    GetProtocolTypeId();

private:
    virtual const char*
    ProtocolName() const;

    void
    DestroySubtree(ActorDestroyReason why);

    void
    DeallocSubtree();

    template<typename T>
    void
    Write(
            const T& v__,
            Message* msg__)
    {
        IPC::WriteParam(msg__, v__);
    }

    template<typename T>
    bool
    Read(
            T* v__,
            const Message* msg__,
            PickleIterator* iter__)
    {
        return IPC::ReadParam(msg__, iter__, v__);
    }

    void
    Write(
            const PRemoteSpellcheckEngineParent* v__,
            Message* msg__,
            bool nullable__);

    MOZ_MUST_USE bool
    Read(
            PRemoteSpellcheckEngineParent** v__,
            const Message* msg__,
            PickleIterator* iter__,
            bool nullable__);

    State mState;
};


} // namespace mozilla

#if 0

//-----------------------------------------------------------------------------
// Skeleton implementation of abstract actor class

// Header file contents
namespace mozilla {
class RemoteSpellcheckEngineParent :
    public PRemoteSpellcheckEngineParent
{
    virtual bool
    RecvCheck(
            const nsString& aWord,
            bool* aIsMisspelled);

    virtual bool
    RecvCheckAndSuggest(
            const nsString& aWord,
            bool* aIsMisspelled,
            nsTArray<nsString>* aSuggestions);

    virtual bool
    RecvSetDictionary(
            const nsString& aDictionary,
            bool* success);

    virtual void
    ActorDestroy(ActorDestroyReason aWhy);

    MOZ_IMPLICIT RemoteSpellcheckEngineParent();
    virtual ~RemoteSpellcheckEngineParent();
};
} // namespace mozilla


// C++ file contents
namespace mozilla {
bool
RemoteSpellcheckEngineParent::RecvCheck(
        const nsString& aWord,
        bool* aIsMisspelled)
{
    return false;
}

bool
RemoteSpellcheckEngineParent::RecvCheckAndSuggest(
        const nsString& aWord,
        bool* aIsMisspelled,
        nsTArray<nsString>* aSuggestions)
{
    return false;
}

bool
RemoteSpellcheckEngineParent::RecvSetDictionary(
        const nsString& aDictionary,
        bool* success)
{
    return false;
}

void
RemoteSpellcheckEngineParent::ActorDestroy(ActorDestroyReason aWhy)
{
}

MOZ_IMPLICIT RemoteSpellcheckEngineParent::RemoteSpellcheckEngineParent()
{
    MOZ_COUNT_CTOR(RemoteSpellcheckEngineParent);
}

MOZ_IMPLICIT RemoteSpellcheckEngineParent::~RemoteSpellcheckEngineParent()
{
    MOZ_COUNT_DTOR(RemoteSpellcheckEngineParent);
}

} // namespace mozilla
#endif // if 0

#endif // ifndef PRemoteSpellcheckEngineParent_h