Make EventHandler::ActiveIntervalTimer mockable.

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 87 matching lines @@
 
 #ifndef NDEBUG
     ThreadIdentifier m_thread;
 #endif
 
     friend class ThreadTimers;
     friend class TimerHeapLessThanFunction;
     friend class TimerHeapReference;
 };
 
+template <typename TimerFiredClass> class MockableTimer;
+
 template <typename TimerFiredClass>
-class Timer FINAL : public TimerBase {
+class Timer : public TimerBase {
+    friend class MockableTimer<TimerFiredClass>;
+
 public:
     typedef void (TimerFiredClass::*TimerFiredFunction)(Timer*);
 
     Timer(TimerFiredClass* o, TimerFiredFunction f)
         : m_object(o), m_function(f) { }
 
 private:
     virtual void fired() OVERRIDE { (m_object->*m_function)(this); }
 
     TimerFiredClass* m_object;
     TimerFiredFunction m_function;
 };
 
+// A mockable timer is useful in manually controlling timers from tests
+// to avoid flakiness. To access a specific instance in layout tests,
+// it has to be plumbed through internals. The plan is to eventually have
+// a mocked system clock that would make this unnecessary.

[eseidel, 2014/01/21 21:24:42]

If this is no longer the plan, we should update this comment.

+template <typename TimerFiredClass>
+class MockableTimer FINAL : public Timer<TimerFiredClass> {
+public:
+    typedef typename Timer<TimerFiredClass>::TimerFiredFunction TimerFiredFunction;
+
+    MockableTimer(TimerFiredClass* o, TimerFiredFunction f)
+        : Timer<TimerFiredClass>(o, f)
+        , m_manualMode(false)
+        , m_firePending(false)
+    {
+    }
+
+    void setManualModeForTesting(bool manualMode) { m_manualMode = manualMode; }
+
+    void manualFireForTesting()
+    {
+        ASSERT(m_manualMode);
+        ASSERT(Timer<TimerFiredClass>::isActive() || m_firePending);
+        Timer<TimerFiredClass>::fired();
+        if (!Timer<TimerFiredClass>::repeatInterval())
+            Timer<TimerFiredClass>::stop();
+        m_firePending = false;
+    }
+
+private:
+    bool m_manualMode;
+    bool m_firePending;
+
+    virtual void fired() OVERRIDE
+    {
+        if (m_manualMode)
+            m_firePending = true;
+        else
+            Timer<TimerFiredClass>::fired();
+    }
+};
+
 inline bool TimerBase::isActive() const
 {
     ASSERT(m_thread == currentThread());
     return m_nextFireTime;
 }
 
 template <typename TimerFiredClass>
 class DeferrableOneShotTimer FINAL : private TimerBase {
 public:
     typedef void (TimerFiredClass::*TimerFiredFunction)(DeferrableOneShotTimer*);
@@ skipping 37 matching lines @@
     TimerFiredClass* m_object;
     TimerFiredFunction m_function;
 
     double m_delay;
     bool m_shouldRestartWhenTimerFires;
 };
 
 }
 
 #endif