Make Timer and CancellableTaskFactory embeddeable in lazily swept objects.

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 44 matching lines @@
     {
         start(interval, 0, caller);
     }
 
     void stop();
     bool isActive() const;
     const WebTraceLocation& location() const { return m_location; }
 
     double nextFireInterval() const;
     double nextUnalignedFireInterval() const;
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     double repeatInterval() const { return m_repeatInterval; }
 
     void augmentRepeatInterval(double delta) {
         double now = monotonicallyIncreasingTime();
         setNextFireTime(now, m_nextFireTime - now + delta);
         m_repeatInterval += delta;
     }
 
     void didChangeAlignmentInterval(double now);
 
+#if defined(ADDRESS_SANITIZER)
+protected:
+    CancellableTaskFactory& cancellableTaskFactory() { return m_cancellableTaskFactory; }
+#endif
+
 private:
     virtual void fired() = 0;
 
     NO_LAZY_SWEEP_SANITIZE_ADDRESS
+    virtual bool canFire() const { return true; }
+
     virtual double alignedFireTime(double fireTime) const { return fireTime; }
 
     void setNextFireTime(double now, double delay);
 
     void run();
 
     double m_nextFireTime; // 0 if inactive
     double m_unalignedNextFireTime; // m_nextFireTime not considering alignment interval
     double m_repeatInterval; // 0 if not repeating
     WebTraceLocation m_location;
@@ skipping 13 matching lines @@
 class TimerIsObjectAliveTrait {
 public:
     static bool isHeapObjectAlive(T*) { return true; }
 };
 
 template<typename T>
 class TimerIsObjectAliveTrait<T, true> {
 public:
     static bool isHeapObjectAlive(T* objectPointer)
     {
-        // Oilpan: if a timer fires while Oilpan heaps are being lazily
-        // swept, it is not safe to proceed if the object is about to
-        // be swept (and this timer will be stopped while doing so.)
         return !Heap::willObjectBeLazilySwept(objectPointer);
     }
 };
 
 template <typename TimerFiredClass>
 class Timer : 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)
+    {
+#if ENABLE(LAZY_SWEEPING) && defined(ADDRESS_SANITIZER)
+        if (IsGarbageCollectedType<TimerFiredClass>::value)
+            cancellableTaskFactory().setUnpoisonBeforeUpdate();
+#endif
+    }
 
 protected:
-    NO_LAZY_SWEEP_SANITIZE_ADDRESS
     virtual void fired() override
     {
-        if (!TimerIsObjectAliveTrait<TimerFiredClass>::isHeapObjectAlive(m_object))
-            return;
         (m_object->*m_function)(this);
     }
 
+    NO_LAZY_SWEEP_SANITIZE_ADDRESS
+    virtual bool canFire() const override
+    {
+        // Oilpan: if a timer fires while Oilpan heaps are being lazily
+        // swept, it is not safe to proceed if the object is about to
+        // be swept (and this timer will be stopped while doing so.)
+        return TimerIsObjectAliveTrait<TimerFiredClass>::isHeapObjectAlive(m_object);
+    }
+
 private:
-    // FIXME: oilpan: TimerBase should be moved to the heap and m_object should be traced.
+    // 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;
 };
 
 NO_LAZY_SWEEP_SANITIZE_ADDRESS
 inline bool TimerBase::isActive() const
 {
     ASSERT(m_thread == currentThread());
     return m_cancellableTaskFactory.isPending();
 }
 
-}
+} // namespace blink
 
-#endif
+#endif // Timer_h