Add ticks counter to Timer.

pkg/dev_compiler/tool/input_sdk/private/isolate_helper.dart

 // Copyright (c) 2012, 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.
 
 library dart._isolate_helper;
 
 import 'dart:_js_embedded_names'
     show
         CLASS_ID_EXTRACTOR,
         CLASS_FIELDS_EXTRACTOR,
@@ skipping 1337 matching lines @@
     _controller.close();
   }
 
   SendPort get sendPort => _rawPort.sendPort;
 }
 
 class TimerImpl implements Timer {
   final bool _once;
   bool _inEventLoop = false;
   int _handle;
+  int _tick = 0;
 
   TimerImpl(int milliseconds, void callback()) : _once = true {
     if (milliseconds == 0 && (!hasTimer() || _globalState.isWorker)) {
       void internalCallback() {
         _handle = null;
         callback();
       }
 
       // Setting _handle to something different from null indicates that the
       // callback has not been run. Hence, the choice of 1 is arbitrary.
       _handle = 1;
 
       // This makes a dependency between the async library and the
       // event loop of the isolate library. The compiler makes sure
       // that the event loop is compiled if [Timer] is used.
       // TODO(7907): In case of web workers, we need to use the event
       // loop instead of setTimeout, to make sure the futures get executed in
       // order.
       _globalState.topEventLoop
           .enqueue(_globalState.currentContext, internalCallback, 'timer');
       _inEventLoop = true;
     } else if (hasTimer()) {
       void internalCallback() {
         _handle = null;
         leaveJsAsync();
+        _tick = 1;
         callback();
       }
 
       enterJsAsync();
 
       _handle = JS(
           'int', '#.setTimeout(#, #)', global, internalCallback, milliseconds);
     } else {
       assert(milliseconds > 0);
       throw new UnsupportedError("Timer greater than 0.");
     }
   }
 
   TimerImpl.periodic(int milliseconds, void callback(Timer timer))
       : _once = false {
     if (hasTimer()) {
       enterJsAsync();
+      int start = JS('int', 'Date.now()');
       _handle = JS('int', '#.setInterval(#, #)', global, () {
+        int tick = this._tick + 1;
+        if (milliseconds > 0) {
+          int duration = JS('int', 'Date.now()') - start;
+          if (duration > (tick + 1) * milliseconds) {
+            tick = duration ~/ milliseconds;
+          }
+        }
+        this._tick = tick;
         callback(this);
       }, milliseconds);
     } else {
       throw new UnsupportedError("Periodic timer.");
     }
   }
 
+  int get tick => _tick;
+
   void cancel() {
     if (hasTimer()) {
       if (_inEventLoop) {
         throw new UnsupportedError("Timer in event loop cannot be canceled.");
       }
       if (_handle == null) return;
       leaveJsAsync();
       if (_once) {
         JS('void', '#.clearTimeout(#)', global, _handle);
       } else {
@@ skipping 41 matching lines @@
   }
 
   bool operator ==(Object other) {
     if (identical(other, this)) return true;
     if (other is CapabilityImpl) {
       return identical(_id, other._id);
     }
     return false;
   }
 }