/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// This header provides virtual, non-templated alternatives to MFBT's RefCounted<T>.

// It intentionally uses MFBT coding style with the intention of moving there

// should there be other use cases for it.

#ifndef MOZILLA_GENERICREFCOUNTED_H_

#define MOZILLA_GENERICREFCOUNTED_H_

#include "mozilla/RefPtr.h"

#include "mozilla/RefCounted.h"

namespace mozilla {

/**

 * Common base class for GenericRefCounted and GenericAtomicRefCounted.

 *

 * Having this shared base class, common to both the atomic and non-atomic

 * cases, allows to have RefPtr's that don't care about whether the

 * objects they're managing have atomic refcounts or not.

 */

class GenericRefCountedBase

{

  protected:

    virtual ~GenericRefCountedBase() {};

  public:

    // AddRef() and Release() method names are for compatibility with nsRefPtr.

    virtual void AddRef() = 0;

    virtual void Release() = 0;

    // ref() and deref() method names are for compatibility with wtf::RefPtr.

    // No virtual keywords here: if a subclass wants to override the refcounting

    // mechanism, it is welcome to do so by overriding AddRef() and Release().

    void ref() { AddRef(); }

    void deref() { Release(); }

#ifdef MOZ_REFCOUNTED_LEAK_CHECKING

    virtual const char* typeName() const = 0;

    virtual size_t typeSize() const = 0;

#endif

};

namespace detail {

template<RefCountAtomicity Atomicity>

class GenericRefCounted : public GenericRefCountedBase

{

  protected:

    GenericRefCounted() : refCnt(0) { }

    virtual ~GenericRefCounted() {

      MOZ_ASSERT(refCnt == detail::DEAD);

    }

  public:

    virtual void AddRef() override {

      // Note: this method must be thread safe for GenericAtomicRefCounted.

      MOZ_ASSERT(int32_t(refCnt) >= 0);

#ifndef MOZ_REFCOUNTED_LEAK_CHECKING

      ++refCnt;

#else

      const char* type = typeName();

      uint32_t size = typeSize();

      const void* ptr = this;

      MozRefCountType cnt = ++refCnt;

      detail::RefCountLogger::logAddRef(ptr, cnt, type, size);

#endif

    }

    virtual void Release() override {

      // Note: this method must be thread safe for GenericAtomicRefCounted.

      MOZ_ASSERT(int32_t(refCnt) > 0);

#ifndef MOZ_REFCOUNTED_LEAK_CHECKING

      MozRefCountType cnt = --refCnt;

#else

      const char* type = typeName();

      const void* ptr = this;

      MozRefCountType cnt = --refCnt;

      // Note: it's not safe to touch |this| after decrementing the refcount,

      // except for below.

      detail::RefCountLogger::logRelease(ptr, cnt, type);

#endif

      if (0 == cnt) {

        // Because we have atomically decremented the refcount above, only

        // one thread can get a 0 count here, so as long as we can assume that

        // everything else in the system is accessing this object through

        // RefPtrs, it's safe to access |this| here.

#ifdef DEBUG

        refCnt = detail::DEAD;

#endif

        delete this;

      }

    }

    MozRefCountType refCount() const { return refCnt; }

    bool hasOneRef() const {

      MOZ_ASSERT(refCnt > 0);

      return refCnt == 1;

    }

  private:

    typename Conditional<Atomicity == AtomicRefCount, Atomic<MozRefCountType>, MozRefCountType>::Type refCnt;

};

} // namespace detail

/**

 * This reference-counting base class is virtual instead of

 * being templated, which is useful in cases where one needs

 * genericity at binary code level, but comes at the cost

 * of a moderate performance and size overhead, like anything virtual.

 */

class GenericRefCounted : public detail::GenericRefCounted<detail::NonAtomicRefCount>

{

};

/**

 * GenericAtomicRefCounted is like GenericRefCounted, with an atomically updated

 * reference counter.

 */

class GenericAtomicRefCounted : public detail::GenericRefCounted<detail::AtomicRefCount>

{

};

} // namespace mozilla

#endif