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;

private:

friend class base::RefCountedThreadSafe<Flag>;

~Flag();

// The current Chromium implementation uses SequenceChecker instead of

// ThreadChecker to support SequencedWorkerPools. CEF does not yet expose

// the concept of SequencedWorkerPools.

ThreadChecker thread_checker_;

bool is_valid_;

};

WeakReference();

explicit WeakReference(const Flag* flag);

~WeakReference();

bool is_valid() const;

private:

scoped_refptr<const Flag> flag_;

public:

WeakReferenceOwner();

~WeakReferenceOwner();

WeakReference GetRef() const;

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

void Invalidate();

private:

mutable scoped_refptr<WeakReference::Flag> flag_;

public:

WeakPtrBase();

~WeakPtrBase();

protected:

explicit WeakPtrBase(const WeakReference& ref);

WeakReference ref_;

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.

template <typename Derived>

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

typedef is_convertible<Derived, cef_internal::SupportsWeakPtrBase&>

convertible;

COMPILE_ASSERT(convertible::value,

AsWeakPtr_argument_inherits_from_SupportsWeakPtr);

return AsWeakPtrImpl<Derived>(t, *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(Derived* t,

const SupportsWeakPtr<Base>&) {

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

return WeakPtr<Derived>(ptr.ref_, static_cast<Derived*>(ptr.ptr_));

}

public:

WeakPtr() : ptr_(NULL) {}

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

// is separate from the (implicit) copy constructor.

template <typename U>

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

T* get() const { return ref_.is_valid() ? ptr_ : NULL; }

T& operator*() const {

DCHECK(get() != NULL);

return *get();

}

T* operator->() const {

DCHECK(get() != NULL);

return get();

}

// Allow WeakPtr<element_type> to be used in boolean expressions, but not

// implicitly convertible to a real bool (which is dangerous).

//

// Note that this trick is only safe when the == and != operators

// are declared explicitly, as otherwise "weak_ptr1 == weak_ptr2"

// will compile but do the wrong thing (i.e., convert to Testable

// and then do the comparison).

private:

typedef T* WeakPtr::*Testable;

public:

operator Testable() const { return get() ? &WeakPtr::ptr_ : NULL; }

void reset() {

ref_ = cef_internal::WeakReference();

ptr_ = NULL;

}

private:

// Explicitly declare comparison operators as required by the bool

// trick, but keep them private.

template <class U>

bool operator==(WeakPtr<U> const&) const;

template <class U>

bool operator!=(WeakPtr<U> const&) const;

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), ptr_(ptr) {}

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

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

T* ptr_;

public:

explicit WeakPtrFactory(T* ptr) : ptr_(ptr) {}

~WeakPtrFactory() { ptr_ = NULL; }

WeakPtr<T> GetWeakPtr() {

DCHECK(ptr_);

return WeakPtr<T>(weak_reference_owner_.GetRef(), 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();

}

private:

cef_internal::WeakReferenceOwner weak_reference_owner_;

T* ptr_;

DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);

public:

SupportsWeakPtr() {}

WeakPtr<T> AsWeakPtr() {

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

}

protected:

~SupportsWeakPtr() {}

private:

cef_internal::WeakReferenceOwner weak_reference_owner_;

DISALLOW_COPY_AND_ASSIGN(SupportsWeakPtr);