ladybird/Kernel/Library/ListedRefCounted.h
Andreas Kling a4b4b358ff AK+Kernel: Remove one_ref_left() footgun
This mechanism was unsafe to use in any multithreaded context, since
the hook function was invoked on a raw pointer *after* decrementing
the local ref count.

Since we don't use it for anything anymore, let's just get rid of it.
2022-01-11 01:12:16 +01:00

58 lines
1.7 KiB
C++

/*
* Copyright (c) 2021, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <AK/RefCounted.h>
namespace Kernel {
// ListedRefCounted<T> is a slot-in replacement for RefCounted<T> to use in classes
// that add themselves to a {Spinlock, Mutex}Protected<IntrusiveList> when constructed.
// The custom unref() implementation here ensures that the list is locked during
// unref(), and that the T is removed from the list before ~T() is invoked.
enum class LockType {
Spinlock,
Mutex,
};
template<typename T, LockType Lock>
class ListedRefCounted : public RefCountedBase {
public:
bool unref() const
{
auto* that = const_cast<T*>(static_cast<T const*>(this));
auto callback = [&](auto& list) {
auto new_ref_count = deref_base();
if (new_ref_count == 0) {
list.remove(const_cast<T&>(*that));
if constexpr (requires { that->revoke_weak_ptrs(); }) {
that->revoke_weak_ptrs();
}
if constexpr (requires { that->remove_from_secondary_lists(); })
that->remove_from_secondary_lists();
}
return new_ref_count;
};
RefCountType new_ref_count;
if constexpr (Lock == LockType::Spinlock)
new_ref_count = T::all_instances().with(callback);
else if constexpr (Lock == LockType::Mutex)
new_ref_count = T::all_instances().with_exclusive(callback);
if (new_ref_count == 0) {
if constexpr (requires { that->will_be_destroyed(); })
that->will_be_destroyed();
delete that;
}
return new_ref_count == 0;
}
};
}