fml::internal::RefCountedThreadSafeBase Class Reference

#include <ref_counted_internal.h>

Inheritance diagram for fml::internal::RefCountedThreadSafeBase:

Public Member Functions
void	AddRef () const
bool	HasOneRef () const
void	AssertHasOneRef () const

Protected Member Functions
	RefCountedThreadSafeBase ()
	~RefCountedThreadSafeBase ()
bool	Release () const
void	Adopt ()

Detailed Description

Definition at line 19 of file ref_counted_internal.h.

Constructor & Destructor Documentation

RefCountedThreadSafeBase()

fml::internal::RefCountedThreadSafeBase::RefCountedThreadSafeBase ( )

inlineprotected

Definition at line 86 of file ref_counted_internal.h.

    : ref_count_(1u)
#ifndef NDEBUG
      ,
      adoption_required_(true)
#endif
{
}

~RefCountedThreadSafeBase()

fml::internal::RefCountedThreadSafeBase::~RefCountedThreadSafeBase ( )

inlineprotected

Definition at line 95 of file ref_counted_internal.h.

                                                           {
#ifndef NDEBUG
  FML_DCHECK(!adoption_required_);
  // Should only be destroyed as a result of |Release()|.
  FML_DCHECK(destruction_started_);
#endif
}

References FML_DCHECK.

Member Function Documentation

AddRef()

void fml::internal::RefCountedThreadSafeBase::AddRef ( ) const

inline

Definition at line 21 of file ref_counted_internal.h.

                      {
#ifndef NDEBUG
    FML_DCHECK(!adoption_required_);
    FML_DCHECK(!destruction_started_);
#endif
    ref_count_.fetch_add(1u, std::memory_order_relaxed);
  }

References FML_DCHECK.

Referenced by flutter::RefCountedDartWrappable< T >::RetainDartWrappableReference(), and flutter::testing::TEST_F().

Adopt()

void fml::internal::RefCountedThreadSafeBase::Adopt ( )

inlineprotected

Definition at line 69 of file ref_counted_internal.h.

               {
    FML_DCHECK(adoption_required_);
    adoption_required_ = false;
  }

References FML_DCHECK.

AssertHasOneRef()

void fml::internal::RefCountedThreadSafeBase::AssertHasOneRef ( ) const

inline

Definition at line 33 of file ref_counted_internal.h.

{ FML_DCHECK(HasOneRef()); }

References FML_DCHECK, and HasOneRef().

HasOneRef()

bool fml::internal::RefCountedThreadSafeBase::HasOneRef ( ) const

inline

Definition at line 29 of file ref_counted_internal.h.

                         {
    return ref_count_.load(std::memory_order_acquire) == 1u;
  }

Referenced by AssertHasOneRef().

Release()

bool fml::internal::RefCountedThreadSafeBase::Release ( ) const

inlineprotected

Definition at line 40 of file ref_counted_internal.h.

                       {
#ifndef NDEBUG
    FML_DCHECK(!adoption_required_);
    FML_DCHECK(!destruction_started_);
#endif
    FML_DCHECK(ref_count_.load(std::memory_order_acquire) != 0u);
    // TODO(vtl): We could add the following:
    //     if (ref_count_.load(std::memory_order_relaxed) == 1u) {
    // #ifndef NDEBUG
    //       destruction_started_= true;
    // #endif
    //       return true;
    //     }
    // This would be correct. On ARM (an Nexus 4), in *single-threaded* tests,
    // this seems to make the destruction case marginally faster (barely
    // measurable), and while the non-destruction case remains about the same
    // (possibly marginally slower, but my measurements aren't good enough to
    // have any confidence in that). I should try multithreaded/multicore tests.
    if (ref_count_.fetch_sub(1u, std::memory_order_release) == 1u) {
      std::atomic_thread_fence(std::memory_order_acquire);
#ifndef NDEBUG
      destruction_started_ = true;
#endif
      return true;
    }
    return false;
  }

References FML_DCHECK.

Referenced by fml::RefCountedThreadSafe< T >::Release().

---

The documentation for this class was generated from the following file:

• fml/memory/ref_counted_internal.h