Avi Drissman | e4622aa | 2022-09-08 20:36:06 | [diff] [blame] | 1 | // Copyright 2012 The Chromium Authors |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 5 | // Weak pointers are pointers to an object that do not affect its lifetime, |
dcheng | efeb19b | 2016-04-05 20:07:40 | [diff] [blame] | 6 | // and which may be invalidated (i.e. reset to nullptr) by the object, or its |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 7 | // owner, at any time, most commonly when the object is about to be deleted. |
| 8 | |
| 9 | // Weak pointers are useful when an object needs to be accessed safely by one |
| 10 | // or more objects other than its owner, and those callers can cope with the |
| 11 | // object vanishing and e.g. tasks posted to it being silently dropped. |
| 12 | // Reference-counting such an object would complicate the ownership graph and |
| 13 | // make it harder to reason about the object's lifetime. |
| 14 | |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 15 | // EXAMPLE: |
| 16 | // |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 17 | // class Controller { |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 18 | // public: |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 19 | // void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); } |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 20 | // void WorkComplete(const Result& result) { ... } |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 21 | // private: |
[email protected] | ed3f6734 | 2013-05-29 08:04:32 | [diff] [blame] | 22 | // // Member variables should appear before the WeakPtrFactory, to ensure |
| 23 | // // that any WeakPtrs to Controller are invalidated before its members |
| 24 | // // variable's destructors are executed, rendering them invalid. |
Jeremy Roman | 0dd0b2f | 2019-07-16 21:00:43 | [diff] [blame] | 25 | // WeakPtrFactory<Controller> weak_factory_{this}; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 26 | // }; |
| 27 | // |
| 28 | // class Worker { |
| 29 | // public: |
Daniel Hosseinian | fff4da5 | 2021-01-27 22:13:08 | [diff] [blame] | 30 | // static void StartNew(WeakPtr<Controller> controller) { |
danakj | b57ac1d | 2021-12-03 21:52:49 | [diff] [blame] | 31 | // // Move WeakPtr when possible to avoid atomic refcounting churn on its |
| 32 | // // internal state. |
Daniel Hosseinian | fff4da5 | 2021-01-27 22:13:08 | [diff] [blame] | 33 | // Worker* worker = new Worker(std::move(controller)); |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 34 | // // Kick off asynchronous processing... |
| 35 | // } |
| 36 | // private: |
Daniel Hosseinian | fff4da5 | 2021-01-27 22:13:08 | [diff] [blame] | 37 | // Worker(WeakPtr<Controller> controller) |
| 38 | // : controller_(std::move(controller)) {} |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 39 | // void DidCompleteAsynchronousProcessing(const Result& result) { |
| 40 | // if (controller_) |
| 41 | // controller_->WorkComplete(result); |
| 42 | // } |
| 43 | // WeakPtr<Controller> controller_; |
| 44 | // }; |
| 45 | // |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 46 | // With this implementation a caller may use SpawnWorker() to dispatch multiple |
| 47 | // Workers and subsequently delete the Controller, without waiting for all |
| 48 | // Workers to have completed. |
| 49 | |
| 50 | // ------------------------- IMPORTANT: Thread-safety ------------------------- |
| 51 | |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 52 | // Weak pointers may be passed safely between sequences, but must always be |
davidben | e58877e | 2014-10-22 18:37:11 | [diff] [blame] | 53 | // dereferenced and invalidated on the same SequencedTaskRunner otherwise |
| 54 | // checking the pointer would be racey. |
[email protected] | ed3f6734 | 2013-05-29 08:04:32 | [diff] [blame] | 55 | // |
| 56 | // To ensure correct use, the first time a WeakPtr issued by a WeakPtrFactory |
| 57 | // is dereferenced, the factory and its WeakPtrs become bound to the calling |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 58 | // sequence or current SequencedWorkerPool token, and cannot be dereferenced or |
davidben | e58877e | 2014-10-22 18:37:11 | [diff] [blame] | 59 | // invalidated on any other task runner. Bound WeakPtrs can still be handed |
| 60 | // off to other task runners, e.g. to use to post tasks back to object on the |
| 61 | // bound sequence. |
[email protected] | ed3f6734 | 2013-05-29 08:04:32 | [diff] [blame] | 62 | // |
scheib | 3ad0372 | 2015-10-05 22:27:41 | [diff] [blame] | 63 | // If all WeakPtr objects are destroyed or invalidated then the factory is |
| 64 | // unbound from the SequencedTaskRunner/Thread. The WeakPtrFactory may then be |
| 65 | // destroyed, or new WeakPtr objects may be used, from a different sequence. |
| 66 | // |
| 67 | // Thus, at least one WeakPtr object must exist and have been dereferenced on |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 68 | // the correct sequence to enforce that other WeakPtr objects will enforce they |
| 69 | // are used on the desired sequence. |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 70 | |
[email protected] | 3b63f8f4 | 2011-03-28 01:54:15 | [diff] [blame] | 71 | #ifndef BASE_MEMORY_WEAK_PTR_H_ |
| 72 | #define BASE_MEMORY_WEAK_PTR_H_ |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 73 | |
dcheng | efeb19b | 2016-04-05 20:07:40 | [diff] [blame] | 74 | #include <cstddef> |
tzik | 403cb6c | 2016-03-10 07:17:25 | [diff] [blame] | 75 | #include <type_traits> |
Sumaid Syed | 22f60eeb | 2021-08-26 05:16:26 | [diff] [blame] | 76 | #include <utility> |
tzik | 403cb6c | 2016-03-10 07:17:25 | [diff] [blame] | 77 | |
[email protected] | 0bea725 | 2011-08-05 15:34:00 | [diff] [blame] | 78 | #include "base/base_export.h" |
Hans Wennborg | 7b53371 | 2020-06-22 20:52:27 | [diff] [blame] | 79 | #include "base/check.h" |
Lukasz Anforowicz | 7623e19 | 2021-12-02 23:19:36 | [diff] [blame] | 80 | #include "base/compiler_specific.h" |
Igor Bukanov | 933bad99 | 2021-09-10 19:47:25 | [diff] [blame] | 81 | #include "base/dcheck_is_on.h" |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 82 | #include "base/memory/raw_ptr.h" |
[email protected] | 3b63f8f4 | 2011-03-28 01:54:15 | [diff] [blame] | 83 | #include "base/memory/ref_counted.h" |
Paul Semel | 5eac04a1 | 2023-06-07 18:17:32 | [diff] [blame] | 84 | #include "base/memory/safe_ref_traits.h" |
[email protected] | d52426c | 2013-07-30 19:26:40 | [diff] [blame] | 85 | #include "base/sequence_checker.h" |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 86 | #include "base/synchronization/atomic_flag.h" |
Joe Mason | 0f6f611 | 2024-02-08 17:48:10 | [diff] [blame] | 87 | |
| 88 | namespace performance_manager { |
| 89 | class FrameNodeImpl; |
| 90 | class PageNodeImpl; |
| 91 | class ProcessNodeImpl; |
| 92 | class WorkerNodeImpl; |
| 93 | } // namespace performance_manager |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 94 | |
| 95 | namespace base { |
| 96 | |
Scott Haseley | da86547 | 2023-05-10 19:03:11 | [diff] [blame] | 97 | namespace sequence_manager::internal { |
| 98 | class TaskQueueImpl; |
| 99 | } |
| 100 | |
[email protected] | 4c44b844 | 2012-06-15 16:36:12 | [diff] [blame] | 101 | template <typename T> class WeakPtr; |
| 102 | |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 103 | namespace internal { |
| 104 | // These classes are part of the WeakPtr implementation. |
| 105 | // DO NOT USE THESE CLASSES DIRECTLY YOURSELF. |
| 106 | |
Lukasz Anforowicz | 7623e19 | 2021-12-02 23:19:36 | [diff] [blame] | 107 | class BASE_EXPORT TRIVIAL_ABI WeakReference { |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 108 | public: |
Wez | fb4a528 | 2018-05-01 09:02:11 | [diff] [blame] | 109 | // Although Flag is bound to a specific SequencedTaskRunner, it may be |
| 110 | // deleted from another via base::WeakPtr::~WeakPtr(). |
[email protected] | a827a56 | 2014-06-11 00:37:42 | [diff] [blame] | 111 | class BASE_EXPORT Flag : public RefCountedThreadSafe<Flag> { |
[email protected] | d52e9709 | 2009-09-17 00:31:09 | [diff] [blame] | 112 | public: |
[email protected] | 1edefc4 | 2011-08-26 17:32:29 | [diff] [blame] | 113 | Flag(); |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 114 | |
hans | 24046fd | 2017-06-29 22:07:42 | [diff] [blame] | 115 | void Invalidate(); |
Hans Wennborg | 4cfa301 | 2017-08-08 03:33:38 | [diff] [blame] | 116 | bool IsValid() const; |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 117 | |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 118 | bool MaybeValid() const; |
| 119 | |
Igor Bukanov | 933bad99 | 2021-09-10 19:47:25 | [diff] [blame] | 120 | #if DCHECK_IS_ON() |
Wez | c5acb1ae | 2019-02-14 03:09:32 | [diff] [blame] | 121 | void DetachFromSequence(); |
Scott Haseley | da86547 | 2023-05-10 19:03:11 | [diff] [blame] | 122 | void BindToCurrentSequence(); |
Igor Bukanov | 933bad99 | 2021-09-10 19:47:25 | [diff] [blame] | 123 | #endif |
Wez | c5acb1ae | 2019-02-14 03:09:32 | [diff] [blame] | 124 | |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 125 | private: |
[email protected] | 05b1cd61 | 2011-04-11 20:47:25 | [diff] [blame] | 126 | friend class base::RefCountedThreadSafe<Flag>; |
| 127 | |
| 128 | ~Flag(); |
| 129 | |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 130 | SEQUENCE_CHECKER(sequence_checker_); |
| 131 | AtomicFlag invalidated_; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 132 | }; |
| 133 | |
[email protected] | 3a3d4747 | 2010-07-15 21:03:54 | [diff] [blame] | 134 | WeakReference(); |
Wez | 7eedd9e | 2018-01-23 00:27:05 | [diff] [blame] | 135 | explicit WeakReference(const scoped_refptr<Flag>& flag); |
[email protected] | 20136647 | 2010-07-16 17:22:49 | [diff] [blame] | 136 | ~WeakReference(); |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 137 | |
mek | 7901681 | 2016-06-24 21:29:04 | [diff] [blame] | 138 | WeakReference(const WeakReference& other); |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 139 | WeakReference& operator=(const WeakReference& other); |
mek | 7901681 | 2016-06-24 21:29:04 | [diff] [blame] | 140 | |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 141 | WeakReference(WeakReference&& other) noexcept; |
| 142 | WeakReference& operator=(WeakReference&& other) noexcept; |
| 143 | |
| 144 | void Reset(); |
| 145 | // Returns whether the WeakReference is valid, meaning the WeakPtrFactory has |
| 146 | // not invalidated the pointer. Unlike, RefIsMaybeValid(), this may only be |
| 147 | // called from the same sequence as where the WeakPtr was created. |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 148 | bool IsValid() const; |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 149 | // Returns false if the WeakReference is confirmed to be invalid. This call is |
| 150 | // safe to make from any thread, e.g. to optimize away unnecessary work, but |
| 151 | // RefIsValid() must always be called, on the correct sequence, before |
| 152 | // actually using the pointer. |
| 153 | // |
| 154 | // Warning: as with any object, this call is only thread-safe if the WeakPtr |
| 155 | // instance isn't being re-assigned or reset() racily with this call. |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 156 | bool MaybeValid() const; |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 157 | |
| 158 | private: |
[email protected] | 1edefc4 | 2011-08-26 17:32:29 | [diff] [blame] | 159 | scoped_refptr<const Flag> flag_; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 160 | }; |
| 161 | |
[email protected] | 0bea725 | 2011-08-05 15:34:00 | [diff] [blame] | 162 | class BASE_EXPORT WeakReferenceOwner { |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 163 | public: |
[email protected] | 3a3d4747 | 2010-07-15 21:03:54 | [diff] [blame] | 164 | WeakReferenceOwner(); |
| 165 | ~WeakReferenceOwner(); |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 166 | |
[email protected] | 3a3d4747 | 2010-07-15 21:03:54 | [diff] [blame] | 167 | WeakReference GetRef() const; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 168 | |
Wez | c5acb1ae | 2019-02-14 03:09:32 | [diff] [blame] | 169 | bool HasRefs() const { return !flag_->HasOneRef(); } |
[email protected] | 59326aac | 2009-09-25 23:34:34 | [diff] [blame] | 170 | |
[email protected] | 3a3d4747 | 2010-07-15 21:03:54 | [diff] [blame] | 171 | void Invalidate(); |
Scott Haseley | da86547 | 2023-05-10 19:03:11 | [diff] [blame] | 172 | void BindToCurrentSequence(); |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 173 | |
| 174 | private: |
Wez | 85ed948 | 2019-11-13 02:23:31 | [diff] [blame] | 175 | scoped_refptr<WeakReference::Flag> flag_; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 176 | }; |
| 177 | |
danakj | 45c9178 | 2021-09-29 18:23:57 | [diff] [blame] | 178 | // Forward declaration from safe_ptr.h. |
| 179 | template <typename T> |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 180 | SafeRef<T> MakeSafeRefFromWeakPtrInternals(internal::WeakReference&& ref, |
danakj | 45c9178 | 2021-09-29 18:23:57 | [diff] [blame] | 181 | T* ptr); |
| 182 | |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 183 | } // namespace internal |
| 184 | |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 185 | template <typename T> class WeakPtrFactory; |
| 186 | |
| 187 | // The WeakPtr class holds a weak reference to |T*|. |
| 188 | // |
| 189 | // This class is designed to be used like a normal pointer. You should always |
| 190 | // null-test an object of this class before using it or invoking a method that |
| 191 | // may result in the underlying object being destroyed. |
| 192 | // |
| 193 | // EXAMPLE: |
| 194 | // |
| 195 | // class Foo { ... }; |
| 196 | // WeakPtr<Foo> foo; |
| 197 | // if (foo) |
| 198 | // foo->method(); |
| 199 | // |
| 200 | template <typename T> |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 201 | class TRIVIAL_ABI WeakPtr { |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 202 | public: |
Chris Watkins | 091d629 | 2017-12-13 04:25:58 | [diff] [blame] | 203 | WeakPtr() = default; |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 204 | // NOLINTNEXTLINE(google-explicit-constructor) |
hans | cc65b299 | 2017-06-29 20:35:28 | [diff] [blame] | 205 | WeakPtr(std::nullptr_t) {} |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 206 | |
[email protected] | c33acdb | 2013-03-02 02:31:45 | [diff] [blame] | 207 | // Allow conversion from U to T provided U "is a" T. Note that this |
mek | 7901681 | 2016-06-24 21:29:04 | [diff] [blame] | 208 | // is separate from the (implicit) copy and move constructors. |
Daniel Cheng | 8d4b30d | 2023-11-14 20:25:54 | [diff] [blame] | 209 | template <typename U> |
| 210 | requires(std::convertible_to<U*, T*>) |
Alan Cutter | 6e972c8 | 2022-10-07 05:03:45 | [diff] [blame] | 211 | // NOLINTNEXTLINE(google-explicit-constructor) |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 212 | WeakPtr(const WeakPtr<U>& other) : ref_(other.ref_), ptr_(other.ptr_) {} |
Daniel Cheng | 8d4b30d | 2023-11-14 20:25:54 | [diff] [blame] | 213 | template <typename U> |
| 214 | requires(std::convertible_to<U*, T*>) |
Alan Cutter | 6e972c8 | 2022-10-07 05:03:45 | [diff] [blame] | 215 | // NOLINTNEXTLINE(google-explicit-constructor) |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 216 | WeakPtr& operator=(const WeakPtr<U>& other) { |
| 217 | ref_ = other.ref_; |
| 218 | ptr_ = other.ptr_; |
| 219 | return *this; |
hans | cc65b299 | 2017-06-29 20:35:28 | [diff] [blame] | 220 | } |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 221 | |
Daniel Cheng | 8d4b30d | 2023-11-14 20:25:54 | [diff] [blame] | 222 | template <typename U> |
| 223 | requires(std::convertible_to<U*, T*>) |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 224 | // NOLINTNEXTLINE(google-explicit-constructor) |
| 225 | WeakPtr(WeakPtr<U>&& other) |
| 226 | : ref_(std::move(other.ref_)), ptr_(std::move(other.ptr_)) {} |
Daniel Cheng | 8d4b30d | 2023-11-14 20:25:54 | [diff] [blame] | 227 | template <typename U> |
| 228 | requires(std::convertible_to<U*, T*>) |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 229 | // NOLINTNEXTLINE(google-explicit-constructor) |
| 230 | WeakPtr& operator=(WeakPtr<U>&& other) { |
| 231 | ref_ = std::move(other.ref_); |
| 232 | ptr_ = std::move(other.ptr_); |
| 233 | return *this; |
hans | 526f714c | 2017-06-29 18:22:36 | [diff] [blame] | 234 | } |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 235 | |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 236 | T* get() const { return ref_.IsValid() ? ptr_ : nullptr; } |
| 237 | |
| 238 | // Provide access to the underlying T as a reference. Will CHECK() if the T |
| 239 | // pointee is no longer alive. |
[email protected] | f1836f4 | 2012-02-29 06:59:03 | [diff] [blame] | 240 | T& operator*() const { |
Daniel Cheng | 0b308a0 | 2020-10-13 19:17:03 | [diff] [blame] | 241 | CHECK(ref_.IsValid()); |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 242 | return *ptr_; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 243 | } |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 244 | |
| 245 | // Used to call methods on the underlying T. Will CHECK() if the T pointee is |
| 246 | // no longer alive. |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 247 | T* operator->() const { |
Daniel Cheng | 0b308a0 | 2020-10-13 19:17:03 | [diff] [blame] | 248 | CHECK(ref_.IsValid()); |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 249 | return ptr_; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 250 | } |
| 251 | |
wez | b9820d4 | 2016-06-22 23:41:04 | [diff] [blame] | 252 | // Allow conditionals to test validity, e.g. if (weak_ptr) {...}; |
Wez | caf863b99 | 2018-05-01 11:03:29 | [diff] [blame] | 253 | explicit operator bool() const { return get() != nullptr; } |
[email protected] | 380b139 | 2013-06-06 05:32:37 | [diff] [blame] | 254 | |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 255 | // Resets the WeakPtr to hold nothing. |
| 256 | // |
| 257 | // The `get()` method will return `nullptr` thereafter, and `MaybeValid()` |
| 258 | // will be `false`. |
| 259 | void reset() { |
| 260 | ref_.Reset(); |
| 261 | ptr_ = nullptr; |
| 262 | } |
| 263 | |
Erik Chen | 7c00119 | 2024-02-07 23:38:46 | [diff] [blame] | 264 | // Do not use this method. Almost all callers should instead use operator |
| 265 | // bool(). |
| 266 | // |
| 267 | // There are a few rare cases where the caller intentionally needs to check |
| 268 | // validity of a base::WeakPtr on a sequence different from the bound sequence |
| 269 | // as an unavoidable performance optimization. This is the only valid use-case |
| 270 | // for this method. See |
| 271 | // https://docs.google.com/document/d/1IGzq9Nx69GS_2iynGmPWo5sFAD2DcCyBY1zIvZwF7k8 |
| 272 | // for details. |
| 273 | // |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 274 | // Returns false if the WeakPtr is confirmed to be invalid. This call is safe |
| 275 | // to make from any thread, e.g. to optimize away unnecessary work, but |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 276 | // RefIsValid() must always be called, on the correct sequence, before |
Nicolas Ouellet-payeur | ff1eab6 | 2018-07-19 18:41:50 | [diff] [blame] | 277 | // actually using the pointer. |
| 278 | // |
| 279 | // Warning: as with any object, this call is only thread-safe if the WeakPtr |
| 280 | // instance isn't being re-assigned or reset() racily with this call. |
| 281 | bool MaybeValid() const { return ref_.MaybeValid(); } |
| 282 | |
Trent Apted | 30f97fd | 2018-08-21 09:03:47 | [diff] [blame] | 283 | // Returns whether the object |this| points to has been invalidated. This can |
| 284 | // be used to distinguish a WeakPtr to a destroyed object from one that has |
Trent Apted | 453d0b5b | 2018-08-23 00:13:22 | [diff] [blame] | 285 | // been explicitly set to null. |
Trent Apted | 30f97fd | 2018-08-21 09:03:47 | [diff] [blame] | 286 | bool WasInvalidated() const { return ptr_ && !ref_.IsValid(); } |
| 287 | |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 288 | private: |
[email protected] | c33acdb | 2013-03-02 02:31:45 | [diff] [blame] | 289 | template <typename U> friend class WeakPtr; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 290 | friend class WeakPtrFactory<T>; |
Alan Cutter | c2d2c47 | 2022-10-20 02:14:43 | [diff] [blame] | 291 | friend class WeakPtrFactory<std::remove_const_t<T>>; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 292 | |
danakj | cfcdfb7a | 2023-02-23 01:05:35 | [diff] [blame] | 293 | WeakPtr(internal::WeakReference&& ref, T* ptr) |
| 294 | : ref_(std::move(ref)), ptr_(ptr) { |
| 295 | DCHECK(ptr); |
| 296 | } |
| 297 | |
| 298 | internal::WeakReference CloneWeakReference() const { return ref_; } |
| 299 | |
| 300 | internal::WeakReference ref_; |
| 301 | |
| 302 | // This pointer is only valid when ref_.is_valid() is true. Otherwise, its |
| 303 | // value is undefined (as opposed to nullptr). The pointer is allowed to |
| 304 | // dangle as we verify its liveness through `ref_` before allowing access to |
| 305 | // the pointee. We don't use raw_ptr<T> here to prevent WeakPtr from keeping |
| 306 | // the memory allocation in quarantine, as it can't be accessed through the |
| 307 | // WeakPtr. |
| 308 | RAW_PTR_EXCLUSION T* ptr_ = nullptr; |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 309 | }; |
| 310 | |
wez | b9820d4 | 2016-06-22 23:41:04 | [diff] [blame] | 311 | // Allow callers to compare WeakPtrs against nullptr to test validity. |
| 312 | template <class T> |
| 313 | bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) { |
| 314 | return !(weak_ptr == nullptr); |
| 315 | } |
| 316 | template <class T> |
| 317 | bool operator!=(std::nullptr_t, const WeakPtr<T>& weak_ptr) { |
| 318 | return weak_ptr != nullptr; |
| 319 | } |
| 320 | template <class T> |
| 321 | bool operator==(const WeakPtr<T>& weak_ptr, std::nullptr_t) { |
| 322 | return weak_ptr.get() == nullptr; |
| 323 | } |
| 324 | template <class T> |
| 325 | bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) { |
| 326 | return weak_ptr == nullptr; |
| 327 | } |
| 328 | |
hans | d2a722f | 2017-06-28 21:12:54 | [diff] [blame] | 329 | namespace internal { |
| 330 | class BASE_EXPORT WeakPtrFactoryBase { |
| 331 | protected: |
| 332 | WeakPtrFactoryBase(uintptr_t ptr); |
| 333 | ~WeakPtrFactoryBase(); |
| 334 | internal::WeakReferenceOwner weak_reference_owner_; |
| 335 | uintptr_t ptr_; |
| 336 | }; |
| 337 | } // namespace internal |
| 338 | |
Joe Mason | 0f6f611 | 2024-02-08 17:48:10 | [diff] [blame] | 339 | namespace subtle { |
| 340 | |
| 341 | // Restricts access to WeakPtrFactory::BindToCurrentSequence() to authorized |
| 342 | // callers. |
| 343 | class BASE_EXPORT BindWeakPtrFactoryPassKey { |
| 344 | private: |
| 345 | // Avoid =default to disallow creation by uniform initialization. |
Sorin Jianu | 1ed1f6c | 2024-09-28 00:31:40 | [diff] [blame^] | 346 | BindWeakPtrFactoryPassKey() = default; |
Joe Mason | 0f6f611 | 2024-02-08 17:48:10 | [diff] [blame] | 347 | |
| 348 | friend class BindWeakPtrFactoryForTesting; |
| 349 | friend class performance_manager::FrameNodeImpl; |
| 350 | friend class performance_manager::PageNodeImpl; |
| 351 | friend class performance_manager::ProcessNodeImpl; |
| 352 | friend class performance_manager::WorkerNodeImpl; |
| 353 | friend class sequence_manager::internal::TaskQueueImpl; |
| 354 | }; |
| 355 | |
| 356 | } // namespace subtle |
| 357 | |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 358 | // A class may be composed of a WeakPtrFactory and thereby |
| 359 | // control how it exposes weak pointers to itself. This is helpful if you only |
| 360 | // need weak pointers within the implementation of a class. This class is also |
| 361 | // useful when working with primitive types. For example, you could have a |
| 362 | // WeakPtrFactory<bool> that is used to pass around a weak reference to a bool. |
| 363 | template <class T> |
hans | d2a722f | 2017-06-28 21:12:54 | [diff] [blame] | 364 | class WeakPtrFactory : public internal::WeakPtrFactoryBase { |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 365 | public: |
Peter Boström | 511258be | 2021-11-03 01:18:46 | [diff] [blame] | 366 | WeakPtrFactory() = delete; |
| 367 | |
hans | d2a722f | 2017-06-28 21:12:54 | [diff] [blame] | 368 | explicit WeakPtrFactory(T* ptr) |
| 369 | : WeakPtrFactoryBase(reinterpret_cast<uintptr_t>(ptr)) {} |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 370 | |
Peter Boström | 511258be | 2021-11-03 01:18:46 | [diff] [blame] | 371 | WeakPtrFactory(const WeakPtrFactory&) = delete; |
| 372 | WeakPtrFactory& operator=(const WeakPtrFactory&) = delete; |
| 373 | |
Chris Watkins | 091d629 | 2017-12-13 04:25:58 | [diff] [blame] | 374 | ~WeakPtrFactory() = default; |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 375 | |
Alan Cutter | c2d2c47 | 2022-10-20 02:14:43 | [diff] [blame] | 376 | WeakPtr<const T> GetWeakPtr() const { |
| 377 | return WeakPtr<const T>(weak_reference_owner_.GetRef(), |
| 378 | reinterpret_cast<const T*>(ptr_)); |
| 379 | } |
Alan Cutter | 4252ed2 | 2022-10-05 09:04:19 | [diff] [blame] | 380 | |
Daniel Cheng | 8d4b30d | 2023-11-14 20:25:54 | [diff] [blame] | 381 | WeakPtr<T> GetWeakPtr() |
| 382 | requires(!std::is_const_v<T>) |
| 383 | { |
Alan Cutter | 4252ed2 | 2022-10-05 09:04:19 | [diff] [blame] | 384 | return WeakPtr<T>(weak_reference_owner_.GetRef(), |
| 385 | reinterpret_cast<T*>(ptr_)); |
| 386 | } |
| 387 | |
Daniel Cheng | 8d4b30d | 2023-11-14 20:25:54 | [diff] [blame] | 388 | WeakPtr<T> GetMutableWeakPtr() const |
| 389 | requires(!std::is_const_v<T>) |
| 390 | { |
hans | d2a722f | 2017-06-28 21:12:54 | [diff] [blame] | 391 | return WeakPtr<T>(weak_reference_owner_.GetRef(), |
| 392 | reinterpret_cast<T*>(ptr_)); |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 393 | } |
| 394 | |
danakj | 45c9178 | 2021-09-29 18:23:57 | [diff] [blame] | 395 | // Returns a smart pointer that is valid until the WeakPtrFactory is |
| 396 | // invalidated. Unlike WeakPtr, this smart pointer cannot be null, and cannot |
| 397 | // be checked to see if the WeakPtrFactory is invalidated. It's intended to |
| 398 | // express that the pointer will not (intentionally) outlive the `T` object it |
| 399 | // points to, and to crash safely in the case of a bug instead of causing a |
| 400 | // use-after-free. This type provides an alternative to WeakPtr to prevent |
| 401 | // use-after-free bugs without also introducing "fuzzy lifetimes" that can be |
| 402 | // checked for at runtime. |
| 403 | SafeRef<T> GetSafeRef() const { |
| 404 | return internal::MakeSafeRefFromWeakPtrInternals( |
| 405 | weak_reference_owner_.GetRef(), reinterpret_cast<T*>(ptr_)); |
| 406 | } |
| 407 | |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 408 | // Call this method to invalidate all existing weak pointers. |
| 409 | void InvalidateWeakPtrs() { |
| 410 | DCHECK(ptr_); |
| 411 | weak_reference_owner_.Invalidate(); |
| 412 | } |
| 413 | |
| 414 | // Call this method to determine if any weak pointers exist. |
| 415 | bool HasWeakPtrs() const { |
| 416 | DCHECK(ptr_); |
| 417 | return weak_reference_owner_.HasRefs(); |
| 418 | } |
Scott Haseley | da86547 | 2023-05-10 19:03:11 | [diff] [blame] | 419 | |
Joe Mason | 0f6f611 | 2024-02-08 17:48:10 | [diff] [blame] | 420 | // Rebind the factory to the current sequence. This allows creating an object |
| 421 | // and associated weak pointers on a different thread from the one they are |
| 422 | // used on. |
| 423 | void BindToCurrentSequence(subtle::BindWeakPtrFactoryPassKey) { |
Scott Haseley | da86547 | 2023-05-10 19:03:11 | [diff] [blame] | 424 | weak_reference_owner_.BindToCurrentSequence(); |
| 425 | } |
[email protected] | 2c69139 | 2013-04-25 20:47:18 | [diff] [blame] | 426 | }; |
| 427 | |
[email protected] | 3125d646 | 2009-09-01 20:50:17 | [diff] [blame] | 428 | } // namespace base |
| 429 | |
[email protected] | 3b63f8f4 | 2011-03-28 01:54:15 | [diff] [blame] | 430 | #endif // BASE_MEMORY_WEAK_PTR_H_ |