gecko-dev/xpcom/threads/nsTimerImpl.h

277 строки
7.5 KiB
C++

/* -*- 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} \
}
class nsTimerImplHolder;
// 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()
{
MOZ_ASSERT(!mHolder);
}
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 SetDelayInternal(uint32_t aDelay, TimeStamp aBase = TimeStamp::Now());
void CancelImpl(bool aClearITimer);
void Fire(int32_t aGeneration);
#ifdef MOZ_TASK_TRACER
void GetTLSTraceInfo();
mozilla::tasktracer::TracedTaskCommon GetTracedTask();
#endif
int32_t GetGeneration()
{
return mGeneration;
}
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;
};
nsresult InitCommon(uint32_t aDelayMS, uint32_t aType,
Callback&& newCallback);
nsresult InitCommon(const mozilla::TimeDuration& aDelay, uint32_t aType,
Callback&& newCallback);
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 &&
mType < nsITimer::TYPE_ONE_SHOT_LOW_PRIORITY;
}
bool IsLowPriority() const
{
return mType == nsITimer::TYPE_ONE_SHOT_LOW_PRIORITY ||
mType == nsITimer::TYPE_REPEATING_SLACK_LOW_PRIORITY;
}
bool IsSlack() const
{
return mType == nsITimer::TYPE_REPEATING_SLACK ||
mType == nsITimer::TYPE_REPEATING_SLACK_LOW_PRIORITY;
}
void GetName(nsACString& aName);
void SetHolder(nsTimerImplHolder* aHolder);
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,
const Callback::Name& aName);
// This weak reference must be cleared by the nsTimerImplHolder by calling
// SetHolder(nullptr) before the holder is destroyed.
nsTimerImplHolder* mHolder;
// 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;
mozilla::TimeDuration mDelay;
// Updated only after this timer has been removed from the timer thread.
mozilla::TimeStamp mTimeout;
#ifdef MOZ_TASK_TRACER
mozilla::tasktracer::TracedTaskCommon mTracedTask;
#endif
static double sDeltaSum;
static double sDeltaSumSquared;
static double sDeltaNum;
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;
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;
};
// A class that holds on to an nsTimerImpl. This lets the nsTimerImpl object
// directly instruct its holder to forget the timer, avoiding list lookups.
class nsTimerImplHolder
{
public:
explicit nsTimerImplHolder(nsTimerImpl* aTimerImpl)
: mTimerImpl(aTimerImpl)
{
if (mTimerImpl) {
mTimerImpl->SetHolder(this);
}
}
~nsTimerImplHolder()
{
if (mTimerImpl) {
mTimerImpl->SetHolder(nullptr);
}
}
void
Forget(nsTimerImpl* aTimerImpl)
{
if (MOZ_UNLIKELY(!mTimerImpl)) {
return;
}
MOZ_ASSERT(aTimerImpl == mTimerImpl);
mTimerImpl->SetHolder(nullptr);
mTimerImpl = nullptr;
}
protected:
RefPtr<nsTimerImpl> mTimerImpl;
};
#endif /* nsTimerImpl_h___ */