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

#ifndef MOZILLA_ATOMICREFCOUNTEDWITHFINALIZE_H_

#define MOZILLA_ATOMICREFCOUNTEDWITHFINALIZE_H_

#include "mozilla/RefPtr.h"

#include "mozilla/Likely.h"

#include "MainThreadUtils.h"

#include "base/message_loop.h"

#include "base/task.h"

#include "mozilla/gfx/Logging.h"

#define ADDREF_MANUALLY(obj)  (obj)->AddRefManually(__FUNCTION__, __FILE__, __LINE__)

#define RELEASE_MANUALLY(obj)  (obj)->ReleaseManually(__FUNCTION__, __FILE__, __LINE__)

namespace mozilla {

template<class U>

class StaticRefPtr;

namespace gl {

template<typename T>

class RefSet;

template<typename T>

class RefQueue;

} // namespace gl

template<typename T>

class AtomicRefCountedWithFinalize

{

protected:

    explicit AtomicRefCountedWithFinalize(const char* aName)

      : mRecycleCallback(nullptr)

      , mClosure(nullptr)

      , mRefCount(0)

#ifdef DEBUG

      , mSpew(false)

      , mManualAddRefs(0)

      , mManualReleases(0)

#endif

#ifdef NS_BUILD_REFCNT_LOGGING

      , mName(aName)

#endif

    {}

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureClient>::AtomicRefCountedWithFinalize(char const*)

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureHost>::AtomicRefCountedWithFinalize(char const*)

    ~AtomicRefCountedWithFinalize() {

      if (mRefCount >= 0) {

        gfxCriticalError() << "Deleting referenced object? " << mRefCount;

      }

    }

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureClient>::~AtomicRefCountedWithFinalize()

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureHost>::~AtomicRefCountedWithFinalize()

public:

    // Mark user classes that are considered flawless.

    template<class U>

    friend class ::mozilla::StaticRefPtr;

    template<class U>

    friend struct mozilla::RefPtrTraits;

    template<typename U>

    friend class ::mozilla::gl::RefSet;

    template<typename U>

    friend class ::mozilla::gl::RefQueue;

    //friend class mozilla::gl::SurfaceFactory;

    void AddRefManually(const char* funcName, const char* fileName, uint32_t lineNum) {

#ifdef DEBUG

      uint32_t count = ++mManualAddRefs;

      if (mSpew) {

        printf_stderr("AddRefManually() #%u in %s at %s:%u\n", count, funcName,

                      fileName, lineNum);

      }

#else

      (void)funcName;

      (void)fileName;

      (void)lineNum;

#endif

      AddRef();

    }

    void ReleaseManually(const char* funcName, const char* fileName, uint32_t lineNum) {

#ifdef DEBUG

      uint32_t count = ++mManualReleases;

      if (mSpew) {

        printf_stderr("ReleaseManually() #%u in %s at %s:%u\n", count, funcName,

                      fileName, lineNum);

      }

#else

      (void)funcName;

      (void)fileName;

      (void)lineNum;

#endif

      Release();

    }

private:

    void AddRef() {

      MOZ_ASSERT(mRefCount >= 0, "AddRef() during/after Finalize()/dtor.");

#ifdef NS_BUILD_REFCNT_LOGGING

      int currCount = ++mRefCount;

      NS_LOG_ADDREF(this, currCount, mName, sizeof(*this));

#else

      ++mRefCount;

#endif

    }

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureClient>::AddRef()

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureHost>::AddRef()

    void Release() {

      MOZ_ASSERT(mRefCount > 0, "Release() during/after Finalize()/dtor.");

      // Read mRecycleCallback early so that it does not get set to

      // deleted memory, if the object is goes away.  See bug 994903.

      // This saves us in the case where there is no callback, so that

      // we can do the "else if" below.

      RecycleCallback recycleCallback = mRecycleCallback;

      int currCount = --mRefCount;

      if (currCount < 0) {

        gfxCriticalError() << "Invalid reference count release" << currCount;

        ++mRefCount;

        return;

      }

#ifdef NS_BUILD_REFCNT_LOGGING

      NS_LOG_RELEASE(this, currCount, mName);

#endif

      if (0 == currCount) {

        mRefCount = detail::DEAD;

        MOZ_ASSERT(IsDead());

        // Recycle listeners must call ClearRecycleCallback

        // before releasing their strong reference.

        if (mRecycleCallback) {

          gfxCriticalError() << "About to release with valid callback";

          mRecycleCallback = nullptr;

        }

        MOZ_ASSERT(mManualAddRefs == mManualReleases);

        T* derived = static_cast<T*>(this);

        derived->Finalize();

        delete derived;

      } else if (1 == currCount && recycleCallback) {

        // There is nothing enforcing this in the code, except how the callers

        // are being careful to never let the reference count go down if there

        // is a callback.

        MOZ_ASSERT(!IsDead());

        T* derived = static_cast<T*>(this);

        recycleCallback(derived, mClosure);

      }

    }

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureClient>::Release()

Unexecuted instantiation: mozilla::AtomicRefCountedWithFinalize<mozilla::layers::TextureHost>::Release()

public:

    typedef void (*RecycleCallback)(T* aObject, void* aClosure);

    /**

     * Set a callback responsible for recycling this object

     * before it is finalized.

     */

    void SetRecycleCallback(RecycleCallback aCallback, void* aClosure)

    {

      MOZ_ASSERT(!IsDead());

      mRecycleCallback = aCallback;

      mClosure = aClosure;

    }

    void ClearRecycleCallback()

    {

      MOZ_ASSERT(!IsDead());

      SetRecycleCallback(nullptr, nullptr);

    }

    bool HasRecycleCallback() const

    {

      MOZ_ASSERT(!IsDead());

      return !!mRecycleCallback;

    }

    bool IsDead() const

    {

      return mRefCount < 0;

    }

    bool HasOneRef() const

    {

      return mRefCount == 1;

    }

private:

    RecycleCallback mRecycleCallback;

    void *mClosure;

    Atomic<int> mRefCount;

#ifdef DEBUG

public:

    bool mSpew;

private:

    Atomic<uint32_t> mManualAddRefs;

    Atomic<uint32_t> mManualReleases;

#endif

#ifdef NS_BUILD_REFCNT_LOGGING

    const char* mName;

#endif

};

} // namespace mozilla

#endif