Copy as Markdown
Other Tools
//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PFileCreator_h
#define PFileCreator_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/IPCBlob.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct FileCreationSuccessResult|
//
namespace mozilla {
namespace dom {
class FileCreationSuccessResult final
{
private:
typedef ::mozilla::dom::IPCBlob IPCBlob;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
FileCreationSuccessResult() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FileCreationSuccessResult(const IPCBlob& _blob) :
blob_(_blob)
{
}
MOZ_IMPLICIT FileCreationSuccessResult(IPCBlob&& _blob) :
blob_(std::move(_blob))
{
}
IPCBlob&
blob()
{
return blob_;
}
const IPCBlob&
blob() const
{
return blob_;
}
private:
::mozilla::ipc::IPDLStructMember<IPCBlob> blob_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::FileCreationSuccessResult>
{
typedef ::mozilla::dom::FileCreationSuccessResult 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 FileCreationErrorResult|
//
namespace mozilla {
namespace dom {
class FileCreationErrorResult final
{
private:
typedef ::nsresult nsresult;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
FileCreationErrorResult() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT FileCreationErrorResult(const nsresult& _errorCode) :
errorCode_(_errorCode)
{
}
MOZ_IMPLICIT FileCreationErrorResult(nsresult&& _errorCode) :
errorCode_(std::move(_errorCode))
{
}
nsresult&
errorCode()
{
return errorCode_;
}
const nsresult&
errorCode() const
{
return errorCode_;
}
private:
::mozilla::ipc::IPDLStructMember<nsresult> errorCode_;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::FileCreationErrorResult>
{
typedef ::mozilla::dom::FileCreationErrorResult 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 |union FileCreationResult|
//
namespace mozilla {
namespace dom {
class FileCreationResult final
{
public:
enum Type {
T__None,
TFileCreationSuccessResult = 1,
TFileCreationErrorResult,
T__Last = TFileCreationErrorResult
};
private:
typedef ::mozilla::dom::FileCreationSuccessResult FileCreationSuccessResult;
typedef ::mozilla::dom::FileCreationErrorResult FileCreationErrorResult;
typedef FileCreationSuccessResult FileCreationSuccessResult__tdef;
typedef FileCreationErrorResult FileCreationErrorResult__tdef;
union Value {
mozilla::AlignedStorage2<FileCreationSuccessResult> VFileCreationSuccessResult;
mozilla::AlignedStorage2<FileCreationErrorResult> VFileCreationErrorResult;
};
FileCreationSuccessResult*
ptr_FileCreationSuccessResult()
{
return ((mValue).VFileCreationSuccessResult).addr();
}
const FileCreationSuccessResult*
constptr_FileCreationSuccessResult() const
{
return ((mValue).VFileCreationSuccessResult).addr();
}
FileCreationErrorResult*
ptr_FileCreationErrorResult()
{
return ((mValue).VFileCreationErrorResult).addr();
}
const FileCreationErrorResult*
constptr_FileCreationErrorResult() const
{
return ((mValue).VFileCreationErrorResult).addr();
}
void
MaybeDestroy();
void
AssertSanity() const
{
MOZ_RELEASE_ASSERT((T__None) <= (mType), "invalid type tag");
MOZ_RELEASE_ASSERT((mType) <= (T__Last), "invalid type tag");
}
void
AssertSanity(Type aType) const
{
AssertSanity();
MOZ_RELEASE_ASSERT((mType) == (aType), "unexpected type tag");
}
public:
MOZ_IMPLICIT FileCreationResult() :
mType(T__None)
{
}
MOZ_IMPLICIT FileCreationResult(const FileCreationSuccessResult& aOther);
MOZ_IMPLICIT FileCreationResult(FileCreationSuccessResult&& aOther);
MOZ_IMPLICIT FileCreationResult(const FileCreationErrorResult& aOther);
MOZ_IMPLICIT FileCreationResult(FileCreationErrorResult&& aOther);
MOZ_IMPLICIT FileCreationResult(const FileCreationResult& aOther);
MOZ_IMPLICIT FileCreationResult(FileCreationResult&& aOther);
~FileCreationResult();
Type
type() const
{
return mType;
}
FileCreationResult&
operator=(const FileCreationSuccessResult& aRhs);
FileCreationResult&
operator=(FileCreationSuccessResult&& aRhs);
FileCreationResult&
operator=(const FileCreationErrorResult& aRhs);
FileCreationResult&
operator=(FileCreationErrorResult&& aRhs);
FileCreationResult&
operator=(const FileCreationResult& aRhs);
FileCreationResult&
operator=(FileCreationResult&& aRhs);
FileCreationSuccessResult&
get_FileCreationSuccessResult()
{
AssertSanity(TFileCreationSuccessResult);
return (*(ptr_FileCreationSuccessResult()));
}
const FileCreationSuccessResult&
get_FileCreationSuccessResult() const
{
AssertSanity(TFileCreationSuccessResult);
return (*(constptr_FileCreationSuccessResult()));
}
operator FileCreationSuccessResult&()
{
return get_FileCreationSuccessResult();
}
operator const FileCreationSuccessResult&() const
{
return get_FileCreationSuccessResult();
}
FileCreationErrorResult&
get_FileCreationErrorResult()
{
AssertSanity(TFileCreationErrorResult);
return (*(ptr_FileCreationErrorResult()));
}
const FileCreationErrorResult&
get_FileCreationErrorResult() const
{
AssertSanity(TFileCreationErrorResult);
return (*(constptr_FileCreationErrorResult()));
}
operator FileCreationErrorResult&()
{
return get_FileCreationErrorResult();
}
operator const FileCreationErrorResult&() const
{
return get_FileCreationErrorResult();
}
private:
Value mValue;
Type mType;
};
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::FileCreationResult>
{
typedef ::mozilla::dom::FileCreationResult 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 PFileCreatorParent;
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
class PFileCreatorChild;
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PFileCreatorChild and PFileCreatorParent
//
namespace mozilla {
namespace dom {
namespace PFileCreator {
nsresult
CreateEndpoints(
base::ProcessId aParentDestPid,
base::ProcessId aChildDestPid,
mozilla::ipc::Endpoint<::mozilla::dom::PFileCreatorParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::PFileCreatorChild>* aChild);
enum MessageType {
PFileCreatorStart = PFileCreatorMsgStart << 16,
Msg___delete____ID,
Reply___delete____ID,
PFileCreatorEnd
};
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId);
} // namespace PFileCreator
} // namespace dom
} // namespace mozilla
#endif // ifndef PFileCreator_h