public:

// Although Flag is bound to a specific ThreaddTaskRunner, 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;

void DetachFromThread();

private:

friend class base::RefCountedThreadSafe<Flag>;

~Flag();

base::ThreadChecker thread_checker_;

AtomicFlag invalidated_;

};

WeakReference();

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

~WeakReference();

WeakReference(WeakReference&& other) noexcept;

WeakReference(const WeakReference& other);

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

WeakReference& operator=(const WeakReference& other) = default;

bool IsValid() const;

bool MaybeValid() const;

private:

scoped_refptr<const Flag> flag_;

public:

WeakReferenceOwner();

~WeakReferenceOwner();

WeakReference GetRef() const;

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

void Invalidate();

private:

scoped_refptr<WeakReference::Flag> flag_;

public:

WeakPtrBase();

~WeakPtrBase();

WeakPtrBase(const WeakPtrBase& other) = default;

WeakPtrBase(WeakPtrBase&& other) noexcept = default;

WeakPtrBase& operator=(const WeakPtrBase& other) = default;

WeakPtrBase& operator=(WeakPtrBase&& other) noexcept = default;

void reset() {

ref_ = cef_internal::WeakReference();

ptr_ = 0;

}

protected:

WeakPtrBase(const WeakReference& ref, uintptr_t ptr);

WeakReference ref_;

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

// value is undefined (as opposed to nullptr).

uintptr_t ptr_;

public:

// A safe static downcast of a WeakPtr<Base> to WeakPtr<Derived>. This

// conversion will only compile if there is exists a Base which inherits

// from SupportsWeakPtr<Base>. See base::AsWeakPtr() below for a helper

// function that makes calling this easier.

//

// Precondition: t != nullptr

template <typename Derived>

static WeakPtr<Derived> StaticAsWeakPtr(Derived* t) {

static_assert(

std::is_base_of<cef_internal::SupportsWeakPtrBase, Derived>::value,

"AsWeakPtr argument must inherit from SupportsWeakPtr");

return AsWeakPtrImpl<Derived>(t);

}

private:

// This template function uses type inference to find a Base of Derived

// which is an instance of SupportsWeakPtr<Base>. We can then safely

// static_cast the Base* to a Derived*.

template <typename Derived, typename Base>

static WeakPtr<Derived> AsWeakPtrImpl(SupportsWeakPtr<Base>* t) {

WeakPtr<Base> ptr = t->AsWeakPtr();

return WeakPtr<Derived>(

ptr.ref_, static_cast<Derived*>(reinterpret_cast<Base*>(ptr.ptr_)));

}

public:

WeakPtr() = default;

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>

WeakPtr(const WeakPtr<U>& other) : WeakPtrBase(other) {

// Need to cast from U* to T* to do pointer adjustment in case of multiple

// inheritance. This also enforces the "U is a T" rule.

T* t = reinterpret_cast<U*>(other.ptr_);

ptr_ = reinterpret_cast<uintptr_t>(t);

}

template <typename U>

WeakPtr(WeakPtr<U>&& other) noexcept : WeakPtrBase(std::move(other)) {

// Need to cast from U* to T* to do pointer adjustment in case of multiple

// inheritance. This also enforces the "U is a T" rule.

T* t = reinterpret_cast<U*>(other.ptr_);

ptr_ = reinterpret_cast<uintptr_t>(t);

}

T* get() const {

return ref_.IsValid() ? reinterpret_cast<T*>(ptr_) : nullptr;

}

T& operator*() const {

CHECK(ref_.IsValid());

return *get();

}

T* operator->() const {

CHECK(ref_.IsValid());

return get();

}

///

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

///

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

///

/// 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

/// operator bool() 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:

friend class cef_internal::SupportsWeakPtrBase;

template <typename U>

friend class WeakPtr;

friend class SupportsWeakPtr<T>;

friend class WeakPtrFactory<T>;

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

: WeakPtrBase(ref, reinterpret_cast<uintptr_t>(ptr)) {}

protected:

WeakPtrFactoryBase(uintptr_t ptr);

~WeakPtrFactoryBase();

cef_internal::WeakReferenceOwner weak_reference_owner_;

uintptr_t ptr_;

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<T> GetWeakPtr() const {

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

reinterpret_cast<T*>(ptr_));

}

///

/// Call this method to invalidate all existing weak pointers.

///

void InvalidateWeakPtrs() {

DCHECK(ptr_);

weak_reference_owner_.Invalidate();

}

///

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

///

bool HasWeakPtrs() const {

DCHECK(ptr_);

return weak_reference_owner_.HasRefs();

}

public:

SupportsWeakPtr() = default;

SupportsWeakPtr(const SupportsWeakPtr&) = delete;

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

WeakPtr<T> AsWeakPtr() {

return WeakPtr<T>(weak_reference_owner_.GetRef(), static_cast<T*>(this));

}

protected:

~SupportsWeakPtr() = default;

private:

cef_internal::WeakReferenceOwner weak_reference_owner_;