- Make sure we schedule another wakeup when handling a timeout

runtime/lib/timer_impl.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Timer heap implemented as a array-based binary heap[0].
 // This allows for O(1) `first`, O(log(n)) `remove`/`removeFirst` and O(log(n))
 // `add`.
 //
 // To ensure the timers are ordered by insertion time, the _Timer class has a
 // `_id` field set when added to the heap.
@@ skipping 97 matching lines @@
   Timer _rightChild(_Timer timer) =>
       _list[_rightChildIndex(timer._indexOrNext)];
 
   static int _parentIndex(int index) => (index - 1) ~/ 2;
   static int _leftChildIndex(int index) => 2 * index + 1;
   static int _rightChildIndex(int index) => 2 * index + 2;
 }
 
 class _Timer implements Timer {
   // Cancels the timer in the event handler.
-  static const int _NO_TIMER = -1;
+  static const _NO_TIMER = -1;
 
   // We distinguish what kind of message arrived based on the value being sent.
   static const _ZERO_EVENT = 1;
   static const _TIMEOUT_EVENT = null;
 
   // Timers are ordered by wakeup time. Timers with a timeout value of > 0 do
   // end up on the TimerHeap. Timers with a timeout of 0 are queued in a list.
   static _TimerHeap _heap = new _TimerHeap();
   static _Timer _firstZeroTimer;
   static _Timer _lastZeroTimer;
 
   // We use an id to be able to sort timers with the same expiration time.
   // ids are recycled after ID_MASK enqueues or when the timer queue is empty.
-  static int _ID_MASK = 0x1fffffff;
+  static const _ID_MASK = 0x1fffffff;
   static int _idCount = 0;
 
   static RawReceivePort _receivePort;
   static SendPort _sendPort;
   static int _scheduledWakeupTime;
 
   static bool _handlingCallbacks = false;
 
   Function _callback;  // Closure to call when timer fires. null if canceled.
   int _wakeupTime;  // Expiration time.
   int _milliSeconds;  // Duration specified at creation.
   bool _repeating;  // Indicates periodic timers.

[koda, 2015/03/03 06:49:20]

final

   var _indexOrNext;  // Index if part of the TimerHeap, link otherwise.
   int _id;  // Incrementing id to enable sorting of timers with same expiry.

[koda, 2015/03/03 06:49:20]

final

 
   // Get the next available id. We accept collisions and reordering when the
   // _idCount overflows and the timers expire at the same millisecond.
   static int _nextId() {
     var result = _idCount;
     _idCount = (_idCount + 1) & _ID_MASK;
     return result;
   }
 
   _Timer._internal(this._callback,
@@ skipping 134 matching lines @@
     if ((_firstZeroTimer == null) && _heap.isEmpty) {
       // No pending timers: Close the receive port and let the event handler
       // know.
       if (_sendPort != null) {
         VMLibraryHooks.eventHandlerSendData(null, _sendPort, _NO_TIMER);
         _shutdownTimerHandler();
       }
       return;
     } else if (_heap.isEmpty) {
       // Only zero timers are left. Cancel any scheduled wakeups.
       VMLibraryHooks.eventHandlerSendData(null, _sendPort, _NO_TIMER);

[koda, 2015/03/03 06:49:20]

Shouldn't you also assign null to _scheduledWakeupTime here, to maintain the
representation invariant?

As the code is now, a zero-timer's callback could cancel all the non-zero timers
without resetting _scheduledWakeupTime, and then if the user adds a zero timer
that in turn adds a non-zero-timer with a wakeup that happens to match
_scheduledWakeupTime, the test below would be incorrect, and that non-zero timer
would be missed, no?

       return;
     }
 
     // Only send a message if the requested wakeup time differs from the
     // already scheduled wakeup time.
     var wakeupTime = _heap.first._wakeupTime;
     if ((_scheduledWakeupTime == null) ||
         (wakeupTime != _scheduledWakeupTime)) {
       if (_sendPort == null) {
         // Create a receive port and register a message handler for the timer
@@ skipping 83 matching lines @@
 
   // Creates a receive port and registers an empty handler on that port. Just
   // the triggering of the event loop will ensure that timers are executed.
   static void _handleMessage(msg) {
     var pendingTimers;
     if (msg == _ZERO_EVENT) {
       pendingTimers = _queueFromZeroEvent();
       assert(pendingTimers.length > 0);
     } else {
       assert(msg == _TIMEOUT_EVENT);
+      _scheduledWakeupTime = null;  // Consumed the last scheduled wakeup now.
       pendingTimers = _queueFromTimeoutEvent();
     }
     _runTimers(pendingTimers);
   }
 
   static void _createTimerHandler() {
     assert(_receivePort == null);
     assert(_sendPort == null);
     _receivePort = new RawReceivePort(_handleMessage);
     _sendPort = _receivePort.sendPort;
@@ skipping 14 matching lines @@
     if (repeating) {
       return new _Timer.periodic(milliSeconds, callback);
     }
     return new _Timer(milliSeconds, callback);
   }
 }
 
 _setupHooks() {
   VMLibraryHooks.timerFactory = _Timer._factory;
 }