blob: 25292e3dcef2e48ee057429dd130df63b4ef8e46 [file] [log] [blame]
Avi Drissmane4622aa2022-09-08 20:36:061// Copyright 2012 The Chromium Authors
[email protected]3125d6462009-09-01 20:50:172// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
[email protected]2c691392013-04-25 20:47:185// Weak pointers are pointers to an object that do not affect its lifetime,
dchengefeb19b2016-04-05 20:07:406// and which may be invalidated (i.e. reset to nullptr) by the object, or its
[email protected]2c691392013-04-25 20:47:187// 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]3125d6462009-09-01 20:50:1715// EXAMPLE:
16//
[email protected]2c691392013-04-25 20:47:1817// class Controller {
[email protected]3125d6462009-09-01 20:50:1718// public:
[email protected]2c691392013-04-25 20:47:1819// void SpawnWorker() { Worker::StartNew(weak_factory_.GetWeakPtr()); }
[email protected]3125d6462009-09-01 20:50:1720// void WorkComplete(const Result& result) { ... }
[email protected]2c691392013-04-25 20:47:1821// private:
[email protected]ed3f67342013-05-29 08:04:3222// // 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 Roman0dd0b2f2019-07-16 21:00:4325// WeakPtrFactory<Controller> weak_factory_{this};
[email protected]3125d6462009-09-01 20:50:1726// };
27//
28// class Worker {
29// public:
Daniel Hosseinianfff4da52021-01-27 22:13:0830// static void StartNew(WeakPtr<Controller> controller) {
danakjb57ac1d2021-12-03 21:52:4931// // Move WeakPtr when possible to avoid atomic refcounting churn on its
32// // internal state.
Daniel Hosseinianfff4da52021-01-27 22:13:0833// Worker* worker = new Worker(std::move(controller));
[email protected]3125d6462009-09-01 20:50:1734// // Kick off asynchronous processing...
35// }
36// private:
Daniel Hosseinianfff4da52021-01-27 22:13:0837// Worker(WeakPtr<Controller> controller)
38// : controller_(std::move(controller)) {}
[email protected]3125d6462009-09-01 20:50:1739// void DidCompleteAsynchronousProcessing(const Result& result) {
40// if (controller_)
41// controller_->WorkComplete(result);
42// }
43// WeakPtr<Controller> controller_;
44// };
45//
[email protected]2c691392013-04-25 20:47:1846// 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-payeurff1eab62018-07-19 18:41:5052// Weak pointers may be passed safely between sequences, but must always be
davidbene58877e2014-10-22 18:37:1153// dereferenced and invalidated on the same SequencedTaskRunner otherwise
54// checking the pointer would be racey.
[email protected]ed3f67342013-05-29 08:04:3255//
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-payeurff1eab62018-07-19 18:41:5058// sequence or current SequencedWorkerPool token, and cannot be dereferenced or
davidbene58877e2014-10-22 18:37:1159// 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]ed3f67342013-05-29 08:04:3262//
scheib3ad03722015-10-05 22:27:4163// 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-payeurff1eab62018-07-19 18:41:5068// the correct sequence to enforce that other WeakPtr objects will enforce they
69// are used on the desired sequence.
[email protected]3125d6462009-09-01 20:50:1770
[email protected]3b63f8f42011-03-28 01:54:1571#ifndef BASE_MEMORY_WEAK_PTR_H_
72#define BASE_MEMORY_WEAK_PTR_H_
[email protected]3125d6462009-09-01 20:50:1773
dchengefeb19b2016-04-05 20:07:4074#include <cstddef>
tzik403cb6c2016-03-10 07:17:2575#include <type_traits>
Sumaid Syed22f60eeb2021-08-26 05:16:2676#include <utility>
tzik403cb6c2016-03-10 07:17:2577
[email protected]0bea7252011-08-05 15:34:0078#include "base/base_export.h"
Hans Wennborg7b533712020-06-22 20:52:2779#include "base/check.h"
Lukasz Anforowicz7623e192021-12-02 23:19:3680#include "base/compiler_specific.h"
Igor Bukanov933bad992021-09-10 19:47:2581#include "base/dcheck_is_on.h"
danakjcfcdfb7a2023-02-23 01:05:3582#include "base/memory/raw_ptr.h"
[email protected]3b63f8f42011-03-28 01:54:1583#include "base/memory/ref_counted.h"
Paul Semel5eac04a12023-06-07 18:17:3284#include "base/memory/safe_ref_traits.h"
[email protected]d52426c2013-07-30 19:26:4085#include "base/sequence_checker.h"
Nicolas Ouellet-payeurff1eab62018-07-19 18:41:5086#include "base/synchronization/atomic_flag.h"
Joe Mason0f6f6112024-02-08 17:48:1087
88namespace performance_manager {
89class FrameNodeImpl;
90class PageNodeImpl;
91class ProcessNodeImpl;
92class WorkerNodeImpl;
93} // namespace performance_manager
[email protected]3125d6462009-09-01 20:50:1794
95namespace base {
96
Scott Haseleyda865472023-05-10 19:03:1197namespace sequence_manager::internal {
98class TaskQueueImpl;
99}
100
[email protected]4c44b8442012-06-15 16:36:12101template <typename T> class WeakPtr;
102
[email protected]3125d6462009-09-01 20:50:17103namespace internal {
104// These classes are part of the WeakPtr implementation.
105// DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
106
Lukasz Anforowicz7623e192021-12-02 23:19:36107class BASE_EXPORT TRIVIAL_ABI WeakReference {
[email protected]3125d6462009-09-01 20:50:17108 public:
Wezfb4a5282018-05-01 09:02:11109 // Although Flag is bound to a specific SequencedTaskRunner, it may be
110 // deleted from another via base::WeakPtr::~WeakPtr().
[email protected]a827a562014-06-11 00:37:42111 class BASE_EXPORT Flag : public RefCountedThreadSafe<Flag> {
[email protected]d52e97092009-09-17 00:31:09112 public:
[email protected]1edefc42011-08-26 17:32:29113 Flag();
[email protected]59326aac2009-09-25 23:34:34114
hans24046fd2017-06-29 22:07:42115 void Invalidate();
Hans Wennborg4cfa3012017-08-08 03:33:38116 bool IsValid() const;
[email protected]59326aac2009-09-25 23:34:34117
Nicolas Ouellet-payeurff1eab62018-07-19 18:41:50118 bool MaybeValid() const;
119
Igor Bukanov933bad992021-09-10 19:47:25120#if DCHECK_IS_ON()
Wezc5acb1ae2019-02-14 03:09:32121 void DetachFromSequence();
Scott Haseleyda865472023-05-10 19:03:11122 void BindToCurrentSequence();
Igor Bukanov933bad992021-09-10 19:47:25123#endif
Wezc5acb1ae2019-02-14 03:09:32124
[email protected]59326aac2009-09-25 23:34:34125 private:
[email protected]05b1cd612011-04-11 20:47:25126 friend class base::RefCountedThreadSafe<Flag>;
127
128 ~Flag();
129
Nicolas Ouellet-payeurff1eab62018-07-19 18:41:50130 SEQUENCE_CHECKER(sequence_checker_);
131 AtomicFlag invalidated_;
[email protected]3125d6462009-09-01 20:50:17132 };
133
[email protected]3a3d47472010-07-15 21:03:54134 WeakReference();
Wez7eedd9e2018-01-23 00:27:05135 explicit WeakReference(const scoped_refptr<Flag>& flag);
[email protected]201366472010-07-16 17:22:49136 ~WeakReference();
[email protected]59326aac2009-09-25 23:34:34137
mek79016812016-06-24 21:29:04138 WeakReference(const WeakReference& other);
danakjcfcdfb7a2023-02-23 01:05:35139 WeakReference& operator=(const WeakReference& other);
mek79016812016-06-24 21:29:04140
danakjcfcdfb7a2023-02-23 01:05:35141 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-payeurff1eab62018-07-19 18:41:50148 bool IsValid() const;
danakjcfcdfb7a2023-02-23 01:05:35149 // 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-payeurff1eab62018-07-19 18:41:50156 bool MaybeValid() const;
[email protected]59326aac2009-09-25 23:34:34157
158 private:
[email protected]1edefc42011-08-26 17:32:29159 scoped_refptr<const Flag> flag_;
[email protected]3125d6462009-09-01 20:50:17160};
161
[email protected]0bea7252011-08-05 15:34:00162class BASE_EXPORT WeakReferenceOwner {
[email protected]3125d6462009-09-01 20:50:17163 public:
[email protected]3a3d47472010-07-15 21:03:54164 WeakReferenceOwner();
165 ~WeakReferenceOwner();
[email protected]59326aac2009-09-25 23:34:34166
[email protected]3a3d47472010-07-15 21:03:54167 WeakReference GetRef() const;
[email protected]3125d6462009-09-01 20:50:17168
Wezc5acb1ae2019-02-14 03:09:32169 bool HasRefs() const { return !flag_->HasOneRef(); }
[email protected]59326aac2009-09-25 23:34:34170
[email protected]3a3d47472010-07-15 21:03:54171 void Invalidate();
Scott Haseleyda865472023-05-10 19:03:11172 void BindToCurrentSequence();
[email protected]3125d6462009-09-01 20:50:17173
174 private:
Wez85ed9482019-11-13 02:23:31175 scoped_refptr<WeakReference::Flag> flag_;
[email protected]3125d6462009-09-01 20:50:17176};
177
danakj45c91782021-09-29 18:23:57178// Forward declaration from safe_ptr.h.
179template <typename T>
danakjcfcdfb7a2023-02-23 01:05:35180SafeRef<T> MakeSafeRefFromWeakPtrInternals(internal::WeakReference&& ref,
danakj45c91782021-09-29 18:23:57181 T* ptr);
182
[email protected]3125d6462009-09-01 20:50:17183} // namespace internal
184
[email protected]3125d6462009-09-01 20:50:17185template <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//
200template <typename T>
danakjcfcdfb7a2023-02-23 01:05:35201class TRIVIAL_ABI WeakPtr {
[email protected]3125d6462009-09-01 20:50:17202 public:
Chris Watkins091d6292017-12-13 04:25:58203 WeakPtr() = default;
danakjcfcdfb7a2023-02-23 01:05:35204 // NOLINTNEXTLINE(google-explicit-constructor)
hanscc65b2992017-06-29 20:35:28205 WeakPtr(std::nullptr_t) {}
[email protected]3125d6462009-09-01 20:50:17206
[email protected]c33acdb2013-03-02 02:31:45207 // Allow conversion from U to T provided U "is a" T. Note that this
mek79016812016-06-24 21:29:04208 // is separate from the (implicit) copy and move constructors.
Daniel Cheng8d4b30d2023-11-14 20:25:54209 template <typename U>
210 requires(std::convertible_to<U*, T*>)
Alan Cutter6e972c82022-10-07 05:03:45211 // NOLINTNEXTLINE(google-explicit-constructor)
danakjcfcdfb7a2023-02-23 01:05:35212 WeakPtr(const WeakPtr<U>& other) : ref_(other.ref_), ptr_(other.ptr_) {}
Daniel Cheng8d4b30d2023-11-14 20:25:54213 template <typename U>
214 requires(std::convertible_to<U*, T*>)
Alan Cutter6e972c82022-10-07 05:03:45215 // NOLINTNEXTLINE(google-explicit-constructor)
danakjcfcdfb7a2023-02-23 01:05:35216 WeakPtr& operator=(const WeakPtr<U>& other) {
217 ref_ = other.ref_;
218 ptr_ = other.ptr_;
219 return *this;
hanscc65b2992017-06-29 20:35:28220 }
[email protected]3125d6462009-09-01 20:50:17221
Daniel Cheng8d4b30d2023-11-14 20:25:54222 template <typename U>
223 requires(std::convertible_to<U*, T*>)
danakjcfcdfb7a2023-02-23 01:05:35224 // NOLINTNEXTLINE(google-explicit-constructor)
225 WeakPtr(WeakPtr<U>&& other)
226 : ref_(std::move(other.ref_)), ptr_(std::move(other.ptr_)) {}
Daniel Cheng8d4b30d2023-11-14 20:25:54227 template <typename U>
228 requires(std::convertible_to<U*, T*>)
danakjcfcdfb7a2023-02-23 01:05:35229 // 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;
hans526f714c2017-06-29 18:22:36234 }
[email protected]3125d6462009-09-01 20:50:17235
danakjcfcdfb7a2023-02-23 01:05:35236 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]f1836f42012-02-29 06:59:03240 T& operator*() const {
Daniel Cheng0b308a02020-10-13 19:17:03241 CHECK(ref_.IsValid());
danakjcfcdfb7a2023-02-23 01:05:35242 return *ptr_;
[email protected]3125d6462009-09-01 20:50:17243 }
danakjcfcdfb7a2023-02-23 01:05:35244
245 // Used to call methods on the underlying T. Will CHECK() if the T pointee is
246 // no longer alive.
[email protected]3125d6462009-09-01 20:50:17247 T* operator->() const {
Daniel Cheng0b308a02020-10-13 19:17:03248 CHECK(ref_.IsValid());
danakjcfcdfb7a2023-02-23 01:05:35249 return ptr_;
[email protected]3125d6462009-09-01 20:50:17250 }
251
wezb9820d42016-06-22 23:41:04252 // Allow conditionals to test validity, e.g. if (weak_ptr) {...};
Wezcaf863b992018-05-01 11:03:29253 explicit operator bool() const { return get() != nullptr; }
[email protected]380b1392013-06-06 05:32:37254
danakjcfcdfb7a2023-02-23 01:05:35255 // 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 Chen7c001192024-02-07 23:38:46264 // 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-payeurff1eab62018-07-19 18:41:50274 // 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
danakjcfcdfb7a2023-02-23 01:05:35276 // RefIsValid() must always be called, on the correct sequence, before
Nicolas Ouellet-payeurff1eab62018-07-19 18:41:50277 // 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 Apted30f97fd2018-08-21 09:03:47283 // 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 Apted453d0b5b2018-08-23 00:13:22285 // been explicitly set to null.
Trent Apted30f97fd2018-08-21 09:03:47286 bool WasInvalidated() const { return ptr_ && !ref_.IsValid(); }
287
[email protected]3125d6462009-09-01 20:50:17288 private:
[email protected]c33acdb2013-03-02 02:31:45289 template <typename U> friend class WeakPtr;
[email protected]3125d6462009-09-01 20:50:17290 friend class WeakPtrFactory<T>;
Alan Cutterc2d2c472022-10-20 02:14:43291 friend class WeakPtrFactory<std::remove_const_t<T>>;
[email protected]3125d6462009-09-01 20:50:17292
danakjcfcdfb7a2023-02-23 01:05:35293 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]3125d6462009-09-01 20:50:17309};
310
wezb9820d42016-06-22 23:41:04311// Allow callers to compare WeakPtrs against nullptr to test validity.
312template <class T>
313bool operator!=(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
314 return !(weak_ptr == nullptr);
315}
316template <class T>
317bool operator!=(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
318 return weak_ptr != nullptr;
319}
320template <class T>
321bool operator==(const WeakPtr<T>& weak_ptr, std::nullptr_t) {
322 return weak_ptr.get() == nullptr;
323}
324template <class T>
325bool operator==(std::nullptr_t, const WeakPtr<T>& weak_ptr) {
326 return weak_ptr == nullptr;
327}
328
hansd2a722f2017-06-28 21:12:54329namespace internal {
330class 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 Mason0f6f6112024-02-08 17:48:10339namespace subtle {
340
341// Restricts access to WeakPtrFactory::BindToCurrentSequence() to authorized
342// callers.
343class BASE_EXPORT BindWeakPtrFactoryPassKey {
344 private:
345 // Avoid =default to disallow creation by uniform initialization.
Sorin Jianu1ed1f6c2024-09-28 00:31:40346 BindWeakPtrFactoryPassKey() = default;
Joe Mason0f6f6112024-02-08 17:48:10347
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]2c691392013-04-25 20:47:18358// 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.
363template <class T>
hansd2a722f2017-06-28 21:12:54364class WeakPtrFactory : public internal::WeakPtrFactoryBase {
[email protected]2c691392013-04-25 20:47:18365 public:
Peter Boström511258be2021-11-03 01:18:46366 WeakPtrFactory() = delete;
367
hansd2a722f2017-06-28 21:12:54368 explicit WeakPtrFactory(T* ptr)
369 : WeakPtrFactoryBase(reinterpret_cast<uintptr_t>(ptr)) {}
[email protected]2c691392013-04-25 20:47:18370
Peter Boström511258be2021-11-03 01:18:46371 WeakPtrFactory(const WeakPtrFactory&) = delete;
372 WeakPtrFactory& operator=(const WeakPtrFactory&) = delete;
373
Chris Watkins091d6292017-12-13 04:25:58374 ~WeakPtrFactory() = default;
[email protected]2c691392013-04-25 20:47:18375
Alan Cutterc2d2c472022-10-20 02:14:43376 WeakPtr<const T> GetWeakPtr() const {
377 return WeakPtr<const T>(weak_reference_owner_.GetRef(),
378 reinterpret_cast<const T*>(ptr_));
379 }
Alan Cutter4252ed22022-10-05 09:04:19380
Daniel Cheng8d4b30d2023-11-14 20:25:54381 WeakPtr<T> GetWeakPtr()
382 requires(!std::is_const_v<T>)
383 {
Alan Cutter4252ed22022-10-05 09:04:19384 return WeakPtr<T>(weak_reference_owner_.GetRef(),
385 reinterpret_cast<T*>(ptr_));
386 }
387
Daniel Cheng8d4b30d2023-11-14 20:25:54388 WeakPtr<T> GetMutableWeakPtr() const
389 requires(!std::is_const_v<T>)
390 {
hansd2a722f2017-06-28 21:12:54391 return WeakPtr<T>(weak_reference_owner_.GetRef(),
392 reinterpret_cast<T*>(ptr_));
[email protected]2c691392013-04-25 20:47:18393 }
394
danakj45c91782021-09-29 18:23:57395 // 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]2c691392013-04-25 20:47:18408 // 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 Haseleyda865472023-05-10 19:03:11419
Joe Mason0f6f6112024-02-08 17:48:10420 // 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 Haseleyda865472023-05-10 19:03:11424 weak_reference_owner_.BindToCurrentSequence();
425 }
[email protected]2c691392013-04-25 20:47:18426};
427
[email protected]3125d6462009-09-01 20:50:17428} // namespace base
429
[email protected]3b63f8f42011-03-28 01:54:15430#endif // BASE_MEMORY_WEAK_PTR_H_