Oilpan: persist Timer<T>'s object while active.

Source/platform/Timer.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 25 matching lines @@
 namespace blink {
 
 // Time intervals are all in seconds.
 
 class PLATFORM_EXPORT TimerBase {
     WTF_MAKE_NONCOPYABLE(TimerBase);
 public:
     TimerBase();
     virtual ~TimerBase();
 
-    void start(double nextFireInterval, double repeatInterval, const TraceLocation&);
+    virtual void start(double nextFireInterval, double repeatInterval, const TraceLocation&);
 
     void startRepeating(double repeatInterval, const TraceLocation& caller)
     {
         start(repeatInterval, repeatInterval, caller);
     }
     void startOneShot(double interval, const TraceLocation& caller)
     {
         start(interval, 0, caller);
     }
 
-    void stop();
+    virtual void stop();
     bool isActive() const;
     const TraceLocation& location() const { return m_location; }
 
     double nextFireInterval() const;
     double nextUnalignedFireInterval() const;
     double repeatInterval() const { return m_repeatInterval; }
 
     void augmentRepeatInterval(double delta) {
         setNextFireTime(m_nextFireTime + delta);
         m_repeatInterval += delta;
     }
 
     void didChangeAlignmentInterval();
 
     static void fireTimersInNestedEventLoop();
 
+protected:
+    virtual void setNextFireTime(double);
+
 private:
     virtual void fired() = 0;
 
     virtual double alignedFireTime(double fireTime) const { return fireTime; }
 
     void checkConsistency() const;
     void checkHeapIndex() const;
 
-    void setNextFireTime(double);
-
     bool inHeap() const { return m_heapIndex != -1; }
 
     bool hasValidHeapPosition() const;
     void updateHeapIfNeeded(double oldTime);
 
     void heapDecreaseKey();
     void heapDelete();
     void heapDeleteMin();
     void heapIncreaseKey();
     void heapInsert();
@@ skipping 12 matching lines @@
 
 #if ENABLE(ASSERT)
     ThreadIdentifier m_thread;
 #endif
 
     friend class ThreadTimers;
     friend class TimerHeapLessThanFunction;
     friend class TimerHeapReference;
 };
 
+class PLATFORM_EXPORT TimerInstanceTracker {
+public:
+    using TraceMethodTrampoline = void (*)(Visitor*, void*);
+
+    static void remove(const void*);
+    static void add(const void*, TraceMethodTrampoline);
+};
+
+template<typename T, bool = IsGarbageCollectedType<T>::value>
+class TimerKeepAliveTrait {
+public:
+    static bool protect(bool, const T*) { return false; }
+    static bool unprotect(bool, const void*) { return false; }
+};
+
+#if ENABLE(OILPAN)
+template<typename T>
+class TimerKeepAliveTrait<T, true> {
+public:
+    static bool protect(bool needsProtection, const T* object)
+    {
+        if (needsProtection)
+            TimerInstanceTracker::add(object, &trampoline);
+
+        return needsProtection;
+    }
+
+    static bool unprotect(bool doesNotNeedProtection, const void* object)
+    {
+        if (doesNotNeedProtection)
+            TimerInstanceTracker::remove(object);
+
+        return doesNotNeedProtection;
+    }
+
+private:
+    static void trampoline(Visitor* visitor, void* self) { (reinterpret_cast<T*>(self)->trace)(visitor); }
+};
+#else
+// FIXME: Oilpan: remove this specialization when lazy sweeping is enabled on trunk.
+template<typename T>
+class TimerKeepAliveTrait<T, true> {
+public:
+    static bool protect(bool, const T*) { return false; }
+    static bool unprotect(bool, const void*) { return false; }
+};
+#endif
+
 template <typename TimerFiredClass>
 class Timer final : public TimerBase {
 public:
     typedef void (TimerFiredClass::*TimerFiredFunction)(Timer*);
 
     Timer(TimerFiredClass* o, TimerFiredFunction f)
-        : m_object(o), m_function(f) { }
+        : m_object(o)
+        , m_function(f)
+        , m_isKeptAlive(false)
+    {
+    }
+
+    ~Timer() override
+    {
+        TimerKeepAliveTrait<TimerFiredClass>::unprotect(m_isKeptAlive, m_object);
+    }
+
+    void start(double nextFireInterval, double repeatInterval, const TraceLocation& caller) override
+    {
+        TimerBase::start(nextFireInterval, repeatInterval, caller);
+        if (TimerKeepAliveTrait<TimerFiredClass>::protect(!m_isKeptAlive && isActive(), m_object))
+            m_isKeptAlive = true;
+    }
+
+    void stop() override
+    {
+        TimerBase::stop();
+        if (TimerKeepAliveTrait<TimerFiredClass>::unprotect(m_isKeptAlive && !isActive(), m_object))
+            m_isKeptAlive = false;
+    }
 
 private:
-    virtual void fired() override { (m_object->*m_function)(this); }
+    void fired() override
+    {
+        if (TimerKeepAliveTrait<TimerFiredClass>::unprotect(m_isKeptAlive && !isActive(), m_object))
+            m_isKeptAlive = false;
+        (m_object->*m_function)(this);
+    }
+
+    void setNextFireTime(double newUnalignedTime) override
+    {
+        TimerBase::setNextFireTime(newUnalignedTime);
+        if (TimerKeepAliveTrait<TimerFiredClass>::unprotect(m_isKeptAlive && !isActive(), m_object))
+            m_isKeptAlive = false;
+    }
 
     // FIXME: oilpan: TimerBase should be moved to the heap and m_object should be traced.
     // This raw pointer is safe as long as Timer<X> is held by the X itself (That's the case
     // in the current code base).
     GC_PLUGIN_IGNORE("363031")
     TimerFiredClass* m_object;
     TimerFiredFunction m_function;
+    bool m_isKeptAlive;
 };
 
 inline bool TimerBase::isActive() const
 {
     ASSERT(m_thread == currentThread());
     return m_nextFireTime;
 }
 
-}
+} // namespace blink
 
-#endif
+#endif // Timer_h