Add ticks counter to Timer.

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.
 
 import 'dart:_internal' hide Symbol;
 
 // 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`.
 //
@@ skipping 128 matching lines @@
 
   static bool _handlingCallbacks = false;
 
   Function _callback; // Closure to call when timer fires. null if canceled.
   int _wakeupTime; // Expiration time.
   final int _milliSeconds; // Duration specified at creation.
   final bool _repeating; // Indicates periodic timers.
   var _indexOrNext; // Index if part of the TimerHeap, link otherwise.
   int _id; // Incrementing id to enable sorting of timers with same expiry.
 
+  int _tick = 0; // Backing for [tick],
+
   // 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, this._wakeupTime, this._milliSeconds, this._repeating)
@@ skipping 31 matching lines @@
   bool get _isInHeap => _indexOrNext is int;
 
   int _compareTo(_Timer other) {
     int c = _wakeupTime - other._wakeupTime;
     if (c != 0) return c;
     return _id - other._id;
   }
 
   bool get isActive => _callback != null;
 
+  int get tick => _tick;
+
   // Cancels a set timer. The timer is removed from the timer heap if it is a
   // non-zero timer. Zero timers are kept in the list as they need to consume
   // the corresponding pending message.
   void cancel() {
     _callback = null;
     // Only heap timers are really removed. Zero timers need to consume their
     // corresponding wakeup message so they are left in the queue.
     if (!_isInHeap) return;
     bool update = _heap.isFirst(this);
     _heap.remove(this);
@@ skipping 146 matching lines @@
         timer._indexOrNext = null;
 
         // One of the timers in the pending_timers list can cancel
         // one of the later timers which will set the callback to
         // null. Or the pending zero timer has been canceled earlier.
         if (timer._callback != null) {
           var callback = timer._callback;
           if (!timer._repeating) {
             // Mark timer as inactive.
             timer._callback = null;
+          } else if (timer._milliSeconds > 0) {
+            var ms = timer._milliSeconds;
+            int overdue =
+                VMLibraryHooks.timerMillisecondClock() - timer._wakeupTime;
+            if (overdue > ms) {
+              int missedTicks = overdue ~/ ms;
+              timer._wakeupTime += missedTicks * ms;
+              timer._tick += missedTicks;
+            }
           }
+          timer._tick += 1;
+
           callback(timer);
           // Re-insert repeating timer if not canceled.
           if (timer._repeating && (timer._callback != null)) {
             timer._advanceWakeupTime();
             timer._enqueue();
           }
           // Execute pending micro tasks.
           var immediateCallback = _removePendingImmediateCallback();
           if (immediateCallback != null) {
             immediateCallback();
@@ skipping 66 matching lines @@
     if (repeating) {
       return new _Timer.periodic(milliSeconds, callback);
     }
     return new _Timer(milliSeconds, callback);
   }
 }
 
 _setupHooks() {
   VMLibraryHooks.timerFactory = _Timer._factory;
 }