Copy as Markdown

Other Tools

//
// Automatically generated by ipdlc.
// Edit at your own risk
//
#ifndef PBackgroundIDBRequest_h
#define PBackgroundIDBRequest_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/dom/indexedDB/Key.h"
#include "mozilla/ipc/IPDLStructMember.h"
#include "mozilla/dom/indexedDB/PBackgroundIDBSharedTypes.h"
//-----------------------------------------------------------------------------
// Declaration of the IPDL type |struct ObjectStoreAddResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreAddResponse final
{
private:
typedef ::mozilla::dom::indexedDB::Key Key;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreAddResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreAddResponse(const Key& _key) :
key_(_key)
{
}
MOZ_IMPLICIT ObjectStoreAddResponse(Key&& _key) :
key_(std::move(_key))
{
}
Key&
key()
{
return key_;
}
const Key&
key() const
{
return key_;
}
private:
::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreAddResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreAddResponse 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 ObjectStorePutResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStorePutResponse final
{
private:
typedef ::mozilla::dom::indexedDB::Key Key;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStorePutResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStorePutResponse(const Key& _key) :
key_(_key)
{
}
MOZ_IMPLICIT ObjectStorePutResponse(Key&& _key) :
key_(std::move(_key))
{
}
Key&
key()
{
return key_;
}
const Key&
key() const
{
return key_;
}
private:
::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStorePutResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStorePutResponse 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 ObjectStoreGetResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetResponse final
{
private:
typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreGetResponse(SerializedStructuredCloneReadInfo&& _cloneInfo) :
cloneInfo_(std::move(_cloneInfo))
{
}
SerializedStructuredCloneReadInfo&
cloneInfo()
{
return cloneInfo_;
}
const SerializedStructuredCloneReadInfo&
cloneInfo() const
{
return cloneInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<SerializedStructuredCloneReadInfo> cloneInfo_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetResponse 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 ObjectStoreGetKeyResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetKeyResponse final
{
private:
typedef ::mozilla::dom::indexedDB::Key Key;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetKeyResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreGetKeyResponse(const Key& _key) :
key_(_key)
{
}
MOZ_IMPLICIT ObjectStoreGetKeyResponse(Key&& _key) :
key_(std::move(_key))
{
}
Key&
key()
{
return key_;
}
const Key&
key() const
{
return key_;
}
private:
::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetKeyResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetKeyResponse 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 ObjectStoreGetAllResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllResponse final
{
private:
typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetAllResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreGetAllResponse(nsTArray<SerializedStructuredCloneReadInfo>&& _cloneInfos) :
cloneInfos_(std::move(_cloneInfos))
{
}
nsTArray<SerializedStructuredCloneReadInfo>&
cloneInfos()
{
return cloneInfos_;
}
const nsTArray<SerializedStructuredCloneReadInfo>&
cloneInfos() const
{
return cloneInfos_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<SerializedStructuredCloneReadInfo>> cloneInfos_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllResponse 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 ObjectStoreGetAllKeysResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllKeysResponse final
{
private:
typedef ::mozilla::dom::indexedDB::Key Key;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetAllKeysResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreGetAllKeysResponse(const nsTArray<Key>& _keys) :
keys_(_keys)
{
}
MOZ_IMPLICIT ObjectStoreGetAllKeysResponse(nsTArray<Key>&& _keys) :
keys_(std::move(_keys))
{
}
nsTArray<Key>&
keys()
{
return keys_;
}
const nsTArray<Key>&
keys() const
{
return keys_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<Key>> keys_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse 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 ObjectStoreDeleteResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreDeleteResponse final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreDeleteResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreDeleteResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreDeleteResponse 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 ObjectStoreClearResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreClearResponse final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreClearResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreClearResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreClearResponse 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 ObjectStoreCountResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreCountResponse final
{
private:
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
ObjectStoreCountResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreCountResponse(const uint64_t& _count) :
count_(_count)
{
}
MOZ_IMPLICIT ObjectStoreCountResponse(uint64_t&& _count) :
count_(std::move(_count))
{
}
uint64_t&
count()
{
return count_;
}
const uint64_t&
count() const
{
return count_;
}
private:
::mozilla::ipc::IPDLStructMember<uint64_t> count_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreCountResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreCountResponse 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 IndexGetResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetResponse final
{
private:
typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IndexGetResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IndexGetResponse(SerializedStructuredCloneReadInfo&& _cloneInfo) :
cloneInfo_(std::move(_cloneInfo))
{
}
SerializedStructuredCloneReadInfo&
cloneInfo()
{
return cloneInfo_;
}
const SerializedStructuredCloneReadInfo&
cloneInfo() const
{
return cloneInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<SerializedStructuredCloneReadInfo> cloneInfo_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetResponse>
{
typedef ::mozilla::dom::indexedDB::IndexGetResponse 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 IndexGetKeyResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetKeyResponse final
{
private:
typedef ::mozilla::dom::indexedDB::Key Key;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IndexGetKeyResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IndexGetKeyResponse(const Key& _key) :
key_(_key)
{
}
MOZ_IMPLICIT IndexGetKeyResponse(Key&& _key) :
key_(std::move(_key))
{
}
Key&
key()
{
return key_;
}
const Key&
key() const
{
return key_;
}
private:
::mozilla::ipc::IPDLStructMember<Key> key_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetKeyResponse>
{
typedef ::mozilla::dom::indexedDB::IndexGetKeyResponse 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 IndexGetAllResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetAllResponse final
{
private:
typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneReadInfo SerializedStructuredCloneReadInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IndexGetAllResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IndexGetAllResponse(nsTArray<SerializedStructuredCloneReadInfo>&& _cloneInfos) :
cloneInfos_(std::move(_cloneInfos))
{
}
nsTArray<SerializedStructuredCloneReadInfo>&
cloneInfos()
{
return cloneInfos_;
}
const nsTArray<SerializedStructuredCloneReadInfo>&
cloneInfos() const
{
return cloneInfos_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<SerializedStructuredCloneReadInfo>> cloneInfos_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetAllResponse>
{
typedef ::mozilla::dom::indexedDB::IndexGetAllResponse 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 IndexGetAllKeysResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexGetAllKeysResponse final
{
private:
typedef ::mozilla::dom::indexedDB::Key Key;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
IndexGetAllKeysResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IndexGetAllKeysResponse(const nsTArray<Key>& _keys) :
keys_(_keys)
{
}
MOZ_IMPLICIT IndexGetAllKeysResponse(nsTArray<Key>&& _keys) :
keys_(std::move(_keys))
{
}
nsTArray<Key>&
keys()
{
return keys_;
}
const nsTArray<Key>&
keys() const
{
return keys_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<Key>> keys_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexGetAllKeysResponse>
{
typedef ::mozilla::dom::indexedDB::IndexGetAllKeysResponse 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 IndexCountResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class IndexCountResponse final
{
private:
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
IndexCountResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT IndexCountResponse(const uint64_t& _count) :
count_(_count)
{
}
MOZ_IMPLICIT IndexCountResponse(uint64_t&& _count) :
count_(std::move(_count))
{
}
uint64_t&
count()
{
return count_;
}
const uint64_t&
count() const
{
return count_;
}
private:
::mozilla::ipc::IPDLStructMember<uint64_t> count_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::IndexCountResponse>
{
typedef ::mozilla::dom::indexedDB::IndexCountResponse 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 RequestResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class RequestResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TObjectStoreGetResponse,
TObjectStoreGetKeyResponse,
TObjectStoreAddResponse,
TObjectStorePutResponse,
TObjectStoreDeleteResponse,
TObjectStoreClearResponse,
TObjectStoreCountResponse,
TObjectStoreGetAllResponse,
TObjectStoreGetAllKeysResponse,
TIndexGetResponse,
TIndexGetKeyResponse,
TIndexGetAllResponse,
TIndexGetAllKeysResponse,
TIndexCountResponse,
T__Last = TIndexCountResponse
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetResponse ObjectStoreGetResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetKeyResponse ObjectStoreGetKeyResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreAddResponse ObjectStoreAddResponse;
typedef ::mozilla::dom::indexedDB::ObjectStorePutResponse ObjectStorePutResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreDeleteResponse ObjectStoreDeleteResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreClearResponse ObjectStoreClearResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreCountResponse ObjectStoreCountResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllResponse ObjectStoreGetAllResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllKeysResponse ObjectStoreGetAllKeysResponse;
typedef ::mozilla::dom::indexedDB::IndexGetResponse IndexGetResponse;
typedef ::mozilla::dom::indexedDB::IndexGetKeyResponse IndexGetKeyResponse;
typedef ::mozilla::dom::indexedDB::IndexGetAllResponse IndexGetAllResponse;
typedef ::mozilla::dom::indexedDB::IndexGetAllKeysResponse IndexGetAllKeysResponse;
typedef ::mozilla::dom::indexedDB::IndexCountResponse IndexCountResponse;
typedef nsresult nsresult__tdef;
typedef ObjectStoreGetResponse ObjectStoreGetResponse__tdef;
typedef ObjectStoreGetKeyResponse ObjectStoreGetKeyResponse__tdef;
typedef ObjectStoreAddResponse ObjectStoreAddResponse__tdef;
typedef ObjectStorePutResponse ObjectStorePutResponse__tdef;
typedef ObjectStoreDeleteResponse ObjectStoreDeleteResponse__tdef;
typedef ObjectStoreClearResponse ObjectStoreClearResponse__tdef;
typedef ObjectStoreCountResponse ObjectStoreCountResponse__tdef;
typedef ObjectStoreGetAllResponse ObjectStoreGetAllResponse__tdef;
typedef ObjectStoreGetAllKeysResponse ObjectStoreGetAllKeysResponse__tdef;
typedef IndexGetResponse IndexGetResponse__tdef;
typedef IndexGetKeyResponse IndexGetKeyResponse__tdef;
typedef IndexGetAllResponse IndexGetAllResponse__tdef;
typedef IndexGetAllKeysResponse IndexGetAllKeysResponse__tdef;
typedef IndexCountResponse IndexCountResponse__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
ObjectStoreGetResponse*
ptr_ObjectStoreGetResponse()
{
return (&(mVObjectStoreGetResponse));
}
const ObjectStoreGetResponse*
constptr_ObjectStoreGetResponse() const
{
return (&(mVObjectStoreGetResponse));
}
ObjectStoreGetKeyResponse*
ptr_ObjectStoreGetKeyResponse()
{
return (&(mVObjectStoreGetKeyResponse));
}
const ObjectStoreGetKeyResponse*
constptr_ObjectStoreGetKeyResponse() const
{
return (&(mVObjectStoreGetKeyResponse));
}
ObjectStoreAddResponse*
ptr_ObjectStoreAddResponse()
{
return (&(mVObjectStoreAddResponse));
}
const ObjectStoreAddResponse*
constptr_ObjectStoreAddResponse() const
{
return (&(mVObjectStoreAddResponse));
}
ObjectStorePutResponse*
ptr_ObjectStorePutResponse()
{
return (&(mVObjectStorePutResponse));
}
const ObjectStorePutResponse*
constptr_ObjectStorePutResponse() const
{
return (&(mVObjectStorePutResponse));
}
ObjectStoreDeleteResponse*
ptr_ObjectStoreDeleteResponse()
{
return (&(mVObjectStoreDeleteResponse));
}
const ObjectStoreDeleteResponse*
constptr_ObjectStoreDeleteResponse() const
{
return (&(mVObjectStoreDeleteResponse));
}
ObjectStoreClearResponse*
ptr_ObjectStoreClearResponse()
{
return (&(mVObjectStoreClearResponse));
}
const ObjectStoreClearResponse*
constptr_ObjectStoreClearResponse() const
{
return (&(mVObjectStoreClearResponse));
}
ObjectStoreCountResponse*
ptr_ObjectStoreCountResponse()
{
return (&(mVObjectStoreCountResponse));
}
const ObjectStoreCountResponse*
constptr_ObjectStoreCountResponse() const
{
return (&(mVObjectStoreCountResponse));
}
ObjectStoreGetAllResponse*
ptr_ObjectStoreGetAllResponse()
{
return (&(mVObjectStoreGetAllResponse));
}
const ObjectStoreGetAllResponse*
constptr_ObjectStoreGetAllResponse() const
{
return (&(mVObjectStoreGetAllResponse));
}
ObjectStoreGetAllKeysResponse*
ptr_ObjectStoreGetAllKeysResponse()
{
return (&(mVObjectStoreGetAllKeysResponse));
}
const ObjectStoreGetAllKeysResponse*
constptr_ObjectStoreGetAllKeysResponse() const
{
return (&(mVObjectStoreGetAllKeysResponse));
}
IndexGetResponse*
ptr_IndexGetResponse()
{
return (&(mVIndexGetResponse));
}
const IndexGetResponse*
constptr_IndexGetResponse() const
{
return (&(mVIndexGetResponse));
}
IndexGetKeyResponse*
ptr_IndexGetKeyResponse()
{
return (&(mVIndexGetKeyResponse));
}
const IndexGetKeyResponse*
constptr_IndexGetKeyResponse() const
{
return (&(mVIndexGetKeyResponse));
}
IndexGetAllResponse*
ptr_IndexGetAllResponse()
{
return (&(mVIndexGetAllResponse));
}
const IndexGetAllResponse*
constptr_IndexGetAllResponse() const
{
return (&(mVIndexGetAllResponse));
}
IndexGetAllKeysResponse*
ptr_IndexGetAllKeysResponse()
{
return (&(mVIndexGetAllKeysResponse));
}
const IndexGetAllKeysResponse*
constptr_IndexGetAllKeysResponse() const
{
return (&(mVIndexGetAllKeysResponse));
}
IndexCountResponse*
ptr_IndexCountResponse()
{
return (&(mVIndexCountResponse));
}
const IndexCountResponse*
constptr_IndexCountResponse() const
{
return (&(mVIndexCountResponse));
}
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 RequestResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT RequestResponse(const nsresult& aOther);
MOZ_IMPLICIT RequestResponse(nsresult&& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreGetResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStoreGetKeyResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreGetKeyResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStoreAddResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreAddResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStorePutResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStorePutResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStoreDeleteResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreDeleteResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStoreClearResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreClearResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStoreCountResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreCountResponse&& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreGetAllResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const ObjectStoreGetAllKeysResponse& aOther);
MOZ_IMPLICIT RequestResponse(ObjectStoreGetAllKeysResponse&& aOther);
MOZ_IMPLICIT RequestResponse(IndexGetResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const IndexGetKeyResponse& aOther);
MOZ_IMPLICIT RequestResponse(IndexGetKeyResponse&& aOther);
MOZ_IMPLICIT RequestResponse(IndexGetAllResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const IndexGetAllKeysResponse& aOther);
MOZ_IMPLICIT RequestResponse(IndexGetAllKeysResponse&& aOther);
MOZ_IMPLICIT RequestResponse(const IndexCountResponse& aOther);
MOZ_IMPLICIT RequestResponse(IndexCountResponse&& aOther);
MOZ_IMPLICIT RequestResponse(RequestResponse&& aOther);
~RequestResponse();
Type
type() const
{
return mType;
}
RequestResponse&
operator=(const nsresult& aRhs);
RequestResponse&
operator=(nsresult&& aRhs);
RequestResponse&
operator=(ObjectStoreGetResponse&& aRhs);
RequestResponse&
operator=(const ObjectStoreGetKeyResponse& aRhs);
RequestResponse&
operator=(ObjectStoreGetKeyResponse&& aRhs);
RequestResponse&
operator=(const ObjectStoreAddResponse& aRhs);
RequestResponse&
operator=(ObjectStoreAddResponse&& aRhs);
RequestResponse&
operator=(const ObjectStorePutResponse& aRhs);
RequestResponse&
operator=(ObjectStorePutResponse&& aRhs);
RequestResponse&
operator=(const ObjectStoreDeleteResponse& aRhs);
RequestResponse&
operator=(ObjectStoreDeleteResponse&& aRhs);
RequestResponse&
operator=(const ObjectStoreClearResponse& aRhs);
RequestResponse&
operator=(ObjectStoreClearResponse&& aRhs);
RequestResponse&
operator=(const ObjectStoreCountResponse& aRhs);
RequestResponse&
operator=(ObjectStoreCountResponse&& aRhs);
RequestResponse&
operator=(ObjectStoreGetAllResponse&& aRhs);
RequestResponse&
operator=(const ObjectStoreGetAllKeysResponse& aRhs);
RequestResponse&
operator=(ObjectStoreGetAllKeysResponse&& aRhs);
RequestResponse&
operator=(IndexGetResponse&& aRhs);
RequestResponse&
operator=(const IndexGetKeyResponse& aRhs);
RequestResponse&
operator=(IndexGetKeyResponse&& aRhs);
RequestResponse&
operator=(IndexGetAllResponse&& aRhs);
RequestResponse&
operator=(const IndexGetAllKeysResponse& aRhs);
RequestResponse&
operator=(IndexGetAllKeysResponse&& aRhs);
RequestResponse&
operator=(const IndexCountResponse& aRhs);
RequestResponse&
operator=(IndexCountResponse&& aRhs);
RequestResponse&
operator=(RequestResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
ObjectStoreGetResponse&
get_ObjectStoreGetResponse()
{
AssertSanity(TObjectStoreGetResponse);
return (*(ptr_ObjectStoreGetResponse()));
}
const ObjectStoreGetResponse&
get_ObjectStoreGetResponse() const
{
AssertSanity(TObjectStoreGetResponse);
return (*(constptr_ObjectStoreGetResponse()));
}
operator ObjectStoreGetResponse&()
{
return get_ObjectStoreGetResponse();
}
operator const ObjectStoreGetResponse&() const
{
return get_ObjectStoreGetResponse();
}
ObjectStoreGetKeyResponse&
get_ObjectStoreGetKeyResponse()
{
AssertSanity(TObjectStoreGetKeyResponse);
return (*(ptr_ObjectStoreGetKeyResponse()));
}
const ObjectStoreGetKeyResponse&
get_ObjectStoreGetKeyResponse() const
{
AssertSanity(TObjectStoreGetKeyResponse);
return (*(constptr_ObjectStoreGetKeyResponse()));
}
operator ObjectStoreGetKeyResponse&()
{
return get_ObjectStoreGetKeyResponse();
}
operator const ObjectStoreGetKeyResponse&() const
{
return get_ObjectStoreGetKeyResponse();
}
ObjectStoreAddResponse&
get_ObjectStoreAddResponse()
{
AssertSanity(TObjectStoreAddResponse);
return (*(ptr_ObjectStoreAddResponse()));
}
const ObjectStoreAddResponse&
get_ObjectStoreAddResponse() const
{
AssertSanity(TObjectStoreAddResponse);
return (*(constptr_ObjectStoreAddResponse()));
}
operator ObjectStoreAddResponse&()
{
return get_ObjectStoreAddResponse();
}
operator const ObjectStoreAddResponse&() const
{
return get_ObjectStoreAddResponse();
}
ObjectStorePutResponse&
get_ObjectStorePutResponse()
{
AssertSanity(TObjectStorePutResponse);
return (*(ptr_ObjectStorePutResponse()));
}
const ObjectStorePutResponse&
get_ObjectStorePutResponse() const
{
AssertSanity(TObjectStorePutResponse);
return (*(constptr_ObjectStorePutResponse()));
}
operator ObjectStorePutResponse&()
{
return get_ObjectStorePutResponse();
}
operator const ObjectStorePutResponse&() const
{
return get_ObjectStorePutResponse();
}
ObjectStoreDeleteResponse&
get_ObjectStoreDeleteResponse()
{
AssertSanity(TObjectStoreDeleteResponse);
return (*(ptr_ObjectStoreDeleteResponse()));
}
const ObjectStoreDeleteResponse&
get_ObjectStoreDeleteResponse() const
{
AssertSanity(TObjectStoreDeleteResponse);
return (*(constptr_ObjectStoreDeleteResponse()));
}
operator ObjectStoreDeleteResponse&()
{
return get_ObjectStoreDeleteResponse();
}
operator const ObjectStoreDeleteResponse&() const
{
return get_ObjectStoreDeleteResponse();
}
ObjectStoreClearResponse&
get_ObjectStoreClearResponse()
{
AssertSanity(TObjectStoreClearResponse);
return (*(ptr_ObjectStoreClearResponse()));
}
const ObjectStoreClearResponse&
get_ObjectStoreClearResponse() const
{
AssertSanity(TObjectStoreClearResponse);
return (*(constptr_ObjectStoreClearResponse()));
}
operator ObjectStoreClearResponse&()
{
return get_ObjectStoreClearResponse();
}
operator const ObjectStoreClearResponse&() const
{
return get_ObjectStoreClearResponse();
}
ObjectStoreCountResponse&
get_ObjectStoreCountResponse()
{
AssertSanity(TObjectStoreCountResponse);
return (*(ptr_ObjectStoreCountResponse()));
}
const ObjectStoreCountResponse&
get_ObjectStoreCountResponse() const
{
AssertSanity(TObjectStoreCountResponse);
return (*(constptr_ObjectStoreCountResponse()));
}
operator ObjectStoreCountResponse&()
{
return get_ObjectStoreCountResponse();
}
operator const ObjectStoreCountResponse&() const
{
return get_ObjectStoreCountResponse();
}
ObjectStoreGetAllResponse&
get_ObjectStoreGetAllResponse()
{
AssertSanity(TObjectStoreGetAllResponse);
return (*(ptr_ObjectStoreGetAllResponse()));
}
const ObjectStoreGetAllResponse&
get_ObjectStoreGetAllResponse() const
{
AssertSanity(TObjectStoreGetAllResponse);
return (*(constptr_ObjectStoreGetAllResponse()));
}
operator ObjectStoreGetAllResponse&()
{
return get_ObjectStoreGetAllResponse();
}
operator const ObjectStoreGetAllResponse&() const
{
return get_ObjectStoreGetAllResponse();
}
ObjectStoreGetAllKeysResponse&
get_ObjectStoreGetAllKeysResponse()
{
AssertSanity(TObjectStoreGetAllKeysResponse);
return (*(ptr_ObjectStoreGetAllKeysResponse()));
}
const ObjectStoreGetAllKeysResponse&
get_ObjectStoreGetAllKeysResponse() const
{
AssertSanity(TObjectStoreGetAllKeysResponse);
return (*(constptr_ObjectStoreGetAllKeysResponse()));
}
operator ObjectStoreGetAllKeysResponse&()
{
return get_ObjectStoreGetAllKeysResponse();
}
operator const ObjectStoreGetAllKeysResponse&() const
{
return get_ObjectStoreGetAllKeysResponse();
}
IndexGetResponse&
get_IndexGetResponse()
{
AssertSanity(TIndexGetResponse);
return (*(ptr_IndexGetResponse()));
}
const IndexGetResponse&
get_IndexGetResponse() const
{
AssertSanity(TIndexGetResponse);
return (*(constptr_IndexGetResponse()));
}
operator IndexGetResponse&()
{
return get_IndexGetResponse();
}
operator const IndexGetResponse&() const
{
return get_IndexGetResponse();
}
IndexGetKeyResponse&
get_IndexGetKeyResponse()
{
AssertSanity(TIndexGetKeyResponse);
return (*(ptr_IndexGetKeyResponse()));
}
const IndexGetKeyResponse&
get_IndexGetKeyResponse() const
{
AssertSanity(TIndexGetKeyResponse);
return (*(constptr_IndexGetKeyResponse()));
}
operator IndexGetKeyResponse&()
{
return get_IndexGetKeyResponse();
}
operator const IndexGetKeyResponse&() const
{
return get_IndexGetKeyResponse();
}
IndexGetAllResponse&
get_IndexGetAllResponse()
{
AssertSanity(TIndexGetAllResponse);
return (*(ptr_IndexGetAllResponse()));
}
const IndexGetAllResponse&
get_IndexGetAllResponse() const
{
AssertSanity(TIndexGetAllResponse);
return (*(constptr_IndexGetAllResponse()));
}
operator IndexGetAllResponse&()
{
return get_IndexGetAllResponse();
}
operator const IndexGetAllResponse&() const
{
return get_IndexGetAllResponse();
}
IndexGetAllKeysResponse&
get_IndexGetAllKeysResponse()
{
AssertSanity(TIndexGetAllKeysResponse);
return (*(ptr_IndexGetAllKeysResponse()));
}
const IndexGetAllKeysResponse&
get_IndexGetAllKeysResponse() const
{
AssertSanity(TIndexGetAllKeysResponse);
return (*(constptr_IndexGetAllKeysResponse()));
}
operator IndexGetAllKeysResponse&()
{
return get_IndexGetAllKeysResponse();
}
operator const IndexGetAllKeysResponse&() const
{
return get_IndexGetAllKeysResponse();
}
IndexCountResponse&
get_IndexCountResponse()
{
AssertSanity(TIndexCountResponse);
return (*(ptr_IndexCountResponse()));
}
const IndexCountResponse&
get_IndexCountResponse() const
{
AssertSanity(TIndexCountResponse);
return (*(constptr_IndexCountResponse()));
}
operator IndexCountResponse&()
{
return get_IndexCountResponse();
}
operator const IndexCountResponse&() const
{
return get_IndexCountResponse();
}
private:
union {
nsresult mVnsresult;
ObjectStoreGetResponse mVObjectStoreGetResponse;
ObjectStoreGetKeyResponse mVObjectStoreGetKeyResponse;
ObjectStoreAddResponse mVObjectStoreAddResponse;
ObjectStorePutResponse mVObjectStorePutResponse;
ObjectStoreDeleteResponse mVObjectStoreDeleteResponse;
ObjectStoreClearResponse mVObjectStoreClearResponse;
ObjectStoreCountResponse mVObjectStoreCountResponse;
ObjectStoreGetAllResponse mVObjectStoreGetAllResponse;
ObjectStoreGetAllKeysResponse mVObjectStoreGetAllKeysResponse;
IndexGetResponse mVIndexGetResponse;
IndexGetKeyResponse mVIndexGetKeyResponse;
IndexGetAllResponse mVIndexGetAllResponse;
IndexGetAllKeysResponse mVIndexGetAllKeysResponse;
IndexCountResponse mVIndexCountResponse;
};
Type mType;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::RequestResponse>
{
typedef ::mozilla::dom::indexedDB::RequestResponse 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 PreprocessInfo|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class PreprocessInfo final
{
private:
typedef ::mozilla::dom::indexedDB::SerializedStructuredCloneFile SerializedStructuredCloneFile;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
PreprocessInfo() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT PreprocessInfo(const nsTArray<SerializedStructuredCloneFile>& _files) :
files_(_files)
{
}
MOZ_IMPLICIT PreprocessInfo(nsTArray<SerializedStructuredCloneFile>&& _files) :
files_(std::move(_files))
{
}
nsTArray<SerializedStructuredCloneFile>&
files()
{
return files_;
}
const nsTArray<SerializedStructuredCloneFile>&
files() const
{
return files_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<SerializedStructuredCloneFile>> files_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::PreprocessInfo>
{
typedef ::mozilla::dom::indexedDB::PreprocessInfo 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 ObjectStoreGetPreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetPreprocessParams final
{
private:
typedef ::mozilla::dom::indexedDB::PreprocessInfo PreprocessInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetPreprocessParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreGetPreprocessParams(const PreprocessInfo& _preprocessInfo) :
preprocessInfo_(_preprocessInfo)
{
}
MOZ_IMPLICIT ObjectStoreGetPreprocessParams(PreprocessInfo&& _preprocessInfo) :
preprocessInfo_(std::move(_preprocessInfo))
{
}
PreprocessInfo&
preprocessInfo()
{
return preprocessInfo_;
}
const PreprocessInfo&
preprocessInfo() const
{
return preprocessInfo_;
}
private:
::mozilla::ipc::IPDLStructMember<PreprocessInfo> preprocessInfo_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams 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 ObjectStoreGetAllPreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllPreprocessParams final
{
private:
typedef ::mozilla::dom::indexedDB::PreprocessInfo PreprocessInfo;
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetAllPreprocessParams() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
MOZ_IMPLICIT ObjectStoreGetAllPreprocessParams(const nsTArray<PreprocessInfo>& _preprocessInfos) :
preprocessInfos_(_preprocessInfos)
{
}
MOZ_IMPLICIT ObjectStoreGetAllPreprocessParams(nsTArray<PreprocessInfo>&& _preprocessInfos) :
preprocessInfos_(std::move(_preprocessInfos))
{
}
nsTArray<PreprocessInfo>&
preprocessInfos()
{
return preprocessInfos_;
}
const nsTArray<PreprocessInfo>&
preprocessInfos() const
{
return preprocessInfos_;
}
private:
::mozilla::ipc::IPDLStructMember<CopyableTArray<PreprocessInfo>> preprocessInfos_;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams 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 PreprocessParams|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class PreprocessParams final
{
public:
enum Type {
T__None,
TObjectStoreGetPreprocessParams = 1,
TObjectStoreGetAllPreprocessParams,
T__Last = TObjectStoreGetAllPreprocessParams
};
private:
typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessParams ObjectStoreGetPreprocessParams;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessParams ObjectStoreGetAllPreprocessParams;
typedef ObjectStoreGetPreprocessParams ObjectStoreGetPreprocessParams__tdef;
typedef ObjectStoreGetAllPreprocessParams ObjectStoreGetAllPreprocessParams__tdef;
ObjectStoreGetPreprocessParams*
ptr_ObjectStoreGetPreprocessParams()
{
return (&(mVObjectStoreGetPreprocessParams));
}
const ObjectStoreGetPreprocessParams*
constptr_ObjectStoreGetPreprocessParams() const
{
return (&(mVObjectStoreGetPreprocessParams));
}
ObjectStoreGetAllPreprocessParams*
ptr_ObjectStoreGetAllPreprocessParams()
{
return (&(mVObjectStoreGetAllPreprocessParams));
}
const ObjectStoreGetAllPreprocessParams*
constptr_ObjectStoreGetAllPreprocessParams() const
{
return (&(mVObjectStoreGetAllPreprocessParams));
}
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 PreprocessParams() :
mType(T__None)
{
}
MOZ_IMPLICIT PreprocessParams(const ObjectStoreGetPreprocessParams& aOther);
MOZ_IMPLICIT PreprocessParams(ObjectStoreGetPreprocessParams&& aOther);
MOZ_IMPLICIT PreprocessParams(const ObjectStoreGetAllPreprocessParams& aOther);
MOZ_IMPLICIT PreprocessParams(ObjectStoreGetAllPreprocessParams&& aOther);
MOZ_IMPLICIT PreprocessParams(const PreprocessParams& aOther);
MOZ_IMPLICIT PreprocessParams(PreprocessParams&& aOther);
~PreprocessParams();
Type
type() const
{
return mType;
}
PreprocessParams&
operator=(const ObjectStoreGetPreprocessParams& aRhs);
PreprocessParams&
operator=(ObjectStoreGetPreprocessParams&& aRhs);
PreprocessParams&
operator=(const ObjectStoreGetAllPreprocessParams& aRhs);
PreprocessParams&
operator=(ObjectStoreGetAllPreprocessParams&& aRhs);
PreprocessParams&
operator=(const PreprocessParams& aRhs);
PreprocessParams&
operator=(PreprocessParams&& aRhs);
ObjectStoreGetPreprocessParams&
get_ObjectStoreGetPreprocessParams()
{
AssertSanity(TObjectStoreGetPreprocessParams);
return (*(ptr_ObjectStoreGetPreprocessParams()));
}
const ObjectStoreGetPreprocessParams&
get_ObjectStoreGetPreprocessParams() const
{
AssertSanity(TObjectStoreGetPreprocessParams);
return (*(constptr_ObjectStoreGetPreprocessParams()));
}
operator ObjectStoreGetPreprocessParams&()
{
return get_ObjectStoreGetPreprocessParams();
}
operator const ObjectStoreGetPreprocessParams&() const
{
return get_ObjectStoreGetPreprocessParams();
}
ObjectStoreGetAllPreprocessParams&
get_ObjectStoreGetAllPreprocessParams()
{
AssertSanity(TObjectStoreGetAllPreprocessParams);
return (*(ptr_ObjectStoreGetAllPreprocessParams()));
}
const ObjectStoreGetAllPreprocessParams&
get_ObjectStoreGetAllPreprocessParams() const
{
AssertSanity(TObjectStoreGetAllPreprocessParams);
return (*(constptr_ObjectStoreGetAllPreprocessParams()));
}
operator ObjectStoreGetAllPreprocessParams&()
{
return get_ObjectStoreGetAllPreprocessParams();
}
operator const ObjectStoreGetAllPreprocessParams&() const
{
return get_ObjectStoreGetAllPreprocessParams();
}
private:
union {
ObjectStoreGetPreprocessParams mVObjectStoreGetPreprocessParams;
ObjectStoreGetAllPreprocessParams mVObjectStoreGetAllPreprocessParams;
};
Type mType;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::PreprocessParams>
{
typedef ::mozilla::dom::indexedDB::PreprocessParams 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 ObjectStoreGetPreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetPreprocessResponse final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetPreprocessResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse 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 ObjectStoreGetAllPreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class ObjectStoreGetAllPreprocessResponse final
{
private:
public:
#ifdef __clang__
# pragma clang diagnostic push
# if __has_warning("-Wdefaulted-function-deleted")
# pragma clang diagnostic ignored "-Wdefaulted-function-deleted"
# endif
#endif
ObjectStoreGetAllPreprocessResponse() = default;
#ifdef __clang__
# pragma clang diagnostic pop
#endif
private:
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse>
{
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse 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 PreprocessResponse|
//
namespace mozilla {
namespace dom {
namespace indexedDB {
class PreprocessResponse final
{
public:
enum Type {
T__None,
Tnsresult = 1,
TObjectStoreGetPreprocessResponse,
TObjectStoreGetAllPreprocessResponse,
T__Last = TObjectStoreGetAllPreprocessResponse
};
private:
typedef ::nsresult nsresult;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetPreprocessResponse ObjectStoreGetPreprocessResponse;
typedef ::mozilla::dom::indexedDB::ObjectStoreGetAllPreprocessResponse ObjectStoreGetAllPreprocessResponse;
typedef nsresult nsresult__tdef;
typedef ObjectStoreGetPreprocessResponse ObjectStoreGetPreprocessResponse__tdef;
typedef ObjectStoreGetAllPreprocessResponse ObjectStoreGetAllPreprocessResponse__tdef;
nsresult*
ptr_nsresult()
{
return (&(mVnsresult));
}
const nsresult*
constptr_nsresult() const
{
return (&(mVnsresult));
}
ObjectStoreGetPreprocessResponse*
ptr_ObjectStoreGetPreprocessResponse()
{
return (&(mVObjectStoreGetPreprocessResponse));
}
const ObjectStoreGetPreprocessResponse*
constptr_ObjectStoreGetPreprocessResponse() const
{
return (&(mVObjectStoreGetPreprocessResponse));
}
ObjectStoreGetAllPreprocessResponse*
ptr_ObjectStoreGetAllPreprocessResponse()
{
return (&(mVObjectStoreGetAllPreprocessResponse));
}
const ObjectStoreGetAllPreprocessResponse*
constptr_ObjectStoreGetAllPreprocessResponse() const
{
return (&(mVObjectStoreGetAllPreprocessResponse));
}
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 PreprocessResponse() :
mType(T__None)
{
}
MOZ_IMPLICIT PreprocessResponse(const nsresult& aOther);
MOZ_IMPLICIT PreprocessResponse(nsresult&& aOther);
MOZ_IMPLICIT PreprocessResponse(const ObjectStoreGetPreprocessResponse& aOther);
MOZ_IMPLICIT PreprocessResponse(ObjectStoreGetPreprocessResponse&& aOther);
MOZ_IMPLICIT PreprocessResponse(const ObjectStoreGetAllPreprocessResponse& aOther);
MOZ_IMPLICIT PreprocessResponse(ObjectStoreGetAllPreprocessResponse&& aOther);
MOZ_IMPLICIT PreprocessResponse(const PreprocessResponse& aOther);
MOZ_IMPLICIT PreprocessResponse(PreprocessResponse&& aOther);
~PreprocessResponse();
Type
type() const
{
return mType;
}
PreprocessResponse&
operator=(const nsresult& aRhs);
PreprocessResponse&
operator=(nsresult&& aRhs);
PreprocessResponse&
operator=(const ObjectStoreGetPreprocessResponse& aRhs);
PreprocessResponse&
operator=(ObjectStoreGetPreprocessResponse&& aRhs);
PreprocessResponse&
operator=(const ObjectStoreGetAllPreprocessResponse& aRhs);
PreprocessResponse&
operator=(ObjectStoreGetAllPreprocessResponse&& aRhs);
PreprocessResponse&
operator=(const PreprocessResponse& aRhs);
PreprocessResponse&
operator=(PreprocessResponse&& aRhs);
nsresult&
get_nsresult()
{
AssertSanity(Tnsresult);
return (*(ptr_nsresult()));
}
const nsresult&
get_nsresult() const
{
AssertSanity(Tnsresult);
return (*(constptr_nsresult()));
}
operator nsresult&()
{
return get_nsresult();
}
operator const nsresult&() const
{
return get_nsresult();
}
ObjectStoreGetPreprocessResponse&
get_ObjectStoreGetPreprocessResponse()
{
AssertSanity(TObjectStoreGetPreprocessResponse);
return (*(ptr_ObjectStoreGetPreprocessResponse()));
}
const ObjectStoreGetPreprocessResponse&
get_ObjectStoreGetPreprocessResponse() const
{
AssertSanity(TObjectStoreGetPreprocessResponse);
return (*(constptr_ObjectStoreGetPreprocessResponse()));
}
operator ObjectStoreGetPreprocessResponse&()
{
return get_ObjectStoreGetPreprocessResponse();
}
operator const ObjectStoreGetPreprocessResponse&() const
{
return get_ObjectStoreGetPreprocessResponse();
}
ObjectStoreGetAllPreprocessResponse&
get_ObjectStoreGetAllPreprocessResponse()
{
AssertSanity(TObjectStoreGetAllPreprocessResponse);
return (*(ptr_ObjectStoreGetAllPreprocessResponse()));
}
const ObjectStoreGetAllPreprocessResponse&
get_ObjectStoreGetAllPreprocessResponse() const
{
AssertSanity(TObjectStoreGetAllPreprocessResponse);
return (*(constptr_ObjectStoreGetAllPreprocessResponse()));
}
operator ObjectStoreGetAllPreprocessResponse&()
{
return get_ObjectStoreGetAllPreprocessResponse();
}
operator const ObjectStoreGetAllPreprocessResponse&() const
{
return get_ObjectStoreGetAllPreprocessResponse();
}
private:
union {
nsresult mVnsresult;
ObjectStoreGetPreprocessResponse mVObjectStoreGetPreprocessResponse;
ObjectStoreGetAllPreprocessResponse mVObjectStoreGetAllPreprocessResponse;
};
Type mType;
};
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace IPC {
template<>
struct ParamTraits <::mozilla::dom::indexedDB::PreprocessResponse>
{
typedef ::mozilla::dom::indexedDB::PreprocessResponse paramType;
static void
Write(
IPC::MessageWriter* aWriter,
const paramType& aVar);
static IPC::ReadResult<paramType>
Read(IPC::MessageReader* aReader);
};
} // namespace IPC
namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBRequestParent;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
namespace mozilla {
namespace dom {
namespace indexedDB {
class PBackgroundIDBRequestChild;
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
//-----------------------------------------------------------------------------
// Code common to PBackgroundIDBRequestChild and PBackgroundIDBRequestParent
//
namespace mozilla {
namespace dom {
namespace indexedDB {
namespace PBackgroundIDBRequest {
nsresult
CreateEndpoints(
mozilla::ipc::EndpointProcInfo aParentDestInfo,
mozilla::ipc::EndpointProcInfo aChildDestInfo,
mozilla::ipc::Endpoint<::mozilla::dom::indexedDB::PBackgroundIDBRequestParent>* aParent,
mozilla::ipc::Endpoint<::mozilla::dom::indexedDB::PBackgroundIDBRequestChild>* aChild);
enum MessageType {
PBackgroundIDBRequestStart = PBackgroundIDBRequestMsgStart << 16,
Msg_Continue__ID,
Msg___delete____ID,
Reply___delete____ID,
Msg_Preprocess__ID,
PBackgroundIDBRequestEnd
};
mozilla::UniquePtr<IPC::Message>
Msg_Continue(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Reply___delete__(int32_t routingId);
mozilla::UniquePtr<IPC::Message>
Msg_Preprocess(int32_t routingId);
} // namespace PBackgroundIDBRequest
} // namespace indexedDB
} // namespace dom
} // namespace mozilla
#endif // ifndef PBackgroundIDBRequest_h