Mypal/xpcom/threads/nsTimerImpl.h

/* -*- 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 nsTimerImpl_h___
#define nsTimerImpl_h___

#include "nsITimer.h"
#include "nsIEventTarget.h"
#include "nsIObserver.h"

#include "nsCOMPtr.h"

#include "mozilla/Attributes.h"
#include "mozilla/Logging.h"
#include "mozilla/Mutex.h"
#include "mozilla/TimeStamp.h"
#include "mozilla/Variant.h"

#ifdef MOZ_TASK_TRACER
#include "TracedTaskCommon.h"
#endif

extern mozilla::LogModule* GetTimerLog();

#define NS_TIMER_CID \
{ /* 5ff24248-1dd2-11b2-8427-fbab44f29bc8 */         \
     0x5ff24248,                                     \
     0x1dd2,                                         \
     0x11b2,                                         \
    {0x84, 0x27, 0xfb, 0xab, 0x44, 0xf2, 0x9b, 0xc8} \
}

// TimerThread, nsTimerEvent, and nsTimer have references to these. nsTimer has
// a separate lifecycle so we can Cancel() the underlying timer when the user of
// the nsTimer has let go of its last reference.
class nsTimerImpl
{
  ~nsTimerImpl() {}
public:
  typedef mozilla::TimeStamp TimeStamp;

  explicit nsTimerImpl(nsITimer* aTimer);
  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(nsTimerImpl)
  NS_DECL_NON_VIRTUAL_NSITIMER

  static nsresult Startup();
  static void Shutdown();

  void Fire(int32_t aGeneration);

#ifdef MOZ_TASK_TRACER
  void GetTLSTraceInfo();
  mozilla::tasktracer::TracedTaskCommon GetTracedTask();
#endif

  int32_t GetGeneration()
  {
    return mGeneration;
  }

  nsresult InitCommon(uint32_t aDelay, uint32_t aType);

  struct Callback {
    Callback() :
      mType(Type::Unknown),
      mName(Nothing),
      mClosure(nullptr)
    {
      mCallback.c = nullptr;
    }

    Callback(const Callback& other) = delete;
    Callback& operator=(const Callback& other) = delete;

    ~Callback()
    {
      if (mType == Type::Interface) {
        NS_RELEASE(mCallback.i);
      } else if (mType == Type::Observer) {
        NS_RELEASE(mCallback.o);
      }
    }

    void swap(Callback& other)
    {
      std::swap(mType, other.mType);
      std::swap(mCallback, other.mCallback);
      std::swap(mName, other.mName);
      std::swap(mClosure, other.mClosure);
    }

    enum class Type : uint8_t {
      Unknown = 0,
      Interface = 1,
      Function = 2,
      Observer = 3,
    };
    Type mType;

    union CallbackUnion
    {
      nsTimerCallbackFunc c;
      // These refcounted references are managed manually, as they are in a union
      nsITimerCallback* MOZ_OWNING_REF i;
      nsIObserver* MOZ_OWNING_REF o;
    } mCallback;

    // |Name| is a tagged union type representing one of (a) nothing, (b) a
    // string, or (c) a function. mozilla::Variant doesn't naturally handle the
    // "nothing" case, so we define a dummy type and value (which is unused and
    // so the exact value doesn't matter) for it.
    typedef const int NameNothing;
    typedef const char* NameString;
    typedef nsTimerNameCallbackFunc NameFunc;
    typedef mozilla::Variant<NameNothing, NameString, NameFunc> Name;
    static const NameNothing Nothing;
    Name mName;

    void*                 mClosure;
  };

  Callback& GetCallback()
  {
    mMutex.AssertCurrentThreadOwns();
    if (mCallback.mType == Callback::Type::Unknown) {
      return mCallbackDuringFire;
    }

    return mCallback;
  }

  bool IsRepeating() const
  {
    static_assert(nsITimer::TYPE_ONE_SHOT < nsITimer::TYPE_REPEATING_SLACK,
                  "invalid ordering of timer types!");
    static_assert(
        nsITimer::TYPE_REPEATING_SLACK < nsITimer::TYPE_REPEATING_PRECISE,
        "invalid ordering of timer types!");
    static_assert(
        nsITimer::TYPE_REPEATING_PRECISE <
          nsITimer::TYPE_REPEATING_PRECISE_CAN_SKIP,
        "invalid ordering of timer types!");
    return mType >= nsITimer::TYPE_REPEATING_SLACK;
  }

  nsCOMPtr<nsIEventTarget> mEventTarget;

  void LogFiring(const Callback& aCallback, uint8_t aType, uint32_t aDelay);

  nsresult InitWithFuncCallbackCommon(nsTimerCallbackFunc aFunc,
                                      void* aClosure,
                                      uint32_t aDelay,
                                      uint32_t aType,
                                      Callback::Name aName);

  // These members are set by the initiating thread, when the timer's type is
  // changed and during the period where it fires on that thread.
  uint8_t               mType;

  // The generation number of this timer, re-generated each time the timer is
  // initialized so one-shot timers can be canceled and re-initialized by the
  // arming thread without any bad race conditions.
  // Updated only after this timer has been removed from the timer thread.
  int32_t               mGeneration;

  uint32_t              mDelay;
  // Updated only after this timer has been removed from the timer thread.
  TimeStamp             mTimeout;

#ifdef MOZ_TASK_TRACER
  mozilla::tasktracer::TracedTaskCommon mTracedTask;
#endif

  static double         sDeltaSum;
  static double         sDeltaSumSquared;
  static double         sDeltaNum;
  const RefPtr<nsITimer>      mITimer;
  mozilla::Mutex mMutex;
  Callback              mCallback;
  Callback              mCallbackDuringFire;
};

class nsTimer final : public nsITimer
{
  virtual ~nsTimer();
public:
  nsTimer() : mImpl(new nsTimerImpl(this)) {}

  friend class TimerThread;
  friend class nsTimerEvent;
  friend struct TimerAdditionComparator;

  NS_DECL_THREADSAFE_ISUPPORTS
  NS_FORWARD_SAFE_NSITIMER(mImpl);

  virtual size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const override;

private:
  // nsTimerImpl holds a strong ref to us. When our refcount goes to 1, we will
  // null this to break the cycle.
  RefPtr<nsTimerImpl> mImpl;
};

#endif /* nsTimerImpl_h___ */