1 files changed, 10 insertions, 75 deletions
diff --git a/indra/llcommon/lleventtimer.h b/indra/llcommon/lleventtimer.h
index e0c2381807..b37d682d29 100644
--- a/indra/llcommon/lleventtimer.h
+++ b/indra/llcommon/lleventtimer.h
@@ -27,13 +27,12 @@
 #ifndef LL_EVENTTIMER_H
 #define LL_EVENTTIMER_H
 
-#include "stdtypes.h"
+#include "llcallbacklist.h"
 #include "lldate.h"
-#include "llinstancetracker.h"
-#include "lltimer.h"
+#include "stdtypes.h"
 
 // class for scheduling a function to be called at a given frequency (approximate, inprecise)
-class LL_COMMON_API LLEventTimer : public LLInstanceTracker<LLEventTimer>
+class LL_COMMON_API LLEventTimer
 {
 public:
 
@@ -41,82 +40,18 @@ public:
     LLEventTimer(const LLDate& time);
     virtual ~LLEventTimer();
 
+    void start();
+    void stop();
+    bool isRunning();
+    F32 getRemaining();
+
     //function to be called at the supplied frequency
-    // Normally return FALSE; TRUE will delete the timer after the function returns.
+    // Normally return false; true will delete the timer after the function returns.
     virtual bool tick() = 0;
 
-    static void updateClass();
-
-    /// Schedule recurring calls to generic callable every period seconds.
-    /// Returns a pointer; if you delete it, cancels the recurring calls.
-    template <typename CALLABLE>
-    static LLEventTimer* run_every(F32 period, const CALLABLE& callable);
-
-    /// Schedule a future call to generic callable. Returns a pointer.
-    /// CAUTION: The object referenced by that pointer WILL BE DELETED once
-    /// the callback has been called! LLEventTimer::getInstance(pointer) (NOT
-    /// pointer->getInstance(pointer)!) can be used to test whether the
-    /// pointer is still valid. If it is, deleting it will cancel the
-    /// callback.
-    template <typename CALLABLE>
-    static LLEventTimer* run_at(const LLDate& time, const CALLABLE& callable);
-
-    /// Like run_at(), but after a time delta rather than at a timestamp.
-    /// Same CAUTION.
-    template <typename CALLABLE>
-    static LLEventTimer* run_after(F32 interval, const CALLABLE& callable);
-
 protected:
-    LLTimer mEventTimer;
+    LL::Timers::temp_handle_t mTimer;
     F32 mPeriod;
-
-private:
-    template <typename CALLABLE>
-    class Generic;
 };
 
-template <typename CALLABLE>
-class LLEventTimer::Generic: public LLEventTimer
-{
-public:
-    // making TIME generic allows engaging either LLEventTimer constructor
-    template <typename TIME>
-    Generic(const TIME& time, bool once, const CALLABLE& callable):
-        LLEventTimer(time),
-        mOnce(once),
-        mCallable(callable)
-    {}
-    bool tick() override
-    {
-        mCallable();
-        // true tells updateClass() to delete this instance
-        return mOnce;
-    }
-
-private:
-    bool mOnce;
-    CALLABLE mCallable;
-};
-
-template <typename CALLABLE>
-LLEventTimer* LLEventTimer::run_every(F32 period, const CALLABLE& callable)
-{
-    // return false to schedule recurring calls
-    return new Generic<CALLABLE>(period, false, callable);
-}
-
-template <typename CALLABLE>
-LLEventTimer* LLEventTimer::run_at(const LLDate& time, const CALLABLE& callable)
-{
-    // return true for one-shot callback
-    return new Generic<CALLABLE>(time, true, callable);
-}
-
-template <typename CALLABLE>
-LLEventTimer* LLEventTimer::run_after(F32 interval, const CALLABLE& callable)
-{
-    // one-shot callback after specified interval
-    return new Generic<CALLABLE>(interval, true, callable);
-}
-
 #endif //LL_EVENTTIMER_H