summaryrefslogtreecommitdiffstats
path: root/mfbt/UniquePtrExtensions.h
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /mfbt/UniquePtrExtensions.h
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'mfbt/UniquePtrExtensions.h')
-rw-r--r--mfbt/UniquePtrExtensions.h310
1 files changed, 310 insertions, 0 deletions
diff --git a/mfbt/UniquePtrExtensions.h b/mfbt/UniquePtrExtensions.h
new file mode 100644
index 0000000000..f5c43ae29e
--- /dev/null
+++ b/mfbt/UniquePtrExtensions.h
@@ -0,0 +1,310 @@
+/* -*- 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/. */
+
+/* Useful extensions to UniquePtr. */
+
+#ifndef mozilla_UniquePtrExtensions_h
+#define mozilla_UniquePtrExtensions_h
+
+#include <type_traits>
+
+#include "mozilla/Attributes.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/fallible.h"
+#include "mozilla/UniquePtr.h"
+
+#ifdef XP_WIN
+# include <cstdint>
+#endif
+#if defined(XP_DARWIN) && !defined(RUST_BINDGEN)
+# include <mach/mach.h>
+#endif
+
+namespace mozilla {
+
+/**
+ * MakeUniqueFallible works exactly like MakeUnique, except that the memory
+ * allocation performed is done fallibly, i.e. it can return nullptr.
+ */
+template <typename T, typename... Args>
+typename detail::UniqueSelector<T>::SingleObject MakeUniqueFallible(
+ Args&&... aArgs) {
+ return UniquePtr<T>(new (fallible) T(std::forward<Args>(aArgs)...));
+}
+
+template <typename T>
+typename detail::UniqueSelector<T>::UnknownBound MakeUniqueFallible(
+ decltype(sizeof(int)) aN) {
+ using ArrayType = std::remove_extent_t<T>;
+ return UniquePtr<T>(new (fallible) ArrayType[aN]());
+}
+
+template <typename T, typename... Args>
+typename detail::UniqueSelector<T>::KnownBound MakeUniqueFallible(
+ Args&&... aArgs) = delete;
+
+/**
+ * MakeUniqueForOverwrite and MakeUniqueFallibleForOverwrite are like MakeUnique
+ * and MakeUniqueFallible except they use default-initialization. This is
+ * useful, for example, when you have a POD type array that will be overwritten
+ * directly after construction and so zero-initialization is a waste.
+ */
+template <typename T, typename... Args>
+typename detail::UniqueSelector<T>::SingleObject MakeUniqueForOverwrite() {
+ return UniquePtr<T>(new T);
+}
+
+template <typename T>
+typename detail::UniqueSelector<T>::UnknownBound MakeUniqueForOverwrite(
+ decltype(sizeof(int)) aN) {
+ using ArrayType = std::remove_extent_t<T>;
+ return UniquePtr<T>(new ArrayType[aN]);
+}
+
+template <typename T, typename... Args>
+typename detail::UniqueSelector<T>::KnownBound MakeUniqueForOverwrite(
+ Args&&... aArgs) = delete;
+
+template <typename T, typename... Args>
+typename detail::UniqueSelector<T>::SingleObject
+MakeUniqueForOverwriteFallible() {
+ return UniquePtr<T>(new (fallible) T);
+}
+
+template <typename T>
+typename detail::UniqueSelector<T>::UnknownBound MakeUniqueForOverwriteFallible(
+ decltype(sizeof(int)) aN) {
+ using ArrayType = std::remove_extent_t<T>;
+ return UniquePtr<T>(new (fallible) ArrayType[aN]);
+}
+
+template <typename T, typename... Args>
+typename detail::UniqueSelector<T>::KnownBound MakeUniqueForOverwriteFallible(
+ Args&&... aArgs) = delete;
+
+namespace detail {
+
+template <typename T>
+struct FreePolicy {
+ void operator()(const void* ptr) { free(const_cast<void*>(ptr)); }
+};
+
+#if defined(XP_WIN)
+// Can't include <windows.h> to get the actual definition of HANDLE
+// because of namespace pollution.
+typedef void* FileHandleType;
+#elif defined(XP_UNIX)
+typedef int FileHandleType;
+#else
+# error "Unsupported OS?"
+#endif
+
+struct FileHandleHelper {
+ MOZ_IMPLICIT FileHandleHelper(FileHandleType aHandle) : mHandle(aHandle) {}
+
+ MOZ_IMPLICIT constexpr FileHandleHelper(std::nullptr_t)
+ : mHandle(kInvalidHandle) {}
+
+ bool operator!=(std::nullptr_t) const {
+#ifdef XP_WIN
+ // Windows uses both nullptr and INVALID_HANDLE_VALUE (-1 cast to
+ // HANDLE) in different situations, but nullptr is more reliably
+ // null while -1 is also valid input to some calls that take
+ // handles. So class considers both to be null (since neither
+ // should be closed) but default-constructs as nullptr.
+ if (mHandle == (void*)-1) {
+ return false;
+ }
+#endif
+ return mHandle != kInvalidHandle;
+ }
+
+ operator FileHandleType() const { return mHandle; }
+
+#ifdef XP_WIN
+ // NSPR uses an integer type for PROsfd, so this conversion is
+ // provided for working with it without needing reinterpret casts
+ // everywhere.
+ operator std::intptr_t() const {
+ return reinterpret_cast<std::intptr_t>(mHandle);
+ }
+#endif
+
+ // When there's only one user-defined conversion operator, the
+ // compiler will use that to derive equality, but that doesn't work
+ // when the conversion is ambiguoug (the XP_WIN case above).
+ bool operator==(const FileHandleHelper& aOther) const {
+ return mHandle == aOther.mHandle;
+ }
+
+ private:
+ FileHandleType mHandle;
+
+#ifdef XP_WIN
+ // See above for why this is nullptr. (Also, INVALID_HANDLE_VALUE
+ // can't be expressed as a constexpr.)
+ static constexpr FileHandleType kInvalidHandle = nullptr;
+#else
+ static constexpr FileHandleType kInvalidHandle = -1;
+#endif
+};
+
+struct FileHandleDeleter {
+ using pointer = FileHandleHelper;
+ using receiver = FileHandleType;
+ MFBT_API void operator()(FileHandleHelper aHelper);
+};
+
+#if defined(XP_DARWIN) && !defined(RUST_BINDGEN)
+struct MachPortHelper {
+ MOZ_IMPLICIT MachPortHelper(mach_port_t aPort) : mPort(aPort) {}
+
+ MOZ_IMPLICIT constexpr MachPortHelper(std::nullptr_t)
+ : mPort(MACH_PORT_NULL) {}
+
+ bool operator!=(std::nullptr_t) const { return mPort != MACH_PORT_NULL; }
+
+ operator const mach_port_t&() const { return mPort; }
+ operator mach_port_t&() { return mPort; }
+
+ private:
+ mach_port_t mPort;
+};
+
+struct MachSendRightDeleter {
+ using pointer = MachPortHelper;
+ using receiver = mach_port_t;
+ MFBT_API void operator()(MachPortHelper aHelper) {
+ DebugOnly<kern_return_t> kr =
+ mach_port_deallocate(mach_task_self(), aHelper);
+ MOZ_ASSERT(kr == KERN_SUCCESS, "failed to deallocate mach send right");
+ }
+};
+
+struct MachReceiveRightDeleter {
+ using pointer = MachPortHelper;
+ using receiver = mach_port_t;
+ MFBT_API void operator()(MachPortHelper aHelper) {
+ DebugOnly<kern_return_t> kr = mach_port_mod_refs(
+ mach_task_self(), aHelper, MACH_PORT_RIGHT_RECEIVE, -1);
+ MOZ_ASSERT(kr == KERN_SUCCESS, "failed to release mach receive right");
+ }
+};
+
+struct MachPortSetDeleter {
+ using pointer = MachPortHelper;
+ using receiver = mach_port_t;
+ MFBT_API void operator()(MachPortHelper aHelper) {
+ DebugOnly<kern_return_t> kr = mach_port_mod_refs(
+ mach_task_self(), aHelper, MACH_PORT_RIGHT_PORT_SET, -1);
+ MOZ_ASSERT(kr == KERN_SUCCESS, "failed to release mach port set");
+ }
+};
+#endif
+
+} // namespace detail
+
+template <typename T>
+using UniqueFreePtr = UniquePtr<T, detail::FreePolicy<T>>;
+
+// A RAII class for the OS construct used for open files and similar
+// objects: a file descriptor on Unix or a handle on Windows.
+using UniqueFileHandle =
+ UniquePtr<detail::FileHandleType, detail::FileHandleDeleter>;
+
+#if defined(XP_DARWIN) && !defined(RUST_BINDGEN)
+// A RAII class for a Mach port that names a send right.
+using UniqueMachSendRight =
+ UniquePtr<mach_port_t, detail::MachSendRightDeleter>;
+// A RAII class for a Mach port that names a receive right.
+using UniqueMachReceiveRight =
+ UniquePtr<mach_port_t, detail::MachReceiveRightDeleter>;
+// A RAII class for a Mach port set.
+using UniqueMachPortSet = UniquePtr<mach_port_t, detail::MachPortSetDeleter>;
+
+// Increases the user reference count for MACH_PORT_RIGHT_SEND by 1 and returns
+// a new UniqueMachSendRight to manage the additional right.
+inline UniqueMachSendRight RetainMachSendRight(mach_port_t aPort) {
+ kern_return_t kr =
+ mach_port_mod_refs(mach_task_self(), aPort, MACH_PORT_RIGHT_SEND, 1);
+ if (kr == KERN_SUCCESS) {
+ return UniqueMachSendRight(aPort);
+ }
+ return nullptr;
+}
+#endif
+
+namespace detail {
+
+struct HasReceiverTypeHelper {
+ template <class U>
+ static double Test(...);
+ template <class U>
+ static char Test(typename U::receiver* = 0);
+};
+
+template <class T>
+class HasReceiverType
+ : public std::integral_constant<bool, sizeof(HasReceiverTypeHelper::Test<T>(
+ 0)) == 1> {};
+
+template <class T, class D, bool = HasReceiverType<D>::value>
+struct ReceiverTypeImpl {
+ using Type = typename D::receiver;
+};
+
+template <class T, class D>
+struct ReceiverTypeImpl<T, D, false> {
+ using Type = typename PointerType<T, D>::Type;
+};
+
+template <class T, class D>
+struct ReceiverType {
+ using Type = typename ReceiverTypeImpl<T, std::remove_reference_t<D>>::Type;
+};
+
+template <typename T, typename D>
+class MOZ_TEMPORARY_CLASS UniquePtrGetterTransfers {
+ public:
+ using Ptr = UniquePtr<T, D>;
+ using Receiver = typename detail::ReceiverType<T, D>::Type;
+
+ explicit UniquePtrGetterTransfers(Ptr& p)
+ : mPtr(p), mReceiver(typename Ptr::Pointer(nullptr)) {}
+ ~UniquePtrGetterTransfers() { mPtr.reset(mReceiver); }
+
+ operator Receiver*() { return &mReceiver; }
+ Receiver& operator*() { return mReceiver; }
+
+ // operator void** is conditionally enabled if `Receiver` is a pointer.
+ template <typename U = Receiver,
+ std::enable_if_t<
+ std::is_pointer_v<U> && std::is_same_v<U, Receiver>, int> = 0>
+ operator void**() {
+ return reinterpret_cast<void**>(&mReceiver);
+ }
+
+ private:
+ Ptr& mPtr;
+ Receiver mReceiver;
+};
+
+} // namespace detail
+
+// Helper for passing a UniquePtr to an old-style function that uses raw
+// pointers for out params. Example usage:
+//
+// void AllocateFoo(Foo** out) { *out = new Foo(); }
+// UniquePtr<Foo> foo;
+// AllocateFoo(getter_Transfers(foo));
+template <typename T, typename D>
+auto getter_Transfers(UniquePtr<T, D>& up) {
+ return detail::UniquePtrGetterTransfers<T, D>(up);
+}
+
+} // namespace mozilla
+
+#endif // mozilla_UniquePtrExtensions_h