public:

// Although Flag is bound to a specific thread, it may be

// deleted from another via base::WeakPtr::~WeakPtr().

class Flag : public RefCountedThreadSafe<Flag> {

public:

Flag();

void Invalidate();

bool IsValid() const;

bool MaybeValid() const;

#if DCHECK_IS_ON()

void DetachFromThread();

void BindToCurrentThread();

#endif

private:

friend class base::RefCountedThreadSafe<Flag>;

~Flag();

base::ThreadChecker thread_checker_;

AtomicFlag invalidated_;

};

WeakReference();

explicit WeakReference(const scoped_refptr<Flag>& flag);

~WeakReference();

WeakReference(const WeakReference& other);

WeakReference& operator=(const WeakReference& other);

WeakReference(WeakReference&& other) noexcept;

WeakReference& operator=(WeakReference&& other) noexcept;

void Reset();

// Returns whether the WeakReference is valid, meaning the WeakPtrFactory has

// not invalidated the pointer. Unlike, MaybeValid(), this may only be

// called from the same thread as where the WeakPtr was created.

bool IsValid() const;

// Returns false if the WeakReference is confirmed to be invalid. This call is

// safe to make from any thread, e.g. to optimize away unnecessary work, but

// IsValid() must always be called, on the correct thread, before

// actually using the pointer.

//

// Warning: as with any object, this call is only thread-safe if the WeakPtr

// instance isn't being re-assigned or reset() racily with this call.

bool MaybeValid() const;

private:

scoped_refptr<const Flag> flag_;

public:

WeakReferenceOwner();

~WeakReferenceOwner();

WeakReference GetRef() const;

bool HasRefs() const { return !flag_->HasOneRef(); }

void Invalidate();

void InvalidateAndDoom();

void BindToCurrentThread();

private:

scoped_refptr<WeakReference::Flag> flag_;

protected:

WeakPtrFactoryBase(uintptr_t ptr);

~WeakPtrFactoryBase();

cef_internal::WeakReferenceOwner weak_reference_owner_;

uintptr_t ptr_;

public:

WeakPtr() = default;

// NOLINTNEXTLINE(google-explicit-constructor)

WeakPtr(std::nullptr_t) {}

///

/// Allow conversion from U to T provided U "is a" T. Note that this

/// is separate from the (implicit) copy and move constructors.

///

template <typename U>

requires(std::convertible_to<U*, T*>)

// NOLINTNEXTLINE(google-explicit-constructor)

WeakPtr(const WeakPtr<U>& other) : ref_(other.ref_), ptr_(other.ptr_) {}

template <typename U>

requires(std::convertible_to<U*, T*>)

// NOLINTNEXTLINE(google-explicit-constructor)

WeakPtr& operator=(const WeakPtr<U>& other) {

ref_ = other.ref_;

ptr_ = other.ptr_;

return *this;

}

template <typename U>

requires(std::convertible_to<U*, T*>)

// NOLINTNEXTLINE(google-explicit-constructor)

WeakPtr(WeakPtr<U>&& other)

: ref_(std::move(other.ref_)), ptr_(std::move(other.ptr_)) {}

template <typename U>

requires(std::convertible_to<U*, T*>)

// NOLINTNEXTLINE(google-explicit-constructor)

WeakPtr& operator=(WeakPtr<U>&& other) {

ref_ = std::move(other.ref_);

ptr_ = std::move(other.ptr_);

return *this;

}

T* get() const { return ref_.IsValid() ? ptr_ : nullptr; }

///

/// Provide access to the underlying T as a reference. Will CHECK() if the T

/// pointee is no longer alive.

///

T& operator*() const {

CHECK(ref_.IsValid());

return *ptr_;

}

///

/// Used to call methods on the underlying T. Will CHECK() if the T pointee

/// is no longer alive.

///

T* operator->() const {

CHECK(ref_.IsValid());

return ptr_;

}

///

/// Allow conditionals to test validity, e.g. if (weak_ptr) {...};

///

explicit operator bool() const { return get() != nullptr; }

///

/// Resets the WeakPtr to hold nothing.

///

/// The `get()` method will return `nullptr` thereafter, and `MaybeValid()`

/// will be `false`.

///

void reset() {

ref_.Reset();

ptr_ = nullptr;

}

///

/// Do not use this method. Almost all callers should instead use operator

/// bool().

///

/// There are a few rare cases where the caller intentionally needs to check

/// validity of a base::WeakPtr on a thread different from the bound thread

/// as an unavoidable performance optimization.

///

/// Returns false if the WeakPtr is confirmed to be invalid. This call is

/// safe to make from any thread, e.g. to optimize away unnecessary work, but

/// IsValid() must always be called, on the correct thread, before actually

/// using the pointer.

///

/// Warning: as with any object, this call is only thread-safe if the WeakPtr

/// instance isn't being re-assigned or reset() racily with this call.

///

bool MaybeValid() const { return ref_.MaybeValid(); }

///

/// Returns whether the object |this| points to has been invalidated. This

/// can be used to distinguish a WeakPtr to a destroyed object from one that

/// has been explicitly set to null.

///

bool WasInvalidated() const { return ptr_ && !ref_.IsValid(); }

private:

template <typename U>

friend class WeakPtr;

friend class WeakPtrFactory<T>;

friend class WeakPtrFactory<std::remove_const_t<T>>;

WeakPtr(cef_internal::WeakReference&& ref, T* ptr)

: ref_(std::move(ref)), ptr_(ptr) {

DCHECK(ptr);

}

cef_internal::WeakReference CloneWeakReference() const { return ref_; }

cef_internal::WeakReference ref_;

// This pointer is only valid when ref_.is_valid() is true. Otherwise, its

// value is undefined (as opposed to nullptr). The pointer is allowed to

// dangle as we verify its liveness through `ref_` before allowing access to

// the pointee.

T* ptr_ = nullptr;

public:

WeakPtrFactory() = delete;

explicit WeakPtrFactory(T* ptr)

: WeakPtrFactoryBase(reinterpret_cast<uintptr_t>(ptr)) {}

WeakPtrFactory(const WeakPtrFactory&) = delete;

WeakPtrFactory& operator=(const WeakPtrFactory&) = delete;

~WeakPtrFactory() = default;

WeakPtr<const T> GetWeakPtr() const {

return WeakPtr<const T>(weak_reference_owner_.GetRef(),

reinterpret_cast<const T*>(ptr_));

}

WeakPtr<T> GetWeakPtr()

requires(!std::is_const_v<T>)

{

return WeakPtr<T>(weak_reference_owner_.GetRef(),

reinterpret_cast<T*>(ptr_));

}

WeakPtr<T> GetMutableWeakPtr() const

requires(!std::is_const_v<T>)

{

return WeakPtr<T>(weak_reference_owner_.GetRef(),

reinterpret_cast<T*>(ptr_));

}

///

/// Invalidates all existing weak pointers.

///

void InvalidateWeakPtrs() {

DCHECK(ptr_);

weak_reference_owner_.Invalidate();

}

///

/// Invalidates all existing weak pointers, and makes the factory unusable

/// (cannot call GetWeakPtr after this). This is more efficient than

/// InvalidateWeakPtrs().

///

void InvalidateWeakPtrsAndDoom() {

DCHECK(ptr_);

weak_reference_owner_.InvalidateAndDoom();

ptr_ = 0;

}

///

/// Call this method to determine if any weak pointers exist.

///

bool HasWeakPtrs() const { return ptr_ && weak_reference_owner_.HasRefs(); }

///

/// Rebind the factory to the current thread. This allows creating an object

/// and associated weak pointers on a different thread from the one they are

/// used on.

///

void BindToCurrentThread() {

weak_reference_owner_.BindToCurrentThread();

}