Adding upstream version 115.8.0esr.upstream/115.8.0esr

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 104 insertions, 0 deletions

diff --git a/ipc/glue/nsIIPCSerializableInputStream.h b/ipc/glue/nsIIPCSerializableInputStream.h
new file mode 100644
index 0000000000..acc7594f66
--- /dev/null
+++ b/ipc/glue/nsIIPCSerializableInputStream.h
@@ -0,0 +1,104 @@
+/* -*- 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