mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-11 08:13:35 +00:00
1aa11ffed6
As serializing IPCStream no longer requires a manager or FileDescriptor array, the arguments are no longer necessary, and can be removed. The AutoIPCStream helper can also be removed, as managed actors are no longer used for serialization, so a delayed start callback is not necessary. The delayed start parameter is also removed from nsIIPCSerializableInputStream instances, but is still present as `aAllowLazy` on the toplevel serialization methods. Differential Revision: https://phabricator.services.mozilla.com/D141048
105 lines
5.1 KiB
C++
105 lines
5.1 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
* You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef mozilla_ipc_nsIIPCSerializableInputStream_h
|
|
#define mozilla_ipc_nsIIPCSerializableInputStream_h
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "nsISupports.h"
|
|
#include "nsTArrayForwardDeclare.h"
|
|
|
|
namespace mozilla {
|
|
namespace ipc {
|
|
|
|
class FileDescriptor;
|
|
class InputStreamParams;
|
|
|
|
} // namespace ipc
|
|
|
|
} // namespace mozilla
|
|
|
|
#define NS_IIPCSERIALIZABLEINPUTSTREAM_IID \
|
|
{ \
|
|
0xb0211b14, 0xea6d, 0x40d4, { \
|
|
0x87, 0xb5, 0x7b, 0xe3, 0xdf, 0xac, 0x09, 0xd1 \
|
|
} \
|
|
}
|
|
|
|
class NS_NO_VTABLE nsIIPCSerializableInputStream : public nsISupports {
|
|
public:
|
|
NS_DECLARE_STATIC_IID_ACCESSOR(NS_IIPCSERIALIZABLEINPUTSTREAM_IID)
|
|
|
|
// Determine the serialized complexity of this input stream, initializing
|
|
// `*aSizeUsed`, `*aPipes` and `*aTransferables` to the number of inline
|
|
// bytes/pipes/transferable resources which would be used. This will be used
|
|
// by other `Serialize` implementations to potentially simplify the resulting
|
|
// stream, reducing the number of pipes or file descriptors required.
|
|
//
|
|
// Each outparameter corresponds to a type of resource which will be included
|
|
// in the serialized message, as follows:
|
|
//
|
|
// *aSizeUsed:
|
|
// Raw bytes to be included inline in the message's payload, usually in the
|
|
// form of a nsCString for a StringInputStreamParams. This must be less
|
|
// than or equal to `aMaxSize`. Larger payloads should instead be
|
|
// serialized using SerializeInputStreamAsPipe.
|
|
// *aPipes:
|
|
// New pipes, created using SerializeInputStreamAsPipe, which will be used
|
|
// to asynchronously transfer part of the pipe over IPC. Callers such as
|
|
// nsMultiplexInputStream may choose to serialize themselves as a DataPipe
|
|
// if they contain DataPipes themselves, so existing DataPipe instances
|
|
// which are cheaply transferred should be counted as transferrables.
|
|
// *aTransferables:
|
|
// Existing objects which can be more cheaply transferred over IPC than by
|
|
// serializing them inline in a payload or transferring them through a new
|
|
// DataPipe. This includes RemoteLazyInputStreams, FileDescriptors, and
|
|
// existing DataPipeReceiver instances.
|
|
//
|
|
// Callers of this method must have initialized all of `*aSizeUsed`,
|
|
// `*aPipes`, and `*aTransferables` to 0, so implementations are not required
|
|
// to initialize all outparameters. The outparameters must not be null.
|
|
virtual void SerializedComplexity(uint32_t aMaxSize, uint32_t* aSizeUsed,
|
|
uint32_t* aPipes,
|
|
uint32_t* aTransferables) = 0;
|
|
|
|
virtual void Serialize(mozilla::ipc::InputStreamParams& aParams,
|
|
uint32_t aMaxSize, uint32_t* aSizeUsed) = 0;
|
|
|
|
virtual bool Deserialize(const mozilla::ipc::InputStreamParams& aParams) = 0;
|
|
};
|
|
|
|
NS_DEFINE_STATIC_IID_ACCESSOR(nsIIPCSerializableInputStream,
|
|
NS_IIPCSERIALIZABLEINPUTSTREAM_IID)
|
|
|
|
#define NS_DECL_NSIIPCSERIALIZABLEINPUTSTREAM \
|
|
virtual void SerializedComplexity(uint32_t aMaxSize, uint32_t* aSizeUsed, \
|
|
uint32_t* aPipes, \
|
|
uint32_t* aTransferrables) override; \
|
|
virtual void Serialize(mozilla::ipc::InputStreamParams&, uint32_t, \
|
|
uint32_t*) override; \
|
|
\
|
|
virtual bool Deserialize(const mozilla::ipc::InputStreamParams&) override;
|
|
|
|
#define NS_FORWARD_NSIIPCSERIALIZABLEINPUTSTREAM(_to) \
|
|
virtual void SerializedComplexity(uint32_t aMaxSize, uint32_t* aSizeUsed, \
|
|
uint32_t* aPipes, \
|
|
uint32_t* aTransferables) override { \
|
|
_to SerializedComplexity(aMaxSize, aSizeUsed, aPipes, aTransferables); \
|
|
}; \
|
|
\
|
|
virtual void Serialize(mozilla::ipc::InputStreamParams& aParams, \
|
|
uint32_t aMaxSize, uint32_t* aSizeUsed) override { \
|
|
_to Serialize(aParams, aMaxSize, aSizeUsed); \
|
|
} \
|
|
\
|
|
virtual bool Deserialize(const mozilla::ipc::InputStreamParams& aParams) \
|
|
override { \
|
|
return _to Deserialize(aParams); \
|
|
}
|
|
|
|
#endif // mozilla_ipc_nsIIPCSerializableInputStream_h
|